1#include "cmd.h"
2
3#include <linux/module.h>
4#include <linux/slab.h>
5#include <linux/etherdevice.h>
6
7#include "wl1251.h"
8#include "reg.h"
9#include "io.h"
10#include "ps.h"
11#include "acx.h"
12
13/**
14 * send command to firmware
15 *
16 * @wl: wl struct
17 * @id: command id
18 * @buf: buffer containing the command, must work with dma
19 * @len: length of the buffer
20 */
21int wl1251_cmd_send(struct wl1251 *wl, u16 id, void *buf, size_t len)
22{
23	struct wl1251_cmd_header *cmd;
24	unsigned long timeout;
25	u32 intr;
26	int ret = 0;
27
28	cmd = buf;
29	cmd->id = id;
30	cmd->status = 0;
31
32	WARN_ON(len % 4 != 0);
33
34	wl1251_mem_write(wl, wl->cmd_box_addr, buf, len);
35
36	wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);
37
38	timeout = jiffies + msecs_to_jiffies(WL1251_COMMAND_TIMEOUT);
39
40	intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
41	while (!(intr & WL1251_ACX_INTR_CMD_COMPLETE)) {
42		if (time_after(jiffies, timeout)) {
43			wl1251_error("command complete timeout");
44			ret = -ETIMEDOUT;
45			goto out;
46		}
47
48		msleep(1);
49
50		intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
51	}
52
53	wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
54			   WL1251_ACX_INTR_CMD_COMPLETE);
55
56out:
57	return ret;
58}
59
60/**
61 * send test command to firmware
62 *
63 * @wl: wl struct
64 * @buf: buffer containing the command, with all headers, must work with dma
65 * @len: length of the buffer
66 * @answer: is answer needed
67 */
68int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer)
69{
70	int ret;
71
72	wl1251_debug(DEBUG_CMD, "cmd test");
73
74	ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len);
75
76	if (ret < 0) {
77		wl1251_warning("TEST command failed");
78		return ret;
79	}
80
81	if (answer) {
82		struct wl1251_command *cmd_answer;
83
84		/*
85		 * The test command got in, we can read the answer.
86		 * The answer would be a wl1251_command, where the
87		 * parameter array contains the actual answer.
88		 */
89		wl1251_mem_read(wl, wl->cmd_box_addr, buf, buf_len);
90
91		cmd_answer = buf;
92
93		if (cmd_answer->header.status != CMD_STATUS_SUCCESS)
94			wl1251_error("TEST command answer error: %d",
95				     cmd_answer->header.status);
96	}
97
98	return 0;
99}
100
101/**
102 * read acx from firmware
103 *
104 * @wl: wl struct
105 * @id: acx id
106 * @buf: buffer for the response, including all headers, must work with dma
107 * @len: length of buf
108 */
109int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)
110{
111	struct acx_header *acx = buf;
112	int ret;
113
114	wl1251_debug(DEBUG_CMD, "cmd interrogate");
115
116	acx->id = id;
117
118	/* payload length, does not include any headers */
119	acx->len = len - sizeof(*acx);
120
121	ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
122	if (ret < 0) {
123		wl1251_error("INTERROGATE command failed");
124		goto out;
125	}
126
127	/* the interrogate command got in, we can read the answer */
128	wl1251_mem_read(wl, wl->cmd_box_addr, buf, len);
129
130	acx = buf;
131	if (acx->cmd.status != CMD_STATUS_SUCCESS)
132		wl1251_error("INTERROGATE command error: %d",
133			     acx->cmd.status);
134
135out:
136	return ret;
137}
138
139/**
140 * write acx value to firmware
141 *
142 * @wl: wl struct
143 * @id: acx id
144 * @buf: buffer containing acx, including all headers, must work with dma
145 * @len: length of buf
146 */
147int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len)
148{
149	struct acx_header *acx = buf;
150	int ret;
151
152	wl1251_debug(DEBUG_CMD, "cmd configure");
153
154	acx->id = id;
155
156	/* payload length, does not include any headers */
157	acx->len = len - sizeof(*acx);
158
159	ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len);
160	if (ret < 0) {
161		wl1251_warning("CONFIGURE command NOK");
162		return ret;
163	}
164
165	return 0;
166}
167
168int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
169		   void *bitmap, u16 bitmap_len, u8 bitmap_control)
170{
171	struct wl1251_cmd_vbm_update *vbm;
172	int ret;
173
174	wl1251_debug(DEBUG_CMD, "cmd vbm");
175
176	vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
177	if (!vbm) {
178		ret = -ENOMEM;
179		goto out;
180	}
181
182	/* Count and period will be filled by the target */
183	vbm->tim.bitmap_ctrl = bitmap_control;
184	if (bitmap_len > PARTIAL_VBM_MAX) {
185		wl1251_warning("cmd vbm len is %d B, truncating to %d",
186			       bitmap_len, PARTIAL_VBM_MAX);
187		bitmap_len = PARTIAL_VBM_MAX;
188	}
189	memcpy(vbm->tim.pvb_field, bitmap, bitmap_len);
190	vbm->tim.identity = identity;
191	vbm->tim.length = bitmap_len + 3;
192
193	vbm->len = cpu_to_le16(bitmap_len + 5);
194
195	ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
196	if (ret < 0) {
197		wl1251_error("VBM command failed");
198		goto out;
199	}
200
201out:
202	kfree(vbm);
203	return ret;
204}
205
206int wl1251_cmd_data_path_rx(struct wl1251 *wl, u8 channel, bool enable)
207{
208	struct cmd_enabledisable_path *cmd;
209	int ret;
210	u16 cmd_rx;
211
212	wl1251_debug(DEBUG_CMD, "cmd data path");
213
214	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
215	if (!cmd) {
216		ret = -ENOMEM;
217		goto out;
218	}
219
220	cmd->channel = channel;
221
222	if (enable)
223		cmd_rx = CMD_ENABLE_RX;
224	else
225		cmd_rx = CMD_DISABLE_RX;
226
227	ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
228	if (ret < 0) {
229		wl1251_error("rx %s cmd for channel %d failed",
230			     enable ? "start" : "stop", channel);
231		goto out;
232	}
233
234	wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
235		     enable ? "start" : "stop", channel);
236
237out:
238	kfree(cmd);
239	return ret;
240}
241
242int wl1251_cmd_data_path_tx(struct wl1251 *wl, u8 channel, bool enable)
243{
244	struct cmd_enabledisable_path *cmd;
245	int ret;
246	u16 cmd_tx;
247
248	wl1251_debug(DEBUG_CMD, "cmd data path");
249
250	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
251	if (!cmd)
252		return -ENOMEM;
253
254	cmd->channel = channel;
255
256	if (enable)
257		cmd_tx = CMD_ENABLE_TX;
258	else
259		cmd_tx = CMD_DISABLE_TX;
260
261	ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
262	if (ret < 0)
263		wl1251_error("tx %s cmd for channel %d failed",
264			     enable ? "start" : "stop", channel);
265	else
266		wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
267			     enable ? "start" : "stop", channel);
268
269	kfree(cmd);
270	return ret;
271}
272
273int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,
274		    u16 beacon_interval, u8 dtim_interval)
275{
276	struct cmd_join *join;
277	int ret, i;
278	u8 *bssid;
279
280	join = kzalloc(sizeof(*join), GFP_KERNEL);
281	if (!join) {
282		ret = -ENOMEM;
283		goto out;
284	}
285
286	wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d",
287		     bss_type == BSS_TYPE_IBSS ? " ibss" : "",
288		     channel, beacon_interval, dtim_interval);
289
290	/* Reverse order BSSID */
291	bssid = (u8 *) &join->bssid_lsb;
292	for (i = 0; i < ETH_ALEN; i++)
293		bssid[i] = wl->bssid[ETH_ALEN - i - 1];
294
295	join->rx_config_options = wl->rx_config;
296	join->rx_filter_options = wl->rx_filter;
297
298	join->basic_rate_set = RATE_MASK_1MBPS | RATE_MASK_2MBPS |
299		RATE_MASK_5_5MBPS | RATE_MASK_11MBPS;
300
301	join->beacon_interval = beacon_interval;
302	join->dtim_interval = dtim_interval;
303	join->bss_type = bss_type;
304	join->channel = channel;
305	join->ctrl = JOIN_CMD_CTRL_TX_FLUSH;
306
307	ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
308	if (ret < 0) {
309		wl1251_error("failed to initiate cmd join");
310		goto out;
311	}
312
313out:
314	kfree(join);
315	return ret;
316}
317
318int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
319{
320	struct wl1251_cmd_ps_params *ps_params = NULL;
321	int ret = 0;
322
323	wl1251_debug(DEBUG_CMD, "cmd set ps mode");
324
325	ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
326	if (!ps_params) {
327		ret = -ENOMEM;
328		goto out;
329	}
330
331	ps_params->ps_mode = ps_mode;
332	ps_params->send_null_data = 1;
333	ps_params->retries = 5;
334	ps_params->hang_over_period = 128;
335	ps_params->null_data_rate = 1; /* 1 Mbps */
336
337	ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
338			      sizeof(*ps_params));
339	if (ret < 0) {
340		wl1251_error("cmd set_ps_mode failed");
341		goto out;
342	}
343
344out:
345	kfree(ps_params);
346	return ret;
347}
348
349int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
350			   size_t len)
351{
352	struct cmd_read_write_memory *cmd;
353	int ret = 0;
354
355	wl1251_debug(DEBUG_CMD, "cmd read memory");
356
357	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
358	if (!cmd) {
359		ret = -ENOMEM;
360		goto out;
361	}
362
363	WARN_ON(len > MAX_READ_SIZE);
364	len = min_t(size_t, len, MAX_READ_SIZE);
365
366	cmd->addr = addr;
367	cmd->size = len;
368
369	ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
370	if (ret < 0) {
371		wl1251_error("read memory command failed: %d", ret);
372		goto out;
373	}
374
375	/* the read command got in, we can now read the answer */
376	wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
377
378	if (cmd->header.status != CMD_STATUS_SUCCESS)
379		wl1251_error("error in read command result: %d",
380			     cmd->header.status);
381
382	memcpy(answer, cmd->value, len);
383
384out:
385	kfree(cmd);
386	return ret;
387}
388
389int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
390			    void *buf, size_t buf_len)
391{
392	struct wl1251_cmd_packet_template *cmd;
393	size_t cmd_len;
394	int ret = 0;
395
396	wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id);
397
398	WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
399	buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
400	cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4);
401
402	cmd = kzalloc(cmd_len, GFP_KERNEL);
403	if (!cmd) {
404		ret = -ENOMEM;
405		goto out;
406	}
407
408	cmd->size = cpu_to_le16(buf_len);
409
410	if (buf)
411		memcpy(cmd->data, buf, buf_len);
412
413	ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len);
414	if (ret < 0) {
415		wl1251_warning("cmd set_template failed: %d", ret);
416		goto out;
417	}
418
419out:
420	kfree(cmd);
421	return ret;
422}
423
424int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len,
425		    struct ieee80211_channel *channels[],
426		    unsigned int n_channels, unsigned int n_probes)
427{
428	struct wl1251_cmd_scan *cmd;
429	int i, ret = 0;
430
431	wl1251_debug(DEBUG_CMD, "cmd scan channels %d", n_channels);
432
433	WARN_ON(n_channels > SCAN_MAX_NUM_OF_CHANNELS);
434
435	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
436	if (!cmd)
437		return -ENOMEM;
438
439	cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
440	cmd->params.rx_filter_options = cpu_to_le32(CFG_RX_PRSP_EN |
441						    CFG_RX_MGMT_EN |
442						    CFG_RX_BCN_EN);
443	cmd->params.scan_options = 0;
444	/*
445	 * Use high priority scan when not associated to prevent fw issue
446	 * causing never-ending scans (sometimes 20+ minutes).
447	 * Note: This bug may be caused by the fw's DTIM handling.
448	 */
449	if (is_zero_ether_addr(wl->bssid))
450		cmd->params.scan_options |= cpu_to_le16(WL1251_SCAN_OPT_PRIORITY_HIGH);
451	cmd->params.num_channels = n_channels;
452	cmd->params.num_probe_requests = n_probes;
453	cmd->params.tx_rate = cpu_to_le16(1 << 1); /* 2 Mbps */
454	cmd->params.tid_trigger = 0;
455
456	for (i = 0; i < n_channels; i++) {
457		cmd->channels[i].min_duration =
458			cpu_to_le32(WL1251_SCAN_MIN_DURATION);
459		cmd->channels[i].max_duration =
460			cpu_to_le32(WL1251_SCAN_MAX_DURATION);
461		memset(&cmd->channels[i].bssid_lsb, 0xff, 4);
462		memset(&cmd->channels[i].bssid_msb, 0xff, 2);
463		cmd->channels[i].early_termination = 0;
464		cmd->channels[i].tx_power_att = 0;
465		cmd->channels[i].channel = channels[i]->hw_value;
466	}
467
468	cmd->params.ssid_len = ssid_len;
469	if (ssid)
470		memcpy(cmd->params.ssid, ssid, ssid_len);
471
472	ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd));
473	if (ret < 0) {
474		wl1251_error("cmd scan failed: %d", ret);
475		goto out;
476	}
477
478	wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
479
480	if (cmd->header.status != CMD_STATUS_SUCCESS) {
481		wl1251_error("cmd scan status wasn't success: %d",
482			     cmd->header.status);
483		ret = -EIO;
484		goto out;
485	}
486
487out:
488	kfree(cmd);
489	return ret;
490}
491
492int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout)
493{
494	struct wl1251_cmd_trigger_scan_to *cmd;
495	int ret;
496
497	wl1251_debug(DEBUG_CMD, "cmd trigger scan to");
498
499	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
500	if (!cmd)
501		return -ENOMEM;
502
503	cmd->timeout = timeout;
504
505	ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd));
506	if (ret < 0) {
507		wl1251_error("cmd trigger scan to failed: %d", ret);
508		goto out;
509	}
510
511out:
512	kfree(cmd);
513	return ret;
514}
515