]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/net/wireless/st/cw1200/wsm.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'nfc-next-4.7-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo...
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / wireless / st / cw1200 / wsm.c
1 /*
2 * WSM host interface (HI) implementation for
3 * ST-Ericsson CW1200 mac80211 drivers.
4 *
5 * Copyright (c) 2010, ST-Ericsson
6 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/skbuff.h>
14 #include <linux/wait.h>
15 #include <linux/delay.h>
16 #include <linux/sched.h>
17 #include <linux/random.h>
18
19 #include "cw1200.h"
20 #include "wsm.h"
21 #include "bh.h"
22 #include "sta.h"
23 #include "debug.h"
24
25 #define WSM_CMD_TIMEOUT (2 * HZ) /* With respect to interrupt loss */
26 #define WSM_CMD_START_TIMEOUT (7 * HZ)
27 #define WSM_CMD_RESET_TIMEOUT (3 * HZ) /* 2 sec. timeout was observed. */
28 #define WSM_CMD_MAX_TIMEOUT (3 * HZ)
29
30 #define WSM_SKIP(buf, size) \
31 do { \
32 if ((buf)->data + size > (buf)->end) \
33 goto underflow; \
34 (buf)->data += size; \
35 } while (0)
36
37 #define WSM_GET(buf, ptr, size) \
38 do { \
39 if ((buf)->data + size > (buf)->end) \
40 goto underflow; \
41 memcpy(ptr, (buf)->data, size); \
42 (buf)->data += size; \
43 } while (0)
44
45 #define __WSM_GET(buf, type, type2, cvt) \
46 ({ \
47 type val; \
48 if ((buf)->data + sizeof(type) > (buf)->end) \
49 goto underflow; \
50 val = cvt(*(type2 *)(buf)->data); \
51 (buf)->data += sizeof(type); \
52 val; \
53 })
54
55 #define WSM_GET8(buf) __WSM_GET(buf, u8, u8, (u8))
56 #define WSM_GET16(buf) __WSM_GET(buf, u16, __le16, __le16_to_cpu)
57 #define WSM_GET32(buf) __WSM_GET(buf, u32, __le32, __le32_to_cpu)
58
59 #define WSM_PUT(buf, ptr, size) \
60 do { \
61 if ((buf)->data + size > (buf)->end) \
62 if (wsm_buf_reserve((buf), size)) \
63 goto nomem; \
64 memcpy((buf)->data, ptr, size); \
65 (buf)->data += size; \
66 } while (0)
67
68 #define __WSM_PUT(buf, val, type, type2, cvt) \
69 do { \
70 if ((buf)->data + sizeof(type) > (buf)->end) \
71 if (wsm_buf_reserve((buf), sizeof(type))) \
72 goto nomem; \
73 *(type2 *)(buf)->data = cvt(val); \
74 (buf)->data += sizeof(type); \
75 } while (0)
76
77 #define WSM_PUT8(buf, val) __WSM_PUT(buf, val, u8, u8, (u8))
78 #define WSM_PUT16(buf, val) __WSM_PUT(buf, val, u16, __le16, __cpu_to_le16)
79 #define WSM_PUT32(buf, val) __WSM_PUT(buf, val, u32, __le32, __cpu_to_le32)
80
81 static void wsm_buf_reset(struct wsm_buf *buf);
82 static int wsm_buf_reserve(struct wsm_buf *buf, size_t extra_size);
83
84 static int wsm_cmd_send(struct cw1200_common *priv,
85 struct wsm_buf *buf,
86 void *arg, u16 cmd, long tmo);
87
88 #define wsm_cmd_lock(__priv) mutex_lock(&((__priv)->wsm_cmd_mux))
89 #define wsm_cmd_unlock(__priv) mutex_unlock(&((__priv)->wsm_cmd_mux))
90
91 /* ******************************************************************** */
92 /* WSM API implementation */
93
94 static int wsm_generic_confirm(struct cw1200_common *priv,
95 void *arg,
96 struct wsm_buf *buf)
97 {
98 u32 status = WSM_GET32(buf);
99 if (status != WSM_STATUS_SUCCESS)
100 return -EINVAL;
101 return 0;
102
103 underflow:
104 WARN_ON(1);
105 return -EINVAL;
106 }
107
108 int wsm_configuration(struct cw1200_common *priv, struct wsm_configuration *arg)
109 {
110 int ret;
111 struct wsm_buf *buf = &priv->wsm_cmd_buf;
112
113 wsm_cmd_lock(priv);
114
115 WSM_PUT32(buf, arg->dot11MaxTransmitMsduLifeTime);
116 WSM_PUT32(buf, arg->dot11MaxReceiveLifeTime);
117 WSM_PUT32(buf, arg->dot11RtsThreshold);
118
119 /* DPD block. */
120 WSM_PUT16(buf, arg->dpdData_size + 12);
121 WSM_PUT16(buf, 1); /* DPD version */
122 WSM_PUT(buf, arg->dot11StationId, ETH_ALEN);
123 WSM_PUT16(buf, 5); /* DPD flags */
124 WSM_PUT(buf, arg->dpdData, arg->dpdData_size);
125
126 ret = wsm_cmd_send(priv, buf, arg,
127 WSM_CONFIGURATION_REQ_ID, WSM_CMD_TIMEOUT);
128
129 wsm_cmd_unlock(priv);
130 return ret;
131
132 nomem:
133 wsm_cmd_unlock(priv);
134 return -ENOMEM;
135 }
136
137 static int wsm_configuration_confirm(struct cw1200_common *priv,
138 struct wsm_configuration *arg,
139 struct wsm_buf *buf)
140 {
141 int i;
142 int status;
143
144 status = WSM_GET32(buf);
145 if (WARN_ON(status != WSM_STATUS_SUCCESS))
146 return -EINVAL;
147
148 WSM_GET(buf, arg->dot11StationId, ETH_ALEN);
149 arg->dot11FrequencyBandsSupported = WSM_GET8(buf);
150 WSM_SKIP(buf, 1);
151 arg->supportedRateMask = WSM_GET32(buf);
152 for (i = 0; i < 2; ++i) {
153 arg->txPowerRange[i].min_power_level = WSM_GET32(buf);
154 arg->txPowerRange[i].max_power_level = WSM_GET32(buf);
155 arg->txPowerRange[i].stepping = WSM_GET32(buf);
156 }
157 return 0;
158
159 underflow:
160 WARN_ON(1);
161 return -EINVAL;
162 }
163
164 /* ******************************************************************** */
165
166 int wsm_reset(struct cw1200_common *priv, const struct wsm_reset *arg)
167 {
168 int ret;
169 struct wsm_buf *buf = &priv->wsm_cmd_buf;
170 u16 cmd = WSM_RESET_REQ_ID | WSM_TX_LINK_ID(arg->link_id);
171
172 wsm_cmd_lock(priv);
173
174 WSM_PUT32(buf, arg->reset_statistics ? 0 : 1);
175 ret = wsm_cmd_send(priv, buf, NULL, cmd, WSM_CMD_RESET_TIMEOUT);
176 wsm_cmd_unlock(priv);
177 return ret;
178
179 nomem:
180 wsm_cmd_unlock(priv);
181 return -ENOMEM;
182 }
183
184 /* ******************************************************************** */
185
186 struct wsm_mib {
187 u16 mib_id;
188 void *buf;
189 size_t buf_size;
190 };
191
192 int wsm_read_mib(struct cw1200_common *priv, u16 mib_id, void *_buf,
193 size_t buf_size)
194 {
195 int ret;
196 struct wsm_buf *buf = &priv->wsm_cmd_buf;
197 struct wsm_mib mib_buf = {
198 .mib_id = mib_id,
199 .buf = _buf,
200 .buf_size = buf_size,
201 };
202 wsm_cmd_lock(priv);
203
204 WSM_PUT16(buf, mib_id);
205 WSM_PUT16(buf, 0);
206
207 ret = wsm_cmd_send(priv, buf, &mib_buf,
208 WSM_READ_MIB_REQ_ID, WSM_CMD_TIMEOUT);
209 wsm_cmd_unlock(priv);
210 return ret;
211
212 nomem:
213 wsm_cmd_unlock(priv);
214 return -ENOMEM;
215 }
216
217 static int wsm_read_mib_confirm(struct cw1200_common *priv,
218 struct wsm_mib *arg,
219 struct wsm_buf *buf)
220 {
221 u16 size;
222 if (WARN_ON(WSM_GET32(buf) != WSM_STATUS_SUCCESS))
223 return -EINVAL;
224
225 if (WARN_ON(WSM_GET16(buf) != arg->mib_id))
226 return -EINVAL;
227
228 size = WSM_GET16(buf);
229 if (size > arg->buf_size)
230 size = arg->buf_size;
231
232 WSM_GET(buf, arg->buf, size);
233 arg->buf_size = size;
234 return 0;
235
236 underflow:
237 WARN_ON(1);
238 return -EINVAL;
239 }
240
241 /* ******************************************************************** */
242
243 int wsm_write_mib(struct cw1200_common *priv, u16 mib_id, void *_buf,
244 size_t buf_size)
245 {
246 int ret;
247 struct wsm_buf *buf = &priv->wsm_cmd_buf;
248 struct wsm_mib mib_buf = {
249 .mib_id = mib_id,
250 .buf = _buf,
251 .buf_size = buf_size,
252 };
253
254 wsm_cmd_lock(priv);
255
256 WSM_PUT16(buf, mib_id);
257 WSM_PUT16(buf, buf_size);
258 WSM_PUT(buf, _buf, buf_size);
259
260 ret = wsm_cmd_send(priv, buf, &mib_buf,
261 WSM_WRITE_MIB_REQ_ID, WSM_CMD_TIMEOUT);
262 wsm_cmd_unlock(priv);
263 return ret;
264
265 nomem:
266 wsm_cmd_unlock(priv);
267 return -ENOMEM;
268 }
269
270 static int wsm_write_mib_confirm(struct cw1200_common *priv,
271 struct wsm_mib *arg,
272 struct wsm_buf *buf)
273 {
274 int ret;
275
276 ret = wsm_generic_confirm(priv, arg, buf);
277 if (ret)
278 return ret;
279
280 if (arg->mib_id == WSM_MIB_ID_OPERATIONAL_POWER_MODE) {
281 /* OperationalMode: update PM status. */
282 const char *p = arg->buf;
283 cw1200_enable_powersave(priv, (p[0] & 0x0F) ? true : false);
284 }
285 return 0;
286 }
287
288 /* ******************************************************************** */
289
290 int wsm_scan(struct cw1200_common *priv, const struct wsm_scan *arg)
291 {
292 int i;
293 int ret;
294 struct wsm_buf *buf = &priv->wsm_cmd_buf;
295
296 if (arg->num_channels > 48)
297 return -EINVAL;
298
299 if (arg->num_ssids > 2)
300 return -EINVAL;
301
302 if (arg->band > 1)
303 return -EINVAL;
304
305 wsm_cmd_lock(priv);
306
307 WSM_PUT8(buf, arg->band);
308 WSM_PUT8(buf, arg->type);
309 WSM_PUT8(buf, arg->flags);
310 WSM_PUT8(buf, arg->max_tx_rate);
311 WSM_PUT32(buf, arg->auto_scan_interval);
312 WSM_PUT8(buf, arg->num_probes);
313 WSM_PUT8(buf, arg->num_channels);
314 WSM_PUT8(buf, arg->num_ssids);
315 WSM_PUT8(buf, arg->probe_delay);
316
317 for (i = 0; i < arg->num_channels; ++i) {
318 WSM_PUT16(buf, arg->ch[i].number);
319 WSM_PUT16(buf, 0);
320 WSM_PUT32(buf, arg->ch[i].min_chan_time);
321 WSM_PUT32(buf, arg->ch[i].max_chan_time);
322 WSM_PUT32(buf, 0);
323 }
324
325 for (i = 0; i < arg->num_ssids; ++i) {
326 WSM_PUT32(buf, arg->ssids[i].length);
327 WSM_PUT(buf, &arg->ssids[i].ssid[0],
328 sizeof(arg->ssids[i].ssid));
329 }
330
331 ret = wsm_cmd_send(priv, buf, NULL,
332 WSM_START_SCAN_REQ_ID, WSM_CMD_TIMEOUT);
333 wsm_cmd_unlock(priv);
334 return ret;
335
336 nomem:
337 wsm_cmd_unlock(priv);
338 return -ENOMEM;
339 }
340
341 /* ******************************************************************** */
342
343 int wsm_stop_scan(struct cw1200_common *priv)
344 {
345 int ret;
346 struct wsm_buf *buf = &priv->wsm_cmd_buf;
347 wsm_cmd_lock(priv);
348 ret = wsm_cmd_send(priv, buf, NULL,
349 WSM_STOP_SCAN_REQ_ID, WSM_CMD_TIMEOUT);
350 wsm_cmd_unlock(priv);
351 return ret;
352 }
353
354
355 static int wsm_tx_confirm(struct cw1200_common *priv,
356 struct wsm_buf *buf,
357 int link_id)
358 {
359 struct wsm_tx_confirm tx_confirm;
360
361 tx_confirm.packet_id = WSM_GET32(buf);
362 tx_confirm.status = WSM_GET32(buf);
363 tx_confirm.tx_rate = WSM_GET8(buf);
364 tx_confirm.ack_failures = WSM_GET8(buf);
365 tx_confirm.flags = WSM_GET16(buf);
366 tx_confirm.media_delay = WSM_GET32(buf);
367 tx_confirm.tx_queue_delay = WSM_GET32(buf);
368
369 cw1200_tx_confirm_cb(priv, link_id, &tx_confirm);
370 return 0;
371
372 underflow:
373 WARN_ON(1);
374 return -EINVAL;
375 }
376
377 static int wsm_multi_tx_confirm(struct cw1200_common *priv,
378 struct wsm_buf *buf, int link_id)
379 {
380 int ret;
381 int count;
382 int i;
383
384 count = WSM_GET32(buf);
385 if (WARN_ON(count <= 0))
386 return -EINVAL;
387
388 if (count > 1) {
389 /* We already released one buffer, now for the rest */
390 ret = wsm_release_tx_buffer(priv, count - 1);
391 if (ret < 0)
392 return ret;
393 else if (ret > 0)
394 cw1200_bh_wakeup(priv);
395 }
396
397 cw1200_debug_txed_multi(priv, count);
398 for (i = 0; i < count; ++i) {
399 ret = wsm_tx_confirm(priv, buf, link_id);
400 if (ret)
401 return ret;
402 }
403 return ret;
404
405 underflow:
406 WARN_ON(1);
407 return -EINVAL;
408 }
409
410 /* ******************************************************************** */
411
412 static int wsm_join_confirm(struct cw1200_common *priv,
413 struct wsm_join_cnf *arg,
414 struct wsm_buf *buf)
415 {
416 arg->status = WSM_GET32(buf);
417 if (WARN_ON(arg->status) != WSM_STATUS_SUCCESS)
418 return -EINVAL;
419
420 arg->min_power_level = WSM_GET32(buf);
421 arg->max_power_level = WSM_GET32(buf);
422
423 return 0;
424
425 underflow:
426 WARN_ON(1);
427 return -EINVAL;
428 }
429
430 int wsm_join(struct cw1200_common *priv, struct wsm_join *arg)
431 {
432 int ret;
433 struct wsm_buf *buf = &priv->wsm_cmd_buf;
434 struct wsm_join_cnf resp;
435 wsm_cmd_lock(priv);
436
437 WSM_PUT8(buf, arg->mode);
438 WSM_PUT8(buf, arg->band);
439 WSM_PUT16(buf, arg->channel_number);
440 WSM_PUT(buf, &arg->bssid[0], sizeof(arg->bssid));
441 WSM_PUT16(buf, arg->atim_window);
442 WSM_PUT8(buf, arg->preamble_type);
443 WSM_PUT8(buf, arg->probe_for_join);
444 WSM_PUT8(buf, arg->dtim_period);
445 WSM_PUT8(buf, arg->flags);
446 WSM_PUT32(buf, arg->ssid_len);
447 WSM_PUT(buf, &arg->ssid[0], sizeof(arg->ssid));
448 WSM_PUT32(buf, arg->beacon_interval);
449 WSM_PUT32(buf, arg->basic_rate_set);
450
451 priv->tx_burst_idx = -1;
452 ret = wsm_cmd_send(priv, buf, &resp,
453 WSM_JOIN_REQ_ID, WSM_CMD_TIMEOUT);
454 /* TODO: Update state based on resp.min|max_power_level */
455
456 priv->join_complete_status = resp.status;
457
458 wsm_cmd_unlock(priv);
459 return ret;
460
461 nomem:
462 wsm_cmd_unlock(priv);
463 return -ENOMEM;
464 }
465
466 /* ******************************************************************** */
467
468 int wsm_set_bss_params(struct cw1200_common *priv,
469 const struct wsm_set_bss_params *arg)
470 {
471 int ret;
472 struct wsm_buf *buf = &priv->wsm_cmd_buf;
473
474 wsm_cmd_lock(priv);
475
476 WSM_PUT8(buf, (arg->reset_beacon_loss ? 0x1 : 0));
477 WSM_PUT8(buf, arg->beacon_lost_count);
478 WSM_PUT16(buf, arg->aid);
479 WSM_PUT32(buf, arg->operational_rate_set);
480
481 ret = wsm_cmd_send(priv, buf, NULL,
482 WSM_SET_BSS_PARAMS_REQ_ID, WSM_CMD_TIMEOUT);
483
484 wsm_cmd_unlock(priv);
485 return ret;
486
487 nomem:
488 wsm_cmd_unlock(priv);
489 return -ENOMEM;
490 }
491
492 /* ******************************************************************** */
493
494 int wsm_add_key(struct cw1200_common *priv, const struct wsm_add_key *arg)
495 {
496 int ret;
497 struct wsm_buf *buf = &priv->wsm_cmd_buf;
498
499 wsm_cmd_lock(priv);
500
501 WSM_PUT(buf, arg, sizeof(*arg));
502
503 ret = wsm_cmd_send(priv, buf, NULL,
504 WSM_ADD_KEY_REQ_ID, WSM_CMD_TIMEOUT);
505
506 wsm_cmd_unlock(priv);
507 return ret;
508
509 nomem:
510 wsm_cmd_unlock(priv);
511 return -ENOMEM;
512 }
513
514 /* ******************************************************************** */
515
516 int wsm_remove_key(struct cw1200_common *priv, const struct wsm_remove_key *arg)
517 {
518 int ret;
519 struct wsm_buf *buf = &priv->wsm_cmd_buf;
520
521 wsm_cmd_lock(priv);
522
523 WSM_PUT8(buf, arg->index);
524 WSM_PUT8(buf, 0);
525 WSM_PUT16(buf, 0);
526
527 ret = wsm_cmd_send(priv, buf, NULL,
528 WSM_REMOVE_KEY_REQ_ID, WSM_CMD_TIMEOUT);
529
530 wsm_cmd_unlock(priv);
531 return ret;
532
533 nomem:
534 wsm_cmd_unlock(priv);
535 return -ENOMEM;
536 }
537
538 /* ******************************************************************** */
539
540 int wsm_set_tx_queue_params(struct cw1200_common *priv,
541 const struct wsm_set_tx_queue_params *arg, u8 id)
542 {
543 int ret;
544 struct wsm_buf *buf = &priv->wsm_cmd_buf;
545 u8 queue_id_to_wmm_aci[] = {3, 2, 0, 1};
546
547 wsm_cmd_lock(priv);
548
549 WSM_PUT8(buf, queue_id_to_wmm_aci[id]);
550 WSM_PUT8(buf, 0);
551 WSM_PUT8(buf, arg->ackPolicy);
552 WSM_PUT8(buf, 0);
553 WSM_PUT32(buf, arg->maxTransmitLifetime);
554 WSM_PUT16(buf, arg->allowedMediumTime);
555 WSM_PUT16(buf, 0);
556
557 ret = wsm_cmd_send(priv, buf, NULL, 0x0012, WSM_CMD_TIMEOUT);
558
559 wsm_cmd_unlock(priv);
560 return ret;
561
562 nomem:
563 wsm_cmd_unlock(priv);
564 return -ENOMEM;
565 }
566
567 /* ******************************************************************** */
568
569 int wsm_set_edca_params(struct cw1200_common *priv,
570 const struct wsm_edca_params *arg)
571 {
572 int ret;
573 struct wsm_buf *buf = &priv->wsm_cmd_buf;
574
575 wsm_cmd_lock(priv);
576
577 /* Implemented according to specification. */
578
579 WSM_PUT16(buf, arg->params[3].cwmin);
580 WSM_PUT16(buf, arg->params[2].cwmin);
581 WSM_PUT16(buf, arg->params[1].cwmin);
582 WSM_PUT16(buf, arg->params[0].cwmin);
583
584 WSM_PUT16(buf, arg->params[3].cwmax);
585 WSM_PUT16(buf, arg->params[2].cwmax);
586 WSM_PUT16(buf, arg->params[1].cwmax);
587 WSM_PUT16(buf, arg->params[0].cwmax);
588
589 WSM_PUT8(buf, arg->params[3].aifns);
590 WSM_PUT8(buf, arg->params[2].aifns);
591 WSM_PUT8(buf, arg->params[1].aifns);
592 WSM_PUT8(buf, arg->params[0].aifns);
593
594 WSM_PUT16(buf, arg->params[3].txop_limit);
595 WSM_PUT16(buf, arg->params[2].txop_limit);
596 WSM_PUT16(buf, arg->params[1].txop_limit);
597 WSM_PUT16(buf, arg->params[0].txop_limit);
598
599 WSM_PUT32(buf, arg->params[3].max_rx_lifetime);
600 WSM_PUT32(buf, arg->params[2].max_rx_lifetime);
601 WSM_PUT32(buf, arg->params[1].max_rx_lifetime);
602 WSM_PUT32(buf, arg->params[0].max_rx_lifetime);
603
604 ret = wsm_cmd_send(priv, buf, NULL,
605 WSM_EDCA_PARAMS_REQ_ID, WSM_CMD_TIMEOUT);
606 wsm_cmd_unlock(priv);
607 return ret;
608
609 nomem:
610 wsm_cmd_unlock(priv);
611 return -ENOMEM;
612 }
613
614 /* ******************************************************************** */
615
616 int wsm_switch_channel(struct cw1200_common *priv,
617 const struct wsm_switch_channel *arg)
618 {
619 int ret;
620 struct wsm_buf *buf = &priv->wsm_cmd_buf;
621
622 wsm_cmd_lock(priv);
623
624 WSM_PUT8(buf, arg->mode);
625 WSM_PUT8(buf, arg->switch_count);
626 WSM_PUT16(buf, arg->channel_number);
627
628 priv->channel_switch_in_progress = 1;
629
630 ret = wsm_cmd_send(priv, buf, NULL,
631 WSM_SWITCH_CHANNEL_REQ_ID, WSM_CMD_TIMEOUT);
632 if (ret)
633 priv->channel_switch_in_progress = 0;
634
635 wsm_cmd_unlock(priv);
636 return ret;
637
638 nomem:
639 wsm_cmd_unlock(priv);
640 return -ENOMEM;
641 }
642
643 /* ******************************************************************** */
644
645 int wsm_set_pm(struct cw1200_common *priv, const struct wsm_set_pm *arg)
646 {
647 int ret;
648 struct wsm_buf *buf = &priv->wsm_cmd_buf;
649 priv->ps_mode_switch_in_progress = 1;
650
651 wsm_cmd_lock(priv);
652
653 WSM_PUT8(buf, arg->mode);
654 WSM_PUT8(buf, arg->fast_psm_idle_period);
655 WSM_PUT8(buf, arg->ap_psm_change_period);
656 WSM_PUT8(buf, arg->min_auto_pspoll_period);
657
658 ret = wsm_cmd_send(priv, buf, NULL,
659 WSM_SET_PM_REQ_ID, WSM_CMD_TIMEOUT);
660
661 wsm_cmd_unlock(priv);
662 return ret;
663
664 nomem:
665 wsm_cmd_unlock(priv);
666 return -ENOMEM;
667 }
668
669 /* ******************************************************************** */
670
671 int wsm_start(struct cw1200_common *priv, const struct wsm_start *arg)
672 {
673 int ret;
674 struct wsm_buf *buf = &priv->wsm_cmd_buf;
675
676 wsm_cmd_lock(priv);
677
678 WSM_PUT8(buf, arg->mode);
679 WSM_PUT8(buf, arg->band);
680 WSM_PUT16(buf, arg->channel_number);
681 WSM_PUT32(buf, arg->ct_window);
682 WSM_PUT32(buf, arg->beacon_interval);
683 WSM_PUT8(buf, arg->dtim_period);
684 WSM_PUT8(buf, arg->preamble);
685 WSM_PUT8(buf, arg->probe_delay);
686 WSM_PUT8(buf, arg->ssid_len);
687 WSM_PUT(buf, arg->ssid, sizeof(arg->ssid));
688 WSM_PUT32(buf, arg->basic_rate_set);
689
690 priv->tx_burst_idx = -1;
691 ret = wsm_cmd_send(priv, buf, NULL,
692 WSM_START_REQ_ID, WSM_CMD_START_TIMEOUT);
693
694 wsm_cmd_unlock(priv);
695 return ret;
696
697 nomem:
698 wsm_cmd_unlock(priv);
699 return -ENOMEM;
700 }
701
702 /* ******************************************************************** */
703
704 int wsm_beacon_transmit(struct cw1200_common *priv,
705 const struct wsm_beacon_transmit *arg)
706 {
707 int ret;
708 struct wsm_buf *buf = &priv->wsm_cmd_buf;
709
710 wsm_cmd_lock(priv);
711
712 WSM_PUT32(buf, arg->enable_beaconing ? 1 : 0);
713
714 ret = wsm_cmd_send(priv, buf, NULL,
715 WSM_BEACON_TRANSMIT_REQ_ID, WSM_CMD_TIMEOUT);
716
717 wsm_cmd_unlock(priv);
718 return ret;
719
720 nomem:
721 wsm_cmd_unlock(priv);
722 return -ENOMEM;
723 }
724
725 /* ******************************************************************** */
726
727 int wsm_start_find(struct cw1200_common *priv)
728 {
729 int ret;
730 struct wsm_buf *buf = &priv->wsm_cmd_buf;
731
732 wsm_cmd_lock(priv);
733 ret = wsm_cmd_send(priv, buf, NULL, 0x0019, WSM_CMD_TIMEOUT);
734 wsm_cmd_unlock(priv);
735 return ret;
736 }
737
738 /* ******************************************************************** */
739
740 int wsm_stop_find(struct cw1200_common *priv)
741 {
742 int ret;
743 struct wsm_buf *buf = &priv->wsm_cmd_buf;
744
745 wsm_cmd_lock(priv);
746 ret = wsm_cmd_send(priv, buf, NULL, 0x001A, WSM_CMD_TIMEOUT);
747 wsm_cmd_unlock(priv);
748 return ret;
749 }
750
751 /* ******************************************************************** */
752
753 int wsm_map_link(struct cw1200_common *priv, const struct wsm_map_link *arg)
754 {
755 int ret;
756 struct wsm_buf *buf = &priv->wsm_cmd_buf;
757 u16 cmd = 0x001C | WSM_TX_LINK_ID(arg->link_id);
758
759 wsm_cmd_lock(priv);
760
761 WSM_PUT(buf, &arg->mac_addr[0], sizeof(arg->mac_addr));
762 WSM_PUT16(buf, 0);
763
764 ret = wsm_cmd_send(priv, buf, NULL, cmd, WSM_CMD_TIMEOUT);
765
766 wsm_cmd_unlock(priv);
767 return ret;
768
769 nomem:
770 wsm_cmd_unlock(priv);
771 return -ENOMEM;
772 }
773
774 /* ******************************************************************** */
775
776 int wsm_update_ie(struct cw1200_common *priv,
777 const struct wsm_update_ie *arg)
778 {
779 int ret;
780 struct wsm_buf *buf = &priv->wsm_cmd_buf;
781
782 wsm_cmd_lock(priv);
783
784 WSM_PUT16(buf, arg->what);
785 WSM_PUT16(buf, arg->count);
786 WSM_PUT(buf, arg->ies, arg->length);
787
788 ret = wsm_cmd_send(priv, buf, NULL, 0x001B, WSM_CMD_TIMEOUT);
789
790 wsm_cmd_unlock(priv);
791 return ret;
792
793 nomem:
794 wsm_cmd_unlock(priv);
795 return -ENOMEM;
796 }
797
798 /* ******************************************************************** */
799 int wsm_set_probe_responder(struct cw1200_common *priv, bool enable)
800 {
801 priv->rx_filter.probeResponder = enable;
802 return wsm_set_rx_filter(priv, &priv->rx_filter);
803 }
804
805 /* ******************************************************************** */
806 /* WSM indication events implementation */
807 const char * const cw1200_fw_types[] = {
808 "ETF",
809 "WFM",
810 "WSM",
811 "HI test",
812 "Platform test"
813 };
814
815 static int wsm_startup_indication(struct cw1200_common *priv,
816 struct wsm_buf *buf)
817 {
818 priv->wsm_caps.input_buffers = WSM_GET16(buf);
819 priv->wsm_caps.input_buffer_size = WSM_GET16(buf);
820 priv->wsm_caps.hw_id = WSM_GET16(buf);
821 priv->wsm_caps.hw_subid = WSM_GET16(buf);
822 priv->wsm_caps.status = WSM_GET16(buf);
823 priv->wsm_caps.fw_cap = WSM_GET16(buf);
824 priv->wsm_caps.fw_type = WSM_GET16(buf);
825 priv->wsm_caps.fw_api = WSM_GET16(buf);
826 priv->wsm_caps.fw_build = WSM_GET16(buf);
827 priv->wsm_caps.fw_ver = WSM_GET16(buf);
828 WSM_GET(buf, priv->wsm_caps.fw_label, sizeof(priv->wsm_caps.fw_label));
829 priv->wsm_caps.fw_label[sizeof(priv->wsm_caps.fw_label) - 1] = 0; /* Do not trust FW too much... */
830
831 if (WARN_ON(priv->wsm_caps.status))
832 return -EINVAL;
833
834 if (WARN_ON(priv->wsm_caps.fw_type > 4))
835 return -EINVAL;
836
837 pr_info("CW1200 WSM init done.\n"
838 " Input buffers: %d x %d bytes\n"
839 " Hardware: %d.%d\n"
840 " %s firmware [%s], ver: %d, build: %d,"
841 " api: %d, cap: 0x%.4X\n",
842 priv->wsm_caps.input_buffers,
843 priv->wsm_caps.input_buffer_size,
844 priv->wsm_caps.hw_id, priv->wsm_caps.hw_subid,
845 cw1200_fw_types[priv->wsm_caps.fw_type],
846 priv->wsm_caps.fw_label, priv->wsm_caps.fw_ver,
847 priv->wsm_caps.fw_build,
848 priv->wsm_caps.fw_api, priv->wsm_caps.fw_cap);
849
850 /* Disable unsupported frequency bands */
851 if (!(priv->wsm_caps.fw_cap & 0x1))
852 priv->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
853 if (!(priv->wsm_caps.fw_cap & 0x2))
854 priv->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
855
856 priv->firmware_ready = 1;
857 wake_up(&priv->wsm_startup_done);
858 return 0;
859
860 underflow:
861 WARN_ON(1);
862 return -EINVAL;
863 }
864
865 static int wsm_receive_indication(struct cw1200_common *priv,
866 int link_id,
867 struct wsm_buf *buf,
868 struct sk_buff **skb_p)
869 {
870 struct wsm_rx rx;
871 struct ieee80211_hdr *hdr;
872 size_t hdr_len;
873 __le16 fctl;
874
875 rx.status = WSM_GET32(buf);
876 rx.channel_number = WSM_GET16(buf);
877 rx.rx_rate = WSM_GET8(buf);
878 rx.rcpi_rssi = WSM_GET8(buf);
879 rx.flags = WSM_GET32(buf);
880
881 /* FW Workaround: Drop probe resp or
882 beacon when RSSI is 0
883 */
884 hdr = (struct ieee80211_hdr *)(*skb_p)->data;
885
886 if (!rx.rcpi_rssi &&
887 (ieee80211_is_probe_resp(hdr->frame_control) ||
888 ieee80211_is_beacon(hdr->frame_control)))
889 return 0;
890
891 /* If no RSSI subscription has been made,
892 * convert RCPI to RSSI here
893 */
894 if (!priv->cqm_use_rssi)
895 rx.rcpi_rssi = rx.rcpi_rssi / 2 - 110;
896
897 fctl = *(__le16 *)buf->data;
898 hdr_len = buf->data - buf->begin;
899 skb_pull(*skb_p, hdr_len);
900 if (!rx.status && ieee80211_is_deauth(fctl)) {
901 if (priv->join_status == CW1200_JOIN_STATUS_STA) {
902 /* Shedule unjoin work */
903 pr_debug("[WSM] Issue unjoin command (RX).\n");
904 wsm_lock_tx_async(priv);
905 if (queue_work(priv->workqueue,
906 &priv->unjoin_work) <= 0)
907 wsm_unlock_tx(priv);
908 }
909 }
910 cw1200_rx_cb(priv, &rx, link_id, skb_p);
911 if (*skb_p)
912 skb_push(*skb_p, hdr_len);
913
914 return 0;
915
916 underflow:
917 return -EINVAL;
918 }
919
920 static int wsm_event_indication(struct cw1200_common *priv, struct wsm_buf *buf)
921 {
922 int first;
923 struct cw1200_wsm_event *event;
924
925 if (priv->mode == NL80211_IFTYPE_UNSPECIFIED) {
926 /* STA is stopped. */
927 return 0;
928 }
929
930 event = kzalloc(sizeof(struct cw1200_wsm_event), GFP_KERNEL);
931 if (!event)
932 return -ENOMEM;
933
934 event->evt.id = WSM_GET32(buf);
935 event->evt.data = WSM_GET32(buf);
936
937 pr_debug("[WSM] Event: %d(%d)\n",
938 event->evt.id, event->evt.data);
939
940 spin_lock(&priv->event_queue_lock);
941 first = list_empty(&priv->event_queue);
942 list_add_tail(&event->link, &priv->event_queue);
943 spin_unlock(&priv->event_queue_lock);
944
945 if (first)
946 queue_work(priv->workqueue, &priv->event_handler);
947
948 return 0;
949
950 underflow:
951 kfree(event);
952 return -EINVAL;
953 }
954
955 static int wsm_channel_switch_indication(struct cw1200_common *priv,
956 struct wsm_buf *buf)
957 {
958 WARN_ON(WSM_GET32(buf));
959
960 priv->channel_switch_in_progress = 0;
961 wake_up(&priv->channel_switch_done);
962
963 wsm_unlock_tx(priv);
964
965 return 0;
966
967 underflow:
968 return -EINVAL;
969 }
970
971 static int wsm_set_pm_indication(struct cw1200_common *priv,
972 struct wsm_buf *buf)
973 {
974 /* TODO: Check buf (struct wsm_set_pm_complete) for validity */
975 if (priv->ps_mode_switch_in_progress) {
976 priv->ps_mode_switch_in_progress = 0;
977 wake_up(&priv->ps_mode_switch_done);
978 }
979 return 0;
980 }
981
982 static int wsm_scan_started(struct cw1200_common *priv, void *arg,
983 struct wsm_buf *buf)
984 {
985 u32 status = WSM_GET32(buf);
986 if (status != WSM_STATUS_SUCCESS) {
987 cw1200_scan_failed_cb(priv);
988 return -EINVAL;
989 }
990 return 0;
991
992 underflow:
993 WARN_ON(1);
994 return -EINVAL;
995 }
996
997 static int wsm_scan_complete_indication(struct cw1200_common *priv,
998 struct wsm_buf *buf)
999 {
1000 struct wsm_scan_complete arg;
1001 arg.status = WSM_GET32(buf);
1002 arg.psm = WSM_GET8(buf);
1003 arg.num_channels = WSM_GET8(buf);
1004 cw1200_scan_complete_cb(priv, &arg);
1005
1006 return 0;
1007
1008 underflow:
1009 return -EINVAL;
1010 }
1011
1012 static int wsm_join_complete_indication(struct cw1200_common *priv,
1013 struct wsm_buf *buf)
1014 {
1015 struct wsm_join_complete arg;
1016 arg.status = WSM_GET32(buf);
1017 pr_debug("[WSM] Join complete indication, status: %d\n", arg.status);
1018 cw1200_join_complete_cb(priv, &arg);
1019
1020 return 0;
1021
1022 underflow:
1023 return -EINVAL;
1024 }
1025
1026 static int wsm_find_complete_indication(struct cw1200_common *priv,
1027 struct wsm_buf *buf)
1028 {
1029 pr_warn("Implement find_complete_indication\n");
1030 return 0;
1031 }
1032
1033 static int wsm_ba_timeout_indication(struct cw1200_common *priv,
1034 struct wsm_buf *buf)
1035 {
1036 u32 dummy;
1037 u8 tid;
1038 u8 dummy2;
1039 u8 addr[ETH_ALEN];
1040
1041 dummy = WSM_GET32(buf);
1042 tid = WSM_GET8(buf);
1043 dummy2 = WSM_GET8(buf);
1044 WSM_GET(buf, addr, ETH_ALEN);
1045
1046 pr_info("BlockACK timeout, tid %d, addr %pM\n",
1047 tid, addr);
1048
1049 return 0;
1050
1051 underflow:
1052 return -EINVAL;
1053 }
1054
1055 static int wsm_suspend_resume_indication(struct cw1200_common *priv,
1056 int link_id, struct wsm_buf *buf)
1057 {
1058 u32 flags;
1059 struct wsm_suspend_resume arg;
1060
1061 flags = WSM_GET32(buf);
1062 arg.link_id = link_id;
1063 arg.stop = !(flags & 1);
1064 arg.multicast = !!(flags & 8);
1065 arg.queue = (flags >> 1) & 3;
1066
1067 cw1200_suspend_resume(priv, &arg);
1068
1069 return 0;
1070
1071 underflow:
1072 return -EINVAL;
1073 }
1074
1075
1076 /* ******************************************************************** */
1077 /* WSM TX */
1078
1079 static int wsm_cmd_send(struct cw1200_common *priv,
1080 struct wsm_buf *buf,
1081 void *arg, u16 cmd, long tmo)
1082 {
1083 size_t buf_len = buf->data - buf->begin;
1084 int ret;
1085
1086 /* Don't bother if we're dead. */
1087 if (priv->bh_error) {
1088 ret = 0;
1089 goto done;
1090 }
1091
1092 /* Block until the cmd buffer is completed. Tortuous. */
1093 spin_lock(&priv->wsm_cmd.lock);
1094 while (!priv->wsm_cmd.done) {
1095 spin_unlock(&priv->wsm_cmd.lock);
1096 spin_lock(&priv->wsm_cmd.lock);
1097 }
1098 priv->wsm_cmd.done = 0;
1099 spin_unlock(&priv->wsm_cmd.lock);
1100
1101 if (cmd == WSM_WRITE_MIB_REQ_ID ||
1102 cmd == WSM_READ_MIB_REQ_ID)
1103 pr_debug("[WSM] >>> 0x%.4X [MIB: 0x%.4X] (%zu)\n",
1104 cmd, __le16_to_cpu(((__le16 *)buf->begin)[2]),
1105 buf_len);
1106 else
1107 pr_debug("[WSM] >>> 0x%.4X (%zu)\n", cmd, buf_len);
1108
1109 /* Due to buggy SPI on CW1200, we need to
1110 * pad the message by a few bytes to ensure
1111 * that it's completely received.
1112 */
1113 buf_len += 4;
1114
1115 /* Fill HI message header */
1116 /* BH will add sequence number */
1117 ((__le16 *)buf->begin)[0] = __cpu_to_le16(buf_len);
1118 ((__le16 *)buf->begin)[1] = __cpu_to_le16(cmd);
1119
1120 spin_lock(&priv->wsm_cmd.lock);
1121 BUG_ON(priv->wsm_cmd.ptr);
1122 priv->wsm_cmd.ptr = buf->begin;
1123 priv->wsm_cmd.len = buf_len;
1124 priv->wsm_cmd.arg = arg;
1125 priv->wsm_cmd.cmd = cmd;
1126 spin_unlock(&priv->wsm_cmd.lock);
1127
1128 cw1200_bh_wakeup(priv);
1129
1130 /* Wait for command completion */
1131 ret = wait_event_timeout(priv->wsm_cmd_wq,
1132 priv->wsm_cmd.done, tmo);
1133
1134 if (!ret && !priv->wsm_cmd.done) {
1135 spin_lock(&priv->wsm_cmd.lock);
1136 priv->wsm_cmd.done = 1;
1137 priv->wsm_cmd.ptr = NULL;
1138 spin_unlock(&priv->wsm_cmd.lock);
1139 if (priv->bh_error) {
1140 /* Return ok to help system cleanup */
1141 ret = 0;
1142 } else {
1143 pr_err("CMD req (0x%04x) stuck in firmware, killing BH\n", priv->wsm_cmd.cmd);
1144 print_hex_dump_bytes("REQDUMP: ", DUMP_PREFIX_NONE,
1145 buf->begin, buf_len);
1146 pr_err("Outstanding outgoing frames: %d\n", priv->hw_bufs_used);
1147
1148 /* Kill BH thread to report the error to the top layer. */
1149 atomic_add(1, &priv->bh_term);
1150 wake_up(&priv->bh_wq);
1151 ret = -ETIMEDOUT;
1152 }
1153 } else {
1154 spin_lock(&priv->wsm_cmd.lock);
1155 BUG_ON(!priv->wsm_cmd.done);
1156 ret = priv->wsm_cmd.ret;
1157 spin_unlock(&priv->wsm_cmd.lock);
1158 }
1159 done:
1160 wsm_buf_reset(buf);
1161 return ret;
1162 }
1163
1164 /* ******************************************************************** */
1165 /* WSM TX port control */
1166
1167 void wsm_lock_tx(struct cw1200_common *priv)
1168 {
1169 wsm_cmd_lock(priv);
1170 if (atomic_add_return(1, &priv->tx_lock) == 1) {
1171 if (wsm_flush_tx(priv))
1172 pr_debug("[WSM] TX is locked.\n");
1173 }
1174 wsm_cmd_unlock(priv);
1175 }
1176
1177 void wsm_lock_tx_async(struct cw1200_common *priv)
1178 {
1179 if (atomic_add_return(1, &priv->tx_lock) == 1)
1180 pr_debug("[WSM] TX is locked (async).\n");
1181 }
1182
1183 bool wsm_flush_tx(struct cw1200_common *priv)
1184 {
1185 unsigned long timestamp = jiffies;
1186 bool pending = false;
1187 long timeout;
1188 int i;
1189
1190 /* Flush must be called with TX lock held. */
1191 BUG_ON(!atomic_read(&priv->tx_lock));
1192
1193 /* First check if we really need to do something.
1194 * It is safe to use unprotected access, as hw_bufs_used
1195 * can only decrements.
1196 */
1197 if (!priv->hw_bufs_used)
1198 return true;
1199
1200 if (priv->bh_error) {
1201 /* In case of failure do not wait for magic. */
1202 pr_err("[WSM] Fatal error occurred, will not flush TX.\n");
1203 return false;
1204 } else {
1205 /* Get a timestamp of "oldest" frame */
1206 for (i = 0; i < 4; ++i)
1207 pending |= cw1200_queue_get_xmit_timestamp(
1208 &priv->tx_queue[i],
1209 &timestamp, 0xffffffff);
1210 /* If there's nothing pending, we're good */
1211 if (!pending)
1212 return true;
1213
1214 timeout = timestamp + WSM_CMD_LAST_CHANCE_TIMEOUT - jiffies;
1215 if (timeout < 0 || wait_event_timeout(priv->bh_evt_wq,
1216 !priv->hw_bufs_used,
1217 timeout) <= 0) {
1218 /* Hmmm... Not good. Frame had stuck in firmware. */
1219 priv->bh_error = 1;
1220 wiphy_err(priv->hw->wiphy, "[WSM] TX Frames (%d) stuck in firmware, killing BH\n", priv->hw_bufs_used);
1221 wake_up(&priv->bh_wq);
1222 return false;
1223 }
1224
1225 /* Ok, everything is flushed. */
1226 return true;
1227 }
1228 }
1229
1230 void wsm_unlock_tx(struct cw1200_common *priv)
1231 {
1232 int tx_lock;
1233 tx_lock = atomic_sub_return(1, &priv->tx_lock);
1234 BUG_ON(tx_lock < 0);
1235
1236 if (tx_lock == 0) {
1237 if (!priv->bh_error)
1238 cw1200_bh_wakeup(priv);
1239 pr_debug("[WSM] TX is unlocked.\n");
1240 }
1241 }
1242
1243 /* ******************************************************************** */
1244 /* WSM RX */
1245
1246 int wsm_handle_exception(struct cw1200_common *priv, u8 *data, size_t len)
1247 {
1248 struct wsm_buf buf;
1249 u32 reason;
1250 u32 reg[18];
1251 char fname[48];
1252 unsigned int i;
1253
1254 static const char * const reason_str[] = {
1255 "undefined instruction",
1256 "prefetch abort",
1257 "data abort",
1258 "unknown error",
1259 };
1260
1261 buf.begin = buf.data = data;
1262 buf.end = &buf.begin[len];
1263
1264 reason = WSM_GET32(&buf);
1265 for (i = 0; i < ARRAY_SIZE(reg); ++i)
1266 reg[i] = WSM_GET32(&buf);
1267 WSM_GET(&buf, fname, sizeof(fname));
1268
1269 if (reason < 4)
1270 wiphy_err(priv->hw->wiphy,
1271 "Firmware exception: %s.\n",
1272 reason_str[reason]);
1273 else
1274 wiphy_err(priv->hw->wiphy,
1275 "Firmware assert at %.*s, line %d\n",
1276 (int) sizeof(fname), fname, reg[1]);
1277
1278 for (i = 0; i < 12; i += 4)
1279 wiphy_err(priv->hw->wiphy,
1280 "R%d: 0x%.8X, R%d: 0x%.8X, R%d: 0x%.8X, R%d: 0x%.8X,\n",
1281 i + 0, reg[i + 0], i + 1, reg[i + 1],
1282 i + 2, reg[i + 2], i + 3, reg[i + 3]);
1283 wiphy_err(priv->hw->wiphy,
1284 "R12: 0x%.8X, SP: 0x%.8X, LR: 0x%.8X, PC: 0x%.8X,\n",
1285 reg[i + 0], reg[i + 1], reg[i + 2], reg[i + 3]);
1286 i += 4;
1287 wiphy_err(priv->hw->wiphy,
1288 "CPSR: 0x%.8X, SPSR: 0x%.8X\n",
1289 reg[i + 0], reg[i + 1]);
1290
1291 print_hex_dump_bytes("R1: ", DUMP_PREFIX_NONE,
1292 fname, sizeof(fname));
1293 return 0;
1294
1295 underflow:
1296 wiphy_err(priv->hw->wiphy, "Firmware exception.\n");
1297 print_hex_dump_bytes("Exception: ", DUMP_PREFIX_NONE,
1298 data, len);
1299 return -EINVAL;
1300 }
1301
1302 int wsm_handle_rx(struct cw1200_common *priv, u16 id,
1303 struct wsm_hdr *wsm, struct sk_buff **skb_p)
1304 {
1305 int ret = 0;
1306 struct wsm_buf wsm_buf;
1307 int link_id = (id >> 6) & 0x0F;
1308
1309 /* Strip link id. */
1310 id &= ~WSM_TX_LINK_ID(WSM_TX_LINK_ID_MAX);
1311
1312 wsm_buf.begin = (u8 *)&wsm[0];
1313 wsm_buf.data = (u8 *)&wsm[1];
1314 wsm_buf.end = &wsm_buf.begin[__le16_to_cpu(wsm->len)];
1315
1316 pr_debug("[WSM] <<< 0x%.4X (%td)\n", id,
1317 wsm_buf.end - wsm_buf.begin);
1318
1319 if (id == WSM_TX_CONFIRM_IND_ID) {
1320 ret = wsm_tx_confirm(priv, &wsm_buf, link_id);
1321 } else if (id == WSM_MULTI_TX_CONFIRM_ID) {
1322 ret = wsm_multi_tx_confirm(priv, &wsm_buf, link_id);
1323 } else if (id & 0x0400) {
1324 void *wsm_arg;
1325 u16 wsm_cmd;
1326
1327 /* Do not trust FW too much. Protection against repeated
1328 * response and race condition removal (see above).
1329 */
1330 spin_lock(&priv->wsm_cmd.lock);
1331 wsm_arg = priv->wsm_cmd.arg;
1332 wsm_cmd = priv->wsm_cmd.cmd &
1333 ~WSM_TX_LINK_ID(WSM_TX_LINK_ID_MAX);
1334 priv->wsm_cmd.cmd = 0xFFFF;
1335 spin_unlock(&priv->wsm_cmd.lock);
1336
1337 if (WARN_ON((id & ~0x0400) != wsm_cmd)) {
1338 /* Note that any non-zero is a fatal retcode. */
1339 ret = -EINVAL;
1340 goto out;
1341 }
1342
1343 /* Note that wsm_arg can be NULL in case of timeout in
1344 * wsm_cmd_send().
1345 */
1346
1347 switch (id) {
1348 case WSM_READ_MIB_RESP_ID:
1349 if (wsm_arg)
1350 ret = wsm_read_mib_confirm(priv, wsm_arg,
1351 &wsm_buf);
1352 break;
1353 case WSM_WRITE_MIB_RESP_ID:
1354 if (wsm_arg)
1355 ret = wsm_write_mib_confirm(priv, wsm_arg,
1356 &wsm_buf);
1357 break;
1358 case WSM_START_SCAN_RESP_ID:
1359 if (wsm_arg)
1360 ret = wsm_scan_started(priv, wsm_arg, &wsm_buf);
1361 break;
1362 case WSM_CONFIGURATION_RESP_ID:
1363 if (wsm_arg)
1364 ret = wsm_configuration_confirm(priv, wsm_arg,
1365 &wsm_buf);
1366 break;
1367 case WSM_JOIN_RESP_ID:
1368 if (wsm_arg)
1369 ret = wsm_join_confirm(priv, wsm_arg, &wsm_buf);
1370 break;
1371 case WSM_STOP_SCAN_RESP_ID:
1372 case WSM_RESET_RESP_ID:
1373 case WSM_ADD_KEY_RESP_ID:
1374 case WSM_REMOVE_KEY_RESP_ID:
1375 case WSM_SET_PM_RESP_ID:
1376 case WSM_SET_BSS_PARAMS_RESP_ID:
1377 case 0x0412: /* set_tx_queue_params */
1378 case WSM_EDCA_PARAMS_RESP_ID:
1379 case WSM_SWITCH_CHANNEL_RESP_ID:
1380 case WSM_START_RESP_ID:
1381 case WSM_BEACON_TRANSMIT_RESP_ID:
1382 case 0x0419: /* start_find */
1383 case 0x041A: /* stop_find */
1384 case 0x041B: /* update_ie */
1385 case 0x041C: /* map_link */
1386 WARN_ON(wsm_arg != NULL);
1387 ret = wsm_generic_confirm(priv, wsm_arg, &wsm_buf);
1388 if (ret) {
1389 wiphy_warn(priv->hw->wiphy,
1390 "wsm_generic_confirm failed for request 0x%04x.\n",
1391 id & ~0x0400);
1392
1393 /* often 0x407 and 0x410 occur, this means we're dead.. */
1394 if (priv->join_status >= CW1200_JOIN_STATUS_JOINING) {
1395 wsm_lock_tx(priv);
1396 if (queue_work(priv->workqueue, &priv->unjoin_work) <= 0)
1397 wsm_unlock_tx(priv);
1398 }
1399 }
1400 break;
1401 default:
1402 wiphy_warn(priv->hw->wiphy,
1403 "Unrecognized confirmation 0x%04x\n",
1404 id & ~0x0400);
1405 }
1406
1407 spin_lock(&priv->wsm_cmd.lock);
1408 priv->wsm_cmd.ret = ret;
1409 priv->wsm_cmd.done = 1;
1410 spin_unlock(&priv->wsm_cmd.lock);
1411
1412 ret = 0; /* Error response from device should ne stop BH. */
1413
1414 wake_up(&priv->wsm_cmd_wq);
1415 } else if (id & 0x0800) {
1416 switch (id) {
1417 case WSM_STARTUP_IND_ID:
1418 ret = wsm_startup_indication(priv, &wsm_buf);
1419 break;
1420 case WSM_RECEIVE_IND_ID:
1421 ret = wsm_receive_indication(priv, link_id,
1422 &wsm_buf, skb_p);
1423 break;
1424 case 0x0805:
1425 ret = wsm_event_indication(priv, &wsm_buf);
1426 break;
1427 case WSM_SCAN_COMPLETE_IND_ID:
1428 ret = wsm_scan_complete_indication(priv, &wsm_buf);
1429 break;
1430 case 0x0808:
1431 ret = wsm_ba_timeout_indication(priv, &wsm_buf);
1432 break;
1433 case 0x0809:
1434 ret = wsm_set_pm_indication(priv, &wsm_buf);
1435 break;
1436 case 0x080A:
1437 ret = wsm_channel_switch_indication(priv, &wsm_buf);
1438 break;
1439 case 0x080B:
1440 ret = wsm_find_complete_indication(priv, &wsm_buf);
1441 break;
1442 case 0x080C:
1443 ret = wsm_suspend_resume_indication(priv,
1444 link_id, &wsm_buf);
1445 break;
1446 case 0x080F:
1447 ret = wsm_join_complete_indication(priv, &wsm_buf);
1448 break;
1449 default:
1450 pr_warn("Unrecognised WSM ID %04x\n", id);
1451 }
1452 } else {
1453 WARN_ON(1);
1454 ret = -EINVAL;
1455 }
1456 out:
1457 return ret;
1458 }
1459
1460 static bool wsm_handle_tx_data(struct cw1200_common *priv,
1461 struct wsm_tx *wsm,
1462 const struct ieee80211_tx_info *tx_info,
1463 const struct cw1200_txpriv *txpriv,
1464 struct cw1200_queue *queue)
1465 {
1466 bool handled = false;
1467 const struct ieee80211_hdr *frame =
1468 (struct ieee80211_hdr *)&((u8 *)wsm)[txpriv->offset];
1469 __le16 fctl = frame->frame_control;
1470 enum {
1471 do_probe,
1472 do_drop,
1473 do_wep,
1474 do_tx,
1475 } action = do_tx;
1476
1477 switch (priv->mode) {
1478 case NL80211_IFTYPE_STATION:
1479 if (priv->join_status == CW1200_JOIN_STATUS_MONITOR)
1480 action = do_tx;
1481 else if (priv->join_status < CW1200_JOIN_STATUS_PRE_STA)
1482 action = do_drop;
1483 break;
1484 case NL80211_IFTYPE_AP:
1485 if (!priv->join_status) {
1486 action = do_drop;
1487 } else if (!(BIT(txpriv->raw_link_id) &
1488 (BIT(0) | priv->link_id_map))) {
1489 wiphy_warn(priv->hw->wiphy,
1490 "A frame with expired link id is dropped.\n");
1491 action = do_drop;
1492 }
1493 if (cw1200_queue_get_generation(wsm->packet_id) >
1494 CW1200_MAX_REQUEUE_ATTEMPTS) {
1495 /* HACK!!! WSM324 firmware has tendency to requeue
1496 * multicast frames in a loop, causing performance
1497 * drop and high power consumption of the driver.
1498 * In this situation it is better just to drop
1499 * the problematic frame.
1500 */
1501 wiphy_warn(priv->hw->wiphy,
1502 "Too many attempts to requeue a frame; dropped.\n");
1503 action = do_drop;
1504 }
1505 break;
1506 case NL80211_IFTYPE_ADHOC:
1507 if (priv->join_status != CW1200_JOIN_STATUS_IBSS)
1508 action = do_drop;
1509 break;
1510 case NL80211_IFTYPE_MESH_POINT:
1511 action = do_tx; /* TODO: Test me! */
1512 break;
1513 case NL80211_IFTYPE_MONITOR:
1514 default:
1515 action = do_drop;
1516 break;
1517 }
1518
1519 if (action == do_tx) {
1520 if (ieee80211_is_nullfunc(fctl)) {
1521 spin_lock(&priv->bss_loss_lock);
1522 if (priv->bss_loss_state) {
1523 priv->bss_loss_confirm_id = wsm->packet_id;
1524 wsm->queue_id = WSM_QUEUE_VOICE;
1525 }
1526 spin_unlock(&priv->bss_loss_lock);
1527 } else if (ieee80211_is_probe_req(fctl)) {
1528 action = do_probe;
1529 } else if (ieee80211_is_deauth(fctl) &&
1530 priv->mode != NL80211_IFTYPE_AP) {
1531 pr_debug("[WSM] Issue unjoin command due to tx deauth.\n");
1532 wsm_lock_tx_async(priv);
1533 if (queue_work(priv->workqueue,
1534 &priv->unjoin_work) <= 0)
1535 wsm_unlock_tx(priv);
1536 } else if (ieee80211_has_protected(fctl) &&
1537 tx_info->control.hw_key &&
1538 tx_info->control.hw_key->keyidx != priv->wep_default_key_id &&
1539 (tx_info->control.hw_key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
1540 tx_info->control.hw_key->cipher == WLAN_CIPHER_SUITE_WEP104)) {
1541 action = do_wep;
1542 }
1543 }
1544
1545 switch (action) {
1546 case do_probe:
1547 /* An interesting FW "feature". Device filters probe responses.
1548 * The easiest way to get it back is to convert
1549 * probe request into WSM start_scan command.
1550 */
1551 pr_debug("[WSM] Convert probe request to scan.\n");
1552 wsm_lock_tx_async(priv);
1553 priv->pending_frame_id = wsm->packet_id;
1554 if (queue_delayed_work(priv->workqueue,
1555 &priv->scan.probe_work, 0) <= 0)
1556 wsm_unlock_tx(priv);
1557 handled = true;
1558 break;
1559 case do_drop:
1560 pr_debug("[WSM] Drop frame (0x%.4X).\n", fctl);
1561 BUG_ON(cw1200_queue_remove(queue, wsm->packet_id));
1562 handled = true;
1563 break;
1564 case do_wep:
1565 pr_debug("[WSM] Issue set_default_wep_key.\n");
1566 wsm_lock_tx_async(priv);
1567 priv->wep_default_key_id = tx_info->control.hw_key->keyidx;
1568 priv->pending_frame_id = wsm->packet_id;
1569 if (queue_work(priv->workqueue, &priv->wep_key_work) <= 0)
1570 wsm_unlock_tx(priv);
1571 handled = true;
1572 break;
1573 case do_tx:
1574 pr_debug("[WSM] Transmit frame.\n");
1575 break;
1576 default:
1577 /* Do nothing */
1578 break;
1579 }
1580 return handled;
1581 }
1582
1583 static int cw1200_get_prio_queue(struct cw1200_common *priv,
1584 u32 link_id_map, int *total)
1585 {
1586 static const int urgent = BIT(CW1200_LINK_ID_AFTER_DTIM) |
1587 BIT(CW1200_LINK_ID_UAPSD);
1588 struct wsm_edca_queue_params *edca;
1589 unsigned score, best = -1;
1590 int winner = -1;
1591 int queued;
1592 int i;
1593
1594 /* search for a winner using edca params */
1595 for (i = 0; i < 4; ++i) {
1596 queued = cw1200_queue_get_num_queued(&priv->tx_queue[i],
1597 link_id_map);
1598 if (!queued)
1599 continue;
1600 *total += queued;
1601 edca = &priv->edca.params[i];
1602 score = ((edca->aifns + edca->cwmin) << 16) +
1603 ((edca->cwmax - edca->cwmin) *
1604 (get_random_int() & 0xFFFF));
1605 if (score < best && (winner < 0 || i != 3)) {
1606 best = score;
1607 winner = i;
1608 }
1609 }
1610
1611 /* override winner if bursting */
1612 if (winner >= 0 && priv->tx_burst_idx >= 0 &&
1613 winner != priv->tx_burst_idx &&
1614 !cw1200_queue_get_num_queued(
1615 &priv->tx_queue[winner],
1616 link_id_map & urgent) &&
1617 cw1200_queue_get_num_queued(
1618 &priv->tx_queue[priv->tx_burst_idx],
1619 link_id_map))
1620 winner = priv->tx_burst_idx;
1621
1622 return winner;
1623 }
1624
1625 static int wsm_get_tx_queue_and_mask(struct cw1200_common *priv,
1626 struct cw1200_queue **queue_p,
1627 u32 *tx_allowed_mask_p,
1628 bool *more)
1629 {
1630 int idx;
1631 u32 tx_allowed_mask;
1632 int total = 0;
1633
1634 /* Search for a queue with multicast frames buffered */
1635 if (priv->tx_multicast) {
1636 tx_allowed_mask = BIT(CW1200_LINK_ID_AFTER_DTIM);
1637 idx = cw1200_get_prio_queue(priv,
1638 tx_allowed_mask, &total);
1639 if (idx >= 0) {
1640 *more = total > 1;
1641 goto found;
1642 }
1643 }
1644
1645 /* Search for unicast traffic */
1646 tx_allowed_mask = ~priv->sta_asleep_mask;
1647 tx_allowed_mask |= BIT(CW1200_LINK_ID_UAPSD);
1648 if (priv->sta_asleep_mask) {
1649 tx_allowed_mask |= priv->pspoll_mask;
1650 tx_allowed_mask &= ~BIT(CW1200_LINK_ID_AFTER_DTIM);
1651 } else {
1652 tx_allowed_mask |= BIT(CW1200_LINK_ID_AFTER_DTIM);
1653 }
1654 idx = cw1200_get_prio_queue(priv,
1655 tx_allowed_mask, &total);
1656 if (idx < 0)
1657 return -ENOENT;
1658
1659 found:
1660 *queue_p = &priv->tx_queue[idx];
1661 *tx_allowed_mask_p = tx_allowed_mask;
1662 return 0;
1663 }
1664
1665 int wsm_get_tx(struct cw1200_common *priv, u8 **data,
1666 size_t *tx_len, int *burst)
1667 {
1668 struct wsm_tx *wsm = NULL;
1669 struct ieee80211_tx_info *tx_info;
1670 struct cw1200_queue *queue = NULL;
1671 int queue_num;
1672 u32 tx_allowed_mask = 0;
1673 const struct cw1200_txpriv *txpriv = NULL;
1674 int count = 0;
1675
1676 /* More is used only for broadcasts. */
1677 bool more = false;
1678
1679 if (priv->wsm_cmd.ptr) { /* CMD request */
1680 ++count;
1681 spin_lock(&priv->wsm_cmd.lock);
1682 BUG_ON(!priv->wsm_cmd.ptr);
1683 *data = priv->wsm_cmd.ptr;
1684 *tx_len = priv->wsm_cmd.len;
1685 *burst = 1;
1686 spin_unlock(&priv->wsm_cmd.lock);
1687 } else {
1688 for (;;) {
1689 int ret;
1690
1691 if (atomic_add_return(0, &priv->tx_lock))
1692 break;
1693
1694 spin_lock_bh(&priv->ps_state_lock);
1695
1696 ret = wsm_get_tx_queue_and_mask(priv, &queue,
1697 &tx_allowed_mask, &more);
1698 queue_num = queue - priv->tx_queue;
1699
1700 if (priv->buffered_multicasts &&
1701 (ret || !more) &&
1702 (priv->tx_multicast || !priv->sta_asleep_mask)) {
1703 priv->buffered_multicasts = false;
1704 if (priv->tx_multicast) {
1705 priv->tx_multicast = false;
1706 queue_work(priv->workqueue,
1707 &priv->multicast_stop_work);
1708 }
1709 }
1710
1711 spin_unlock_bh(&priv->ps_state_lock);
1712
1713 if (ret)
1714 break;
1715
1716 if (cw1200_queue_get(queue,
1717 tx_allowed_mask,
1718 &wsm, &tx_info, &txpriv))
1719 continue;
1720
1721 if (wsm_handle_tx_data(priv, wsm,
1722 tx_info, txpriv, queue))
1723 continue; /* Handled by WSM */
1724
1725 wsm->hdr.id &= __cpu_to_le16(
1726 ~WSM_TX_LINK_ID(WSM_TX_LINK_ID_MAX));
1727 wsm->hdr.id |= cpu_to_le16(
1728 WSM_TX_LINK_ID(txpriv->raw_link_id));
1729 priv->pspoll_mask &= ~BIT(txpriv->raw_link_id);
1730
1731 *data = (u8 *)wsm;
1732 *tx_len = __le16_to_cpu(wsm->hdr.len);
1733
1734 /* allow bursting if txop is set */
1735 if (priv->edca.params[queue_num].txop_limit)
1736 *burst = min(*burst,
1737 (int)cw1200_queue_get_num_queued(queue, tx_allowed_mask) + 1);
1738 else
1739 *burst = 1;
1740
1741 /* store index of bursting queue */
1742 if (*burst > 1)
1743 priv->tx_burst_idx = queue_num;
1744 else
1745 priv->tx_burst_idx = -1;
1746
1747 if (more) {
1748 struct ieee80211_hdr *hdr =
1749 (struct ieee80211_hdr *)
1750 &((u8 *)wsm)[txpriv->offset];
1751 /* more buffered multicast/broadcast frames
1752 * ==> set MoreData flag in IEEE 802.11 header
1753 * to inform PS STAs
1754 */
1755 hdr->frame_control |=
1756 cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1757 }
1758
1759 pr_debug("[WSM] >>> 0x%.4X (%zu) %p %c\n",
1760 0x0004, *tx_len, *data,
1761 wsm->more ? 'M' : ' ');
1762 ++count;
1763 break;
1764 }
1765 }
1766
1767 return count;
1768 }
1769
1770 void wsm_txed(struct cw1200_common *priv, u8 *data)
1771 {
1772 if (data == priv->wsm_cmd.ptr) {
1773 spin_lock(&priv->wsm_cmd.lock);
1774 priv->wsm_cmd.ptr = NULL;
1775 spin_unlock(&priv->wsm_cmd.lock);
1776 }
1777 }
1778
1779 /* ******************************************************************** */
1780 /* WSM buffer */
1781
1782 void wsm_buf_init(struct wsm_buf *buf)
1783 {
1784 BUG_ON(buf->begin);
1785 buf->begin = kmalloc(FWLOAD_BLOCK_SIZE, GFP_KERNEL | GFP_DMA);
1786 buf->end = buf->begin ? &buf->begin[FWLOAD_BLOCK_SIZE] : buf->begin;
1787 wsm_buf_reset(buf);
1788 }
1789
1790 void wsm_buf_deinit(struct wsm_buf *buf)
1791 {
1792 kfree(buf->begin);
1793 buf->begin = buf->data = buf->end = NULL;
1794 }
1795
1796 static void wsm_buf_reset(struct wsm_buf *buf)
1797 {
1798 if (buf->begin) {
1799 buf->data = &buf->begin[4];
1800 *(u32 *)buf->begin = 0;
1801 } else {
1802 buf->data = buf->begin;
1803 }
1804 }
1805
1806 static int wsm_buf_reserve(struct wsm_buf *buf, size_t extra_size)
1807 {
1808 size_t pos = buf->data - buf->begin;
1809 size_t size = pos + extra_size;
1810
1811 size = round_up(size, FWLOAD_BLOCK_SIZE);
1812
1813 buf->begin = krealloc(buf->begin, size, GFP_KERNEL | GFP_DMA);
1814 if (buf->begin) {
1815 buf->data = &buf->begin[pos];
1816 buf->end = &buf->begin[size];
1817 return 0;
1818 } else {
1819 buf->end = buf->data = buf->begin;
1820 return -ENOMEM;
1821 }
1822 }
Ubuntu Hirsute Linux kernel mirror