1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "decl.h"
21#include "ioctl.h"
22#include "util.h"
23#include "fw.h"
24#include "main.h"
25#include "wmm.h"
26#include "11n.h"
27#include "11ac.h"
28
29
30
31
32
33
34
35
36
37static void
38mwifiex_init_cmd_node(struct mwifiex_private *priv,
39 struct cmd_ctrl_node *cmd_node,
40 u32 cmd_oid, void *data_buf)
41{
42 cmd_node->priv = priv;
43 cmd_node->cmd_oid = cmd_oid;
44 if (priv->adapter->cmd_wait_q_required) {
45 cmd_node->wait_q_enabled = priv->adapter->cmd_wait_q_required;
46 priv->adapter->cmd_wait_q_required = false;
47 cmd_node->cmd_wait_q_woken = false;
48 cmd_node->condition = &cmd_node->cmd_wait_q_woken;
49 }
50 cmd_node->data_buf = data_buf;
51 cmd_node->cmd_skb = cmd_node->skb;
52}
53
54
55
56
57
58static struct cmd_ctrl_node *
59mwifiex_get_cmd_node(struct mwifiex_adapter *adapter)
60{
61 struct cmd_ctrl_node *cmd_node;
62 unsigned long flags;
63
64 spin_lock_irqsave(&adapter->cmd_free_q_lock, flags);
65 if (list_empty(&adapter->cmd_free_q)) {
66 dev_err(adapter->dev, "GET_CMD_NODE: cmd node not available\n");
67 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
68 return NULL;
69 }
70 cmd_node = list_first_entry(&adapter->cmd_free_q,
71 struct cmd_ctrl_node, list);
72 list_del(&cmd_node->list);
73 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
74
75 return cmd_node;
76}
77
78
79
80
81
82
83
84
85
86
87
88
89static void
90mwifiex_clean_cmd_node(struct mwifiex_adapter *adapter,
91 struct cmd_ctrl_node *cmd_node)
92{
93 cmd_node->cmd_oid = 0;
94 cmd_node->cmd_flag = 0;
95 cmd_node->data_buf = NULL;
96 cmd_node->wait_q_enabled = false;
97
98 if (cmd_node->cmd_skb)
99 skb_trim(cmd_node->cmd_skb, 0);
100
101 if (cmd_node->resp_skb) {
102 adapter->if_ops.cmdrsp_complete(adapter, cmd_node->resp_skb);
103 cmd_node->resp_skb = NULL;
104 }
105}
106
107
108
109
110
111
112
113
114static int mwifiex_cmd_host_cmd(struct mwifiex_private *priv,
115 struct host_cmd_ds_command *cmd,
116 struct mwifiex_ds_misc_cmd *pcmd_ptr)
117{
118
119 memcpy(cmd, pcmd_ptr->cmd, pcmd_ptr->len);
120 dev_dbg(priv->adapter->dev, "cmd: host cmd size = %d\n", pcmd_ptr->len);
121 return 0;
122}
123
124
125
126
127
128
129
130
131
132static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private *priv,
133 struct cmd_ctrl_node *cmd_node)
134{
135
136 struct mwifiex_adapter *adapter = priv->adapter;
137 int ret;
138 struct host_cmd_ds_command *host_cmd;
139 uint16_t cmd_code;
140 uint16_t cmd_size;
141 struct timeval tstamp;
142 unsigned long flags;
143 __le32 tmp;
144
145 if (!adapter || !cmd_node)
146 return -1;
147
148 host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
149
150
151 if (host_cmd == NULL || host_cmd->size == 0) {
152 dev_err(adapter->dev, "DNLD_CMD: host_cmd is null"
153 " or cmd size is 0, not sending\n");
154 if (cmd_node->wait_q_enabled)
155 adapter->cmd_wait_q.status = -1;
156 mwifiex_recycle_cmd_node(adapter, cmd_node);
157 return -1;
158 }
159
160 cmd_code = le16_to_cpu(host_cmd->command);
161 cmd_size = le16_to_cpu(host_cmd->size);
162
163 if (adapter->hw_status == MWIFIEX_HW_STATUS_RESET &&
164 cmd_code != HostCmd_CMD_FUNC_SHUTDOWN &&
165 cmd_code != HostCmd_CMD_FUNC_INIT) {
166 dev_err(adapter->dev,
167 "DNLD_CMD: FW in reset state, ignore cmd %#x\n",
168 cmd_code);
169 mwifiex_complete_cmd(adapter, cmd_node);
170 mwifiex_recycle_cmd_node(adapter, cmd_node);
171 return -1;
172 }
173
174
175 adapter->seq_num++;
176 host_cmd->seq_num = cpu_to_le16(HostCmd_SET_SEQ_NO_BSS_INFO
177 (adapter->seq_num,
178 cmd_node->priv->bss_num,
179 cmd_node->priv->bss_type));
180
181 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
182 adapter->curr_cmd = cmd_node;
183 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
184
185
186 if (cmd_node->cmd_skb->len > cmd_size)
187
188
189
190
191 skb_trim(cmd_node->cmd_skb, cmd_size);
192 else if (cmd_node->cmd_skb->len < cmd_size)
193
194
195
196
197
198 skb_put(cmd_node->cmd_skb, cmd_size - cmd_node->cmd_skb->len);
199
200 do_gettimeofday(&tstamp);
201 dev_dbg(adapter->dev, "cmd: DNLD_CMD: (%lu.%lu): %#x, act %#x, len %d,"
202 " seqno %#x\n",
203 tstamp.tv_sec, tstamp.tv_usec, cmd_code,
204 le16_to_cpu(*(__le16 *) ((u8 *) host_cmd + S_DS_GEN)), cmd_size,
205 le16_to_cpu(host_cmd->seq_num));
206
207 if (adapter->iface_type == MWIFIEX_USB) {
208 tmp = cpu_to_le32(MWIFIEX_USB_TYPE_CMD);
209 skb_push(cmd_node->cmd_skb, MWIFIEX_TYPE_LEN);
210 memcpy(cmd_node->cmd_skb->data, &tmp, MWIFIEX_TYPE_LEN);
211 adapter->cmd_sent = true;
212 ret = adapter->if_ops.host_to_card(adapter,
213 MWIFIEX_USB_EP_CMD_EVENT,
214 cmd_node->cmd_skb, NULL);
215 skb_pull(cmd_node->cmd_skb, MWIFIEX_TYPE_LEN);
216 if (ret == -EBUSY)
217 cmd_node->cmd_skb = NULL;
218 } else {
219 skb_push(cmd_node->cmd_skb, INTF_HEADER_LEN);
220 ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
221 cmd_node->cmd_skb, NULL);
222 skb_pull(cmd_node->cmd_skb, INTF_HEADER_LEN);
223 }
224
225 if (ret == -1) {
226 dev_err(adapter->dev, "DNLD_CMD: host to card failed\n");
227 if (adapter->iface_type == MWIFIEX_USB)
228 adapter->cmd_sent = false;
229 if (cmd_node->wait_q_enabled)
230 adapter->cmd_wait_q.status = -1;
231 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
232
233 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
234 adapter->curr_cmd = NULL;
235 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
236
237 adapter->dbg.num_cmd_host_to_card_failure++;
238 return -1;
239 }
240
241
242 adapter->dbg.last_cmd_index =
243 (adapter->dbg.last_cmd_index + 1) % DBG_CMD_NUM;
244 adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index] = cmd_code;
245 adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index] =
246 le16_to_cpu(*(__le16 *) ((u8 *) host_cmd + S_DS_GEN));
247
248
249 cmd_code &= HostCmd_CMD_ID_MASK;
250
251
252 mod_timer(&adapter->cmd_timer,
253 jiffies + msecs_to_jiffies(MWIFIEX_TIMER_10S));
254
255 return 0;
256}
257
258
259
260
261
262
263
264
265
266
267static int mwifiex_dnld_sleep_confirm_cmd(struct mwifiex_adapter *adapter)
268{
269 int ret;
270 struct mwifiex_private *priv;
271 struct mwifiex_opt_sleep_confirm *sleep_cfm_buf =
272 (struct mwifiex_opt_sleep_confirm *)
273 adapter->sleep_cfm->data;
274 struct sk_buff *sleep_cfm_tmp;
275 __le32 tmp;
276
277 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
278
279 sleep_cfm_buf->seq_num =
280 cpu_to_le16((HostCmd_SET_SEQ_NO_BSS_INFO
281 (adapter->seq_num, priv->bss_num,
282 priv->bss_type)));
283 adapter->seq_num++;
284
285 if (adapter->iface_type == MWIFIEX_USB) {
286 sleep_cfm_tmp =
287 dev_alloc_skb(sizeof(struct mwifiex_opt_sleep_confirm)
288 + MWIFIEX_TYPE_LEN);
289 skb_put(sleep_cfm_tmp, sizeof(struct mwifiex_opt_sleep_confirm)
290 + MWIFIEX_TYPE_LEN);
291 tmp = cpu_to_le32(MWIFIEX_USB_TYPE_CMD);
292 memcpy(sleep_cfm_tmp->data, &tmp, MWIFIEX_TYPE_LEN);
293 memcpy(sleep_cfm_tmp->data + MWIFIEX_TYPE_LEN,
294 adapter->sleep_cfm->data,
295 sizeof(struct mwifiex_opt_sleep_confirm));
296 ret = adapter->if_ops.host_to_card(adapter,
297 MWIFIEX_USB_EP_CMD_EVENT,
298 sleep_cfm_tmp, NULL);
299 if (ret != -EBUSY)
300 dev_kfree_skb_any(sleep_cfm_tmp);
301 } else {
302 skb_push(adapter->sleep_cfm, INTF_HEADER_LEN);
303 ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
304 adapter->sleep_cfm, NULL);
305 skb_pull(adapter->sleep_cfm, INTF_HEADER_LEN);
306 }
307
308 if (ret == -1) {
309 dev_err(adapter->dev, "SLEEP_CFM: failed\n");
310 adapter->dbg.num_cmd_sleep_cfm_host_to_card_failure++;
311 return -1;
312 }
313 if (GET_BSS_ROLE(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY))
314 == MWIFIEX_BSS_ROLE_STA) {
315 if (!sleep_cfm_buf->resp_ctrl)
316
317
318 adapter->ps_state = PS_STATE_SLEEP;
319 else
320 adapter->ps_state = PS_STATE_SLEEP_CFM;
321
322 if (!sleep_cfm_buf->resp_ctrl &&
323 (adapter->is_hs_configured &&
324 !adapter->sleep_period.period)) {
325 adapter->pm_wakeup_card_req = true;
326 mwifiex_hs_activated_event(mwifiex_get_priv
327 (adapter, MWIFIEX_BSS_ROLE_STA), true);
328 }
329 }
330
331 return ret;
332}
333
334
335
336
337
338
339
340
341
342
343
344
345
346int mwifiex_alloc_cmd_buffer(struct mwifiex_adapter *adapter)
347{
348 struct cmd_ctrl_node *cmd_array;
349 u32 i;
350
351
352 cmd_array = kcalloc(MWIFIEX_NUM_OF_CMD_BUFFER,
353 sizeof(struct cmd_ctrl_node), GFP_KERNEL);
354 if (!cmd_array)
355 return -ENOMEM;
356
357 adapter->cmd_pool = cmd_array;
358
359
360 for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++) {
361 cmd_array[i].skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER);
362 if (!cmd_array[i].skb) {
363 dev_err(adapter->dev, "ALLOC_CMD_BUF: out of memory\n");
364 return -1;
365 }
366 }
367
368 for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++)
369 mwifiex_insert_cmd_to_free_q(adapter, &cmd_array[i]);
370
371 return 0;
372}
373
374
375
376
377
378
379
380int mwifiex_free_cmd_buffer(struct mwifiex_adapter *adapter)
381{
382 struct cmd_ctrl_node *cmd_array;
383 u32 i;
384
385
386 if (!adapter->cmd_pool) {
387 dev_dbg(adapter->dev, "info: FREE_CMD_BUF: cmd_pool is null\n");
388 return 0;
389 }
390
391 cmd_array = adapter->cmd_pool;
392
393
394 for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++) {
395 if (cmd_array[i].skb) {
396 dev_dbg(adapter->dev, "cmd: free cmd buffer %d\n", i);
397 dev_kfree_skb_any(cmd_array[i].skb);
398 }
399 if (!cmd_array[i].resp_skb)
400 continue;
401
402 if (adapter->iface_type == MWIFIEX_USB)
403 adapter->if_ops.cmdrsp_complete(adapter,
404 cmd_array[i].resp_skb);
405 else
406 dev_kfree_skb_any(cmd_array[i].resp_skb);
407 }
408
409 if (adapter->cmd_pool) {
410 dev_dbg(adapter->dev, "cmd: free cmd pool\n");
411 kfree(adapter->cmd_pool);
412 adapter->cmd_pool = NULL;
413 }
414
415 return 0;
416}
417
418
419
420
421
422
423
424
425
426
427
428int mwifiex_process_event(struct mwifiex_adapter *adapter)
429{
430 int ret;
431 struct mwifiex_private *priv =
432 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
433 struct sk_buff *skb = adapter->event_skb;
434 u32 eventcause = adapter->event_cause;
435 struct timeval tstamp;
436 struct mwifiex_rxinfo *rx_info;
437
438
439 adapter->dbg.last_event_index =
440 (adapter->dbg.last_event_index + 1) % DBG_CMD_NUM;
441 adapter->dbg.last_event[adapter->dbg.last_event_index] =
442 (u16) eventcause;
443
444
445 priv = mwifiex_get_priv_by_id(adapter, EVENT_GET_BSS_NUM(eventcause),
446 EVENT_GET_BSS_TYPE(eventcause));
447 if (!priv)
448 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
449
450 eventcause &= EVENT_ID_MASK;
451 adapter->event_cause = eventcause;
452
453 if (skb) {
454 rx_info = MWIFIEX_SKB_RXCB(skb);
455 rx_info->bss_num = priv->bss_num;
456 rx_info->bss_type = priv->bss_type;
457 }
458
459 if (eventcause != EVENT_PS_SLEEP && eventcause != EVENT_PS_AWAKE) {
460 do_gettimeofday(&tstamp);
461 dev_dbg(adapter->dev, "event: %lu.%lu: cause: %#x\n",
462 tstamp.tv_sec, tstamp.tv_usec, eventcause);
463 } else {
464
465 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
466 if (!priv)
467 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
468 }
469
470 if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP)
471 ret = mwifiex_process_uap_event(priv);
472 else
473 ret = mwifiex_process_sta_event(priv);
474
475 adapter->event_cause = 0;
476 adapter->event_skb = NULL;
477 adapter->if_ops.event_complete(adapter, skb);
478
479 return ret;
480}
481
482
483
484
485
486
487
488int mwifiex_send_cmd_sync(struct mwifiex_private *priv, uint16_t cmd_no,
489 u16 cmd_action, u32 cmd_oid, void *data_buf)
490{
491 int ret = 0;
492 struct mwifiex_adapter *adapter = priv->adapter;
493
494 adapter->cmd_wait_q_required = true;
495
496 ret = mwifiex_send_cmd_async(priv, cmd_no, cmd_action, cmd_oid,
497 data_buf);
498
499 return ret;
500}
501
502
503
504
505
506
507
508
509
510
511
512
513
514int mwifiex_send_cmd_async(struct mwifiex_private *priv, uint16_t cmd_no,
515 u16 cmd_action, u32 cmd_oid, void *data_buf)
516{
517 int ret;
518 struct mwifiex_adapter *adapter = priv->adapter;
519 struct cmd_ctrl_node *cmd_node;
520 struct host_cmd_ds_command *cmd_ptr;
521
522 if (!adapter) {
523 pr_err("PREP_CMD: adapter is NULL\n");
524 return -1;
525 }
526
527 if (adapter->is_suspended) {
528 dev_err(adapter->dev, "PREP_CMD: device in suspended state\n");
529 return -1;
530 }
531
532 if (adapter->surprise_removed) {
533 dev_err(adapter->dev, "PREP_CMD: card is removed\n");
534 return -1;
535 }
536
537 if (adapter->hw_status == MWIFIEX_HW_STATUS_RESET) {
538 if (cmd_no != HostCmd_CMD_FUNC_INIT) {
539 dev_err(adapter->dev, "PREP_CMD: FW in reset state\n");
540 return -1;
541 }
542 }
543
544
545 cmd_node = mwifiex_get_cmd_node(adapter);
546
547 if (!cmd_node) {
548 dev_err(adapter->dev, "PREP_CMD: no free cmd node\n");
549 return -1;
550 }
551
552
553 mwifiex_init_cmd_node(priv, cmd_node, cmd_oid, data_buf);
554
555 if (!cmd_node->cmd_skb) {
556 dev_err(adapter->dev, "PREP_CMD: no free cmd buf\n");
557 return -1;
558 }
559
560 memset(skb_put(cmd_node->cmd_skb, sizeof(struct host_cmd_ds_command)),
561 0, sizeof(struct host_cmd_ds_command));
562
563 cmd_ptr = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
564 cmd_ptr->command = cpu_to_le16(cmd_no);
565 cmd_ptr->result = 0;
566
567
568 if (cmd_no) {
569 switch (cmd_no) {
570 case HostCmd_CMD_UAP_SYS_CONFIG:
571 case HostCmd_CMD_UAP_BSS_START:
572 case HostCmd_CMD_UAP_BSS_STOP:
573 case HostCmd_CMD_UAP_STA_DEAUTH:
574 ret = mwifiex_uap_prepare_cmd(priv, cmd_no, cmd_action,
575 cmd_oid, data_buf,
576 cmd_ptr);
577 break;
578 default:
579 ret = mwifiex_sta_prepare_cmd(priv, cmd_no, cmd_action,
580 cmd_oid, data_buf,
581 cmd_ptr);
582 break;
583 }
584 } else {
585 ret = mwifiex_cmd_host_cmd(priv, cmd_ptr, data_buf);
586 cmd_node->cmd_flag |= CMD_F_HOSTCMD;
587 }
588
589
590 if (ret) {
591 dev_err(adapter->dev, "PREP_CMD: cmd %#x preparation failed\n",
592 cmd_no);
593 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
594 return -1;
595 }
596
597
598 if (cmd_no == HostCmd_CMD_802_11_SCAN) {
599 mwifiex_queue_scan_cmd(priv, cmd_node);
600 } else {
601 mwifiex_insert_cmd_to_pending_q(adapter, cmd_node, true);
602 queue_work(adapter->workqueue, &adapter->main_work);
603 if (cmd_node->wait_q_enabled)
604 ret = mwifiex_wait_queue_complete(adapter, cmd_node);
605 }
606
607 return ret;
608}
609
610
611
612
613
614
615
616void
617mwifiex_insert_cmd_to_free_q(struct mwifiex_adapter *adapter,
618 struct cmd_ctrl_node *cmd_node)
619{
620 unsigned long flags;
621
622 if (!cmd_node)
623 return;
624
625 if (cmd_node->wait_q_enabled)
626 mwifiex_complete_cmd(adapter, cmd_node);
627
628 mwifiex_clean_cmd_node(adapter, cmd_node);
629
630
631 spin_lock_irqsave(&adapter->cmd_free_q_lock, flags);
632 list_add_tail(&cmd_node->list, &adapter->cmd_free_q);
633 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
634}
635
636
637void mwifiex_recycle_cmd_node(struct mwifiex_adapter *adapter,
638 struct cmd_ctrl_node *cmd_node)
639{
640 struct host_cmd_ds_command *host_cmd = (void *)cmd_node->cmd_skb->data;
641
642 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
643
644 atomic_dec(&adapter->cmd_pending);
645 dev_dbg(adapter->dev, "cmd: FREE_CMD: cmd=%#x, cmd_pending=%d\n",
646 le16_to_cpu(host_cmd->command),
647 atomic_read(&adapter->cmd_pending));
648}
649
650
651
652
653
654
655
656
657void
658mwifiex_insert_cmd_to_pending_q(struct mwifiex_adapter *adapter,
659 struct cmd_ctrl_node *cmd_node, u32 add_tail)
660{
661 struct host_cmd_ds_command *host_cmd = NULL;
662 u16 command;
663 unsigned long flags;
664
665 host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
666 if (!host_cmd) {
667 dev_err(adapter->dev, "QUEUE_CMD: host_cmd is NULL\n");
668 return;
669 }
670
671 command = le16_to_cpu(host_cmd->command);
672
673
674 if (command == HostCmd_CMD_802_11_PS_MODE_ENH) {
675 struct host_cmd_ds_802_11_ps_mode_enh *pm =
676 &host_cmd->params.psmode_enh;
677 if ((le16_to_cpu(pm->action) == DIS_PS) ||
678 (le16_to_cpu(pm->action) == DIS_AUTO_PS)) {
679 if (adapter->ps_state != PS_STATE_AWAKE)
680 add_tail = false;
681 }
682 }
683
684 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
685 if (add_tail)
686 list_add_tail(&cmd_node->list, &adapter->cmd_pending_q);
687 else
688 list_add(&cmd_node->list, &adapter->cmd_pending_q);
689 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
690
691 atomic_inc(&adapter->cmd_pending);
692 dev_dbg(adapter->dev, "cmd: QUEUE_CMD: cmd=%#x, cmd_pending=%d\n",
693 command, atomic_read(&adapter->cmd_pending));
694}
695
696
697
698
699
700
701
702
703
704
705
706
707int mwifiex_exec_next_cmd(struct mwifiex_adapter *adapter)
708{
709 struct mwifiex_private *priv;
710 struct cmd_ctrl_node *cmd_node;
711 int ret = 0;
712 struct host_cmd_ds_command *host_cmd;
713 unsigned long cmd_flags;
714 unsigned long cmd_pending_q_flags;
715
716
717 if (adapter->curr_cmd) {
718 dev_err(adapter->dev, "EXEC_NEXT_CMD: cmd in processing\n");
719 return -1;
720 }
721
722 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
723
724 spin_lock_irqsave(&adapter->cmd_pending_q_lock, cmd_pending_q_flags);
725 if (list_empty(&adapter->cmd_pending_q)) {
726 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
727 cmd_pending_q_flags);
728 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
729 return 0;
730 }
731 cmd_node = list_first_entry(&adapter->cmd_pending_q,
732 struct cmd_ctrl_node, list);
733 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
734 cmd_pending_q_flags);
735
736 host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
737 priv = cmd_node->priv;
738
739 if (adapter->ps_state != PS_STATE_AWAKE) {
740 dev_err(adapter->dev, "%s: cannot send cmd in sleep state,"
741 " this should not happen\n", __func__);
742 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
743 return ret;
744 }
745
746 spin_lock_irqsave(&adapter->cmd_pending_q_lock, cmd_pending_q_flags);
747 list_del(&cmd_node->list);
748 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
749 cmd_pending_q_flags);
750
751 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
752 ret = mwifiex_dnld_cmd_to_fw(priv, cmd_node);
753 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
754
755
756
757
758 if (priv && (host_cmd->command !=
759 cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH))) {
760 if (adapter->hs_activated) {
761 adapter->is_hs_configured = false;
762 mwifiex_hs_activated_event(priv, false);
763 }
764 }
765
766 return ret;
767}
768
769
770
771
772
773
774
775int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter)
776{
777 struct host_cmd_ds_command *resp;
778 struct mwifiex_private *priv =
779 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
780 int ret = 0;
781 uint16_t orig_cmdresp_no;
782 uint16_t cmdresp_no;
783 uint16_t cmdresp_result;
784 struct timeval tstamp;
785 unsigned long flags;
786
787
788 del_timer(&adapter->cmd_timer);
789
790 if (!adapter->curr_cmd || !adapter->curr_cmd->resp_skb) {
791 resp = (struct host_cmd_ds_command *) adapter->upld_buf;
792 dev_err(adapter->dev, "CMD_RESP: NULL curr_cmd, %#x\n",
793 le16_to_cpu(resp->command));
794 return -1;
795 }
796
797 adapter->num_cmd_timeout = 0;
798
799 resp = (struct host_cmd_ds_command *) adapter->curr_cmd->resp_skb->data;
800 if (adapter->curr_cmd->cmd_flag & CMD_F_CANCELED) {
801 dev_err(adapter->dev, "CMD_RESP: %#x been canceled\n",
802 le16_to_cpu(resp->command));
803 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
804 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
805 adapter->curr_cmd = NULL;
806 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
807 return -1;
808 }
809
810 if (adapter->curr_cmd->cmd_flag & CMD_F_HOSTCMD) {
811
812 struct mwifiex_ds_misc_cmd *hostcmd;
813 uint16_t size = le16_to_cpu(resp->size);
814 dev_dbg(adapter->dev, "info: host cmd resp size = %d\n", size);
815 size = min_t(u16, size, MWIFIEX_SIZE_OF_CMD_BUFFER);
816 if (adapter->curr_cmd->data_buf) {
817 hostcmd = adapter->curr_cmd->data_buf;
818 hostcmd->len = size;
819 memcpy(hostcmd->cmd, resp, size);
820 }
821 }
822 orig_cmdresp_no = le16_to_cpu(resp->command);
823
824
825 priv = mwifiex_get_priv_by_id(adapter,
826 HostCmd_GET_BSS_NO(le16_to_cpu(resp->seq_num)),
827 HostCmd_GET_BSS_TYPE(le16_to_cpu(resp->seq_num)));
828 if (!priv)
829 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
830
831 resp->command = cpu_to_le16(orig_cmdresp_no & HostCmd_CMD_ID_MASK);
832
833 cmdresp_no = le16_to_cpu(resp->command);
834 cmdresp_result = le16_to_cpu(resp->result);
835
836
837 adapter->dbg.last_cmd_resp_index =
838 (adapter->dbg.last_cmd_resp_index + 1) % DBG_CMD_NUM;
839 adapter->dbg.last_cmd_resp_id[adapter->dbg.last_cmd_resp_index] =
840 orig_cmdresp_no;
841
842 do_gettimeofday(&tstamp);
843 dev_dbg(adapter->dev, "cmd: CMD_RESP: (%lu.%lu): 0x%x, result %d,"
844 " len %d, seqno 0x%x\n",
845 tstamp.tv_sec, tstamp.tv_usec, orig_cmdresp_no, cmdresp_result,
846 le16_to_cpu(resp->size), le16_to_cpu(resp->seq_num));
847
848 if (!(orig_cmdresp_no & HostCmd_RET_BIT)) {
849 dev_err(adapter->dev, "CMD_RESP: invalid cmd resp\n");
850 if (adapter->curr_cmd->wait_q_enabled)
851 adapter->cmd_wait_q.status = -1;
852
853 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
854 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
855 adapter->curr_cmd = NULL;
856 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
857 return -1;
858 }
859
860 if (adapter->curr_cmd->cmd_flag & CMD_F_HOSTCMD) {
861 adapter->curr_cmd->cmd_flag &= ~CMD_F_HOSTCMD;
862 if ((cmdresp_result == HostCmd_RESULT_OK) &&
863 (cmdresp_no == HostCmd_CMD_802_11_HS_CFG_ENH))
864 ret = mwifiex_ret_802_11_hs_cfg(priv, resp);
865 } else {
866
867 ret = mwifiex_process_sta_cmdresp(priv, cmdresp_no, resp);
868 }
869
870
871 if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING) {
872 if (ret) {
873 dev_err(adapter->dev, "%s: cmd %#x failed during "
874 "initialization\n", __func__, cmdresp_no);
875 mwifiex_init_fw_complete(adapter);
876 return -1;
877 } else if (adapter->last_init_cmd == cmdresp_no)
878 adapter->hw_status = MWIFIEX_HW_STATUS_INIT_DONE;
879 }
880
881 if (adapter->curr_cmd) {
882 if (adapter->curr_cmd->wait_q_enabled)
883 adapter->cmd_wait_q.status = ret;
884
885 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
886
887 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
888 adapter->curr_cmd = NULL;
889 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
890 }
891
892 return ret;
893}
894
895
896
897
898
899
900void
901mwifiex_cmd_timeout_func(unsigned long function_context)
902{
903 struct mwifiex_adapter *adapter =
904 (struct mwifiex_adapter *) function_context;
905 struct cmd_ctrl_node *cmd_node;
906 struct timeval tstamp;
907
908 adapter->num_cmd_timeout++;
909 adapter->dbg.num_cmd_timeout++;
910 if (!adapter->curr_cmd) {
911 dev_dbg(adapter->dev, "cmd: empty curr_cmd\n");
912 return;
913 }
914 cmd_node = adapter->curr_cmd;
915 if (cmd_node) {
916 adapter->dbg.timeout_cmd_id =
917 adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index];
918 adapter->dbg.timeout_cmd_act =
919 adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index];
920 do_gettimeofday(&tstamp);
921 dev_err(adapter->dev,
922 "%s: Timeout cmd id (%lu.%lu) = %#x, act = %#x\n",
923 __func__, tstamp.tv_sec, tstamp.tv_usec,
924 adapter->dbg.timeout_cmd_id,
925 adapter->dbg.timeout_cmd_act);
926
927 dev_err(adapter->dev, "num_data_h2c_failure = %d\n",
928 adapter->dbg.num_tx_host_to_card_failure);
929 dev_err(adapter->dev, "num_cmd_h2c_failure = %d\n",
930 adapter->dbg.num_cmd_host_to_card_failure);
931
932 dev_err(adapter->dev, "num_cmd_timeout = %d\n",
933 adapter->dbg.num_cmd_timeout);
934 dev_err(adapter->dev, "num_tx_timeout = %d\n",
935 adapter->dbg.num_tx_timeout);
936
937 dev_err(adapter->dev, "last_cmd_index = %d\n",
938 adapter->dbg.last_cmd_index);
939 dev_err(adapter->dev, "last_cmd_id: %*ph\n",
940 (int)sizeof(adapter->dbg.last_cmd_id),
941 adapter->dbg.last_cmd_id);
942 dev_err(adapter->dev, "last_cmd_act: %*ph\n",
943 (int)sizeof(adapter->dbg.last_cmd_act),
944 adapter->dbg.last_cmd_act);
945
946 dev_err(adapter->dev, "last_cmd_resp_index = %d\n",
947 adapter->dbg.last_cmd_resp_index);
948 dev_err(adapter->dev, "last_cmd_resp_id: %*ph\n",
949 (int)sizeof(adapter->dbg.last_cmd_resp_id),
950 adapter->dbg.last_cmd_resp_id);
951
952 dev_err(adapter->dev, "last_event_index = %d\n",
953 adapter->dbg.last_event_index);
954 dev_err(adapter->dev, "last_event: %*ph\n",
955 (int)sizeof(adapter->dbg.last_event),
956 adapter->dbg.last_event);
957
958 dev_err(adapter->dev, "data_sent=%d cmd_sent=%d\n",
959 adapter->data_sent, adapter->cmd_sent);
960
961 dev_err(adapter->dev, "ps_mode=%d ps_state=%d\n",
962 adapter->ps_mode, adapter->ps_state);
963
964 if (cmd_node->wait_q_enabled) {
965 adapter->cmd_wait_q.status = -ETIMEDOUT;
966 wake_up_interruptible(&adapter->cmd_wait_q.wait);
967 mwifiex_cancel_pending_ioctl(adapter);
968
969 adapter->cmd_sent = false;
970 }
971 }
972 if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING)
973 mwifiex_init_fw_complete(adapter);
974
975 if (adapter->if_ops.card_reset)
976 adapter->if_ops.card_reset(adapter);
977}
978
979
980
981
982
983
984
985
986void
987mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter)
988{
989 struct cmd_ctrl_node *cmd_node = NULL, *tmp_node;
990 unsigned long flags;
991
992
993 if ((adapter->curr_cmd) && (adapter->curr_cmd->wait_q_enabled)) {
994 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
995 adapter->curr_cmd->wait_q_enabled = false;
996 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
997 adapter->cmd_wait_q.status = -1;
998 mwifiex_complete_cmd(adapter, adapter->curr_cmd);
999 }
1000
1001 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
1002 list_for_each_entry_safe(cmd_node, tmp_node,
1003 &adapter->cmd_pending_q, list) {
1004 list_del(&cmd_node->list);
1005 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
1006
1007 if (cmd_node->wait_q_enabled) {
1008 adapter->cmd_wait_q.status = -1;
1009 mwifiex_complete_cmd(adapter, cmd_node);
1010 cmd_node->wait_q_enabled = false;
1011 }
1012 mwifiex_recycle_cmd_node(adapter, cmd_node);
1013 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
1014 }
1015 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
1016
1017
1018 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
1019 list_for_each_entry_safe(cmd_node, tmp_node,
1020 &adapter->scan_pending_q, list) {
1021 list_del(&cmd_node->list);
1022 spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
1023
1024 cmd_node->wait_q_enabled = false;
1025 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
1026 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
1027 }
1028 spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
1029
1030 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
1031 adapter->scan_processing = false;
1032 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
1033}
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045void
1046mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter)
1047{
1048 struct cmd_ctrl_node *cmd_node = NULL, *tmp_node = NULL;
1049 unsigned long cmd_flags;
1050 unsigned long scan_pending_q_flags;
1051 uint16_t cancel_scan_cmd = false;
1052
1053 if ((adapter->curr_cmd) &&
1054 (adapter->curr_cmd->wait_q_enabled)) {
1055 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
1056 cmd_node = adapter->curr_cmd;
1057 cmd_node->wait_q_enabled = false;
1058 cmd_node->cmd_flag |= CMD_F_CANCELED;
1059 mwifiex_recycle_cmd_node(adapter, cmd_node);
1060 mwifiex_complete_cmd(adapter, adapter->curr_cmd);
1061 adapter->curr_cmd = NULL;
1062 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
1063 }
1064
1065
1066 spin_lock_irqsave(&adapter->scan_pending_q_lock,
1067 scan_pending_q_flags);
1068 list_for_each_entry_safe(cmd_node, tmp_node,
1069 &adapter->scan_pending_q, list) {
1070 list_del(&cmd_node->list);
1071 spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
1072 scan_pending_q_flags);
1073 cmd_node->wait_q_enabled = false;
1074 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
1075 spin_lock_irqsave(&adapter->scan_pending_q_lock,
1076 scan_pending_q_flags);
1077 cancel_scan_cmd = true;
1078 }
1079 spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
1080 scan_pending_q_flags);
1081
1082 if (cancel_scan_cmd) {
1083 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
1084 adapter->scan_processing = false;
1085 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
1086 }
1087 adapter->cmd_wait_q.status = -1;
1088}
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099void
1100mwifiex_check_ps_cond(struct mwifiex_adapter *adapter)
1101{
1102 if (!adapter->cmd_sent &&
1103 !adapter->curr_cmd && !IS_CARD_RX_RCVD(adapter))
1104 mwifiex_dnld_sleep_confirm_cmd(adapter);
1105 else
1106 dev_dbg(adapter->dev,
1107 "cmd: Delay Sleep Confirm (%s%s%s)\n",
1108 (adapter->cmd_sent) ? "D" : "",
1109 (adapter->curr_cmd) ? "C" : "",
1110 (IS_CARD_RX_RCVD(adapter)) ? "R" : "");
1111}
1112
1113
1114
1115
1116
1117
1118void
1119mwifiex_hs_activated_event(struct mwifiex_private *priv, u8 activated)
1120{
1121 if (activated) {
1122 if (priv->adapter->is_hs_configured) {
1123 priv->adapter->hs_activated = true;
1124 mwifiex_update_rxreor_flags(priv->adapter,
1125 RXREOR_FORCE_NO_DROP);
1126 dev_dbg(priv->adapter->dev, "event: hs_activated\n");
1127 priv->adapter->hs_activate_wait_q_woken = true;
1128 wake_up_interruptible(
1129 &priv->adapter->hs_activate_wait_q);
1130 } else {
1131 dev_dbg(priv->adapter->dev, "event: HS not configured\n");
1132 }
1133 } else {
1134 dev_dbg(priv->adapter->dev, "event: hs_deactivated\n");
1135 priv->adapter->hs_activated = false;
1136 }
1137}
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149int mwifiex_ret_802_11_hs_cfg(struct mwifiex_private *priv,
1150 struct host_cmd_ds_command *resp)
1151{
1152 struct mwifiex_adapter *adapter = priv->adapter;
1153 struct host_cmd_ds_802_11_hs_cfg_enh *phs_cfg =
1154 &resp->params.opt_hs_cfg;
1155 uint32_t conditions = le32_to_cpu(phs_cfg->params.hs_config.conditions);
1156
1157 if (phs_cfg->action == cpu_to_le16(HS_ACTIVATE) &&
1158 adapter->iface_type == MWIFIEX_SDIO) {
1159 mwifiex_hs_activated_event(priv, true);
1160 return 0;
1161 } else {
1162 dev_dbg(adapter->dev, "cmd: CMD_RESP: HS_CFG cmd reply"
1163 " result=%#x, conditions=0x%x gpio=0x%x gap=0x%x\n",
1164 resp->result, conditions,
1165 phs_cfg->params.hs_config.gpio,
1166 phs_cfg->params.hs_config.gap);
1167 }
1168 if (conditions != HS_CFG_CANCEL) {
1169 adapter->is_hs_configured = true;
1170 if (adapter->iface_type == MWIFIEX_USB ||
1171 adapter->iface_type == MWIFIEX_PCIE)
1172 mwifiex_hs_activated_event(priv, true);
1173 } else {
1174 adapter->is_hs_configured = false;
1175 if (adapter->hs_activated)
1176 mwifiex_hs_activated_event(priv, false);
1177 }
1178
1179 return 0;
1180}
1181
1182
1183
1184
1185
1186void
1187mwifiex_process_hs_config(struct mwifiex_adapter *adapter)
1188{
1189 dev_dbg(adapter->dev, "info: %s: auto cancelling host sleep"
1190 " since there is interrupt from the firmware\n", __func__);
1191
1192 adapter->if_ops.wakeup(adapter);
1193 adapter->hs_activated = false;
1194 adapter->is_hs_configured = false;
1195 adapter->is_suspended = false;
1196 mwifiex_hs_activated_event(mwifiex_get_priv(adapter,
1197 MWIFIEX_BSS_ROLE_ANY),
1198 false);
1199}
1200EXPORT_SYMBOL_GPL(mwifiex_process_hs_config);
1201
1202
1203
1204
1205
1206
1207void
1208mwifiex_process_sleep_confirm_resp(struct mwifiex_adapter *adapter,
1209 u8 *pbuf, u32 upld_len)
1210{
1211 struct host_cmd_ds_command *cmd = (struct host_cmd_ds_command *) pbuf;
1212 struct mwifiex_private *priv =
1213 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1214 uint16_t result = le16_to_cpu(cmd->result);
1215 uint16_t command = le16_to_cpu(cmd->command);
1216 uint16_t seq_num = le16_to_cpu(cmd->seq_num);
1217
1218 if (!upld_len) {
1219 dev_err(adapter->dev, "%s: cmd size is 0\n", __func__);
1220 return;
1221 }
1222
1223
1224 priv = mwifiex_get_priv_by_id(adapter, HostCmd_GET_BSS_NO(seq_num),
1225 HostCmd_GET_BSS_TYPE(seq_num));
1226 if (!priv)
1227 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1228
1229
1230 seq_num = HostCmd_GET_SEQ_NO(seq_num);
1231
1232 command &= HostCmd_CMD_ID_MASK;
1233
1234 if (command != HostCmd_CMD_802_11_PS_MODE_ENH) {
1235 dev_err(adapter->dev,
1236 "%s: rcvd unexpected resp for cmd %#x, result = %x\n",
1237 __func__, command, result);
1238 return;
1239 }
1240
1241 if (result) {
1242 dev_err(adapter->dev, "%s: sleep confirm cmd failed\n",
1243 __func__);
1244 adapter->pm_wakeup_card_req = false;
1245 adapter->ps_state = PS_STATE_AWAKE;
1246 return;
1247 }
1248 adapter->pm_wakeup_card_req = true;
1249 if (adapter->is_hs_configured)
1250 mwifiex_hs_activated_event(mwifiex_get_priv
1251 (adapter, MWIFIEX_BSS_ROLE_ANY),
1252 true);
1253 adapter->ps_state = PS_STATE_SLEEP;
1254 cmd->command = cpu_to_le16(command);
1255 cmd->seq_num = cpu_to_le16(seq_num);
1256}
1257EXPORT_SYMBOL_GPL(mwifiex_process_sleep_confirm_resp);
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271int mwifiex_cmd_enh_power_mode(struct mwifiex_private *priv,
1272 struct host_cmd_ds_command *cmd,
1273 u16 cmd_action, uint16_t ps_bitmap,
1274 struct mwifiex_ds_auto_ds *auto_ds)
1275{
1276 struct host_cmd_ds_802_11_ps_mode_enh *psmode_enh =
1277 &cmd->params.psmode_enh;
1278 u8 *tlv;
1279 u16 cmd_size = 0;
1280
1281 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_PS_MODE_ENH);
1282 if (cmd_action == DIS_AUTO_PS) {
1283 psmode_enh->action = cpu_to_le16(DIS_AUTO_PS);
1284 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1285 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(psmode_enh->action) +
1286 sizeof(psmode_enh->params.ps_bitmap));
1287 } else if (cmd_action == GET_PS) {
1288 psmode_enh->action = cpu_to_le16(GET_PS);
1289 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1290 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(psmode_enh->action) +
1291 sizeof(psmode_enh->params.ps_bitmap));
1292 } else if (cmd_action == EN_AUTO_PS) {
1293 psmode_enh->action = cpu_to_le16(EN_AUTO_PS);
1294 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1295 cmd_size = S_DS_GEN + sizeof(psmode_enh->action) +
1296 sizeof(psmode_enh->params.ps_bitmap);
1297 tlv = (u8 *) cmd + cmd_size;
1298 if (ps_bitmap & BITMAP_STA_PS) {
1299 struct mwifiex_adapter *adapter = priv->adapter;
1300 struct mwifiex_ie_types_ps_param *ps_tlv =
1301 (struct mwifiex_ie_types_ps_param *) tlv;
1302 struct mwifiex_ps_param *ps_mode = &ps_tlv->param;
1303 ps_tlv->header.type = cpu_to_le16(TLV_TYPE_PS_PARAM);
1304 ps_tlv->header.len = cpu_to_le16(sizeof(*ps_tlv) -
1305 sizeof(struct mwifiex_ie_types_header));
1306 cmd_size += sizeof(*ps_tlv);
1307 tlv += sizeof(*ps_tlv);
1308 dev_dbg(adapter->dev, "cmd: PS Command: Enter PS\n");
1309 ps_mode->null_pkt_interval =
1310 cpu_to_le16(adapter->null_pkt_interval);
1311 ps_mode->multiple_dtims =
1312 cpu_to_le16(adapter->multiple_dtim);
1313 ps_mode->bcn_miss_timeout =
1314 cpu_to_le16(adapter->bcn_miss_time_out);
1315 ps_mode->local_listen_interval =
1316 cpu_to_le16(adapter->local_listen_interval);
1317 ps_mode->adhoc_wake_period =
1318 cpu_to_le16(adapter->adhoc_awake_period);
1319 ps_mode->delay_to_ps =
1320 cpu_to_le16(adapter->delay_to_ps);
1321 ps_mode->mode = cpu_to_le16(adapter->enhanced_ps_mode);
1322
1323 }
1324 if (ps_bitmap & BITMAP_AUTO_DS) {
1325 struct mwifiex_ie_types_auto_ds_param *auto_ds_tlv =
1326 (struct mwifiex_ie_types_auto_ds_param *) tlv;
1327 u16 idletime = 0;
1328
1329 auto_ds_tlv->header.type =
1330 cpu_to_le16(TLV_TYPE_AUTO_DS_PARAM);
1331 auto_ds_tlv->header.len =
1332 cpu_to_le16(sizeof(*auto_ds_tlv) -
1333 sizeof(struct mwifiex_ie_types_header));
1334 cmd_size += sizeof(*auto_ds_tlv);
1335 tlv += sizeof(*auto_ds_tlv);
1336 if (auto_ds)
1337 idletime = auto_ds->idle_time;
1338 dev_dbg(priv->adapter->dev,
1339 "cmd: PS Command: Enter Auto Deep Sleep\n");
1340 auto_ds_tlv->deep_sleep_timeout = cpu_to_le16(idletime);
1341 }
1342 cmd->size = cpu_to_le16(cmd_size);
1343 }
1344 return 0;
1345}
1346
1347
1348
1349
1350
1351
1352
1353
1354int mwifiex_ret_enh_power_mode(struct mwifiex_private *priv,
1355 struct host_cmd_ds_command *resp,
1356 struct mwifiex_ds_pm_cfg *pm_cfg)
1357{
1358 struct mwifiex_adapter *adapter = priv->adapter;
1359 struct host_cmd_ds_802_11_ps_mode_enh *ps_mode =
1360 &resp->params.psmode_enh;
1361 uint16_t action = le16_to_cpu(ps_mode->action);
1362 uint16_t ps_bitmap = le16_to_cpu(ps_mode->params.ps_bitmap);
1363 uint16_t auto_ps_bitmap =
1364 le16_to_cpu(ps_mode->params.ps_bitmap);
1365
1366 dev_dbg(adapter->dev,
1367 "info: %s: PS_MODE cmd reply result=%#x action=%#X\n",
1368 __func__, resp->result, action);
1369 if (action == EN_AUTO_PS) {
1370 if (auto_ps_bitmap & BITMAP_AUTO_DS) {
1371 dev_dbg(adapter->dev, "cmd: Enabled auto deep sleep\n");
1372 priv->adapter->is_deep_sleep = true;
1373 }
1374 if (auto_ps_bitmap & BITMAP_STA_PS) {
1375 dev_dbg(adapter->dev, "cmd: Enabled STA power save\n");
1376 if (adapter->sleep_period.period)
1377 dev_dbg(adapter->dev,
1378 "cmd: set to uapsd/pps mode\n");
1379 }
1380 } else if (action == DIS_AUTO_PS) {
1381 if (ps_bitmap & BITMAP_AUTO_DS) {
1382 priv->adapter->is_deep_sleep = false;
1383 dev_dbg(adapter->dev, "cmd: Disabled auto deep sleep\n");
1384 }
1385 if (ps_bitmap & BITMAP_STA_PS) {
1386 dev_dbg(adapter->dev, "cmd: Disabled STA power save\n");
1387 if (adapter->sleep_period.period) {
1388 adapter->delay_null_pkt = false;
1389 adapter->tx_lock_flag = false;
1390 adapter->pps_uapsd_mode = false;
1391 }
1392 }
1393 } else if (action == GET_PS) {
1394 if (ps_bitmap & BITMAP_STA_PS)
1395 adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_PSP;
1396 else
1397 adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM;
1398
1399 dev_dbg(adapter->dev, "cmd: ps_bitmap=%#x\n", ps_bitmap);
1400
1401 if (pm_cfg) {
1402
1403 if (ps_bitmap & BITMAP_STA_PS)
1404 pm_cfg->param.ps_mode = 1;
1405 else
1406 pm_cfg->param.ps_mode = 0;
1407 }
1408 }
1409 return 0;
1410}
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420int mwifiex_cmd_get_hw_spec(struct mwifiex_private *priv,
1421 struct host_cmd_ds_command *cmd)
1422{
1423 struct host_cmd_ds_get_hw_spec *hw_spec = &cmd->params.hw_spec;
1424
1425 cmd->command = cpu_to_le16(HostCmd_CMD_GET_HW_SPEC);
1426 cmd->size =
1427 cpu_to_le16(sizeof(struct host_cmd_ds_get_hw_spec) + S_DS_GEN);
1428 memcpy(hw_spec->permanent_addr, priv->curr_addr, ETH_ALEN);
1429
1430 return 0;
1431}
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453int mwifiex_ret_get_hw_spec(struct mwifiex_private *priv,
1454 struct host_cmd_ds_command *resp)
1455{
1456 struct host_cmd_ds_get_hw_spec *hw_spec = &resp->params.hw_spec;
1457 struct mwifiex_adapter *adapter = priv->adapter;
1458 int i;
1459
1460 adapter->fw_cap_info = le32_to_cpu(hw_spec->fw_cap_info);
1461
1462 if (IS_SUPPORT_MULTI_BANDS(adapter))
1463 adapter->fw_bands = (u8) GET_FW_DEFAULT_BANDS(adapter);
1464 else
1465 adapter->fw_bands = BAND_B;
1466
1467 adapter->config_bands = adapter->fw_bands;
1468
1469 if (adapter->fw_bands & BAND_A) {
1470 if (adapter->fw_bands & BAND_GN) {
1471 adapter->config_bands |= BAND_AN;
1472 adapter->fw_bands |= BAND_AN;
1473 }
1474 if (adapter->fw_bands & BAND_AN) {
1475 adapter->adhoc_start_band = BAND_A | BAND_AN;
1476 adapter->adhoc_11n_enabled = true;
1477 } else {
1478 adapter->adhoc_start_band = BAND_A;
1479 }
1480 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL_A;
1481 } else if (adapter->fw_bands & BAND_GN) {
1482 adapter->adhoc_start_band = BAND_G | BAND_B | BAND_GN;
1483 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1484 adapter->adhoc_11n_enabled = true;
1485 } else if (adapter->fw_bands & BAND_G) {
1486 adapter->adhoc_start_band = BAND_G | BAND_B;
1487 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1488 } else if (adapter->fw_bands & BAND_B) {
1489 adapter->adhoc_start_band = BAND_B;
1490 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1491 }
1492
1493 adapter->fw_release_number = le32_to_cpu(hw_spec->fw_release_number);
1494 adapter->number_of_antenna = le16_to_cpu(hw_spec->number_of_antenna);
1495
1496 if (le32_to_cpu(hw_spec->dot_11ac_dev_cap)) {
1497 adapter->is_hw_11ac_capable = true;
1498
1499
1500 adapter->hw_dot_11ac_dev_cap =
1501 le32_to_cpu(hw_spec->dot_11ac_dev_cap);
1502 adapter->usr_dot_11ac_dev_cap_bg = adapter->hw_dot_11ac_dev_cap;
1503 adapter->usr_dot_11ac_dev_cap_a = adapter->hw_dot_11ac_dev_cap;
1504
1505
1506 adapter->hw_dot_11ac_mcs_support =
1507 le32_to_cpu(hw_spec->dot_11ac_mcs_support);
1508 adapter->usr_dot_11ac_mcs_support =
1509 adapter->hw_dot_11ac_mcs_support;
1510 } else {
1511 adapter->is_hw_11ac_capable = false;
1512 }
1513
1514 dev_dbg(adapter->dev, "info: GET_HW_SPEC: fw_release_number- %#x\n",
1515 adapter->fw_release_number);
1516 dev_dbg(adapter->dev, "info: GET_HW_SPEC: permanent addr: %pM\n",
1517 hw_spec->permanent_addr);
1518 dev_dbg(adapter->dev,
1519 "info: GET_HW_SPEC: hw_if_version=%#x version=%#x\n",
1520 le16_to_cpu(hw_spec->hw_if_version),
1521 le16_to_cpu(hw_spec->version));
1522
1523 if (priv->curr_addr[0] == 0xff)
1524 memmove(priv->curr_addr, hw_spec->permanent_addr, ETH_ALEN);
1525
1526 adapter->region_code = le16_to_cpu(hw_spec->region_code);
1527
1528 for (i = 0; i < MWIFIEX_MAX_REGION_CODE; i++)
1529
1530 if (adapter->region_code == region_code_index[i])
1531 break;
1532
1533
1534 if (i >= MWIFIEX_MAX_REGION_CODE) {
1535 adapter->region_code = 0x10;
1536 dev_dbg(adapter->dev,
1537 "cmd: unknown region code, use default (USA)\n");
1538 }
1539
1540 adapter->hw_dot_11n_dev_cap = le32_to_cpu(hw_spec->dot_11n_dev_cap);
1541 adapter->hw_dev_mcs_support = hw_spec->dev_mcs_support;
1542
1543 if (adapter->if_ops.update_mp_end_port)
1544 adapter->if_ops.update_mp_end_port(adapter,
1545 le16_to_cpu(hw_spec->mp_end_port));
1546
1547 return 0;
1548}
1549