]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/net/wireless/mwifiex/cmdevt.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[~shefty/rdma-dev.git] / drivers / net / wireless / mwifiex / cmdevt.c
1 /*
2  * Marvell Wireless LAN device driver: commands and events
3  *
4  * Copyright (C) 2011, Marvell International Ltd.
5  *
6  * This software file (the "File") is distributed by Marvell International
7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8  * (the "License").  You may use, redistribute and/or modify this File in
9  * accordance with the terms and conditions of the License, a copy of which
10  * is available by writing to the Free Software Foundation, Inc.,
11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13  *
14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
17  * this warranty disclaimer.
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
28 /*
29  * This function initializes a command node.
30  *
31  * The actual allocation of the node is not done by this function. It only
32  * initiates a node by filling it with default parameters. Similarly,
33  * allocation of the different buffers used (IOCTL buffer, data buffer) are
34  * not done by this function either.
35  */
36 static void
37 mwifiex_init_cmd_node(struct mwifiex_private *priv,
38                       struct cmd_ctrl_node *cmd_node,
39                       u32 cmd_oid, void *data_buf)
40 {
41         cmd_node->priv = priv;
42         cmd_node->cmd_oid = cmd_oid;
43         if (priv->adapter->cmd_wait_q_required) {
44                 cmd_node->wait_q_enabled = priv->adapter->cmd_wait_q_required;
45                 priv->adapter->cmd_wait_q_required = false;
46                 cmd_node->cmd_wait_q_woken = false;
47                 cmd_node->condition = &cmd_node->cmd_wait_q_woken;
48         }
49         cmd_node->data_buf = data_buf;
50         cmd_node->cmd_skb = cmd_node->skb;
51 }
52
53 /*
54  * This function returns a command node from the free queue depending upon
55  * availability.
56  */
57 static struct cmd_ctrl_node *
58 mwifiex_get_cmd_node(struct mwifiex_adapter *adapter)
59 {
60         struct cmd_ctrl_node *cmd_node;
61         unsigned long flags;
62
63         spin_lock_irqsave(&adapter->cmd_free_q_lock, flags);
64         if (list_empty(&adapter->cmd_free_q)) {
65                 dev_err(adapter->dev, "GET_CMD_NODE: cmd node not available\n");
66                 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
67                 return NULL;
68         }
69         cmd_node = list_first_entry(&adapter->cmd_free_q,
70                                     struct cmd_ctrl_node, list);
71         list_del(&cmd_node->list);
72         spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
73
74         return cmd_node;
75 }
76
77 /*
78  * This function cleans up a command node.
79  *
80  * The function resets the fields including the buffer pointers.
81  * This function does not try to free the buffers. They must be
82  * freed before calling this function.
83  *
84  * This function will however call the receive completion callback
85  * in case a response buffer is still available before resetting
86  * the pointer.
87  */
88 static void
89 mwifiex_clean_cmd_node(struct mwifiex_adapter *adapter,
90                        struct cmd_ctrl_node *cmd_node)
91 {
92         cmd_node->cmd_oid = 0;
93         cmd_node->cmd_flag = 0;
94         cmd_node->data_buf = NULL;
95         cmd_node->wait_q_enabled = false;
96
97         if (cmd_node->cmd_skb)
98                 skb_trim(cmd_node->cmd_skb, 0);
99
100         if (cmd_node->resp_skb) {
101                 adapter->if_ops.cmdrsp_complete(adapter, cmd_node->resp_skb);
102                 cmd_node->resp_skb = NULL;
103         }
104 }
105
106 /*
107  * This function sends a host command to the firmware.
108  *
109  * The function copies the host command into the driver command
110  * buffer, which will be transferred to the firmware later by the
111  * main thread.
112  */
113 static int mwifiex_cmd_host_cmd(struct mwifiex_private *priv,
114                                 struct host_cmd_ds_command *cmd,
115                                 struct mwifiex_ds_misc_cmd *pcmd_ptr)
116 {
117         /* Copy the HOST command to command buffer */
118         memcpy(cmd, pcmd_ptr->cmd, pcmd_ptr->len);
119         dev_dbg(priv->adapter->dev, "cmd: host cmd size = %d\n", pcmd_ptr->len);
120         return 0;
121 }
122
123 /*
124  * This function downloads a command to the firmware.
125  *
126  * The function performs sanity tests, sets the command sequence
127  * number and size, converts the header fields to CPU format before
128  * sending. Afterwards, it logs the command ID and action for debugging
129  * and sets up the command timeout timer.
130  */
131 static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private *priv,
132                                   struct cmd_ctrl_node *cmd_node)
133 {
134
135         struct mwifiex_adapter *adapter = priv->adapter;
136         int ret;
137         struct host_cmd_ds_command *host_cmd;
138         uint16_t cmd_code;
139         uint16_t cmd_size;
140         struct timeval tstamp;
141         unsigned long flags;
142         __le32 tmp;
143
144         if (!adapter || !cmd_node)
145                 return -1;
146
147         host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
148
149         /* Sanity test */
150         if (host_cmd == NULL || host_cmd->size == 0) {
151                 dev_err(adapter->dev, "DNLD_CMD: host_cmd is null"
152                         " or cmd size is 0, not sending\n");
153                 if (cmd_node->wait_q_enabled)
154                         adapter->cmd_wait_q.status = -1;
155                 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
156                 return -1;
157         }
158
159         /* Set command sequence number */
160         adapter->seq_num++;
161         host_cmd->seq_num = cpu_to_le16(HostCmd_SET_SEQ_NO_BSS_INFO
162                                         (adapter->seq_num,
163                                          cmd_node->priv->bss_num,
164                                          cmd_node->priv->bss_type));
165
166         spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
167         adapter->curr_cmd = cmd_node;
168         spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
169
170         cmd_code = le16_to_cpu(host_cmd->command);
171         cmd_size = le16_to_cpu(host_cmd->size);
172
173         /* Adjust skb length */
174         if (cmd_node->cmd_skb->len > cmd_size)
175                 /*
176                  * cmd_size is less than sizeof(struct host_cmd_ds_command).
177                  * Trim off the unused portion.
178                  */
179                 skb_trim(cmd_node->cmd_skb, cmd_size);
180         else if (cmd_node->cmd_skb->len < cmd_size)
181                 /*
182                  * cmd_size is larger than sizeof(struct host_cmd_ds_command)
183                  * because we have appended custom IE TLV. Increase skb length
184                  * accordingly.
185                  */
186                 skb_put(cmd_node->cmd_skb, cmd_size - cmd_node->cmd_skb->len);
187
188         do_gettimeofday(&tstamp);
189         dev_dbg(adapter->dev, "cmd: DNLD_CMD: (%lu.%lu): %#x, act %#x, len %d,"
190                 " seqno %#x\n",
191                 tstamp.tv_sec, tstamp.tv_usec, cmd_code,
192                 le16_to_cpu(*(__le16 *) ((u8 *) host_cmd + S_DS_GEN)), cmd_size,
193                 le16_to_cpu(host_cmd->seq_num));
194
195         if (adapter->iface_type == MWIFIEX_USB) {
196                 tmp = cpu_to_le32(MWIFIEX_USB_TYPE_CMD);
197                 skb_push(cmd_node->cmd_skb, MWIFIEX_TYPE_LEN);
198                 memcpy(cmd_node->cmd_skb->data, &tmp, MWIFIEX_TYPE_LEN);
199                 adapter->cmd_sent = true;
200                 ret = adapter->if_ops.host_to_card(adapter,
201                                                    MWIFIEX_USB_EP_CMD_EVENT,
202                                                    cmd_node->cmd_skb, NULL);
203                 skb_pull(cmd_node->cmd_skb, MWIFIEX_TYPE_LEN);
204                 if (ret == -EBUSY)
205                         cmd_node->cmd_skb = NULL;
206         } else {
207                 skb_push(cmd_node->cmd_skb, INTF_HEADER_LEN);
208                 ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
209                                                    cmd_node->cmd_skb, NULL);
210                 skb_pull(cmd_node->cmd_skb, INTF_HEADER_LEN);
211         }
212
213         if (ret == -1) {
214                 dev_err(adapter->dev, "DNLD_CMD: host to card failed\n");
215                 if (adapter->iface_type == MWIFIEX_USB)
216                         adapter->cmd_sent = false;
217                 if (cmd_node->wait_q_enabled)
218                         adapter->cmd_wait_q.status = -1;
219                 mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);
220
221                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
222                 adapter->curr_cmd = NULL;
223                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
224
225                 adapter->dbg.num_cmd_host_to_card_failure++;
226                 return -1;
227         }
228
229         /* Save the last command id and action to debug log */
230         adapter->dbg.last_cmd_index =
231                         (adapter->dbg.last_cmd_index + 1) % DBG_CMD_NUM;
232         adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index] = cmd_code;
233         adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index] =
234                         le16_to_cpu(*(__le16 *) ((u8 *) host_cmd + S_DS_GEN));
235
236         /* Clear BSS_NO_BITS from HostCmd */
237         cmd_code &= HostCmd_CMD_ID_MASK;
238
239         /* Setup the timer after transmit command */
240         mod_timer(&adapter->cmd_timer,
241                   jiffies + (MWIFIEX_TIMER_10S * HZ) / 1000);
242
243         return 0;
244 }
245
246 /*
247  * This function downloads a sleep confirm command to the firmware.
248  *
249  * The function performs sanity tests, sets the command sequence
250  * number and size, converts the header fields to CPU format before
251  * sending.
252  *
253  * No responses are needed for sleep confirm command.
254  */
255 static int mwifiex_dnld_sleep_confirm_cmd(struct mwifiex_adapter *adapter)
256 {
257         int ret;
258         struct mwifiex_private *priv;
259         struct mwifiex_opt_sleep_confirm *sleep_cfm_buf =
260                                 (struct mwifiex_opt_sleep_confirm *)
261                                                 adapter->sleep_cfm->data;
262         struct sk_buff *sleep_cfm_tmp;
263         __le32 tmp;
264
265         priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
266
267         sleep_cfm_buf->seq_num =
268                 cpu_to_le16((HostCmd_SET_SEQ_NO_BSS_INFO
269                                         (adapter->seq_num, priv->bss_num,
270                                          priv->bss_type)));
271         adapter->seq_num++;
272
273         if (adapter->iface_type == MWIFIEX_USB) {
274                 sleep_cfm_tmp =
275                         dev_alloc_skb(sizeof(struct mwifiex_opt_sleep_confirm)
276                                       + MWIFIEX_TYPE_LEN);
277                 skb_put(sleep_cfm_tmp, sizeof(struct mwifiex_opt_sleep_confirm)
278                         + MWIFIEX_TYPE_LEN);
279                 tmp = cpu_to_le32(MWIFIEX_USB_TYPE_CMD);
280                 memcpy(sleep_cfm_tmp->data, &tmp, MWIFIEX_TYPE_LEN);
281                 memcpy(sleep_cfm_tmp->data + MWIFIEX_TYPE_LEN,
282                        adapter->sleep_cfm->data,
283                        sizeof(struct mwifiex_opt_sleep_confirm));
284                 ret = adapter->if_ops.host_to_card(adapter,
285                                                    MWIFIEX_USB_EP_CMD_EVENT,
286                                                    sleep_cfm_tmp, NULL);
287                 if (ret != -EBUSY)
288                         dev_kfree_skb_any(sleep_cfm_tmp);
289         } else {
290                 skb_push(adapter->sleep_cfm, INTF_HEADER_LEN);
291                 ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
292                                                    adapter->sleep_cfm, NULL);
293                 skb_pull(adapter->sleep_cfm, INTF_HEADER_LEN);
294         }
295
296         if (ret == -1) {
297                 dev_err(adapter->dev, "SLEEP_CFM: failed\n");
298                 adapter->dbg.num_cmd_sleep_cfm_host_to_card_failure++;
299                 return -1;
300         }
301         if (GET_BSS_ROLE(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY))
302             == MWIFIEX_BSS_ROLE_STA) {
303                 if (!sleep_cfm_buf->resp_ctrl)
304                         /* Response is not needed for sleep
305                            confirm command */
306                         adapter->ps_state = PS_STATE_SLEEP;
307                 else
308                         adapter->ps_state = PS_STATE_SLEEP_CFM;
309
310                 if (!sleep_cfm_buf->resp_ctrl &&
311                     (adapter->is_hs_configured &&
312                      !adapter->sleep_period.period)) {
313                         adapter->pm_wakeup_card_req = true;
314                         mwifiex_hs_activated_event(mwifiex_get_priv
315                                         (adapter, MWIFIEX_BSS_ROLE_STA), true);
316                 }
317         }
318
319         return ret;
320 }
321
322 /*
323  * This function allocates the command buffers and links them to
324  * the command free queue.
325  *
326  * The driver uses a pre allocated number of command buffers, which
327  * are created at driver initializations and freed at driver cleanup.
328  * Every command needs to obtain a command buffer from this pool before
329  * it can be issued. The command free queue lists the command buffers
330  * currently free to use, while the command pending queue lists the
331  * command buffers already in use and awaiting handling. Command buffers
332  * are returned to the free queue after use.
333  */
334 int mwifiex_alloc_cmd_buffer(struct mwifiex_adapter *adapter)
335 {
336         struct cmd_ctrl_node *cmd_array;
337         u32 buf_size;
338         u32 i;
339
340         /* Allocate and initialize struct cmd_ctrl_node */
341         buf_size = sizeof(struct cmd_ctrl_node) * MWIFIEX_NUM_OF_CMD_BUFFER;
342         cmd_array = kzalloc(buf_size, GFP_KERNEL);
343         if (!cmd_array) {
344                 dev_err(adapter->dev, "%s: failed to alloc cmd_array\n",
345                         __func__);
346                 return -ENOMEM;
347         }
348
349         adapter->cmd_pool = cmd_array;
350         memset(adapter->cmd_pool, 0, buf_size);
351
352         /* Allocate and initialize command buffers */
353         for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++) {
354                 cmd_array[i].skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER);
355                 if (!cmd_array[i].skb) {
356                         dev_err(adapter->dev, "ALLOC_CMD_BUF: out of memory\n");
357                         return -1;
358                 }
359         }
360
361         for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++)
362                 mwifiex_insert_cmd_to_free_q(adapter, &cmd_array[i]);
363
364         return 0;
365 }
366
367 /*
368  * This function frees the command buffers.
369  *
370  * The function calls the completion callback for all the command
371  * buffers that still have response buffers associated with them.
372  */
373 int mwifiex_free_cmd_buffer(struct mwifiex_adapter *adapter)
374 {
375         struct cmd_ctrl_node *cmd_array;
376         u32 i;
377
378         /* Need to check if cmd pool is allocated or not */
379         if (!adapter->cmd_pool) {
380                 dev_dbg(adapter->dev, "info: FREE_CMD_BUF: cmd_pool is null\n");
381                 return 0;
382         }
383
384         cmd_array = adapter->cmd_pool;
385
386         /* Release shared memory buffers */
387         for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++) {
388                 if (cmd_array[i].skb) {
389                         dev_dbg(adapter->dev, "cmd: free cmd buffer %d\n", i);
390                         dev_kfree_skb_any(cmd_array[i].skb);
391                 }
392                 if (!cmd_array[i].resp_skb)
393                         continue;
394
395                 if (adapter->iface_type == MWIFIEX_USB)
396                         adapter->if_ops.cmdrsp_complete(adapter,
397                                                         cmd_array[i].resp_skb);
398                 else
399                         dev_kfree_skb_any(cmd_array[i].resp_skb);
400         }
401         /* Release struct cmd_ctrl_node */
402         if (adapter->cmd_pool) {
403                 dev_dbg(adapter->dev, "cmd: free cmd pool\n");
404                 kfree(adapter->cmd_pool);
405                 adapter->cmd_pool = NULL;
406         }
407
408         return 0;
409 }
410
411 /*
412  * This function handles events generated by firmware.
413  *
414  * Event body of events received from firmware are not used (though they are
415  * saved), only the event ID is used. Some events are re-invoked by
416  * the driver, with a new event body.
417  *
418  * After processing, the function calls the completion callback
419  * for cleanup.
420  */
421 int mwifiex_process_event(struct mwifiex_adapter *adapter)
422 {
423         int ret;
424         struct mwifiex_private *priv =
425                 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
426         struct sk_buff *skb = adapter->event_skb;
427         u32 eventcause = adapter->event_cause;
428         struct timeval tstamp;
429         struct mwifiex_rxinfo *rx_info;
430
431         /* Save the last event to debug log */
432         adapter->dbg.last_event_index =
433                         (adapter->dbg.last_event_index + 1) % DBG_CMD_NUM;
434         adapter->dbg.last_event[adapter->dbg.last_event_index] =
435                                                         (u16) eventcause;
436
437         /* Get BSS number and corresponding priv */
438         priv = mwifiex_get_priv_by_id(adapter, EVENT_GET_BSS_NUM(eventcause),
439                                       EVENT_GET_BSS_TYPE(eventcause));
440         if (!priv)
441                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
442         /* Clear BSS_NO_BITS from event */
443         eventcause &= EVENT_ID_MASK;
444         adapter->event_cause = eventcause;
445
446         if (skb) {
447                 rx_info = MWIFIEX_SKB_RXCB(skb);
448                 rx_info->bss_num = priv->bss_num;
449                 rx_info->bss_type = priv->bss_type;
450         }
451
452         if (eventcause != EVENT_PS_SLEEP && eventcause != EVENT_PS_AWAKE) {
453                 do_gettimeofday(&tstamp);
454                 dev_dbg(adapter->dev, "event: %lu.%lu: cause: %#x\n",
455                         tstamp.tv_sec, tstamp.tv_usec, eventcause);
456         } else {
457                 /* Handle PS_SLEEP/AWAKE events on STA */
458                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
459                 if (!priv)
460                         priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
461         }
462
463         if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP)
464                 ret = mwifiex_process_uap_event(priv);
465         else
466                 ret = mwifiex_process_sta_event(priv);
467
468         adapter->event_cause = 0;
469         adapter->event_skb = NULL;
470         adapter->if_ops.event_complete(adapter, skb);
471
472         return ret;
473 }
474
475 /*
476  * This function is used to send synchronous command to the firmware.
477  *
478  * it allocates a wait queue for the command and wait for the command
479  * response.
480  */
481 int mwifiex_send_cmd_sync(struct mwifiex_private *priv, uint16_t cmd_no,
482                           u16 cmd_action, u32 cmd_oid, void *data_buf)
483 {
484         int ret = 0;
485         struct mwifiex_adapter *adapter = priv->adapter;
486
487         adapter->cmd_wait_q_required = true;
488
489         ret = mwifiex_send_cmd_async(priv, cmd_no, cmd_action, cmd_oid,
490                                      data_buf);
491         if (!ret)
492                 ret = mwifiex_wait_queue_complete(adapter);
493
494         return ret;
495 }
496
497
498 /*
499  * This function prepares a command and asynchronously send it to the firmware.
500  *
501  * Preparation includes -
502  *      - Sanity tests to make sure the card is still present or the FW
503  *        is not reset
504  *      - Getting a new command node from the command free queue
505  *      - Initializing the command node for default parameters
506  *      - Fill up the non-default parameters and buffer pointers
507  *      - Add the command to pending queue
508  */
509 int mwifiex_send_cmd_async(struct mwifiex_private *priv, uint16_t cmd_no,
510                            u16 cmd_action, u32 cmd_oid, void *data_buf)
511 {
512         int ret;
513         struct mwifiex_adapter *adapter = priv->adapter;
514         struct cmd_ctrl_node *cmd_node;
515         struct host_cmd_ds_command *cmd_ptr;
516
517         if (!adapter) {
518                 pr_err("PREP_CMD: adapter is NULL\n");
519                 return -1;
520         }
521
522         if (adapter->is_suspended) {
523                 dev_err(adapter->dev, "PREP_CMD: device in suspended state\n");
524                 return -1;
525         }
526
527         if (adapter->surprise_removed) {
528                 dev_err(adapter->dev, "PREP_CMD: card is removed\n");
529                 return -1;
530         }
531
532         if (adapter->hw_status == MWIFIEX_HW_STATUS_RESET) {
533                 if (cmd_no != HostCmd_CMD_FUNC_INIT) {
534                         dev_err(adapter->dev, "PREP_CMD: FW in reset state\n");
535                         return -1;
536                 }
537         }
538
539         /* Get a new command node */
540         cmd_node = mwifiex_get_cmd_node(adapter);
541
542         if (!cmd_node) {
543                 dev_err(adapter->dev, "PREP_CMD: no free cmd node\n");
544                 return -1;
545         }
546
547         /* Initialize the command node */
548         mwifiex_init_cmd_node(priv, cmd_node, cmd_oid, data_buf);
549
550         if (!cmd_node->cmd_skb) {
551                 dev_err(adapter->dev, "PREP_CMD: no free cmd buf\n");
552                 return -1;
553         }
554
555         memset(skb_put(cmd_node->cmd_skb, sizeof(struct host_cmd_ds_command)),
556                0, sizeof(struct host_cmd_ds_command));
557
558         cmd_ptr = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
559         cmd_ptr->command = cpu_to_le16(cmd_no);
560         cmd_ptr->result = 0;
561
562         /* Prepare command */
563         if (cmd_no) {
564                 switch (cmd_no) {
565                 case HostCmd_CMD_UAP_SYS_CONFIG:
566                 case HostCmd_CMD_UAP_BSS_START:
567                 case HostCmd_CMD_UAP_BSS_STOP:
568                         ret = mwifiex_uap_prepare_cmd(priv, cmd_no, cmd_action,
569                                                       cmd_oid, data_buf,
570                                                       cmd_ptr);
571                         break;
572                 default:
573                         ret = mwifiex_sta_prepare_cmd(priv, cmd_no, cmd_action,
574                                                       cmd_oid, data_buf,
575                                                       cmd_ptr);
576                         break;
577                 }
578         } else {
579                 ret = mwifiex_cmd_host_cmd(priv, cmd_ptr, data_buf);
580                 cmd_node->cmd_flag |= CMD_F_HOSTCMD;
581         }
582
583         /* Return error, since the command preparation failed */
584         if (ret) {
585                 dev_err(adapter->dev, "PREP_CMD: cmd %#x preparation failed\n",
586                         cmd_no);
587                 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
588                 return -1;
589         }
590
591         /* Send command */
592         if (cmd_no == HostCmd_CMD_802_11_SCAN) {
593                 mwifiex_queue_scan_cmd(priv, cmd_node);
594         } else {
595                 adapter->cmd_queued = cmd_node;
596                 mwifiex_insert_cmd_to_pending_q(adapter, cmd_node, true);
597                 queue_work(adapter->workqueue, &adapter->main_work);
598         }
599
600         return ret;
601 }
602
603 /*
604  * This function returns a command to the command free queue.
605  *
606  * The function also calls the completion callback if required, before
607  * cleaning the command node and re-inserting it into the free queue.
608  */
609 void
610 mwifiex_insert_cmd_to_free_q(struct mwifiex_adapter *adapter,
611                              struct cmd_ctrl_node *cmd_node)
612 {
613         unsigned long flags;
614
615         if (!cmd_node)
616                 return;
617
618         if (cmd_node->wait_q_enabled)
619                 mwifiex_complete_cmd(adapter, cmd_node);
620         /* Clean the node */
621         mwifiex_clean_cmd_node(adapter, cmd_node);
622
623         /* Insert node into cmd_free_q */
624         spin_lock_irqsave(&adapter->cmd_free_q_lock, flags);
625         list_add_tail(&cmd_node->list, &adapter->cmd_free_q);
626         spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
627 }
628
629 /*
630  * This function queues a command to the command pending queue.
631  *
632  * This in effect adds the command to the command list to be executed.
633  * Exit PS command is handled specially, by placing it always to the
634  * front of the command queue.
635  */
636 void
637 mwifiex_insert_cmd_to_pending_q(struct mwifiex_adapter *adapter,
638                                 struct cmd_ctrl_node *cmd_node, u32 add_tail)
639 {
640         struct host_cmd_ds_command *host_cmd = NULL;
641         u16 command;
642         unsigned long flags;
643
644         host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
645         if (!host_cmd) {
646                 dev_err(adapter->dev, "QUEUE_CMD: host_cmd is NULL\n");
647                 return;
648         }
649
650         command = le16_to_cpu(host_cmd->command);
651
652         /* Exit_PS command needs to be queued in the header always. */
653         if (command == HostCmd_CMD_802_11_PS_MODE_ENH) {
654                 struct host_cmd_ds_802_11_ps_mode_enh *pm =
655                                                 &host_cmd->params.psmode_enh;
656                 if ((le16_to_cpu(pm->action) == DIS_PS) ||
657                     (le16_to_cpu(pm->action) == DIS_AUTO_PS)) {
658                         if (adapter->ps_state != PS_STATE_AWAKE)
659                                 add_tail = false;
660                 }
661         }
662
663         spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
664         if (add_tail)
665                 list_add_tail(&cmd_node->list, &adapter->cmd_pending_q);
666         else
667                 list_add(&cmd_node->list, &adapter->cmd_pending_q);
668         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
669
670         dev_dbg(adapter->dev, "cmd: QUEUE_CMD: cmd=%#x is queued\n", command);
671 }
672
673 /*
674  * This function executes the next command in command pending queue.
675  *
676  * This function will fail if a command is already in processing stage,
677  * otherwise it will dequeue the first command from the command pending
678  * queue and send to the firmware.
679  *
680  * If the device is currently in host sleep mode, any commands, except the
681  * host sleep configuration command will de-activate the host sleep. For PS
682  * mode, the function will put the firmware back to sleep if applicable.
683  */
684 int mwifiex_exec_next_cmd(struct mwifiex_adapter *adapter)
685 {
686         struct mwifiex_private *priv;
687         struct cmd_ctrl_node *cmd_node;
688         int ret = 0;
689         struct host_cmd_ds_command *host_cmd;
690         unsigned long cmd_flags;
691         unsigned long cmd_pending_q_flags;
692
693         /* Check if already in processing */
694         if (adapter->curr_cmd) {
695                 dev_err(adapter->dev, "EXEC_NEXT_CMD: cmd in processing\n");
696                 return -1;
697         }
698
699         spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
700         /* Check if any command is pending */
701         spin_lock_irqsave(&adapter->cmd_pending_q_lock, cmd_pending_q_flags);
702         if (list_empty(&adapter->cmd_pending_q)) {
703                 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
704                                        cmd_pending_q_flags);
705                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
706                 return 0;
707         }
708         cmd_node = list_first_entry(&adapter->cmd_pending_q,
709                                     struct cmd_ctrl_node, list);
710         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
711                                cmd_pending_q_flags);
712
713         host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
714         priv = cmd_node->priv;
715
716         if (adapter->ps_state != PS_STATE_AWAKE) {
717                 dev_err(adapter->dev, "%s: cannot send cmd in sleep state,"
718                                 " this should not happen\n", __func__);
719                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
720                 return ret;
721         }
722
723         spin_lock_irqsave(&adapter->cmd_pending_q_lock, cmd_pending_q_flags);
724         list_del(&cmd_node->list);
725         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
726                                cmd_pending_q_flags);
727
728         spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
729         ret = mwifiex_dnld_cmd_to_fw(priv, cmd_node);
730         priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
731         /* Any command sent to the firmware when host is in sleep
732          * mode should de-configure host sleep. We should skip the
733          * host sleep configuration command itself though
734          */
735         if (priv && (host_cmd->command !=
736              cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH))) {
737                 if (adapter->hs_activated) {
738                         adapter->is_hs_configured = false;
739                         mwifiex_hs_activated_event(priv, false);
740                 }
741         }
742
743         return ret;
744 }
745
746 /*
747  * This function handles the command response.
748  *
749  * After processing, the function cleans the command node and puts
750  * it back to the command free queue.
751  */
752 int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter)
753 {
754         struct host_cmd_ds_command *resp;
755         struct mwifiex_private *priv =
756                 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
757         int ret = 0;
758         uint16_t orig_cmdresp_no;
759         uint16_t cmdresp_no;
760         uint16_t cmdresp_result;
761         struct timeval tstamp;
762         unsigned long flags;
763
764         /* Now we got response from FW, cancel the command timer */
765         del_timer(&adapter->cmd_timer);
766
767         if (!adapter->curr_cmd || !adapter->curr_cmd->resp_skb) {
768                 resp = (struct host_cmd_ds_command *) adapter->upld_buf;
769                 dev_err(adapter->dev, "CMD_RESP: NULL curr_cmd, %#x\n",
770                         le16_to_cpu(resp->command));
771                 return -1;
772         }
773
774         adapter->num_cmd_timeout = 0;
775
776         resp = (struct host_cmd_ds_command *) adapter->curr_cmd->resp_skb->data;
777         if (adapter->curr_cmd->cmd_flag & CMD_F_CANCELED) {
778                 dev_err(adapter->dev, "CMD_RESP: %#x been canceled\n",
779                         le16_to_cpu(resp->command));
780                 mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);
781                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
782                 adapter->curr_cmd = NULL;
783                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
784                 return -1;
785         }
786
787         if (adapter->curr_cmd->cmd_flag & CMD_F_HOSTCMD) {
788                 /* Copy original response back to response buffer */
789                 struct mwifiex_ds_misc_cmd *hostcmd;
790                 uint16_t size = le16_to_cpu(resp->size);
791                 dev_dbg(adapter->dev, "info: host cmd resp size = %d\n", size);
792                 size = min_t(u16, size, MWIFIEX_SIZE_OF_CMD_BUFFER);
793                 if (adapter->curr_cmd->data_buf) {
794                         hostcmd = adapter->curr_cmd->data_buf;
795                         hostcmd->len = size;
796                         memcpy(hostcmd->cmd, resp, size);
797                 }
798         }
799         orig_cmdresp_no = le16_to_cpu(resp->command);
800
801         /* Get BSS number and corresponding priv */
802         priv = mwifiex_get_priv_by_id(adapter,
803                              HostCmd_GET_BSS_NO(le16_to_cpu(resp->seq_num)),
804                              HostCmd_GET_BSS_TYPE(le16_to_cpu(resp->seq_num)));
805         if (!priv)
806                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
807         /* Clear RET_BIT from HostCmd */
808         resp->command = cpu_to_le16(orig_cmdresp_no & HostCmd_CMD_ID_MASK);
809
810         cmdresp_no = le16_to_cpu(resp->command);
811         cmdresp_result = le16_to_cpu(resp->result);
812
813         /* Save the last command response to debug log */
814         adapter->dbg.last_cmd_resp_index =
815                         (adapter->dbg.last_cmd_resp_index + 1) % DBG_CMD_NUM;
816         adapter->dbg.last_cmd_resp_id[adapter->dbg.last_cmd_resp_index] =
817                                                                 orig_cmdresp_no;
818
819         do_gettimeofday(&tstamp);
820         dev_dbg(adapter->dev, "cmd: CMD_RESP: (%lu.%lu): 0x%x, result %d,"
821                 " len %d, seqno 0x%x\n",
822                tstamp.tv_sec, tstamp.tv_usec, orig_cmdresp_no, cmdresp_result,
823                le16_to_cpu(resp->size), le16_to_cpu(resp->seq_num));
824
825         if (!(orig_cmdresp_no & HostCmd_RET_BIT)) {
826                 dev_err(adapter->dev, "CMD_RESP: invalid cmd resp\n");
827                 if (adapter->curr_cmd->wait_q_enabled)
828                         adapter->cmd_wait_q.status = -1;
829
830                 mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);
831                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
832                 adapter->curr_cmd = NULL;
833                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
834                 return -1;
835         }
836
837         if (adapter->curr_cmd->cmd_flag & CMD_F_HOSTCMD) {
838                 adapter->curr_cmd->cmd_flag &= ~CMD_F_HOSTCMD;
839                 if ((cmdresp_result == HostCmd_RESULT_OK) &&
840                     (cmdresp_no == HostCmd_CMD_802_11_HS_CFG_ENH))
841                         ret = mwifiex_ret_802_11_hs_cfg(priv, resp);
842         } else {
843                 /* handle response */
844                 ret = mwifiex_process_sta_cmdresp(priv, cmdresp_no, resp);
845         }
846
847         /* Check init command response */
848         if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING) {
849                 if (ret) {
850                         dev_err(adapter->dev, "%s: cmd %#x failed during "
851                                 "initialization\n", __func__, cmdresp_no);
852                         mwifiex_init_fw_complete(adapter);
853                         return -1;
854                 } else if (adapter->last_init_cmd == cmdresp_no)
855                         adapter->hw_status = MWIFIEX_HW_STATUS_INIT_DONE;
856         }
857
858         if (adapter->curr_cmd) {
859                 if (adapter->curr_cmd->wait_q_enabled)
860                         adapter->cmd_wait_q.status = ret;
861
862                 /* Clean up and put current command back to cmd_free_q */
863                 mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);
864
865                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
866                 adapter->curr_cmd = NULL;
867                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
868         }
869
870         return ret;
871 }
872
873 /*
874  * This function handles the timeout of command sending.
875  *
876  * It will re-send the same command again.
877  */
878 void
879 mwifiex_cmd_timeout_func(unsigned long function_context)
880 {
881         struct mwifiex_adapter *adapter =
882                 (struct mwifiex_adapter *) function_context;
883         struct cmd_ctrl_node *cmd_node;
884         struct timeval tstamp;
885
886         adapter->num_cmd_timeout++;
887         adapter->dbg.num_cmd_timeout++;
888         if (!adapter->curr_cmd) {
889                 dev_dbg(adapter->dev, "cmd: empty curr_cmd\n");
890                 return;
891         }
892         cmd_node = adapter->curr_cmd;
893         if (cmd_node) {
894                 adapter->dbg.timeout_cmd_id =
895                         adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index];
896                 adapter->dbg.timeout_cmd_act =
897                         adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index];
898                 do_gettimeofday(&tstamp);
899                 dev_err(adapter->dev,
900                         "%s: Timeout cmd id (%lu.%lu) = %#x, act = %#x\n",
901                         __func__, tstamp.tv_sec, tstamp.tv_usec,
902                         adapter->dbg.timeout_cmd_id,
903                         adapter->dbg.timeout_cmd_act);
904
905                 dev_err(adapter->dev, "num_data_h2c_failure = %d\n",
906                         adapter->dbg.num_tx_host_to_card_failure);
907                 dev_err(adapter->dev, "num_cmd_h2c_failure = %d\n",
908                         adapter->dbg.num_cmd_host_to_card_failure);
909
910                 dev_err(adapter->dev, "num_cmd_timeout = %d\n",
911                         adapter->dbg.num_cmd_timeout);
912                 dev_err(adapter->dev, "num_tx_timeout = %d\n",
913                         adapter->dbg.num_tx_timeout);
914
915                 dev_err(adapter->dev, "last_cmd_index = %d\n",
916                         adapter->dbg.last_cmd_index);
917                 print_hex_dump_bytes("last_cmd_id: ", DUMP_PREFIX_OFFSET,
918                                      adapter->dbg.last_cmd_id, DBG_CMD_NUM);
919                 print_hex_dump_bytes("last_cmd_act: ", DUMP_PREFIX_OFFSET,
920                                      adapter->dbg.last_cmd_act, DBG_CMD_NUM);
921
922                 dev_err(adapter->dev, "last_cmd_resp_index = %d\n",
923                         adapter->dbg.last_cmd_resp_index);
924                 print_hex_dump_bytes("last_cmd_resp_id: ", DUMP_PREFIX_OFFSET,
925                                      adapter->dbg.last_cmd_resp_id,
926                                      DBG_CMD_NUM);
927
928                 dev_err(adapter->dev, "last_event_index = %d\n",
929                         adapter->dbg.last_event_index);
930                 print_hex_dump_bytes("last_event: ", DUMP_PREFIX_OFFSET,
931                                      adapter->dbg.last_event, DBG_CMD_NUM);
932
933                 dev_err(adapter->dev, "data_sent=%d cmd_sent=%d\n",
934                         adapter->data_sent, adapter->cmd_sent);
935
936                 dev_err(adapter->dev, "ps_mode=%d ps_state=%d\n",
937                         adapter->ps_mode, adapter->ps_state);
938
939                 if (cmd_node->wait_q_enabled) {
940                         adapter->cmd_wait_q.status = -ETIMEDOUT;
941                         wake_up_interruptible(&adapter->cmd_wait_q.wait);
942                         mwifiex_cancel_pending_ioctl(adapter);
943                         /* reset cmd_sent flag to unblock new commands */
944                         adapter->cmd_sent = false;
945                 }
946         }
947         if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING)
948                 mwifiex_init_fw_complete(adapter);
949 }
950
951 /*
952  * This function cancels all the pending commands.
953  *
954  * The current command, all commands in command pending queue and all scan
955  * commands in scan pending queue are cancelled. All the completion callbacks
956  * are called with failure status to ensure cleanup.
957  */
958 void
959 mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter)
960 {
961         struct cmd_ctrl_node *cmd_node = NULL, *tmp_node;
962         unsigned long flags;
963
964         /* Cancel current cmd */
965         if ((adapter->curr_cmd) && (adapter->curr_cmd->wait_q_enabled)) {
966                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
967                 adapter->curr_cmd->wait_q_enabled = false;
968                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
969                 adapter->cmd_wait_q.status = -1;
970                 mwifiex_complete_cmd(adapter, adapter->curr_cmd);
971         }
972         /* Cancel all pending command */
973         spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
974         list_for_each_entry_safe(cmd_node, tmp_node,
975                                  &adapter->cmd_pending_q, list) {
976                 list_del(&cmd_node->list);
977                 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
978
979                 if (cmd_node->wait_q_enabled) {
980                         adapter->cmd_wait_q.status = -1;
981                         mwifiex_complete_cmd(adapter, cmd_node);
982                         cmd_node->wait_q_enabled = false;
983                 }
984                 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
985                 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
986         }
987         spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
988
989         /* Cancel all pending scan command */
990         spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
991         list_for_each_entry_safe(cmd_node, tmp_node,
992                                  &adapter->scan_pending_q, list) {
993                 list_del(&cmd_node->list);
994                 spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
995
996                 cmd_node->wait_q_enabled = false;
997                 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
998                 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
999         }
1000         spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
1001
1002         spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
1003         adapter->scan_processing = false;
1004         spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
1005 }
1006
1007 /*
1008  * This function cancels all pending commands that matches with
1009  * the given IOCTL request.
1010  *
1011  * Both the current command buffer and the pending command queue are
1012  * searched for matching IOCTL request. The completion callback of
1013  * the matched command is called with failure status to ensure cleanup.
1014  * In case of scan commands, all pending commands in scan pending queue
1015  * are cancelled.
1016  */
1017 void
1018 mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter)
1019 {
1020         struct cmd_ctrl_node *cmd_node = NULL, *tmp_node = NULL;
1021         unsigned long cmd_flags;
1022         unsigned long scan_pending_q_flags;
1023         uint16_t cancel_scan_cmd = false;
1024
1025         if ((adapter->curr_cmd) &&
1026             (adapter->curr_cmd->wait_q_enabled)) {
1027                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
1028                 cmd_node = adapter->curr_cmd;
1029                 cmd_node->wait_q_enabled = false;
1030                 cmd_node->cmd_flag |= CMD_F_CANCELED;
1031                 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
1032                 mwifiex_complete_cmd(adapter, adapter->curr_cmd);
1033                 adapter->curr_cmd = NULL;
1034                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
1035         }
1036
1037         /* Cancel all pending scan command */
1038         spin_lock_irqsave(&adapter->scan_pending_q_lock,
1039                           scan_pending_q_flags);
1040         list_for_each_entry_safe(cmd_node, tmp_node,
1041                                  &adapter->scan_pending_q, list) {
1042                 list_del(&cmd_node->list);
1043                 spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
1044                                        scan_pending_q_flags);
1045                 cmd_node->wait_q_enabled = false;
1046                 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
1047                 spin_lock_irqsave(&adapter->scan_pending_q_lock,
1048                                   scan_pending_q_flags);
1049                 cancel_scan_cmd = true;
1050         }
1051         spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
1052                                scan_pending_q_flags);
1053
1054         if (cancel_scan_cmd) {
1055                 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
1056                 adapter->scan_processing = false;
1057                 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
1058         }
1059         adapter->cmd_wait_q.status = -1;
1060 }
1061
1062 /*
1063  * This function sends the sleep confirm command to firmware, if
1064  * possible.
1065  *
1066  * The sleep confirm command cannot be issued if command response,
1067  * data response or event response is awaiting handling, or if we
1068  * are in the middle of sending a command, or expecting a command
1069  * response.
1070  */
1071 void
1072 mwifiex_check_ps_cond(struct mwifiex_adapter *adapter)
1073 {
1074         if (!adapter->cmd_sent &&
1075             !adapter->curr_cmd && !IS_CARD_RX_RCVD(adapter))
1076                 mwifiex_dnld_sleep_confirm_cmd(adapter);
1077         else
1078                 dev_dbg(adapter->dev,
1079                         "cmd: Delay Sleep Confirm (%s%s%s)\n",
1080                         (adapter->cmd_sent) ? "D" : "",
1081                         (adapter->curr_cmd) ? "C" : "",
1082                         (IS_CARD_RX_RCVD(adapter)) ? "R" : "");
1083 }
1084
1085 /*
1086  * This function sends a Host Sleep activated event to applications.
1087  *
1088  * This event is generated by the driver, with a blank event body.
1089  */
1090 void
1091 mwifiex_hs_activated_event(struct mwifiex_private *priv, u8 activated)
1092 {
1093         if (activated) {
1094                 if (priv->adapter->is_hs_configured) {
1095                         priv->adapter->hs_activated = true;
1096                         mwifiex_update_rxreor_flags(priv->adapter,
1097                                                     RXREOR_FORCE_NO_DROP);
1098                         dev_dbg(priv->adapter->dev, "event: hs_activated\n");
1099                         priv->adapter->hs_activate_wait_q_woken = true;
1100                         wake_up_interruptible(
1101                                 &priv->adapter->hs_activate_wait_q);
1102                 } else {
1103                         dev_dbg(priv->adapter->dev, "event: HS not configured\n");
1104                 }
1105         } else {
1106                 dev_dbg(priv->adapter->dev, "event: hs_deactivated\n");
1107                 priv->adapter->hs_activated = false;
1108         }
1109 }
1110
1111 /*
1112  * This function handles the command response of a Host Sleep configuration
1113  * command.
1114  *
1115  * Handling includes changing the header fields into CPU format
1116  * and setting the current host sleep activation status in driver.
1117  *
1118  * In case host sleep status change, the function generates an event to
1119  * notify the applications.
1120  */
1121 int mwifiex_ret_802_11_hs_cfg(struct mwifiex_private *priv,
1122                               struct host_cmd_ds_command *resp)
1123 {
1124         struct mwifiex_adapter *adapter = priv->adapter;
1125         struct host_cmd_ds_802_11_hs_cfg_enh *phs_cfg =
1126                 &resp->params.opt_hs_cfg;
1127         uint32_t conditions = le32_to_cpu(phs_cfg->params.hs_config.conditions);
1128
1129         if (phs_cfg->action == cpu_to_le16(HS_ACTIVATE) &&
1130             adapter->iface_type == MWIFIEX_SDIO) {
1131                 mwifiex_hs_activated_event(priv, true);
1132                 return 0;
1133         } else {
1134                 dev_dbg(adapter->dev, "cmd: CMD_RESP: HS_CFG cmd reply"
1135                         " result=%#x, conditions=0x%x gpio=0x%x gap=0x%x\n",
1136                         resp->result, conditions,
1137                         phs_cfg->params.hs_config.gpio,
1138                         phs_cfg->params.hs_config.gap);
1139         }
1140         if (conditions != HOST_SLEEP_CFG_CANCEL) {
1141                 adapter->is_hs_configured = true;
1142                 if (adapter->iface_type == MWIFIEX_USB ||
1143                     adapter->iface_type == MWIFIEX_PCIE)
1144                         mwifiex_hs_activated_event(priv, true);
1145         } else {
1146                 adapter->is_hs_configured = false;
1147                 if (adapter->hs_activated)
1148                         mwifiex_hs_activated_event(priv, false);
1149         }
1150
1151         return 0;
1152 }
1153
1154 /*
1155  * This function wakes up the adapter and generates a Host Sleep
1156  * cancel event on receiving the power up interrupt.
1157  */
1158 void
1159 mwifiex_process_hs_config(struct mwifiex_adapter *adapter)
1160 {
1161         dev_dbg(adapter->dev, "info: %s: auto cancelling host sleep"
1162                 " since there is interrupt from the firmware\n", __func__);
1163
1164         adapter->if_ops.wakeup(adapter);
1165         adapter->hs_activated = false;
1166         adapter->is_hs_configured = false;
1167         mwifiex_hs_activated_event(mwifiex_get_priv(adapter,
1168                                                     MWIFIEX_BSS_ROLE_ANY),
1169                                    false);
1170 }
1171 EXPORT_SYMBOL_GPL(mwifiex_process_hs_config);
1172
1173 /*
1174  * This function handles the command response of a sleep confirm command.
1175  *
1176  * The function sets the card state to SLEEP if the response indicates success.
1177  */
1178 void
1179 mwifiex_process_sleep_confirm_resp(struct mwifiex_adapter *adapter,
1180                                    u8 *pbuf, u32 upld_len)
1181 {
1182         struct host_cmd_ds_command *cmd = (struct host_cmd_ds_command *) pbuf;
1183         struct mwifiex_private *priv =
1184                 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1185         uint16_t result = le16_to_cpu(cmd->result);
1186         uint16_t command = le16_to_cpu(cmd->command);
1187         uint16_t seq_num = le16_to_cpu(cmd->seq_num);
1188
1189         if (!upld_len) {
1190                 dev_err(adapter->dev, "%s: cmd size is 0\n", __func__);
1191                 return;
1192         }
1193
1194         /* Get BSS number and corresponding priv */
1195         priv = mwifiex_get_priv_by_id(adapter, HostCmd_GET_BSS_NO(seq_num),
1196                                       HostCmd_GET_BSS_TYPE(seq_num));
1197         if (!priv)
1198                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1199
1200         /* Update sequence number */
1201         seq_num = HostCmd_GET_SEQ_NO(seq_num);
1202         /* Clear RET_BIT from HostCmd */
1203         command &= HostCmd_CMD_ID_MASK;
1204
1205         if (command != HostCmd_CMD_802_11_PS_MODE_ENH) {
1206                 dev_err(adapter->dev,
1207                         "%s: rcvd unexpected resp for cmd %#x, result = %x\n",
1208                         __func__, command, result);
1209                 return;
1210         }
1211
1212         if (result) {
1213                 dev_err(adapter->dev, "%s: sleep confirm cmd failed\n",
1214                         __func__);
1215                 adapter->pm_wakeup_card_req = false;
1216                 adapter->ps_state = PS_STATE_AWAKE;
1217                 return;
1218         }
1219         adapter->pm_wakeup_card_req = true;
1220         if (adapter->is_hs_configured)
1221                 mwifiex_hs_activated_event(mwifiex_get_priv
1222                                                 (adapter, MWIFIEX_BSS_ROLE_ANY),
1223                                            true);
1224         adapter->ps_state = PS_STATE_SLEEP;
1225         cmd->command = cpu_to_le16(command);
1226         cmd->seq_num = cpu_to_le16(seq_num);
1227 }
1228 EXPORT_SYMBOL_GPL(mwifiex_process_sleep_confirm_resp);
1229
1230 /*
1231  * This function prepares an enhanced power mode command.
1232  *
1233  * This function can be used to disable power save or to configure
1234  * power save with auto PS or STA PS or auto deep sleep.
1235  *
1236  * Preparation includes -
1237  *      - Setting command ID, action and proper size
1238  *      - Setting Power Save bitmap, PS parameters TLV, PS mode TLV,
1239  *        auto deep sleep TLV (as required)
1240  *      - Ensuring correct endian-ness
1241  */
1242 int mwifiex_cmd_enh_power_mode(struct mwifiex_private *priv,
1243                                struct host_cmd_ds_command *cmd,
1244                                u16 cmd_action, uint16_t ps_bitmap,
1245                                struct mwifiex_ds_auto_ds *auto_ds)
1246 {
1247         struct host_cmd_ds_802_11_ps_mode_enh *psmode_enh =
1248                 &cmd->params.psmode_enh;
1249         u8 *tlv;
1250         u16 cmd_size = 0;
1251
1252         cmd->command = cpu_to_le16(HostCmd_CMD_802_11_PS_MODE_ENH);
1253         if (cmd_action == DIS_AUTO_PS) {
1254                 psmode_enh->action = cpu_to_le16(DIS_AUTO_PS);
1255                 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1256                 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(psmode_enh->action) +
1257                                         sizeof(psmode_enh->params.ps_bitmap));
1258         } else if (cmd_action == GET_PS) {
1259                 psmode_enh->action = cpu_to_le16(GET_PS);
1260                 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1261                 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(psmode_enh->action) +
1262                                         sizeof(psmode_enh->params.ps_bitmap));
1263         } else if (cmd_action == EN_AUTO_PS) {
1264                 psmode_enh->action = cpu_to_le16(EN_AUTO_PS);
1265                 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1266                 cmd_size = S_DS_GEN + sizeof(psmode_enh->action) +
1267                                         sizeof(psmode_enh->params.ps_bitmap);
1268                 tlv = (u8 *) cmd + cmd_size;
1269                 if (ps_bitmap & BITMAP_STA_PS) {
1270                         struct mwifiex_adapter *adapter = priv->adapter;
1271                         struct mwifiex_ie_types_ps_param *ps_tlv =
1272                                 (struct mwifiex_ie_types_ps_param *) tlv;
1273                         struct mwifiex_ps_param *ps_mode = &ps_tlv->param;
1274                         ps_tlv->header.type = cpu_to_le16(TLV_TYPE_PS_PARAM);
1275                         ps_tlv->header.len = cpu_to_le16(sizeof(*ps_tlv) -
1276                                         sizeof(struct mwifiex_ie_types_header));
1277                         cmd_size += sizeof(*ps_tlv);
1278                         tlv += sizeof(*ps_tlv);
1279                         dev_dbg(adapter->dev, "cmd: PS Command: Enter PS\n");
1280                         ps_mode->null_pkt_interval =
1281                                         cpu_to_le16(adapter->null_pkt_interval);
1282                         ps_mode->multiple_dtims =
1283                                         cpu_to_le16(adapter->multiple_dtim);
1284                         ps_mode->bcn_miss_timeout =
1285                                         cpu_to_le16(adapter->bcn_miss_time_out);
1286                         ps_mode->local_listen_interval =
1287                                 cpu_to_le16(adapter->local_listen_interval);
1288                         ps_mode->adhoc_wake_period =
1289                                 cpu_to_le16(adapter->adhoc_awake_period);
1290                         ps_mode->delay_to_ps =
1291                                         cpu_to_le16(adapter->delay_to_ps);
1292                         ps_mode->mode = cpu_to_le16(adapter->enhanced_ps_mode);
1293
1294                 }
1295                 if (ps_bitmap & BITMAP_AUTO_DS) {
1296                         struct mwifiex_ie_types_auto_ds_param *auto_ds_tlv =
1297                                 (struct mwifiex_ie_types_auto_ds_param *) tlv;
1298                         u16 idletime = 0;
1299
1300                         auto_ds_tlv->header.type =
1301                                 cpu_to_le16(TLV_TYPE_AUTO_DS_PARAM);
1302                         auto_ds_tlv->header.len =
1303                                 cpu_to_le16(sizeof(*auto_ds_tlv) -
1304                                         sizeof(struct mwifiex_ie_types_header));
1305                         cmd_size += sizeof(*auto_ds_tlv);
1306                         tlv += sizeof(*auto_ds_tlv);
1307                         if (auto_ds)
1308                                 idletime = auto_ds->idle_time;
1309                         dev_dbg(priv->adapter->dev,
1310                                 "cmd: PS Command: Enter Auto Deep Sleep\n");
1311                         auto_ds_tlv->deep_sleep_timeout = cpu_to_le16(idletime);
1312                 }
1313                 cmd->size = cpu_to_le16(cmd_size);
1314         }
1315         return 0;
1316 }
1317
1318 /*
1319  * This function handles the command response of an enhanced power mode
1320  * command.
1321  *
1322  * Handling includes changing the header fields into CPU format
1323  * and setting the current enhanced power mode in driver.
1324  */
1325 int mwifiex_ret_enh_power_mode(struct mwifiex_private *priv,
1326                                struct host_cmd_ds_command *resp,
1327                                struct mwifiex_ds_pm_cfg *pm_cfg)
1328 {
1329         struct mwifiex_adapter *adapter = priv->adapter;
1330         struct host_cmd_ds_802_11_ps_mode_enh *ps_mode =
1331                 &resp->params.psmode_enh;
1332         uint16_t action = le16_to_cpu(ps_mode->action);
1333         uint16_t ps_bitmap = le16_to_cpu(ps_mode->params.ps_bitmap);
1334         uint16_t auto_ps_bitmap =
1335                 le16_to_cpu(ps_mode->params.ps_bitmap);
1336
1337         dev_dbg(adapter->dev,
1338                 "info: %s: PS_MODE cmd reply result=%#x action=%#X\n",
1339                 __func__, resp->result, action);
1340         if (action == EN_AUTO_PS) {
1341                 if (auto_ps_bitmap & BITMAP_AUTO_DS) {
1342                         dev_dbg(adapter->dev, "cmd: Enabled auto deep sleep\n");
1343                         priv->adapter->is_deep_sleep = true;
1344                 }
1345                 if (auto_ps_bitmap & BITMAP_STA_PS) {
1346                         dev_dbg(adapter->dev, "cmd: Enabled STA power save\n");
1347                         if (adapter->sleep_period.period)
1348                                 dev_dbg(adapter->dev,
1349                                         "cmd: set to uapsd/pps mode\n");
1350                 }
1351         } else if (action == DIS_AUTO_PS) {
1352                 if (ps_bitmap & BITMAP_AUTO_DS) {
1353                         priv->adapter->is_deep_sleep = false;
1354                         dev_dbg(adapter->dev, "cmd: Disabled auto deep sleep\n");
1355                 }
1356                 if (ps_bitmap & BITMAP_STA_PS) {
1357                         dev_dbg(adapter->dev, "cmd: Disabled STA power save\n");
1358                         if (adapter->sleep_period.period) {
1359                                 adapter->delay_null_pkt = false;
1360                                 adapter->tx_lock_flag = false;
1361                                 adapter->pps_uapsd_mode = false;
1362                         }
1363                 }
1364         } else if (action == GET_PS) {
1365                 if (ps_bitmap & BITMAP_STA_PS)
1366                         adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_PSP;
1367                 else
1368                         adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM;
1369
1370                 dev_dbg(adapter->dev, "cmd: ps_bitmap=%#x\n", ps_bitmap);
1371
1372                 if (pm_cfg) {
1373                         /* This section is for get power save mode */
1374                         if (ps_bitmap & BITMAP_STA_PS)
1375                                 pm_cfg->param.ps_mode = 1;
1376                         else
1377                                 pm_cfg->param.ps_mode = 0;
1378                 }
1379         }
1380         return 0;
1381 }
1382
1383 /*
1384  * This function prepares command to get hardware specifications.
1385  *
1386  * Preparation includes -
1387  *      - Setting command ID, action and proper size
1388  *      - Setting permanent address parameter
1389  *      - Ensuring correct endian-ness
1390  */
1391 int mwifiex_cmd_get_hw_spec(struct mwifiex_private *priv,
1392                             struct host_cmd_ds_command *cmd)
1393 {
1394         struct host_cmd_ds_get_hw_spec *hw_spec = &cmd->params.hw_spec;
1395
1396         cmd->command = cpu_to_le16(HostCmd_CMD_GET_HW_SPEC);
1397         cmd->size =
1398                 cpu_to_le16(sizeof(struct host_cmd_ds_get_hw_spec) + S_DS_GEN);
1399         memcpy(hw_spec->permanent_addr, priv->curr_addr, ETH_ALEN);
1400
1401         return 0;
1402 }
1403
1404 /*
1405  * This function handles the command response of get hardware
1406  * specifications.
1407  *
1408  * Handling includes changing the header fields into CPU format
1409  * and saving/updating the following parameters in driver -
1410  *      - Firmware capability information
1411  *      - Firmware band settings
1412  *      - Ad-hoc start band and channel
1413  *      - Ad-hoc 11n activation status
1414  *      - Firmware release number
1415  *      - Number of antennas
1416  *      - Hardware address
1417  *      - Hardware interface version
1418  *      - Firmware version
1419  *      - Region code
1420  *      - 11n capabilities
1421  *      - MCS support fields
1422  *      - MP end port
1423  */
1424 int mwifiex_ret_get_hw_spec(struct mwifiex_private *priv,
1425                             struct host_cmd_ds_command *resp)
1426 {
1427         struct host_cmd_ds_get_hw_spec *hw_spec = &resp->params.hw_spec;
1428         struct mwifiex_adapter *adapter = priv->adapter;
1429         int i;
1430
1431         adapter->fw_cap_info = le32_to_cpu(hw_spec->fw_cap_info);
1432
1433         if (IS_SUPPORT_MULTI_BANDS(adapter))
1434                 adapter->fw_bands = (u8) GET_FW_DEFAULT_BANDS(adapter);
1435         else
1436                 adapter->fw_bands = BAND_B;
1437
1438         adapter->config_bands = adapter->fw_bands;
1439
1440         if (adapter->fw_bands & BAND_A) {
1441                 if (adapter->fw_bands & BAND_GN) {
1442                         adapter->config_bands |= BAND_AN;
1443                         adapter->fw_bands |= BAND_AN;
1444                 }
1445                 if (adapter->fw_bands & BAND_AN) {
1446                         adapter->adhoc_start_band = BAND_A | BAND_AN;
1447                         adapter->adhoc_11n_enabled = true;
1448                 } else {
1449                         adapter->adhoc_start_band = BAND_A;
1450                 }
1451                 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL_A;
1452         } else if (adapter->fw_bands & BAND_GN) {
1453                 adapter->adhoc_start_band = BAND_G | BAND_B | BAND_GN;
1454                 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1455                 adapter->adhoc_11n_enabled = true;
1456         } else if (adapter->fw_bands & BAND_G) {
1457                 adapter->adhoc_start_band = BAND_G | BAND_B;
1458                 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1459         } else if (adapter->fw_bands & BAND_B) {
1460                 adapter->adhoc_start_band = BAND_B;
1461                 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1462         }
1463
1464         adapter->fw_release_number = le32_to_cpu(hw_spec->fw_release_number);
1465         adapter->number_of_antenna = le16_to_cpu(hw_spec->number_of_antenna);
1466
1467         dev_dbg(adapter->dev, "info: GET_HW_SPEC: fw_release_number- %#x\n",
1468                 adapter->fw_release_number);
1469         dev_dbg(adapter->dev, "info: GET_HW_SPEC: permanent addr: %pM\n",
1470                 hw_spec->permanent_addr);
1471         dev_dbg(adapter->dev,
1472                 "info: GET_HW_SPEC: hw_if_version=%#x version=%#x\n",
1473                 le16_to_cpu(hw_spec->hw_if_version),
1474                 le16_to_cpu(hw_spec->version));
1475
1476         if (priv->curr_addr[0] == 0xff)
1477                 memmove(priv->curr_addr, hw_spec->permanent_addr, ETH_ALEN);
1478
1479         adapter->region_code = le16_to_cpu(hw_spec->region_code);
1480
1481         for (i = 0; i < MWIFIEX_MAX_REGION_CODE; i++)
1482                 /* Use the region code to search for the index */
1483                 if (adapter->region_code == region_code_index[i])
1484                         break;
1485
1486         /* If it's unidentified region code, use the default (USA) */
1487         if (i >= MWIFIEX_MAX_REGION_CODE) {
1488                 adapter->region_code = 0x10;
1489                 dev_dbg(adapter->dev,
1490                         "cmd: unknown region code, use default (USA)\n");
1491         }
1492
1493         adapter->hw_dot_11n_dev_cap = le32_to_cpu(hw_spec->dot_11n_dev_cap);
1494         adapter->hw_dev_mcs_support = hw_spec->dev_mcs_support;
1495
1496         if (adapter->if_ops.update_mp_end_port)
1497                 adapter->if_ops.update_mp_end_port(adapter,
1498                                         le16_to_cpu(hw_spec->mp_end_port));
1499
1500         return 0;
1501 }