Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cmdevt.c
Go to the documentation of this file.
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;
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++;
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 
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) {
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,
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 =
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);
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,
286  sleep_cfm_tmp, NULL);
287  if (ret != -EBUSY)
288  dev_kfree_skb_any(sleep_cfm_tmp);
289  } else {
291  ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
292  adapter->sleep_cfm, NULL);
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))
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  */
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  */
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  */
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  */
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  */
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) {
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
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
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) {
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  */
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 !=
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  */
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,
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)
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);
943  /* reset cmd_sent flag to unblock new commands */
944  adapter->cmd_sent = false;
945  }
946  }
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
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
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 */
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);
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
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
1092 {
1093  if (activated) {
1094  if (priv->adapter->is_hs_configured) {
1095  priv->adapter->hs_activated = true;
1098  dev_dbg(priv->adapter->dev, "event: hs_activated\n");
1099  priv->adapter->hs_activate_wait_q_woken = true;
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  */
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
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,
1169  false);
1170 }
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
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);
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 }
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  */
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 
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 =
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 =
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  */
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);
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)
1367  else
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  */
1392  struct host_cmd_ds_command *cmd)
1393 {
1394  struct host_cmd_ds_get_hw_spec *hw_spec = &cmd->params.hw_spec;
1395 
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  */
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  }
1452  } else if (adapter->fw_bands & BAND_GN) {
1453  adapter->adhoc_start_band = BAND_G | BAND_B | BAND_GN;
1455  adapter->adhoc_11n_enabled = true;
1456  } else if (adapter->fw_bands & BAND_G) {
1457  adapter->adhoc_start_band = BAND_G | BAND_B;
1459  } else if (adapter->fw_bands & BAND_B) {
1460  adapter->adhoc_start_band = BAND_B;
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 }