diff options
author | Luciano Coelho <coelho@ti.com> | 2011-11-20 14:40:41 -0500 |
---|---|---|
committer | Luciano Coelho <coelho@ti.com> | 2012-04-12 01:43:55 -0400 |
commit | 90921014608d91a03766d0025fa32662dc7c5062 (patch) | |
tree | adba69dd7be20600cdec0cc856263dc2ca3bfdb1 /drivers/net/wireless/ti/wl1251/cmd.c | |
parent | 16f3eb530fb5e7eacbdaaf09c66edc273087a21d (diff) |
wireless/wl12xx/wl1251: move TI WLAN modules to a common ti subdirectory
Move wl12xx and wl1251 modules into a new drivers/net/wireless/ti
directory. Add a TI WLAN Kconfig option and Makefile to support this
change.
Signed-off-by: Luciano Coelho <coelho@ti.com>
Cc: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless/ti/wl1251/cmd.c')
-rw-r--r-- | drivers/net/wireless/ti/wl1251/cmd.c | 496 |
1 files changed, 496 insertions, 0 deletions
diff --git a/drivers/net/wireless/ti/wl1251/cmd.c b/drivers/net/wireless/ti/wl1251/cmd.c new file mode 100644 index 000000000000..d14d69d733a0 --- /dev/null +++ b/drivers/net/wireless/ti/wl1251/cmd.c | |||
@@ -0,0 +1,496 @@ | |||
1 | #include "cmd.h" | ||
2 | |||
3 | #include <linux/module.h> | ||
4 | #include <linux/slab.h> | ||
5 | #include <linux/crc7.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 | */ | ||
21 | int 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 | |||
56 | out: | ||
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 | */ | ||
68 | int 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 | */ | ||
109 | int 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 | |||
135 | out: | ||
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 | */ | ||
147 | int 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 | |||
168 | int 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 | |||
201 | out: | ||
202 | kfree(vbm); | ||
203 | return ret; | ||
204 | } | ||
205 | |||
206 | int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable) | ||
207 | { | ||
208 | struct cmd_enabledisable_path *cmd; | ||
209 | int ret; | ||
210 | u16 cmd_rx, cmd_tx; | ||
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 | cmd_tx = CMD_ENABLE_TX; | ||
225 | } else { | ||
226 | cmd_rx = CMD_DISABLE_RX; | ||
227 | cmd_tx = CMD_DISABLE_TX; | ||
228 | } | ||
229 | |||
230 | ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd)); | ||
231 | if (ret < 0) { | ||
232 | wl1251_error("rx %s cmd for channel %d failed", | ||
233 | enable ? "start" : "stop", channel); | ||
234 | goto out; | ||
235 | } | ||
236 | |||
237 | wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d", | ||
238 | enable ? "start" : "stop", channel); | ||
239 | |||
240 | ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd)); | ||
241 | if (ret < 0) { | ||
242 | wl1251_error("tx %s cmd for channel %d failed", | ||
243 | enable ? "start" : "stop", channel); | ||
244 | goto out; | ||
245 | } | ||
246 | |||
247 | wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d", | ||
248 | enable ? "start" : "stop", channel); | ||
249 | |||
250 | out: | ||
251 | kfree(cmd); | ||
252 | return ret; | ||
253 | } | ||
254 | |||
255 | int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel, | ||
256 | u16 beacon_interval, u8 dtim_interval) | ||
257 | { | ||
258 | struct cmd_join *join; | ||
259 | int ret, i; | ||
260 | u8 *bssid; | ||
261 | |||
262 | join = kzalloc(sizeof(*join), GFP_KERNEL); | ||
263 | if (!join) { | ||
264 | ret = -ENOMEM; | ||
265 | goto out; | ||
266 | } | ||
267 | |||
268 | wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d", | ||
269 | bss_type == BSS_TYPE_IBSS ? " ibss" : "", | ||
270 | channel, beacon_interval, dtim_interval); | ||
271 | |||
272 | /* Reverse order BSSID */ | ||
273 | bssid = (u8 *) &join->bssid_lsb; | ||
274 | for (i = 0; i < ETH_ALEN; i++) | ||
275 | bssid[i] = wl->bssid[ETH_ALEN - i - 1]; | ||
276 | |||
277 | join->rx_config_options = wl->rx_config; | ||
278 | join->rx_filter_options = wl->rx_filter; | ||
279 | |||
280 | /* | ||
281 | * FIXME: disable temporarily all filters because after commit | ||
282 | * 9cef8737 "mac80211: fix managed mode BSSID handling" broke | ||
283 | * association. The filter logic needs to be implemented properly | ||
284 | * and once that is done, this hack can be removed. | ||
285 | */ | ||
286 | join->rx_config_options = 0; | ||
287 | join->rx_filter_options = WL1251_DEFAULT_RX_FILTER; | ||
288 | |||
289 | join->basic_rate_set = RATE_MASK_1MBPS | RATE_MASK_2MBPS | | ||
290 | RATE_MASK_5_5MBPS | RATE_MASK_11MBPS; | ||
291 | |||
292 | join->beacon_interval = beacon_interval; | ||
293 | join->dtim_interval = dtim_interval; | ||
294 | join->bss_type = bss_type; | ||
295 | join->channel = channel; | ||
296 | join->ctrl = JOIN_CMD_CTRL_TX_FLUSH; | ||
297 | |||
298 | ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join)); | ||
299 | if (ret < 0) { | ||
300 | wl1251_error("failed to initiate cmd join"); | ||
301 | goto out; | ||
302 | } | ||
303 | |||
304 | out: | ||
305 | kfree(join); | ||
306 | return ret; | ||
307 | } | ||
308 | |||
309 | int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode) | ||
310 | { | ||
311 | struct wl1251_cmd_ps_params *ps_params = NULL; | ||
312 | int ret = 0; | ||
313 | |||
314 | wl1251_debug(DEBUG_CMD, "cmd set ps mode"); | ||
315 | |||
316 | ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL); | ||
317 | if (!ps_params) { | ||
318 | ret = -ENOMEM; | ||
319 | goto out; | ||
320 | } | ||
321 | |||
322 | ps_params->ps_mode = ps_mode; | ||
323 | ps_params->send_null_data = 1; | ||
324 | ps_params->retries = 5; | ||
325 | ps_params->hang_over_period = 128; | ||
326 | ps_params->null_data_rate = 1; /* 1 Mbps */ | ||
327 | |||
328 | ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params, | ||
329 | sizeof(*ps_params)); | ||
330 | if (ret < 0) { | ||
331 | wl1251_error("cmd set_ps_mode failed"); | ||
332 | goto out; | ||
333 | } | ||
334 | |||
335 | out: | ||
336 | kfree(ps_params); | ||
337 | return ret; | ||
338 | } | ||
339 | |||
340 | int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer, | ||
341 | size_t len) | ||
342 | { | ||
343 | struct cmd_read_write_memory *cmd; | ||
344 | int ret = 0; | ||
345 | |||
346 | wl1251_debug(DEBUG_CMD, "cmd read memory"); | ||
347 | |||
348 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | ||
349 | if (!cmd) { | ||
350 | ret = -ENOMEM; | ||
351 | goto out; | ||
352 | } | ||
353 | |||
354 | WARN_ON(len > MAX_READ_SIZE); | ||
355 | len = min_t(size_t, len, MAX_READ_SIZE); | ||
356 | |||
357 | cmd->addr = addr; | ||
358 | cmd->size = len; | ||
359 | |||
360 | ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd)); | ||
361 | if (ret < 0) { | ||
362 | wl1251_error("read memory command failed: %d", ret); | ||
363 | goto out; | ||
364 | } | ||
365 | |||
366 | /* the read command got in, we can now read the answer */ | ||
367 | wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd)); | ||
368 | |||
369 | if (cmd->header.status != CMD_STATUS_SUCCESS) | ||
370 | wl1251_error("error in read command result: %d", | ||
371 | cmd->header.status); | ||
372 | |||
373 | memcpy(answer, cmd->value, len); | ||
374 | |||
375 | out: | ||
376 | kfree(cmd); | ||
377 | return ret; | ||
378 | } | ||
379 | |||
380 | int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id, | ||
381 | void *buf, size_t buf_len) | ||
382 | { | ||
383 | struct wl1251_cmd_packet_template *cmd; | ||
384 | size_t cmd_len; | ||
385 | int ret = 0; | ||
386 | |||
387 | wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id); | ||
388 | |||
389 | WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE); | ||
390 | buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE); | ||
391 | cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4); | ||
392 | |||
393 | cmd = kzalloc(cmd_len, GFP_KERNEL); | ||
394 | if (!cmd) { | ||
395 | ret = -ENOMEM; | ||
396 | goto out; | ||
397 | } | ||
398 | |||
399 | cmd->size = cpu_to_le16(buf_len); | ||
400 | |||
401 | if (buf) | ||
402 | memcpy(cmd->data, buf, buf_len); | ||
403 | |||
404 | ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len); | ||
405 | if (ret < 0) { | ||
406 | wl1251_warning("cmd set_template failed: %d", ret); | ||
407 | goto out; | ||
408 | } | ||
409 | |||
410 | out: | ||
411 | kfree(cmd); | ||
412 | return ret; | ||
413 | } | ||
414 | |||
415 | int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len, | ||
416 | struct ieee80211_channel *channels[], | ||
417 | unsigned int n_channels, unsigned int n_probes) | ||
418 | { | ||
419 | struct wl1251_cmd_scan *cmd; | ||
420 | int i, ret = 0; | ||
421 | |||
422 | wl1251_debug(DEBUG_CMD, "cmd scan"); | ||
423 | |||
424 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | ||
425 | if (!cmd) | ||
426 | return -ENOMEM; | ||
427 | |||
428 | cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD); | ||
429 | cmd->params.rx_filter_options = cpu_to_le32(CFG_RX_PRSP_EN | | ||
430 | CFG_RX_MGMT_EN | | ||
431 | CFG_RX_BCN_EN); | ||
432 | cmd->params.scan_options = 0; | ||
433 | cmd->params.num_channels = n_channels; | ||
434 | cmd->params.num_probe_requests = n_probes; | ||
435 | cmd->params.tx_rate = cpu_to_le16(1 << 1); /* 2 Mbps */ | ||
436 | cmd->params.tid_trigger = 0; | ||
437 | |||
438 | for (i = 0; i < n_channels; i++) { | ||
439 | cmd->channels[i].min_duration = | ||
440 | cpu_to_le32(WL1251_SCAN_MIN_DURATION); | ||
441 | cmd->channels[i].max_duration = | ||
442 | cpu_to_le32(WL1251_SCAN_MAX_DURATION); | ||
443 | memset(&cmd->channels[i].bssid_lsb, 0xff, 4); | ||
444 | memset(&cmd->channels[i].bssid_msb, 0xff, 2); | ||
445 | cmd->channels[i].early_termination = 0; | ||
446 | cmd->channels[i].tx_power_att = 0; | ||
447 | cmd->channels[i].channel = channels[i]->hw_value; | ||
448 | } | ||
449 | |||
450 | cmd->params.ssid_len = ssid_len; | ||
451 | if (ssid) | ||
452 | memcpy(cmd->params.ssid, ssid, ssid_len); | ||
453 | |||
454 | ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd)); | ||
455 | if (ret < 0) { | ||
456 | wl1251_error("cmd scan failed: %d", ret); | ||
457 | goto out; | ||
458 | } | ||
459 | |||
460 | wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd)); | ||
461 | |||
462 | if (cmd->header.status != CMD_STATUS_SUCCESS) { | ||
463 | wl1251_error("cmd scan status wasn't success: %d", | ||
464 | cmd->header.status); | ||
465 | ret = -EIO; | ||
466 | goto out; | ||
467 | } | ||
468 | |||
469 | out: | ||
470 | kfree(cmd); | ||
471 | return ret; | ||
472 | } | ||
473 | |||
474 | int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout) | ||
475 | { | ||
476 | struct wl1251_cmd_trigger_scan_to *cmd; | ||
477 | int ret; | ||
478 | |||
479 | wl1251_debug(DEBUG_CMD, "cmd trigger scan to"); | ||
480 | |||
481 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | ||
482 | if (!cmd) | ||
483 | return -ENOMEM; | ||
484 | |||
485 | cmd->timeout = timeout; | ||
486 | |||
487 | ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd)); | ||
488 | if (ret < 0) { | ||
489 | wl1251_error("cmd trigger scan to failed: %d", ret); | ||
490 | goto out; | ||
491 | } | ||
492 | |||
493 | out: | ||
494 | kfree(cmd); | ||
495 | return ret; | ||
496 | } | ||