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