2 * Marvell Wireless LAN device driver: commands and events
4 * Copyright (C) 2011, Marvell International Ltd.
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.
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.
29 * This function initializes a command node.
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.
37 mwifiex_init_cmd_node(struct mwifiex_private
*priv
,
38 struct cmd_ctrl_node
*cmd_node
,
39 u32 cmd_oid
, void *data_buf
)
41 cmd_node
->priv
= priv
;
42 cmd_node
->cmd_oid
= cmd_oid
;
43 cmd_node
->wait_q_enabled
= priv
->adapter
->cmd_wait_q_required
;
44 priv
->adapter
->cmd_wait_q_required
= false;
45 cmd_node
->data_buf
= data_buf
;
46 cmd_node
->cmd_skb
= cmd_node
->skb
;
50 * This function returns a command node from the free queue depending upon
53 static struct cmd_ctrl_node
*
54 mwifiex_get_cmd_node(struct mwifiex_adapter
*adapter
)
56 struct cmd_ctrl_node
*cmd_node
;
59 spin_lock_irqsave(&adapter
->cmd_free_q_lock
, flags
);
60 if (list_empty(&adapter
->cmd_free_q
)) {
61 dev_err(adapter
->dev
, "GET_CMD_NODE: cmd node not available\n");
62 spin_unlock_irqrestore(&adapter
->cmd_free_q_lock
, flags
);
65 cmd_node
= list_first_entry(&adapter
->cmd_free_q
,
66 struct cmd_ctrl_node
, list
);
67 list_del(&cmd_node
->list
);
68 spin_unlock_irqrestore(&adapter
->cmd_free_q_lock
, flags
);
74 * This function cleans up a command node.
76 * The function resets the fields including the buffer pointers.
77 * This function does not try to free the buffers. They must be
78 * freed before calling this function.
80 * This function will however call the receive completion callback
81 * in case a response buffer is still available before resetting
85 mwifiex_clean_cmd_node(struct mwifiex_adapter
*adapter
,
86 struct cmd_ctrl_node
*cmd_node
)
88 cmd_node
->cmd_oid
= 0;
89 cmd_node
->cmd_flag
= 0;
90 cmd_node
->data_buf
= NULL
;
91 cmd_node
->wait_q_enabled
= false;
93 if (cmd_node
->resp_skb
) {
94 mwifiex_recv_complete(adapter
, cmd_node
->resp_skb
, 0);
95 cmd_node
->resp_skb
= NULL
;
102 * This function sends a host command to the firmware.
104 * The function copies the host command into the driver command
105 * buffer, which will be transferred to the firmware later by the
108 static int mwifiex_cmd_host_cmd(struct mwifiex_private
*priv
,
109 struct host_cmd_ds_command
*cmd
, void *data_buf
)
111 struct mwifiex_ds_misc_cmd
*pcmd_ptr
=
112 (struct mwifiex_ds_misc_cmd
*) data_buf
;
114 /* Copy the HOST command to command buffer */
115 memcpy((void *) cmd
, pcmd_ptr
->cmd
, pcmd_ptr
->len
);
116 dev_dbg(priv
->adapter
->dev
, "cmd: host cmd size = %d\n", pcmd_ptr
->len
);
121 * This function downloads a command to the firmware.
123 * The function performs sanity tests, sets the command sequence
124 * number and size, converts the header fields to CPU format before
125 * sending. Afterwards, it logs the command ID and action for debugging
126 * and sets up the command timeout timer.
128 static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private
*priv
,
129 struct cmd_ctrl_node
*cmd_node
)
132 struct mwifiex_adapter
*adapter
= priv
->adapter
;
134 struct host_cmd_ds_command
*host_cmd
;
137 struct timeval tstamp
;
140 if (!adapter
|| !cmd_node
)
143 host_cmd
= (struct host_cmd_ds_command
*) (cmd_node
->cmd_skb
->data
);
146 if (host_cmd
== NULL
|| host_cmd
->size
== 0) {
147 dev_err(adapter
->dev
, "DNLD_CMD: host_cmd is null"
148 " or cmd size is 0, not sending\n");
149 if (cmd_node
->wait_q_enabled
)
150 adapter
->cmd_wait_q
.status
= -1;
151 mwifiex_insert_cmd_to_free_q(adapter
, cmd_node
);
155 /* Set command sequence number */
157 host_cmd
->seq_num
= cpu_to_le16(HostCmd_SET_SEQ_NO_BSS_INFO
158 (adapter
->seq_num
, cmd_node
->priv
->bss_num
,
159 cmd_node
->priv
->bss_type
));
161 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
162 adapter
->curr_cmd
= cmd_node
;
163 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
165 cmd_code
= le16_to_cpu(host_cmd
->command
);
166 cmd_size
= le16_to_cpu(host_cmd
->size
);
168 skb_trim(cmd_node
->cmd_skb
, cmd_size
);
170 do_gettimeofday(&tstamp
);
171 dev_dbg(adapter
->dev
, "cmd: DNLD_CMD: (%lu.%lu): %#x, act %#x, len %d,"
173 tstamp
.tv_sec
, tstamp
.tv_usec
, cmd_code
,
174 le16_to_cpu(*(__le16
*) ((u8
*) host_cmd
+ S_DS_GEN
)), cmd_size
,
175 le16_to_cpu(host_cmd
->seq_num
));
177 skb_push(cmd_node
->cmd_skb
, INTF_HEADER_LEN
);
179 ret
= adapter
->if_ops
.host_to_card(adapter
, MWIFIEX_TYPE_CMD
,
180 cmd_node
->cmd_skb
->data
,
181 cmd_node
->cmd_skb
->len
, NULL
);
183 skb_pull(cmd_node
->cmd_skb
, INTF_HEADER_LEN
);
186 dev_err(adapter
->dev
, "DNLD_CMD: host to card failed\n");
187 if (cmd_node
->wait_q_enabled
)
188 adapter
->cmd_wait_q
.status
= -1;
189 mwifiex_insert_cmd_to_free_q(adapter
, adapter
->curr_cmd
);
191 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
192 adapter
->curr_cmd
= NULL
;
193 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
195 adapter
->dbg
.num_cmd_host_to_card_failure
++;
199 /* Save the last command id and action to debug log */
200 adapter
->dbg
.last_cmd_index
=
201 (adapter
->dbg
.last_cmd_index
+ 1) % DBG_CMD_NUM
;
202 adapter
->dbg
.last_cmd_id
[adapter
->dbg
.last_cmd_index
] = cmd_code
;
203 adapter
->dbg
.last_cmd_act
[adapter
->dbg
.last_cmd_index
] =
204 le16_to_cpu(*(__le16
*) ((u8
*) host_cmd
+ S_DS_GEN
));
206 /* Clear BSS_NO_BITS from HostCmd */
207 cmd_code
&= HostCmd_CMD_ID_MASK
;
209 /* Setup the timer after transmit command */
210 mod_timer(&adapter
->cmd_timer
,
211 jiffies
+ (MWIFIEX_TIMER_10S
* HZ
) / 1000);
217 * This function downloads a sleep confirm command to the firmware.
219 * The function performs sanity tests, sets the command sequence
220 * number and size, converts the header fields to CPU format before
223 * No responses are needed for sleep confirm command.
225 static int mwifiex_dnld_sleep_confirm_cmd(struct mwifiex_adapter
*adapter
)
229 struct mwifiex_private
*priv
;
230 struct mwifiex_opt_sleep_confirm_buffer
*sleep_cfm_buf
=
231 (struct mwifiex_opt_sleep_confirm_buffer
*)
232 adapter
->sleep_cfm
->data
;
233 cmd_len
= sizeof(struct mwifiex_opt_sleep_confirm
);
234 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
236 sleep_cfm_buf
->ps_cfm_sleep
.seq_num
=
237 cpu_to_le16((HostCmd_SET_SEQ_NO_BSS_INFO
238 (adapter
->seq_num
, priv
->bss_num
,
242 ret
= adapter
->if_ops
.host_to_card(adapter
, MWIFIEX_TYPE_CMD
,
243 adapter
->sleep_cfm
->data
,
244 adapter
->sleep_cfm
->len
+
245 INTF_HEADER_LEN
, NULL
);
248 dev_err(adapter
->dev
, "SLEEP_CFM: failed\n");
249 adapter
->dbg
.num_cmd_sleep_cfm_host_to_card_failure
++;
252 if (GET_BSS_ROLE(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
))
253 == MWIFIEX_BSS_ROLE_STA
) {
254 if (!sleep_cfm_buf
->ps_cfm_sleep
.resp_ctrl
)
255 /* Response is not needed for sleep
257 adapter
->ps_state
= PS_STATE_SLEEP
;
259 adapter
->ps_state
= PS_STATE_SLEEP_CFM
;
261 if (!sleep_cfm_buf
->ps_cfm_sleep
.resp_ctrl
262 && (adapter
->is_hs_configured
263 && !adapter
->sleep_period
.period
)) {
264 adapter
->pm_wakeup_card_req
= true;
265 mwifiex_hs_activated_event(mwifiex_get_priv(adapter
,
266 MWIFIEX_BSS_ROLE_STA
), true);
274 * This function allocates the command buffers and links them to
275 * the command free queue.
277 * The driver uses a pre allocated number of command buffers, which
278 * are created at driver initializations and freed at driver cleanup.
279 * Every command needs to obtain a command buffer from this pool before
280 * it can be issued. The command free queue lists the command buffers
281 * currently free to use, while the command pending queue lists the
282 * command buffers already in use and awaiting handling. Command buffers
283 * are returned to the free queue after use.
285 int mwifiex_alloc_cmd_buffer(struct mwifiex_adapter
*adapter
)
287 struct cmd_ctrl_node
*cmd_array
;
291 /* Allocate and initialize struct cmd_ctrl_node */
292 buf_size
= sizeof(struct cmd_ctrl_node
) * MWIFIEX_NUM_OF_CMD_BUFFER
;
293 cmd_array
= kzalloc(buf_size
, GFP_KERNEL
);
295 dev_err(adapter
->dev
, "%s: failed to alloc cmd_array\n",
300 adapter
->cmd_pool
= cmd_array
;
301 memset(adapter
->cmd_pool
, 0, buf_size
);
303 /* Allocate and initialize command buffers */
304 for (i
= 0; i
< MWIFIEX_NUM_OF_CMD_BUFFER
; i
++) {
305 cmd_array
[i
].skb
= dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER
);
306 if (!cmd_array
[i
].skb
) {
307 dev_err(adapter
->dev
, "ALLOC_CMD_BUF: out of memory\n");
312 for (i
= 0; i
< MWIFIEX_NUM_OF_CMD_BUFFER
; i
++)
313 mwifiex_insert_cmd_to_free_q(adapter
, &cmd_array
[i
]);
319 * This function frees the command buffers.
321 * The function calls the completion callback for all the command
322 * buffers that still have response buffers associated with them.
324 int mwifiex_free_cmd_buffer(struct mwifiex_adapter
*adapter
)
326 struct cmd_ctrl_node
*cmd_array
;
329 /* Need to check if cmd pool is allocated or not */
330 if (!adapter
->cmd_pool
) {
331 dev_dbg(adapter
->dev
, "info: FREE_CMD_BUF: cmd_pool is null\n");
335 cmd_array
= adapter
->cmd_pool
;
337 /* Release shared memory buffers */
338 for (i
= 0; i
< MWIFIEX_NUM_OF_CMD_BUFFER
; i
++) {
339 if (cmd_array
[i
].skb
) {
340 dev_dbg(adapter
->dev
, "cmd: free cmd buffer %d\n", i
);
341 dev_kfree_skb_any(cmd_array
[i
].skb
);
343 if (!cmd_array
[i
].resp_skb
)
345 mwifiex_recv_complete(adapter
, cmd_array
[i
].resp_skb
, 0);
347 /* Release struct cmd_ctrl_node */
348 if (adapter
->cmd_pool
) {
349 dev_dbg(adapter
->dev
, "cmd: free cmd pool\n");
350 kfree(adapter
->cmd_pool
);
351 adapter
->cmd_pool
= NULL
;
358 * This function handles events generated by firmware.
360 * Event body of events received from firmware are not used (though they are
361 * saved), only the event ID is used. Some events are re-invoked by
362 * the driver, with a new event body.
364 * After processing, the function calls the completion callback
367 int mwifiex_process_event(struct mwifiex_adapter
*adapter
)
370 struct mwifiex_private
*priv
=
371 mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
372 struct sk_buff
*skb
= adapter
->event_skb
;
373 u32 eventcause
= adapter
->event_cause
;
374 struct timeval tstamp
;
375 struct mwifiex_rxinfo
*rx_info
= NULL
;
377 /* Save the last event to debug log */
378 adapter
->dbg
.last_event_index
=
379 (adapter
->dbg
.last_event_index
+ 1) % DBG_CMD_NUM
;
380 adapter
->dbg
.last_event
[adapter
->dbg
.last_event_index
] =
383 /* Get BSS number and corresponding priv */
384 priv
= mwifiex_get_priv_by_id(adapter
, EVENT_GET_BSS_NUM(eventcause
),
385 EVENT_GET_BSS_TYPE(eventcause
));
387 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
388 /* Clear BSS_NO_BITS from event */
389 eventcause
&= EVENT_ID_MASK
;
390 adapter
->event_cause
= eventcause
;
393 rx_info
= MWIFIEX_SKB_RXCB(skb
);
394 rx_info
->bss_index
= priv
->bss_index
;
397 if (eventcause
!= EVENT_PS_SLEEP
&& eventcause
!= EVENT_PS_AWAKE
) {
398 do_gettimeofday(&tstamp
);
399 dev_dbg(adapter
->dev
, "event: %lu.%lu: cause: %#x\n",
400 tstamp
.tv_sec
, tstamp
.tv_usec
, eventcause
);
403 ret
= mwifiex_process_sta_event(priv
);
405 adapter
->event_cause
= 0;
406 adapter
->event_skb
= NULL
;
408 mwifiex_recv_complete(adapter
, skb
, 0);
414 * This function is used to send synchronous command to the firmware.
416 * it allocates a wait queue for the command and wait for the command
419 int mwifiex_send_cmd_sync(struct mwifiex_private
*priv
, uint16_t cmd_no
,
420 u16 cmd_action
, u32 cmd_oid
, void *data_buf
)
423 struct mwifiex_adapter
*adapter
= priv
->adapter
;
425 adapter
->cmd_wait_q_required
= true;
426 adapter
->cmd_wait_q
.condition
= false;
428 ret
= mwifiex_send_cmd_async(priv
, cmd_no
, cmd_action
, cmd_oid
,
431 ret
= mwifiex_wait_queue_complete(adapter
);
438 * This function prepares a command and asynchronously send it to the firmware.
440 * Preparation includes -
441 * - Sanity tests to make sure the card is still present or the FW
443 * - Getting a new command node from the command free queue
444 * - Initializing the command node for default parameters
445 * - Fill up the non-default parameters and buffer pointers
446 * - Add the command to pending queue
448 int mwifiex_send_cmd_async(struct mwifiex_private
*priv
, uint16_t cmd_no
,
449 u16 cmd_action
, u32 cmd_oid
, void *data_buf
)
452 struct mwifiex_adapter
*adapter
= priv
->adapter
;
453 struct cmd_ctrl_node
*cmd_node
= NULL
;
454 struct host_cmd_ds_command
*cmd_ptr
= NULL
;
457 pr_err("PREP_CMD: adapter is NULL\n");
461 if (adapter
->is_suspended
) {
462 dev_err(adapter
->dev
, "PREP_CMD: device in suspended state\n");
466 if (adapter
->surprise_removed
) {
467 dev_err(adapter
->dev
, "PREP_CMD: card is removed\n");
471 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_RESET
) {
472 if (cmd_no
!= HostCmd_CMD_FUNC_INIT
) {
473 dev_err(adapter
->dev
, "PREP_CMD: FW in reset state\n");
478 /* Get a new command node */
479 cmd_node
= mwifiex_get_cmd_node(adapter
);
482 dev_err(adapter
->dev
, "PREP_CMD: no free cmd node\n");
486 /* Initialize the command node */
487 mwifiex_init_cmd_node(priv
, cmd_node
, cmd_oid
, data_buf
);
489 if (!cmd_node
->cmd_skb
) {
490 dev_err(adapter
->dev
, "PREP_CMD: no free cmd buf\n");
494 memset(skb_put(cmd_node
->cmd_skb
, sizeof(struct host_cmd_ds_command
)),
495 0, sizeof(struct host_cmd_ds_command
));
497 cmd_ptr
= (struct host_cmd_ds_command
*) (cmd_node
->cmd_skb
->data
);
498 cmd_ptr
->command
= cpu_to_le16(cmd_no
);
501 /* Prepare command */
503 ret
= mwifiex_sta_prepare_cmd(priv
, cmd_no
, cmd_action
,
504 cmd_oid
, data_buf
, cmd_ptr
);
506 ret
= mwifiex_cmd_host_cmd(priv
, cmd_ptr
, data_buf
);
507 cmd_node
->cmd_flag
|= CMD_F_HOSTCMD
;
510 /* Return error, since the command preparation failed */
512 dev_err(adapter
->dev
, "PREP_CMD: cmd %#x preparation failed\n",
514 mwifiex_insert_cmd_to_free_q(adapter
, cmd_node
);
519 if (cmd_no
== HostCmd_CMD_802_11_SCAN
)
520 mwifiex_queue_scan_cmd(priv
, cmd_node
);
522 mwifiex_insert_cmd_to_pending_q(adapter
, cmd_node
, true);
528 * This function returns a command to the command free queue.
530 * The function also calls the completion callback if required, before
531 * cleaning the command node and re-inserting it into the free queue.
534 mwifiex_insert_cmd_to_free_q(struct mwifiex_adapter
*adapter
,
535 struct cmd_ctrl_node
*cmd_node
)
539 if (cmd_node
== NULL
)
542 if (cmd_node
->wait_q_enabled
)
543 mwifiex_complete_cmd(adapter
);
545 mwifiex_clean_cmd_node(adapter
, cmd_node
);
547 /* Insert node into cmd_free_q */
548 spin_lock_irqsave(&adapter
->cmd_free_q_lock
, flags
);
549 list_add_tail(&cmd_node
->list
, &adapter
->cmd_free_q
);
550 spin_unlock_irqrestore(&adapter
->cmd_free_q_lock
, flags
);
556 * This function queues a command to the command pending queue.
558 * This in effect adds the command to the command list to be executed.
559 * Exit PS command is handled specially, by placing it always to the
560 * front of the command queue.
563 mwifiex_insert_cmd_to_pending_q(struct mwifiex_adapter
*adapter
,
564 struct cmd_ctrl_node
*cmd_node
, u32 add_tail
)
566 struct host_cmd_ds_command
*host_cmd
= NULL
;
570 host_cmd
= (struct host_cmd_ds_command
*) (cmd_node
->cmd_skb
->data
);
572 dev_err(adapter
->dev
, "QUEUE_CMD: host_cmd is NULL\n");
576 command
= le16_to_cpu(host_cmd
->command
);
578 /* Exit_PS command needs to be queued in the header always. */
579 if (command
== HostCmd_CMD_802_11_PS_MODE_ENH
) {
580 struct host_cmd_ds_802_11_ps_mode_enh
*pm
=
581 &host_cmd
->params
.psmode_enh
;
582 if ((le16_to_cpu(pm
->action
) == DIS_PS
)
583 || (le16_to_cpu(pm
->action
) == DIS_AUTO_PS
)) {
584 if (adapter
->ps_state
!= PS_STATE_AWAKE
)
589 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
591 list_add_tail(&cmd_node
->list
, &adapter
->cmd_pending_q
);
593 list_add(&cmd_node
->list
, &adapter
->cmd_pending_q
);
594 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
596 dev_dbg(adapter
->dev
, "cmd: QUEUE_CMD: cmd=%#x is queued\n", command
);
602 * This function executes the next command in command pending queue.
604 * This function will fail if a command is already in processing stage,
605 * otherwise it will dequeue the first command from the command pending
606 * queue and send to the firmware.
608 * If the device is currently in host sleep mode, any commands, except the
609 * host sleep configuration command will de-activate the host sleep. For PS
610 * mode, the function will put the firmware back to sleep if applicable.
612 int mwifiex_exec_next_cmd(struct mwifiex_adapter
*adapter
)
614 struct mwifiex_private
*priv
= NULL
;
615 struct cmd_ctrl_node
*cmd_node
= NULL
;
617 struct host_cmd_ds_command
*host_cmd
;
618 unsigned long cmd_flags
;
619 unsigned long cmd_pending_q_flags
;
621 /* Check if already in processing */
622 if (adapter
->curr_cmd
) {
623 dev_err(adapter
->dev
, "EXEC_NEXT_CMD: cmd in processing\n");
627 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
628 /* Check if any command is pending */
629 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, cmd_pending_q_flags
);
630 if (list_empty(&adapter
->cmd_pending_q
)) {
631 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
,
632 cmd_pending_q_flags
);
633 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
636 cmd_node
= list_first_entry(&adapter
->cmd_pending_q
,
637 struct cmd_ctrl_node
, list
);
638 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
,
639 cmd_pending_q_flags
);
641 host_cmd
= (struct host_cmd_ds_command
*) (cmd_node
->cmd_skb
->data
);
642 priv
= cmd_node
->priv
;
644 if (adapter
->ps_state
!= PS_STATE_AWAKE
) {
645 dev_err(adapter
->dev
, "%s: cannot send cmd in sleep state,"
646 " this should not happen\n", __func__
);
647 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
651 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, cmd_pending_q_flags
);
652 list_del(&cmd_node
->list
);
653 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
,
654 cmd_pending_q_flags
);
656 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
657 ret
= mwifiex_dnld_cmd_to_fw(priv
, cmd_node
);
658 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
659 /* Any command sent to the firmware when host is in sleep
660 * mode should de-configure host sleep. We should skip the
661 * host sleep configuration command itself though
663 if (priv
&& (host_cmd
->command
!=
664 cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH
))) {
665 if (adapter
->hs_activated
) {
666 adapter
->is_hs_configured
= false;
667 mwifiex_hs_activated_event(priv
, false);
675 * This function handles the command response.
677 * After processing, the function cleans the command node and puts
678 * it back to the command free queue.
680 int mwifiex_process_cmdresp(struct mwifiex_adapter
*adapter
)
682 struct host_cmd_ds_command
*resp
= NULL
;
683 struct mwifiex_private
*priv
=
684 mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
686 uint16_t orig_cmdresp_no
;
688 uint16_t cmdresp_result
;
689 struct timeval tstamp
;
692 /* Now we got response from FW, cancel the command timer */
693 del_timer(&adapter
->cmd_timer
);
695 if (!adapter
->curr_cmd
|| !adapter
->curr_cmd
->resp_skb
) {
696 resp
= (struct host_cmd_ds_command
*) adapter
->upld_buf
;
697 dev_err(adapter
->dev
, "CMD_RESP: NULL curr_cmd, %#x\n",
698 le16_to_cpu(resp
->command
));
702 adapter
->num_cmd_timeout
= 0;
704 resp
= (struct host_cmd_ds_command
*) adapter
->curr_cmd
->resp_skb
->data
;
705 if (adapter
->curr_cmd
->cmd_flag
& CMD_F_CANCELED
) {
706 dev_err(adapter
->dev
, "CMD_RESP: %#x been canceled\n",
707 le16_to_cpu(resp
->command
));
708 mwifiex_insert_cmd_to_free_q(adapter
, adapter
->curr_cmd
);
709 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
710 adapter
->curr_cmd
= NULL
;
711 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
715 if (adapter
->curr_cmd
->cmd_flag
& CMD_F_HOSTCMD
) {
716 /* Copy original response back to response buffer */
717 struct mwifiex_ds_misc_cmd
*hostcmd
= NULL
;
718 uint16_t size
= le16_to_cpu(resp
->size
);
719 dev_dbg(adapter
->dev
, "info: host cmd resp size = %d\n", size
);
720 size
= min_t(u16
, size
, MWIFIEX_SIZE_OF_CMD_BUFFER
);
721 if (adapter
->curr_cmd
->data_buf
) {
722 hostcmd
= (struct mwifiex_ds_misc_cmd
*)
723 adapter
->curr_cmd
->data_buf
;
725 memcpy(hostcmd
->cmd
, (void *) resp
, size
);
728 orig_cmdresp_no
= le16_to_cpu(resp
->command
);
730 /* Get BSS number and corresponding priv */
731 priv
= mwifiex_get_priv_by_id(adapter
,
732 HostCmd_GET_BSS_NO(le16_to_cpu(resp
->seq_num
)),
733 HostCmd_GET_BSS_TYPE(le16_to_cpu(resp
->seq_num
)));
735 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
736 /* Clear RET_BIT from HostCmd */
737 resp
->command
= cpu_to_le16(orig_cmdresp_no
& HostCmd_CMD_ID_MASK
);
739 cmdresp_no
= le16_to_cpu(resp
->command
);
740 cmdresp_result
= le16_to_cpu(resp
->result
);
742 /* Save the last command response to debug log */
743 adapter
->dbg
.last_cmd_resp_index
=
744 (adapter
->dbg
.last_cmd_resp_index
+ 1) % DBG_CMD_NUM
;
745 adapter
->dbg
.last_cmd_resp_id
[adapter
->dbg
.last_cmd_resp_index
] =
748 do_gettimeofday(&tstamp
);
749 dev_dbg(adapter
->dev
, "cmd: CMD_RESP: (%lu.%lu): 0x%x, result %d,"
750 " len %d, seqno 0x%x\n",
751 tstamp
.tv_sec
, tstamp
.tv_usec
, orig_cmdresp_no
, cmdresp_result
,
752 le16_to_cpu(resp
->size
), le16_to_cpu(resp
->seq_num
));
754 if (!(orig_cmdresp_no
& HostCmd_RET_BIT
)) {
755 dev_err(adapter
->dev
, "CMD_RESP: invalid cmd resp\n");
756 if (adapter
->curr_cmd
->wait_q_enabled
)
757 adapter
->cmd_wait_q
.status
= -1;
759 mwifiex_insert_cmd_to_free_q(adapter
, adapter
->curr_cmd
);
760 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
761 adapter
->curr_cmd
= NULL
;
762 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
766 if (adapter
->curr_cmd
->cmd_flag
& CMD_F_HOSTCMD
) {
767 adapter
->curr_cmd
->cmd_flag
&= ~CMD_F_HOSTCMD
;
768 if ((cmdresp_result
== HostCmd_RESULT_OK
)
769 && (cmdresp_no
== HostCmd_CMD_802_11_HS_CFG_ENH
))
770 ret
= mwifiex_ret_802_11_hs_cfg(priv
, resp
);
772 /* handle response */
773 ret
= mwifiex_process_sta_cmdresp(priv
, cmdresp_no
, resp
);
776 /* Check init command response */
777 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_INITIALIZING
) {
779 dev_err(adapter
->dev
, "%s: cmd %#x failed during "
780 "initialization\n", __func__
, cmdresp_no
);
781 mwifiex_init_fw_complete(adapter
);
783 } else if (adapter
->last_init_cmd
== cmdresp_no
)
784 adapter
->hw_status
= MWIFIEX_HW_STATUS_INIT_DONE
;
787 if (adapter
->curr_cmd
) {
788 if (adapter
->curr_cmd
->wait_q_enabled
&& (!ret
))
789 adapter
->cmd_wait_q
.status
= 0;
790 else if (adapter
->curr_cmd
->wait_q_enabled
&& (ret
== -1))
791 adapter
->cmd_wait_q
.status
= -1;
793 /* Clean up and put current command back to cmd_free_q */
794 mwifiex_insert_cmd_to_free_q(adapter
, adapter
->curr_cmd
);
796 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
797 adapter
->curr_cmd
= NULL
;
798 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
805 * This function handles the timeout of command sending.
807 * It will re-send the same command again.
810 mwifiex_cmd_timeout_func(unsigned long function_context
)
812 struct mwifiex_adapter
*adapter
=
813 (struct mwifiex_adapter
*) function_context
;
814 struct cmd_ctrl_node
*cmd_node
= NULL
;
815 struct timeval tstamp
;
817 adapter
->num_cmd_timeout
++;
818 adapter
->dbg
.num_cmd_timeout
++;
819 if (!adapter
->curr_cmd
) {
820 dev_dbg(adapter
->dev
, "cmd: empty curr_cmd\n");
823 cmd_node
= adapter
->curr_cmd
;
824 if (cmd_node
->wait_q_enabled
)
825 adapter
->cmd_wait_q
.status
= -ETIMEDOUT
;
828 adapter
->dbg
.timeout_cmd_id
=
829 adapter
->dbg
.last_cmd_id
[adapter
->dbg
.last_cmd_index
];
830 adapter
->dbg
.timeout_cmd_act
=
831 adapter
->dbg
.last_cmd_act
[adapter
->dbg
.last_cmd_index
];
832 do_gettimeofday(&tstamp
);
833 dev_err(adapter
->dev
, "%s: Timeout cmd id (%lu.%lu) = %#x,"
834 " act = %#x\n", __func__
,
835 tstamp
.tv_sec
, tstamp
.tv_usec
,
836 adapter
->dbg
.timeout_cmd_id
,
837 adapter
->dbg
.timeout_cmd_act
);
839 dev_err(adapter
->dev
, "num_data_h2c_failure = %d\n",
840 adapter
->dbg
.num_tx_host_to_card_failure
);
841 dev_err(adapter
->dev
, "num_cmd_h2c_failure = %d\n",
842 adapter
->dbg
.num_cmd_host_to_card_failure
);
844 dev_err(adapter
->dev
, "num_cmd_timeout = %d\n",
845 adapter
->dbg
.num_cmd_timeout
);
846 dev_err(adapter
->dev
, "num_tx_timeout = %d\n",
847 adapter
->dbg
.num_tx_timeout
);
849 dev_err(adapter
->dev
, "last_cmd_index = %d\n",
850 adapter
->dbg
.last_cmd_index
);
851 print_hex_dump_bytes("last_cmd_id: ", DUMP_PREFIX_OFFSET
,
852 adapter
->dbg
.last_cmd_id
, DBG_CMD_NUM
);
853 print_hex_dump_bytes("last_cmd_act: ", DUMP_PREFIX_OFFSET
,
854 adapter
->dbg
.last_cmd_act
, DBG_CMD_NUM
);
856 dev_err(adapter
->dev
, "last_cmd_resp_index = %d\n",
857 adapter
->dbg
.last_cmd_resp_index
);
858 print_hex_dump_bytes("last_cmd_resp_id: ", DUMP_PREFIX_OFFSET
,
859 adapter
->dbg
.last_cmd_resp_id
, DBG_CMD_NUM
);
861 dev_err(adapter
->dev
, "last_event_index = %d\n",
862 adapter
->dbg
.last_event_index
);
863 print_hex_dump_bytes("last_event: ", DUMP_PREFIX_OFFSET
,
864 adapter
->dbg
.last_event
, DBG_CMD_NUM
);
866 dev_err(adapter
->dev
, "data_sent=%d cmd_sent=%d\n",
867 adapter
->data_sent
, adapter
->cmd_sent
);
869 dev_err(adapter
->dev
, "ps_mode=%d ps_state=%d\n",
870 adapter
->ps_mode
, adapter
->ps_state
);
872 if (adapter
->hw_status
== MWIFIEX_HW_STATUS_INITIALIZING
)
873 mwifiex_init_fw_complete(adapter
);
879 * This function cancels all the pending commands.
881 * The current command, all commands in command pending queue and all scan
882 * commands in scan pending queue are cancelled. All the completion callbacks
883 * are called with failure status to ensure cleanup.
886 mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter
*adapter
)
888 struct cmd_ctrl_node
*cmd_node
= NULL
, *tmp_node
= NULL
;
891 /* Cancel current cmd */
892 if ((adapter
->curr_cmd
) && (adapter
->curr_cmd
->wait_q_enabled
)) {
893 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
894 adapter
->curr_cmd
->wait_q_enabled
= false;
895 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
896 adapter
->cmd_wait_q
.status
= -1;
897 mwifiex_complete_cmd(adapter
);
899 /* Cancel all pending command */
900 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
901 list_for_each_entry_safe(cmd_node
, tmp_node
,
902 &adapter
->cmd_pending_q
, list
) {
903 list_del(&cmd_node
->list
);
904 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
906 if (cmd_node
->wait_q_enabled
) {
907 adapter
->cmd_wait_q
.status
= -1;
908 mwifiex_complete_cmd(adapter
);
909 cmd_node
->wait_q_enabled
= false;
911 mwifiex_insert_cmd_to_free_q(adapter
, cmd_node
);
912 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
, flags
);
914 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
, flags
);
916 /* Cancel all pending scan command */
917 spin_lock_irqsave(&adapter
->scan_pending_q_lock
, flags
);
918 list_for_each_entry_safe(cmd_node
, tmp_node
,
919 &adapter
->scan_pending_q
, list
) {
920 list_del(&cmd_node
->list
);
921 spin_unlock_irqrestore(&adapter
->scan_pending_q_lock
, flags
);
923 cmd_node
->wait_q_enabled
= false;
924 mwifiex_insert_cmd_to_free_q(adapter
, cmd_node
);
925 spin_lock_irqsave(&adapter
->scan_pending_q_lock
, flags
);
927 spin_unlock_irqrestore(&adapter
->scan_pending_q_lock
, flags
);
929 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, flags
);
930 adapter
->scan_processing
= false;
931 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, flags
);
935 * This function cancels all pending commands that matches with
936 * the given IOCTL request.
938 * Both the current command buffer and the pending command queue are
939 * searched for matching IOCTL request. The completion callback of
940 * the matched command is called with failure status to ensure cleanup.
941 * In case of scan commands, all pending commands in scan pending queue
945 mwifiex_cancel_pending_ioctl(struct mwifiex_adapter
*adapter
)
947 struct cmd_ctrl_node
*cmd_node
= NULL
, *tmp_node
= NULL
;
948 unsigned long cmd_flags
;
949 unsigned long cmd_pending_q_flags
;
950 unsigned long scan_pending_q_flags
;
951 uint16_t cancel_scan_cmd
= false;
953 if ((adapter
->curr_cmd
) &&
954 (adapter
->curr_cmd
->wait_q_enabled
)) {
955 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
956 cmd_node
= adapter
->curr_cmd
;
957 cmd_node
->wait_q_enabled
= false;
958 cmd_node
->cmd_flag
|= CMD_F_CANCELED
;
959 spin_lock_irqsave(&adapter
->cmd_pending_q_lock
,
960 cmd_pending_q_flags
);
961 list_del(&cmd_node
->list
);
962 spin_unlock_irqrestore(&adapter
->cmd_pending_q_lock
,
963 cmd_pending_q_flags
);
964 mwifiex_insert_cmd_to_free_q(adapter
, cmd_node
);
965 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
968 /* Cancel all pending scan command */
969 spin_lock_irqsave(&adapter
->scan_pending_q_lock
,
970 scan_pending_q_flags
);
971 list_for_each_entry_safe(cmd_node
, tmp_node
,
972 &adapter
->scan_pending_q
, list
) {
973 list_del(&cmd_node
->list
);
974 spin_unlock_irqrestore(&adapter
->scan_pending_q_lock
,
975 scan_pending_q_flags
);
976 cmd_node
->wait_q_enabled
= false;
977 mwifiex_insert_cmd_to_free_q(adapter
, cmd_node
);
978 spin_lock_irqsave(&adapter
->scan_pending_q_lock
,
979 scan_pending_q_flags
);
980 cancel_scan_cmd
= true;
982 spin_unlock_irqrestore(&adapter
->scan_pending_q_lock
,
983 scan_pending_q_flags
);
985 if (cancel_scan_cmd
) {
986 spin_lock_irqsave(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
987 adapter
->scan_processing
= false;
988 spin_unlock_irqrestore(&adapter
->mwifiex_cmd_lock
, cmd_flags
);
990 adapter
->cmd_wait_q
.status
= -1;
991 mwifiex_complete_cmd(adapter
);
997 * This function sends the sleep confirm command to firmware, if
1000 * The sleep confirm command cannot be issued if command response,
1001 * data response or event response is awaiting handling, or if we
1002 * are in the middle of sending a command, or expecting a command
1006 mwifiex_check_ps_cond(struct mwifiex_adapter
*adapter
)
1008 if (!adapter
->cmd_sent
&&
1009 !adapter
->curr_cmd
&& !IS_CARD_RX_RCVD(adapter
))
1010 mwifiex_dnld_sleep_confirm_cmd(adapter
);
1012 dev_dbg(adapter
->dev
,
1013 "cmd: Delay Sleep Confirm (%s%s%s)\n",
1014 (adapter
->cmd_sent
) ? "D" : "",
1015 (adapter
->curr_cmd
) ? "C" : "",
1016 (IS_CARD_RX_RCVD(adapter
)) ? "R" : "");
1020 * This function sends a Host Sleep activated event to applications.
1022 * This event is generated by the driver, with a blank event body.
1025 mwifiex_hs_activated_event(struct mwifiex_private
*priv
, u8 activated
)
1028 if (priv
->adapter
->is_hs_configured
) {
1029 priv
->adapter
->hs_activated
= true;
1030 dev_dbg(priv
->adapter
->dev
, "event: hs_activated\n");
1031 priv
->adapter
->hs_activate_wait_q_woken
= true;
1032 wake_up_interruptible(
1033 &priv
->adapter
->hs_activate_wait_q
);
1035 dev_dbg(priv
->adapter
->dev
, "event: HS not configured\n");
1038 dev_dbg(priv
->adapter
->dev
, "event: hs_deactivated\n");
1039 priv
->adapter
->hs_activated
= false;
1044 * This function handles the command response of a Host Sleep configuration
1047 * Handling includes changing the header fields into CPU format
1048 * and setting the current host sleep activation status in driver.
1050 * In case host sleep status change, the function generates an event to
1051 * notify the applications.
1053 int mwifiex_ret_802_11_hs_cfg(struct mwifiex_private
*priv
,
1054 struct host_cmd_ds_command
*resp
)
1056 struct mwifiex_adapter
*adapter
= priv
->adapter
;
1057 struct host_cmd_ds_802_11_hs_cfg_enh
*phs_cfg
=
1058 &resp
->params
.opt_hs_cfg
;
1059 uint32_t conditions
= le32_to_cpu(phs_cfg
->params
.hs_config
.conditions
);
1061 if (phs_cfg
->action
== cpu_to_le16(HS_ACTIVATE
)) {
1062 mwifiex_hs_activated_event(priv
, true);
1065 dev_dbg(adapter
->dev
, "cmd: CMD_RESP: HS_CFG cmd reply"
1066 " result=%#x, conditions=0x%x gpio=0x%x gap=0x%x\n",
1067 resp
->result
, conditions
,
1068 phs_cfg
->params
.hs_config
.gpio
,
1069 phs_cfg
->params
.hs_config
.gap
);
1071 if (conditions
!= HOST_SLEEP_CFG_CANCEL
) {
1072 adapter
->is_hs_configured
= true;
1074 adapter
->is_hs_configured
= false;
1075 if (adapter
->hs_activated
)
1076 mwifiex_hs_activated_event(priv
, false);
1083 * This function wakes up the adapter and generates a Host Sleep
1084 * cancel event on receiving the power up interrupt.
1087 mwifiex_process_hs_config(struct mwifiex_adapter
*adapter
)
1089 dev_dbg(adapter
->dev
, "info: %s: auto cancelling host sleep"
1090 " since there is interrupt from the firmware\n", __func__
);
1092 adapter
->if_ops
.wakeup(adapter
);
1093 adapter
->hs_activated
= false;
1094 adapter
->is_hs_configured
= false;
1095 mwifiex_hs_activated_event(mwifiex_get_priv(adapter
,
1096 MWIFIEX_BSS_ROLE_ANY
), false);
1101 * This function handles the command response of a sleep confirm command.
1103 * The function sets the card state to SLEEP if the response indicates success.
1106 mwifiex_process_sleep_confirm_resp(struct mwifiex_adapter
*adapter
,
1107 u8
*pbuf
, u32 upld_len
)
1109 struct host_cmd_ds_command
*cmd
= (struct host_cmd_ds_command
*) pbuf
;
1110 struct mwifiex_private
*priv
=
1111 mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
1112 uint16_t result
= le16_to_cpu(cmd
->result
);
1113 uint16_t command
= le16_to_cpu(cmd
->command
);
1114 uint16_t seq_num
= le16_to_cpu(cmd
->seq_num
);
1117 dev_err(adapter
->dev
, "%s: cmd size is 0\n", __func__
);
1121 /* Get BSS number and corresponding priv */
1122 priv
= mwifiex_get_priv_by_id(adapter
, HostCmd_GET_BSS_NO(seq_num
),
1123 HostCmd_GET_BSS_TYPE(seq_num
));
1125 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
1127 /* Update sequence number */
1128 seq_num
= HostCmd_GET_SEQ_NO(seq_num
);
1129 /* Clear RET_BIT from HostCmd */
1130 command
&= HostCmd_CMD_ID_MASK
;
1132 if (command
!= HostCmd_CMD_802_11_PS_MODE_ENH
) {
1133 dev_err(adapter
->dev
, "%s: received unexpected response for"
1134 " cmd %x, result = %x\n", __func__
, command
, result
);
1139 dev_err(adapter
->dev
, "%s: sleep confirm cmd failed\n",
1141 adapter
->pm_wakeup_card_req
= false;
1142 adapter
->ps_state
= PS_STATE_AWAKE
;
1145 adapter
->pm_wakeup_card_req
= true;
1146 if (adapter
->is_hs_configured
)
1147 mwifiex_hs_activated_event(mwifiex_get_priv(adapter
,
1148 MWIFIEX_BSS_ROLE_ANY
), true);
1149 adapter
->ps_state
= PS_STATE_SLEEP
;
1150 cmd
->command
= cpu_to_le16(command
);
1151 cmd
->seq_num
= cpu_to_le16(seq_num
);
1153 EXPORT_SYMBOL_GPL(mwifiex_process_sleep_confirm_resp
);
1156 * This function prepares an enhanced power mode command.
1158 * This function can be used to disable power save or to configure
1159 * power save with auto PS or STA PS or auto deep sleep.
1161 * Preparation includes -
1162 * - Setting command ID, action and proper size
1163 * - Setting Power Save bitmap, PS parameters TLV, PS mode TLV,
1164 * auto deep sleep TLV (as required)
1165 * - Ensuring correct endian-ness
1167 int mwifiex_cmd_enh_power_mode(struct mwifiex_private
*priv
,
1168 struct host_cmd_ds_command
*cmd
,
1169 u16 cmd_action
, uint16_t ps_bitmap
,
1172 struct host_cmd_ds_802_11_ps_mode_enh
*psmode_enh
=
1173 &cmd
->params
.psmode_enh
;
1177 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_PS_MODE_ENH
);
1178 if (cmd_action
== DIS_AUTO_PS
) {
1179 psmode_enh
->action
= cpu_to_le16(DIS_AUTO_PS
);
1180 psmode_enh
->params
.ps_bitmap
= cpu_to_le16(ps_bitmap
);
1181 cmd
->size
= cpu_to_le16(S_DS_GEN
+ sizeof(psmode_enh
->action
) +
1182 sizeof(psmode_enh
->params
.ps_bitmap
));
1183 } else if (cmd_action
== GET_PS
) {
1184 psmode_enh
->action
= cpu_to_le16(GET_PS
);
1185 psmode_enh
->params
.ps_bitmap
= cpu_to_le16(ps_bitmap
);
1186 cmd
->size
= cpu_to_le16(S_DS_GEN
+ sizeof(psmode_enh
->action
) +
1187 sizeof(psmode_enh
->params
.ps_bitmap
));
1188 } else if (cmd_action
== EN_AUTO_PS
) {
1189 psmode_enh
->action
= cpu_to_le16(EN_AUTO_PS
);
1190 psmode_enh
->params
.ps_bitmap
= cpu_to_le16(ps_bitmap
);
1191 cmd_size
= S_DS_GEN
+ sizeof(psmode_enh
->action
) +
1192 sizeof(psmode_enh
->params
.ps_bitmap
);
1193 tlv
= (u8
*) cmd
+ cmd_size
;
1194 if (ps_bitmap
& BITMAP_STA_PS
) {
1195 struct mwifiex_adapter
*adapter
= priv
->adapter
;
1196 struct mwifiex_ie_types_ps_param
*ps_tlv
=
1197 (struct mwifiex_ie_types_ps_param
*) tlv
;
1198 struct mwifiex_ps_param
*ps_mode
= &ps_tlv
->param
;
1199 ps_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_PS_PARAM
);
1200 ps_tlv
->header
.len
= cpu_to_le16(sizeof(*ps_tlv
) -
1201 sizeof(struct mwifiex_ie_types_header
));
1202 cmd_size
+= sizeof(*ps_tlv
);
1203 tlv
+= sizeof(*ps_tlv
);
1204 dev_dbg(adapter
->dev
, "cmd: PS Command: Enter PS\n");
1205 ps_mode
->null_pkt_interval
=
1206 cpu_to_le16(adapter
->null_pkt_interval
);
1207 ps_mode
->multiple_dtims
=
1208 cpu_to_le16(adapter
->multiple_dtim
);
1209 ps_mode
->bcn_miss_timeout
=
1210 cpu_to_le16(adapter
->bcn_miss_time_out
);
1211 ps_mode
->local_listen_interval
=
1212 cpu_to_le16(adapter
->local_listen_interval
);
1213 ps_mode
->adhoc_wake_period
=
1214 cpu_to_le16(adapter
->adhoc_awake_period
);
1215 ps_mode
->delay_to_ps
=
1216 cpu_to_le16(adapter
->delay_to_ps
);
1218 cpu_to_le16(adapter
->enhanced_ps_mode
);
1221 if (ps_bitmap
& BITMAP_AUTO_DS
) {
1222 struct mwifiex_ie_types_auto_ds_param
*auto_ds_tlv
=
1223 (struct mwifiex_ie_types_auto_ds_param
*) tlv
;
1226 auto_ds_tlv
->header
.type
=
1227 cpu_to_le16(TLV_TYPE_AUTO_DS_PARAM
);
1228 auto_ds_tlv
->header
.len
=
1229 cpu_to_le16(sizeof(*auto_ds_tlv
) -
1230 sizeof(struct mwifiex_ie_types_header
));
1231 cmd_size
+= sizeof(*auto_ds_tlv
);
1232 tlv
+= sizeof(*auto_ds_tlv
);
1234 idletime
= ((struct mwifiex_ds_auto_ds
*)
1235 data_buf
)->idle_time
;
1236 dev_dbg(priv
->adapter
->dev
,
1237 "cmd: PS Command: Enter Auto Deep Sleep\n");
1238 auto_ds_tlv
->deep_sleep_timeout
= cpu_to_le16(idletime
);
1240 cmd
->size
= cpu_to_le16(cmd_size
);
1246 * This function handles the command response of an enhanced power mode
1249 * Handling includes changing the header fields into CPU format
1250 * and setting the current enhanced power mode in driver.
1252 int mwifiex_ret_enh_power_mode(struct mwifiex_private
*priv
,
1253 struct host_cmd_ds_command
*resp
,
1256 struct mwifiex_adapter
*adapter
= priv
->adapter
;
1257 struct host_cmd_ds_802_11_ps_mode_enh
*ps_mode
=
1258 &resp
->params
.psmode_enh
;
1259 uint16_t action
= le16_to_cpu(ps_mode
->action
);
1260 uint16_t ps_bitmap
= le16_to_cpu(ps_mode
->params
.ps_bitmap
);
1261 uint16_t auto_ps_bitmap
=
1262 le16_to_cpu(ps_mode
->params
.ps_bitmap
);
1264 dev_dbg(adapter
->dev
, "info: %s: PS_MODE cmd reply result=%#x action=%#X\n",
1265 __func__
, resp
->result
, action
);
1266 if (action
== EN_AUTO_PS
) {
1267 if (auto_ps_bitmap
& BITMAP_AUTO_DS
) {
1268 dev_dbg(adapter
->dev
, "cmd: Enabled auto deep sleep\n");
1269 priv
->adapter
->is_deep_sleep
= true;
1271 if (auto_ps_bitmap
& BITMAP_STA_PS
) {
1272 dev_dbg(adapter
->dev
, "cmd: Enabled STA power save\n");
1273 if (adapter
->sleep_period
.period
)
1274 dev_dbg(adapter
->dev
, "cmd: set to uapsd/pps mode\n");
1276 } else if (action
== DIS_AUTO_PS
) {
1277 if (ps_bitmap
& BITMAP_AUTO_DS
) {
1278 priv
->adapter
->is_deep_sleep
= false;
1279 dev_dbg(adapter
->dev
, "cmd: Disabled auto deep sleep\n");
1281 if (ps_bitmap
& BITMAP_STA_PS
) {
1282 dev_dbg(adapter
->dev
, "cmd: Disabled STA power save\n");
1283 if (adapter
->sleep_period
.period
) {
1284 adapter
->delay_null_pkt
= false;
1285 adapter
->tx_lock_flag
= false;
1286 adapter
->pps_uapsd_mode
= false;
1289 } else if (action
== GET_PS
) {
1290 if (ps_bitmap
& BITMAP_STA_PS
)
1291 adapter
->ps_mode
= MWIFIEX_802_11_POWER_MODE_PSP
;
1293 adapter
->ps_mode
= MWIFIEX_802_11_POWER_MODE_CAM
;
1295 dev_dbg(adapter
->dev
, "cmd: ps_bitmap=%#x\n", ps_bitmap
);
1298 /* This section is for get power save mode */
1299 struct mwifiex_ds_pm_cfg
*pm_cfg
=
1300 (struct mwifiex_ds_pm_cfg
*)data_buf
;
1301 if (ps_bitmap
& BITMAP_STA_PS
)
1302 pm_cfg
->param
.ps_mode
= 1;
1304 pm_cfg
->param
.ps_mode
= 0;
1311 * This function prepares command to get hardware specifications.
1313 * Preparation includes -
1314 * - Setting command ID, action and proper size
1315 * - Setting permanent address parameter
1316 * - Ensuring correct endian-ness
1318 int mwifiex_cmd_get_hw_spec(struct mwifiex_private
*priv
,
1319 struct host_cmd_ds_command
*cmd
)
1321 struct host_cmd_ds_get_hw_spec
*hw_spec
= &cmd
->params
.hw_spec
;
1323 cmd
->command
= cpu_to_le16(HostCmd_CMD_GET_HW_SPEC
);
1325 cpu_to_le16(sizeof(struct host_cmd_ds_get_hw_spec
) + S_DS_GEN
);
1326 memcpy(hw_spec
->permanent_addr
, priv
->curr_addr
, ETH_ALEN
);
1332 * This function handles the command response of get hardware
1335 * Handling includes changing the header fields into CPU format
1336 * and saving/updating the following parameters in driver -
1337 * - Firmware capability information
1338 * - Firmware band settings
1339 * - Ad-hoc start band and channel
1340 * - Ad-hoc 11n activation status
1341 * - Firmware release number
1342 * - Number of antennas
1343 * - Hardware address
1344 * - Hardware interface version
1345 * - Firmware version
1347 * - 11n capabilities
1348 * - MCS support fields
1351 int mwifiex_ret_get_hw_spec(struct mwifiex_private
*priv
,
1352 struct host_cmd_ds_command
*resp
)
1354 struct host_cmd_ds_get_hw_spec
*hw_spec
= &resp
->params
.hw_spec
;
1355 struct mwifiex_adapter
*adapter
= priv
->adapter
;
1358 adapter
->fw_cap_info
= le32_to_cpu(hw_spec
->fw_cap_info
);
1360 if (IS_SUPPORT_MULTI_BANDS(adapter
))
1361 adapter
->fw_bands
= (u8
) GET_FW_DEFAULT_BANDS(adapter
);
1363 adapter
->fw_bands
= BAND_B
;
1365 adapter
->config_bands
= adapter
->fw_bands
;
1367 if (adapter
->fw_bands
& BAND_A
) {
1368 if (adapter
->fw_bands
& BAND_GN
) {
1369 adapter
->config_bands
|= BAND_AN
;
1370 adapter
->fw_bands
|= BAND_AN
;
1372 if (adapter
->fw_bands
& BAND_AN
) {
1373 adapter
->adhoc_start_band
= BAND_A
| BAND_AN
;
1374 adapter
->adhoc_11n_enabled
= true;
1376 adapter
->adhoc_start_band
= BAND_A
;
1378 priv
->adhoc_channel
= DEFAULT_AD_HOC_CHANNEL_A
;
1379 } else if (adapter
->fw_bands
& BAND_GN
) {
1380 adapter
->adhoc_start_band
= BAND_G
| BAND_B
| BAND_GN
;
1381 priv
->adhoc_channel
= DEFAULT_AD_HOC_CHANNEL
;
1382 adapter
->adhoc_11n_enabled
= true;
1383 } else if (adapter
->fw_bands
& BAND_G
) {
1384 adapter
->adhoc_start_band
= BAND_G
| BAND_B
;
1385 priv
->adhoc_channel
= DEFAULT_AD_HOC_CHANNEL
;
1386 } else if (adapter
->fw_bands
& BAND_B
) {
1387 adapter
->adhoc_start_band
= BAND_B
;
1388 priv
->adhoc_channel
= DEFAULT_AD_HOC_CHANNEL
;
1391 adapter
->fw_release_number
= le32_to_cpu(hw_spec
->fw_release_number
);
1392 adapter
->number_of_antenna
= le16_to_cpu(hw_spec
->number_of_antenna
);
1394 dev_dbg(adapter
->dev
, "info: GET_HW_SPEC: fw_release_number- %#x\n",
1395 adapter
->fw_release_number
);
1396 dev_dbg(adapter
->dev
, "info: GET_HW_SPEC: permanent addr: %pM\n",
1397 hw_spec
->permanent_addr
);
1398 dev_dbg(adapter
->dev
, "info: GET_HW_SPEC: hw_if_version=%#x version=%#x\n",
1399 le16_to_cpu(hw_spec
->hw_if_version
),
1400 le16_to_cpu(hw_spec
->version
));
1402 if (priv
->curr_addr
[0] == 0xff)
1403 memmove(priv
->curr_addr
, hw_spec
->permanent_addr
, ETH_ALEN
);
1405 adapter
->region_code
= le16_to_cpu(hw_spec
->region_code
);
1407 for (i
= 0; i
< MWIFIEX_MAX_REGION_CODE
; i
++)
1408 /* Use the region code to search for the index */
1409 if (adapter
->region_code
== region_code_index
[i
])
1412 /* If it's unidentified region code, use the default (USA) */
1413 if (i
>= MWIFIEX_MAX_REGION_CODE
) {
1414 adapter
->region_code
= 0x10;
1415 dev_dbg(adapter
->dev
, "cmd: unknown region code, use default (USA)\n");
1418 adapter
->hw_dot_11n_dev_cap
= le32_to_cpu(hw_spec
->dot_11n_dev_cap
);
1419 adapter
->hw_dev_mcs_support
= hw_spec
->dev_mcs_support
;
1421 if (adapter
->if_ops
.update_mp_end_port
)
1422 adapter
->if_ops
.update_mp_end_port(adapter
,
1423 le16_to_cpu(hw_spec
->mp_end_port
));