blob: 2d761477d15e5761ed968200484a6fd55d066f39 [file] [log] [blame]
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001/*
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"
Yogesh Ashok Powara5f39052013-02-15 21:44:30 -080027#include "11ac.h"
Bing Zhao5e6e3a92011-03-21 18:00:50 -070028
29/*
30 * This function initializes a command node.
31 *
32 * The actual allocation of the node is not done by this function. It only
33 * initiates a node by filling it with default parameters. Similarly,
34 * allocation of the different buffers used (IOCTL buffer, data buffer) are
35 * not done by this function either.
36 */
37static void
38mwifiex_init_cmd_node(struct mwifiex_private *priv,
39 struct cmd_ctrl_node *cmd_node,
Amitkumar Karwar600f5d92011-04-13 17:27:06 -070040 u32 cmd_oid, void *data_buf)
Bing Zhao5e6e3a92011-03-21 18:00:50 -070041{
42 cmd_node->priv = priv;
43 cmd_node->cmd_oid = cmd_oid;
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -070044 if (priv->adapter->cmd_wait_q_required) {
45 cmd_node->wait_q_enabled = priv->adapter->cmd_wait_q_required;
46 priv->adapter->cmd_wait_q_required = false;
47 cmd_node->cmd_wait_q_woken = false;
48 cmd_node->condition = &cmd_node->cmd_wait_q_woken;
49 }
Bing Zhao5e6e3a92011-03-21 18:00:50 -070050 cmd_node->data_buf = data_buf;
51 cmd_node->cmd_skb = cmd_node->skb;
52}
53
54/*
55 * This function returns a command node from the free queue depending upon
56 * availability.
57 */
58static struct cmd_ctrl_node *
59mwifiex_get_cmd_node(struct mwifiex_adapter *adapter)
60{
61 struct cmd_ctrl_node *cmd_node;
62 unsigned long flags;
63
64 spin_lock_irqsave(&adapter->cmd_free_q_lock, flags);
65 if (list_empty(&adapter->cmd_free_q)) {
66 dev_err(adapter->dev, "GET_CMD_NODE: cmd node not available\n");
67 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
68 return NULL;
69 }
70 cmd_node = list_first_entry(&adapter->cmd_free_q,
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -070071 struct cmd_ctrl_node, list);
Bing Zhao5e6e3a92011-03-21 18:00:50 -070072 list_del(&cmd_node->list);
73 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
74
75 return cmd_node;
76}
77
78/*
79 * This function cleans up a command node.
80 *
81 * The function resets the fields including the buffer pointers.
82 * This function does not try to free the buffers. They must be
83 * freed before calling this function.
84 *
85 * This function will however call the receive completion callback
86 * in case a response buffer is still available before resetting
87 * the pointer.
88 */
89static void
90mwifiex_clean_cmd_node(struct mwifiex_adapter *adapter,
91 struct cmd_ctrl_node *cmd_node)
92{
93 cmd_node->cmd_oid = 0;
94 cmd_node->cmd_flag = 0;
Bing Zhao5e6e3a92011-03-21 18:00:50 -070095 cmd_node->data_buf = NULL;
Amitkumar Karwar600f5d92011-04-13 17:27:06 -070096 cmd_node->wait_q_enabled = false;
Bing Zhao5e6e3a92011-03-21 18:00:50 -070097
Amitkumar Karwar5cf80992011-09-21 21:43:25 -070098 if (cmd_node->cmd_skb)
99 skb_trim(cmd_node->cmd_skb, 0);
100
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700101 if (cmd_node->resp_skb) {
Amitkumar Karward930fae2011-10-11 17:41:21 -0700102 adapter->if_ops.cmdrsp_complete(adapter, cmd_node->resp_skb);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700103 cmd_node->resp_skb = NULL;
104 }
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700105}
106
107/*
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700108 * This function sends a host command to the firmware.
109 *
110 * The function copies the host command into the driver command
111 * buffer, which will be transferred to the firmware later by the
112 * main thread.
113 */
114static int mwifiex_cmd_host_cmd(struct mwifiex_private *priv,
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -0700115 struct host_cmd_ds_command *cmd,
116 struct mwifiex_ds_misc_cmd *pcmd_ptr)
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700117{
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700118 /* Copy the HOST command to command buffer */
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -0700119 memcpy(cmd, pcmd_ptr->cmd, pcmd_ptr->len);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700120 dev_dbg(priv->adapter->dev, "cmd: host cmd size = %d\n", pcmd_ptr->len);
121 return 0;
122}
123
124/*
125 * This function downloads a command to the firmware.
126 *
127 * The function performs sanity tests, sets the command sequence
128 * number and size, converts the header fields to CPU format before
129 * sending. Afterwards, it logs the command ID and action for debugging
130 * and sets up the command timeout timer.
131 */
132static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private *priv,
133 struct cmd_ctrl_node *cmd_node)
134{
135
136 struct mwifiex_adapter *adapter = priv->adapter;
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700137 int ret;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700138 struct host_cmd_ds_command *host_cmd;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700139 uint16_t cmd_code;
140 uint16_t cmd_size;
141 struct timeval tstamp;
142 unsigned long flags;
Amitkumar Karwar4daffe32012-04-18 20:08:28 -0700143 __le32 tmp;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700144
145 if (!adapter || !cmd_node)
146 return -1;
147
148 host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700149
150 /* Sanity test */
151 if (host_cmd == NULL || host_cmd->size == 0) {
152 dev_err(adapter->dev, "DNLD_CMD: host_cmd is null"
153 " or cmd size is 0, not sending\n");
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700154 if (cmd_node->wait_q_enabled)
155 adapter->cmd_wait_q.status = -1;
Bing Zhao9908b072013-04-01 12:44:46 -0700156 mwifiex_recycle_cmd_node(adapter, cmd_node);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700157 return -1;
158 }
159
Bing Zhaoa3e240c2013-03-15 18:47:06 -0700160 cmd_code = le16_to_cpu(host_cmd->command);
161 cmd_size = le16_to_cpu(host_cmd->size);
162
163 if (adapter->hw_status == MWIFIEX_HW_STATUS_RESET &&
164 cmd_code != HostCmd_CMD_FUNC_SHUTDOWN &&
165 cmd_code != HostCmd_CMD_FUNC_INIT) {
166 dev_err(adapter->dev,
167 "DNLD_CMD: FW in reset state, ignore cmd %#x\n",
168 cmd_code);
169 mwifiex_complete_cmd(adapter, cmd_node);
Bing Zhao9908b072013-04-01 12:44:46 -0700170 mwifiex_recycle_cmd_node(adapter, cmd_node);
Bing Zhaoa3e240c2013-03-15 18:47:06 -0700171 return -1;
172 }
173
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700174 /* Set command sequence number */
175 adapter->seq_num++;
176 host_cmd->seq_num = cpu_to_le16(HostCmd_SET_SEQ_NO_BSS_INFO
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700177 (adapter->seq_num,
178 cmd_node->priv->bss_num,
179 cmd_node->priv->bss_type));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700180
181 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
182 adapter->curr_cmd = cmd_node;
183 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
184
Stone Piaoda251862012-08-22 20:26:31 -0700185 /* Adjust skb length */
186 if (cmd_node->cmd_skb->len > cmd_size)
187 /*
188 * cmd_size is less than sizeof(struct host_cmd_ds_command).
189 * Trim off the unused portion.
190 */
191 skb_trim(cmd_node->cmd_skb, cmd_size);
192 else if (cmd_node->cmd_skb->len < cmd_size)
193 /*
194 * cmd_size is larger than sizeof(struct host_cmd_ds_command)
195 * because we have appended custom IE TLV. Increase skb length
196 * accordingly.
197 */
198 skb_put(cmd_node->cmd_skb, cmd_size - cmd_node->cmd_skb->len);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700199
200 do_gettimeofday(&tstamp);
201 dev_dbg(adapter->dev, "cmd: DNLD_CMD: (%lu.%lu): %#x, act %#x, len %d,"
202 " seqno %#x\n",
203 tstamp.tv_sec, tstamp.tv_usec, cmd_code,
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700204 le16_to_cpu(*(__le16 *) ((u8 *) host_cmd + S_DS_GEN)), cmd_size,
205 le16_to_cpu(host_cmd->seq_num));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700206
Amitkumar Karwar4daffe32012-04-18 20:08:28 -0700207 if (adapter->iface_type == MWIFIEX_USB) {
208 tmp = cpu_to_le32(MWIFIEX_USB_TYPE_CMD);
209 skb_push(cmd_node->cmd_skb, MWIFIEX_TYPE_LEN);
210 memcpy(cmd_node->cmd_skb->data, &tmp, MWIFIEX_TYPE_LEN);
211 adapter->cmd_sent = true;
212 ret = adapter->if_ops.host_to_card(adapter,
213 MWIFIEX_USB_EP_CMD_EVENT,
214 cmd_node->cmd_skb, NULL);
215 skb_pull(cmd_node->cmd_skb, MWIFIEX_TYPE_LEN);
216 if (ret == -EBUSY)
217 cmd_node->cmd_skb = NULL;
218 } else {
219 skb_push(cmd_node->cmd_skb, INTF_HEADER_LEN);
220 ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
221 cmd_node->cmd_skb, NULL);
222 skb_pull(cmd_node->cmd_skb, INTF_HEADER_LEN);
223 }
Bing Zhao18bf9652011-04-06 16:46:55 -0700224
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700225 if (ret == -1) {
226 dev_err(adapter->dev, "DNLD_CMD: host to card failed\n");
Amitkumar Karwar4daffe32012-04-18 20:08:28 -0700227 if (adapter->iface_type == MWIFIEX_USB)
228 adapter->cmd_sent = false;
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700229 if (cmd_node->wait_q_enabled)
230 adapter->cmd_wait_q.status = -1;
Bing Zhao9908b072013-04-01 12:44:46 -0700231 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700232
233 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
234 adapter->curr_cmd = NULL;
235 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
236
237 adapter->dbg.num_cmd_host_to_card_failure++;
238 return -1;
239 }
240
241 /* Save the last command id and action to debug log */
242 adapter->dbg.last_cmd_index =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700243 (adapter->dbg.last_cmd_index + 1) % DBG_CMD_NUM;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700244 adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index] = cmd_code;
245 adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index] =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700246 le16_to_cpu(*(__le16 *) ((u8 *) host_cmd + S_DS_GEN));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700247
248 /* Clear BSS_NO_BITS from HostCmd */
249 cmd_code &= HostCmd_CMD_ID_MASK;
250
251 /* Setup the timer after transmit command */
252 mod_timer(&adapter->cmd_timer,
Bing Zhao4587eea2013-04-19 17:44:44 -0700253 jiffies + msecs_to_jiffies(MWIFIEX_TIMER_10S));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700254
255 return 0;
256}
257
258/*
259 * This function downloads a sleep confirm command to the firmware.
260 *
261 * The function performs sanity tests, sets the command sequence
262 * number and size, converts the header fields to CPU format before
263 * sending.
264 *
265 * No responses are needed for sleep confirm command.
266 */
267static int mwifiex_dnld_sleep_confirm_cmd(struct mwifiex_adapter *adapter)
268{
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700269 int ret;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700270 struct mwifiex_private *priv;
Amitkumar Karwar7cc5eb62011-05-09 19:00:18 -0700271 struct mwifiex_opt_sleep_confirm *sleep_cfm_buf =
272 (struct mwifiex_opt_sleep_confirm *)
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700273 adapter->sleep_cfm->data;
Amitkumar Karwar4daffe32012-04-18 20:08:28 -0700274 struct sk_buff *sleep_cfm_tmp;
275 __le32 tmp;
276
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700277 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
278
Amitkumar Karwar7cc5eb62011-05-09 19:00:18 -0700279 sleep_cfm_buf->seq_num =
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700280 cpu_to_le16((HostCmd_SET_SEQ_NO_BSS_INFO
281 (adapter->seq_num, priv->bss_num,
282 priv->bss_type)));
283 adapter->seq_num++;
284
Amitkumar Karwar4daffe32012-04-18 20:08:28 -0700285 if (adapter->iface_type == MWIFIEX_USB) {
286 sleep_cfm_tmp =
287 dev_alloc_skb(sizeof(struct mwifiex_opt_sleep_confirm)
288 + MWIFIEX_TYPE_LEN);
289 skb_put(sleep_cfm_tmp, sizeof(struct mwifiex_opt_sleep_confirm)
290 + MWIFIEX_TYPE_LEN);
291 tmp = cpu_to_le32(MWIFIEX_USB_TYPE_CMD);
292 memcpy(sleep_cfm_tmp->data, &tmp, MWIFIEX_TYPE_LEN);
293 memcpy(sleep_cfm_tmp->data + MWIFIEX_TYPE_LEN,
294 adapter->sleep_cfm->data,
295 sizeof(struct mwifiex_opt_sleep_confirm));
296 ret = adapter->if_ops.host_to_card(adapter,
297 MWIFIEX_USB_EP_CMD_EVENT,
298 sleep_cfm_tmp, NULL);
299 if (ret != -EBUSY)
300 dev_kfree_skb_any(sleep_cfm_tmp);
301 } else {
302 skb_push(adapter->sleep_cfm, INTF_HEADER_LEN);
303 ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_CMD,
304 adapter->sleep_cfm, NULL);
305 skb_pull(adapter->sleep_cfm, INTF_HEADER_LEN);
306 }
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700307
308 if (ret == -1) {
309 dev_err(adapter->dev, "SLEEP_CFM: failed\n");
310 adapter->dbg.num_cmd_sleep_cfm_host_to_card_failure++;
311 return -1;
312 }
313 if (GET_BSS_ROLE(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY))
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700314 == MWIFIEX_BSS_ROLE_STA) {
Amitkumar Karwar7cc5eb62011-05-09 19:00:18 -0700315 if (!sleep_cfm_buf->resp_ctrl)
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700316 /* Response is not needed for sleep
317 confirm command */
318 adapter->ps_state = PS_STATE_SLEEP;
319 else
320 adapter->ps_state = PS_STATE_SLEEP_CFM;
321
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700322 if (!sleep_cfm_buf->resp_ctrl &&
323 (adapter->is_hs_configured &&
324 !adapter->sleep_period.period)) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700325 adapter->pm_wakeup_card_req = true;
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700326 mwifiex_hs_activated_event(mwifiex_get_priv
327 (adapter, MWIFIEX_BSS_ROLE_STA), true);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700328 }
329 }
330
331 return ret;
332}
333
334/*
335 * This function allocates the command buffers and links them to
336 * the command free queue.
337 *
338 * The driver uses a pre allocated number of command buffers, which
339 * are created at driver initializations and freed at driver cleanup.
340 * Every command needs to obtain a command buffer from this pool before
341 * it can be issued. The command free queue lists the command buffers
342 * currently free to use, while the command pending queue lists the
343 * command buffers already in use and awaiting handling. Command buffers
344 * are returned to the free queue after use.
345 */
346int mwifiex_alloc_cmd_buffer(struct mwifiex_adapter *adapter)
347{
348 struct cmd_ctrl_node *cmd_array;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700349 u32 i;
350
351 /* Allocate and initialize struct cmd_ctrl_node */
Joe Perches0d2e7a52013-02-03 17:28:14 +0000352 cmd_array = kcalloc(MWIFIEX_NUM_OF_CMD_BUFFER,
353 sizeof(struct cmd_ctrl_node), GFP_KERNEL);
354 if (!cmd_array)
Christoph Fritzb53575e2011-05-08 22:50:09 +0200355 return -ENOMEM;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700356
357 adapter->cmd_pool = cmd_array;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700358
359 /* Allocate and initialize command buffers */
360 for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++) {
361 cmd_array[i].skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER);
362 if (!cmd_array[i].skb) {
363 dev_err(adapter->dev, "ALLOC_CMD_BUF: out of memory\n");
364 return -1;
365 }
366 }
367
368 for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++)
369 mwifiex_insert_cmd_to_free_q(adapter, &cmd_array[i]);
370
371 return 0;
372}
373
374/*
375 * This function frees the command buffers.
376 *
377 * The function calls the completion callback for all the command
378 * buffers that still have response buffers associated with them.
379 */
380int mwifiex_free_cmd_buffer(struct mwifiex_adapter *adapter)
381{
382 struct cmd_ctrl_node *cmd_array;
383 u32 i;
384
385 /* Need to check if cmd pool is allocated or not */
386 if (!adapter->cmd_pool) {
387 dev_dbg(adapter->dev, "info: FREE_CMD_BUF: cmd_pool is null\n");
388 return 0;
389 }
390
391 cmd_array = adapter->cmd_pool;
392
393 /* Release shared memory buffers */
394 for (i = 0; i < MWIFIEX_NUM_OF_CMD_BUFFER; i++) {
395 if (cmd_array[i].skb) {
396 dev_dbg(adapter->dev, "cmd: free cmd buffer %d\n", i);
397 dev_kfree_skb_any(cmd_array[i].skb);
398 }
399 if (!cmd_array[i].resp_skb)
400 continue;
Amitkumar Karwar4daffe32012-04-18 20:08:28 -0700401
402 if (adapter->iface_type == MWIFIEX_USB)
403 adapter->if_ops.cmdrsp_complete(adapter,
404 cmd_array[i].resp_skb);
405 else
406 dev_kfree_skb_any(cmd_array[i].resp_skb);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700407 }
408 /* Release struct cmd_ctrl_node */
409 if (adapter->cmd_pool) {
410 dev_dbg(adapter->dev, "cmd: free cmd pool\n");
411 kfree(adapter->cmd_pool);
412 adapter->cmd_pool = NULL;
413 }
414
415 return 0;
416}
417
418/*
419 * This function handles events generated by firmware.
420 *
421 * Event body of events received from firmware are not used (though they are
422 * saved), only the event ID is used. Some events are re-invoked by
423 * the driver, with a new event body.
424 *
425 * After processing, the function calls the completion callback
426 * for cleanup.
427 */
428int mwifiex_process_event(struct mwifiex_adapter *adapter)
429{
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700430 int ret;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700431 struct mwifiex_private *priv =
432 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
433 struct sk_buff *skb = adapter->event_skb;
434 u32 eventcause = adapter->event_cause;
435 struct timeval tstamp;
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700436 struct mwifiex_rxinfo *rx_info;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700437
438 /* Save the last event to debug log */
439 adapter->dbg.last_event_index =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700440 (adapter->dbg.last_event_index + 1) % DBG_CMD_NUM;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700441 adapter->dbg.last_event[adapter->dbg.last_event_index] =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700442 (u16) eventcause;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700443
444 /* Get BSS number and corresponding priv */
445 priv = mwifiex_get_priv_by_id(adapter, EVENT_GET_BSS_NUM(eventcause),
446 EVENT_GET_BSS_TYPE(eventcause));
447 if (!priv)
448 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
449 /* Clear BSS_NO_BITS from event */
450 eventcause &= EVENT_ID_MASK;
451 adapter->event_cause = eventcause;
452
453 if (skb) {
454 rx_info = MWIFIEX_SKB_RXCB(skb);
Yogesh Ashok Powar9da9a3b2012-01-11 20:06:11 -0800455 rx_info->bss_num = priv->bss_num;
456 rx_info->bss_type = priv->bss_type;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700457 }
458
459 if (eventcause != EVENT_PS_SLEEP && eventcause != EVENT_PS_AWAKE) {
460 do_gettimeofday(&tstamp);
461 dev_dbg(adapter->dev, "event: %lu.%lu: cause: %#x\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700462 tstamp.tv_sec, tstamp.tv_usec, eventcause);
Avinash Patil03785382012-05-08 18:30:14 -0700463 } else {
464 /* Handle PS_SLEEP/AWAKE events on STA */
465 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
466 if (!priv)
467 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700468 }
469
Avinash Patil3d99d982012-08-03 18:06:06 -0700470 if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP)
471 ret = mwifiex_process_uap_event(priv);
472 else
473 ret = mwifiex_process_sta_event(priv);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700474
475 adapter->event_cause = 0;
476 adapter->event_skb = NULL;
Amitkumar Karward930fae2011-10-11 17:41:21 -0700477 adapter->if_ops.event_complete(adapter, skb);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700478
479 return ret;
480}
481
482/*
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700483 * This function is used to send synchronous command to the firmware.
484 *
485 * it allocates a wait queue for the command and wait for the command
486 * response.
487 */
488int mwifiex_send_cmd_sync(struct mwifiex_private *priv, uint16_t cmd_no,
489 u16 cmd_action, u32 cmd_oid, void *data_buf)
490{
491 int ret = 0;
492 struct mwifiex_adapter *adapter = priv->adapter;
493
494 adapter->cmd_wait_q_required = true;
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700495
496 ret = mwifiex_send_cmd_async(priv, cmd_no, cmd_action, cmd_oid,
497 data_buf);
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700498
499 return ret;
500}
501
502
503/*
504 * This function prepares a command and asynchronously send it to the firmware.
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700505 *
506 * Preparation includes -
507 * - Sanity tests to make sure the card is still present or the FW
508 * is not reset
509 * - Getting a new command node from the command free queue
510 * - Initializing the command node for default parameters
511 * - Fill up the non-default parameters and buffer pointers
512 * - Add the command to pending queue
513 */
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700514int mwifiex_send_cmd_async(struct mwifiex_private *priv, uint16_t cmd_no,
515 u16 cmd_action, u32 cmd_oid, void *data_buf)
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700516{
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700517 int ret;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700518 struct mwifiex_adapter *adapter = priv->adapter;
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700519 struct cmd_ctrl_node *cmd_node;
520 struct host_cmd_ds_command *cmd_ptr;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700521
522 if (!adapter) {
523 pr_err("PREP_CMD: adapter is NULL\n");
524 return -1;
525 }
526
527 if (adapter->is_suspended) {
528 dev_err(adapter->dev, "PREP_CMD: device in suspended state\n");
529 return -1;
530 }
531
532 if (adapter->surprise_removed) {
533 dev_err(adapter->dev, "PREP_CMD: card is removed\n");
534 return -1;
535 }
536
537 if (adapter->hw_status == MWIFIEX_HW_STATUS_RESET) {
538 if (cmd_no != HostCmd_CMD_FUNC_INIT) {
539 dev_err(adapter->dev, "PREP_CMD: FW in reset state\n");
540 return -1;
541 }
542 }
543
544 /* Get a new command node */
545 cmd_node = mwifiex_get_cmd_node(adapter);
546
547 if (!cmd_node) {
548 dev_err(adapter->dev, "PREP_CMD: no free cmd node\n");
549 return -1;
550 }
551
552 /* Initialize the command node */
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700553 mwifiex_init_cmd_node(priv, cmd_node, cmd_oid, data_buf);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700554
555 if (!cmd_node->cmd_skb) {
556 dev_err(adapter->dev, "PREP_CMD: no free cmd buf\n");
557 return -1;
558 }
559
560 memset(skb_put(cmd_node->cmd_skb, sizeof(struct host_cmd_ds_command)),
561 0, sizeof(struct host_cmd_ds_command));
562
563 cmd_ptr = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
564 cmd_ptr->command = cpu_to_le16(cmd_no);
565 cmd_ptr->result = 0;
566
567 /* Prepare command */
568 if (cmd_no) {
Avinash Patil40d07032012-05-08 18:30:19 -0700569 switch (cmd_no) {
570 case HostCmd_CMD_UAP_SYS_CONFIG:
571 case HostCmd_CMD_UAP_BSS_START:
572 case HostCmd_CMD_UAP_BSS_STOP:
Avinash Patil0f9e9b82013-05-17 17:50:23 -0700573 case HostCmd_CMD_UAP_STA_DEAUTH:
Avinash Patil40d07032012-05-08 18:30:19 -0700574 ret = mwifiex_uap_prepare_cmd(priv, cmd_no, cmd_action,
575 cmd_oid, data_buf,
576 cmd_ptr);
577 break;
578 default:
579 ret = mwifiex_sta_prepare_cmd(priv, cmd_no, cmd_action,
580 cmd_oid, data_buf,
581 cmd_ptr);
582 break;
583 }
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700584 } else {
585 ret = mwifiex_cmd_host_cmd(priv, cmd_ptr, data_buf);
586 cmd_node->cmd_flag |= CMD_F_HOSTCMD;
587 }
588
589 /* Return error, since the command preparation failed */
590 if (ret) {
591 dev_err(adapter->dev, "PREP_CMD: cmd %#x preparation failed\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700592 cmd_no);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700593 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
594 return -1;
595 }
596
597 /* Send command */
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -0700598 if (cmd_no == HostCmd_CMD_802_11_SCAN) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700599 mwifiex_queue_scan_cmd(priv, cmd_node);
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -0700600 } else {
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700601 mwifiex_insert_cmd_to_pending_q(adapter, cmd_node, true);
Amitkumar Karwar1a1fb972012-06-27 19:57:56 -0700602 queue_work(adapter->workqueue, &adapter->main_work);
Amitkumar Karwar00d7ea12013-03-15 18:47:05 -0700603 if (cmd_node->wait_q_enabled)
604 ret = mwifiex_wait_queue_complete(adapter, cmd_node);
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -0700605 }
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700606
607 return ret;
608}
609
610/*
611 * This function returns a command to the command free queue.
612 *
613 * The function also calls the completion callback if required, before
614 * cleaning the command node and re-inserting it into the free queue.
615 */
616void
617mwifiex_insert_cmd_to_free_q(struct mwifiex_adapter *adapter,
618 struct cmd_ctrl_node *cmd_node)
619{
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700620 unsigned long flags;
621
Yogesh Ashok Powar19a89862011-04-13 17:27:07 -0700622 if (!cmd_node)
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700623 return;
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700624
625 if (cmd_node->wait_q_enabled)
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -0700626 mwifiex_complete_cmd(adapter, cmd_node);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700627 /* Clean the node */
628 mwifiex_clean_cmd_node(adapter, cmd_node);
629
630 /* Insert node into cmd_free_q */
631 spin_lock_irqsave(&adapter->cmd_free_q_lock, flags);
632 list_add_tail(&cmd_node->list, &adapter->cmd_free_q);
633 spin_unlock_irqrestore(&adapter->cmd_free_q_lock, flags);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700634}
635
Bing Zhao9908b072013-04-01 12:44:46 -0700636/* This function reuses a command node. */
637void mwifiex_recycle_cmd_node(struct mwifiex_adapter *adapter,
638 struct cmd_ctrl_node *cmd_node)
639{
640 struct host_cmd_ds_command *host_cmd = (void *)cmd_node->cmd_skb->data;
641
642 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
643
644 atomic_dec(&adapter->cmd_pending);
645 dev_dbg(adapter->dev, "cmd: FREE_CMD: cmd=%#x, cmd_pending=%d\n",
646 le16_to_cpu(host_cmd->command),
647 atomic_read(&adapter->cmd_pending));
648}
649
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700650/*
651 * This function queues a command to the command pending queue.
652 *
653 * This in effect adds the command to the command list to be executed.
654 * Exit PS command is handled specially, by placing it always to the
655 * front of the command queue.
656 */
657void
658mwifiex_insert_cmd_to_pending_q(struct mwifiex_adapter *adapter,
659 struct cmd_ctrl_node *cmd_node, u32 add_tail)
660{
661 struct host_cmd_ds_command *host_cmd = NULL;
662 u16 command;
663 unsigned long flags;
664
665 host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
666 if (!host_cmd) {
667 dev_err(adapter->dev, "QUEUE_CMD: host_cmd is NULL\n");
668 return;
669 }
670
671 command = le16_to_cpu(host_cmd->command);
672
673 /* Exit_PS command needs to be queued in the header always. */
674 if (command == HostCmd_CMD_802_11_PS_MODE_ENH) {
675 struct host_cmd_ds_802_11_ps_mode_enh *pm =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700676 &host_cmd->params.psmode_enh;
677 if ((le16_to_cpu(pm->action) == DIS_PS) ||
678 (le16_to_cpu(pm->action) == DIS_AUTO_PS)) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700679 if (adapter->ps_state != PS_STATE_AWAKE)
680 add_tail = false;
681 }
682 }
683
684 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
685 if (add_tail)
686 list_add_tail(&cmd_node->list, &adapter->cmd_pending_q);
687 else
688 list_add(&cmd_node->list, &adapter->cmd_pending_q);
689 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
690
Bing Zhao9908b072013-04-01 12:44:46 -0700691 atomic_inc(&adapter->cmd_pending);
692 dev_dbg(adapter->dev, "cmd: QUEUE_CMD: cmd=%#x, cmd_pending=%d\n",
693 command, atomic_read(&adapter->cmd_pending));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700694}
695
696/*
697 * This function executes the next command in command pending queue.
698 *
699 * This function will fail if a command is already in processing stage,
700 * otherwise it will dequeue the first command from the command pending
701 * queue and send to the firmware.
702 *
703 * If the device is currently in host sleep mode, any commands, except the
704 * host sleep configuration command will de-activate the host sleep. For PS
705 * mode, the function will put the firmware back to sleep if applicable.
706 */
707int mwifiex_exec_next_cmd(struct mwifiex_adapter *adapter)
708{
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700709 struct mwifiex_private *priv;
710 struct cmd_ctrl_node *cmd_node;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700711 int ret = 0;
712 struct host_cmd_ds_command *host_cmd;
713 unsigned long cmd_flags;
714 unsigned long cmd_pending_q_flags;
715
716 /* Check if already in processing */
717 if (adapter->curr_cmd) {
718 dev_err(adapter->dev, "EXEC_NEXT_CMD: cmd in processing\n");
719 return -1;
720 }
721
722 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
723 /* Check if any command is pending */
724 spin_lock_irqsave(&adapter->cmd_pending_q_lock, cmd_pending_q_flags);
725 if (list_empty(&adapter->cmd_pending_q)) {
726 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
727 cmd_pending_q_flags);
728 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
729 return 0;
730 }
731 cmd_node = list_first_entry(&adapter->cmd_pending_q,
732 struct cmd_ctrl_node, list);
733 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
734 cmd_pending_q_flags);
735
736 host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);
737 priv = cmd_node->priv;
738
739 if (adapter->ps_state != PS_STATE_AWAKE) {
740 dev_err(adapter->dev, "%s: cannot send cmd in sleep state,"
741 " this should not happen\n", __func__);
742 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
743 return ret;
744 }
745
746 spin_lock_irqsave(&adapter->cmd_pending_q_lock, cmd_pending_q_flags);
747 list_del(&cmd_node->list);
748 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,
749 cmd_pending_q_flags);
750
751 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
752 ret = mwifiex_dnld_cmd_to_fw(priv, cmd_node);
753 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
754 /* Any command sent to the firmware when host is in sleep
755 * mode should de-configure host sleep. We should skip the
756 * host sleep configuration command itself though
757 */
758 if (priv && (host_cmd->command !=
759 cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH))) {
760 if (adapter->hs_activated) {
761 adapter->is_hs_configured = false;
762 mwifiex_hs_activated_event(priv, false);
763 }
764 }
765
766 return ret;
767}
768
769/*
770 * This function handles the command response.
771 *
772 * After processing, the function cleans the command node and puts
773 * it back to the command free queue.
774 */
775int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter)
776{
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700777 struct host_cmd_ds_command *resp;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700778 struct mwifiex_private *priv =
779 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
780 int ret = 0;
781 uint16_t orig_cmdresp_no;
782 uint16_t cmdresp_no;
783 uint16_t cmdresp_result;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700784 struct timeval tstamp;
785 unsigned long flags;
786
787 /* Now we got response from FW, cancel the command timer */
788 del_timer(&adapter->cmd_timer);
789
790 if (!adapter->curr_cmd || !adapter->curr_cmd->resp_skb) {
791 resp = (struct host_cmd_ds_command *) adapter->upld_buf;
792 dev_err(adapter->dev, "CMD_RESP: NULL curr_cmd, %#x\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700793 le16_to_cpu(resp->command));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700794 return -1;
795 }
796
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700797 adapter->num_cmd_timeout = 0;
798
799 resp = (struct host_cmd_ds_command *) adapter->curr_cmd->resp_skb->data;
800 if (adapter->curr_cmd->cmd_flag & CMD_F_CANCELED) {
801 dev_err(adapter->dev, "CMD_RESP: %#x been canceled\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700802 le16_to_cpu(resp->command));
Bing Zhao9908b072013-04-01 12:44:46 -0700803 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700804 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
805 adapter->curr_cmd = NULL;
806 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
807 return -1;
808 }
809
810 if (adapter->curr_cmd->cmd_flag & CMD_F_HOSTCMD) {
811 /* Copy original response back to response buffer */
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -0700812 struct mwifiex_ds_misc_cmd *hostcmd;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700813 uint16_t size = le16_to_cpu(resp->size);
814 dev_dbg(adapter->dev, "info: host cmd resp size = %d\n", size);
815 size = min_t(u16, size, MWIFIEX_SIZE_OF_CMD_BUFFER);
816 if (adapter->curr_cmd->data_buf) {
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -0700817 hostcmd = adapter->curr_cmd->data_buf;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700818 hostcmd->len = size;
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -0700819 memcpy(hostcmd->cmd, resp, size);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700820 }
821 }
822 orig_cmdresp_no = le16_to_cpu(resp->command);
823
824 /* Get BSS number and corresponding priv */
825 priv = mwifiex_get_priv_by_id(adapter,
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700826 HostCmd_GET_BSS_NO(le16_to_cpu(resp->seq_num)),
827 HostCmd_GET_BSS_TYPE(le16_to_cpu(resp->seq_num)));
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700828 if (!priv)
829 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
830 /* Clear RET_BIT from HostCmd */
831 resp->command = cpu_to_le16(orig_cmdresp_no & HostCmd_CMD_ID_MASK);
832
833 cmdresp_no = le16_to_cpu(resp->command);
834 cmdresp_result = le16_to_cpu(resp->result);
835
836 /* Save the last command response to debug log */
837 adapter->dbg.last_cmd_resp_index =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700838 (adapter->dbg.last_cmd_resp_index + 1) % DBG_CMD_NUM;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700839 adapter->dbg.last_cmd_resp_id[adapter->dbg.last_cmd_resp_index] =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700840 orig_cmdresp_no;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700841
842 do_gettimeofday(&tstamp);
843 dev_dbg(adapter->dev, "cmd: CMD_RESP: (%lu.%lu): 0x%x, result %d,"
844 " len %d, seqno 0x%x\n",
845 tstamp.tv_sec, tstamp.tv_usec, orig_cmdresp_no, cmdresp_result,
846 le16_to_cpu(resp->size), le16_to_cpu(resp->seq_num));
847
848 if (!(orig_cmdresp_no & HostCmd_RET_BIT)) {
849 dev_err(adapter->dev, "CMD_RESP: invalid cmd resp\n");
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700850 if (adapter->curr_cmd->wait_q_enabled)
851 adapter->cmd_wait_q.status = -1;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700852
Bing Zhao9908b072013-04-01 12:44:46 -0700853 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700854 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
855 adapter->curr_cmd = NULL;
856 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
857 return -1;
858 }
859
860 if (adapter->curr_cmd->cmd_flag & CMD_F_HOSTCMD) {
861 adapter->curr_cmd->cmd_flag &= ~CMD_F_HOSTCMD;
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700862 if ((cmdresp_result == HostCmd_RESULT_OK) &&
863 (cmdresp_no == HostCmd_CMD_802_11_HS_CFG_ENH))
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700864 ret = mwifiex_ret_802_11_hs_cfg(priv, resp);
865 } else {
866 /* handle response */
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700867 ret = mwifiex_process_sta_cmdresp(priv, cmdresp_no, resp);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700868 }
869
870 /* Check init command response */
871 if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING) {
Amitkumar Karwara0f6d6c2012-02-24 21:36:05 -0800872 if (ret) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700873 dev_err(adapter->dev, "%s: cmd %#x failed during "
874 "initialization\n", __func__, cmdresp_no);
875 mwifiex_init_fw_complete(adapter);
876 return -1;
877 } else if (adapter->last_init_cmd == cmdresp_no)
878 adapter->hw_status = MWIFIEX_HW_STATUS_INIT_DONE;
879 }
880
881 if (adapter->curr_cmd) {
Amitkumar Karwara0f6d6c2012-02-24 21:36:05 -0800882 if (adapter->curr_cmd->wait_q_enabled)
883 adapter->cmd_wait_q.status = ret;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700884
Bing Zhao9908b072013-04-01 12:44:46 -0700885 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700886
887 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
888 adapter->curr_cmd = NULL;
889 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
890 }
891
892 return ret;
893}
894
895/*
896 * This function handles the timeout of command sending.
897 *
898 * It will re-send the same command again.
899 */
900void
901mwifiex_cmd_timeout_func(unsigned long function_context)
902{
903 struct mwifiex_adapter *adapter =
904 (struct mwifiex_adapter *) function_context;
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700905 struct cmd_ctrl_node *cmd_node;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700906 struct timeval tstamp;
907
908 adapter->num_cmd_timeout++;
909 adapter->dbg.num_cmd_timeout++;
910 if (!adapter->curr_cmd) {
911 dev_dbg(adapter->dev, "cmd: empty curr_cmd\n");
912 return;
913 }
914 cmd_node = adapter->curr_cmd;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700915 if (cmd_node) {
916 adapter->dbg.timeout_cmd_id =
917 adapter->dbg.last_cmd_id[adapter->dbg.last_cmd_index];
918 adapter->dbg.timeout_cmd_act =
919 adapter->dbg.last_cmd_act[adapter->dbg.last_cmd_index];
920 do_gettimeofday(&tstamp);
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700921 dev_err(adapter->dev,
922 "%s: Timeout cmd id (%lu.%lu) = %#x, act = %#x\n",
923 __func__, tstamp.tv_sec, tstamp.tv_usec,
924 adapter->dbg.timeout_cmd_id,
925 adapter->dbg.timeout_cmd_act);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700926
927 dev_err(adapter->dev, "num_data_h2c_failure = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700928 adapter->dbg.num_tx_host_to_card_failure);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700929 dev_err(adapter->dev, "num_cmd_h2c_failure = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700930 adapter->dbg.num_cmd_host_to_card_failure);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700931
932 dev_err(adapter->dev, "num_cmd_timeout = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700933 adapter->dbg.num_cmd_timeout);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700934 dev_err(adapter->dev, "num_tx_timeout = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700935 adapter->dbg.num_tx_timeout);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700936
937 dev_err(adapter->dev, "last_cmd_index = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700938 adapter->dbg.last_cmd_index);
Andrei Emeltchenkoafe38402012-10-05 13:57:49 -0700939 dev_err(adapter->dev, "last_cmd_id: %*ph\n",
940 (int)sizeof(adapter->dbg.last_cmd_id),
941 adapter->dbg.last_cmd_id);
942 dev_err(adapter->dev, "last_cmd_act: %*ph\n",
943 (int)sizeof(adapter->dbg.last_cmd_act),
944 adapter->dbg.last_cmd_act);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700945
946 dev_err(adapter->dev, "last_cmd_resp_index = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700947 adapter->dbg.last_cmd_resp_index);
Andrei Emeltchenkoafe38402012-10-05 13:57:49 -0700948 dev_err(adapter->dev, "last_cmd_resp_id: %*ph\n",
949 (int)sizeof(adapter->dbg.last_cmd_resp_id),
950 adapter->dbg.last_cmd_resp_id);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700951
952 dev_err(adapter->dev, "last_event_index = %d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700953 adapter->dbg.last_event_index);
Andrei Emeltchenkoafe38402012-10-05 13:57:49 -0700954 dev_err(adapter->dev, "last_event: %*ph\n",
955 (int)sizeof(adapter->dbg.last_event),
956 adapter->dbg.last_event);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700957
958 dev_err(adapter->dev, "data_sent=%d cmd_sent=%d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700959 adapter->data_sent, adapter->cmd_sent);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700960
961 dev_err(adapter->dev, "ps_mode=%d ps_state=%d\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -0700962 adapter->ps_mode, adapter->ps_state);
Bing Zhaob1a47aa2012-11-15 15:58:47 -0800963
964 if (cmd_node->wait_q_enabled) {
965 adapter->cmd_wait_q.status = -ETIMEDOUT;
966 wake_up_interruptible(&adapter->cmd_wait_q.wait);
967 mwifiex_cancel_pending_ioctl(adapter);
968 /* reset cmd_sent flag to unblock new commands */
969 adapter->cmd_sent = false;
970 }
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700971 }
972 if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING)
973 mwifiex_init_fw_complete(adapter);
Amitkumar Karward31ab352012-11-01 18:44:14 -0700974
975 if (adapter->if_ops.card_reset)
976 adapter->if_ops.card_reset(adapter);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700977}
978
979/*
980 * This function cancels all the pending commands.
981 *
982 * The current command, all commands in command pending queue and all scan
983 * commands in scan pending queue are cancelled. All the completion callbacks
984 * are called with failure status to ensure cleanup.
985 */
986void
987mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter)
988{
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -0700989 struct cmd_ctrl_node *cmd_node = NULL, *tmp_node;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700990 unsigned long flags;
991
992 /* Cancel current cmd */
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700993 if ((adapter->curr_cmd) && (adapter->curr_cmd->wait_q_enabled)) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700994 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700995 adapter->curr_cmd->wait_q_enabled = false;
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700996 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
Amitkumar Karwar600f5d92011-04-13 17:27:06 -0700997 adapter->cmd_wait_q.status = -1;
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -0700998 mwifiex_complete_cmd(adapter, adapter->curr_cmd);
Bing Zhao5e6e3a92011-03-21 18:00:50 -0700999 }
1000 /* Cancel all pending command */
1001 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
1002 list_for_each_entry_safe(cmd_node, tmp_node,
1003 &adapter->cmd_pending_q, list) {
1004 list_del(&cmd_node->list);
1005 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
1006
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001007 if (cmd_node->wait_q_enabled) {
1008 adapter->cmd_wait_q.status = -1;
Amitkumar Karwarefaaa8b2011-10-12 20:28:06 -07001009 mwifiex_complete_cmd(adapter, cmd_node);
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001010 cmd_node->wait_q_enabled = false;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001011 }
Bing Zhao9908b072013-04-01 12:44:46 -07001012 mwifiex_recycle_cmd_node(adapter, cmd_node);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001013 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
1014 }
1015 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
1016
1017 /* Cancel all pending scan command */
1018 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
1019 list_for_each_entry_safe(cmd_node, tmp_node,
1020 &adapter->scan_pending_q, list) {
1021 list_del(&cmd_node->list);
1022 spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
1023
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001024 cmd_node->wait_q_enabled = false;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001025 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
1026 spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
1027 }
1028 spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
1029
1030 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
1031 adapter->scan_processing = false;
1032 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
1033}
1034
1035/*
1036 * This function cancels all pending commands that matches with
1037 * the given IOCTL request.
1038 *
1039 * Both the current command buffer and the pending command queue are
1040 * searched for matching IOCTL request. The completion callback of
1041 * the matched command is called with failure status to ensure cleanup.
1042 * In case of scan commands, all pending commands in scan pending queue
1043 * are cancelled.
1044 */
1045void
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001046mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter)
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001047{
1048 struct cmd_ctrl_node *cmd_node = NULL, *tmp_node = NULL;
1049 unsigned long cmd_flags;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001050 unsigned long scan_pending_q_flags;
1051 uint16_t cancel_scan_cmd = false;
1052
1053 if ((adapter->curr_cmd) &&
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001054 (adapter->curr_cmd->wait_q_enabled)) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001055 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
1056 cmd_node = adapter->curr_cmd;
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001057 cmd_node->wait_q_enabled = false;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001058 cmd_node->cmd_flag |= CMD_F_CANCELED;
Bing Zhao9908b072013-04-01 12:44:46 -07001059 mwifiex_recycle_cmd_node(adapter, cmd_node);
Yogesh Ashok Powar51e708c2011-12-13 20:43:16 -08001060 mwifiex_complete_cmd(adapter, adapter->curr_cmd);
1061 adapter->curr_cmd = NULL;
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001062 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001063 }
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001064
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001065 /* Cancel all pending scan command */
1066 spin_lock_irqsave(&adapter->scan_pending_q_lock,
1067 scan_pending_q_flags);
1068 list_for_each_entry_safe(cmd_node, tmp_node,
1069 &adapter->scan_pending_q, list) {
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001070 list_del(&cmd_node->list);
1071 spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
1072 scan_pending_q_flags);
1073 cmd_node->wait_q_enabled = false;
1074 mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
1075 spin_lock_irqsave(&adapter->scan_pending_q_lock,
1076 scan_pending_q_flags);
1077 cancel_scan_cmd = true;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001078 }
1079 spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
1080 scan_pending_q_flags);
1081
1082 if (cancel_scan_cmd) {
1083 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);
1084 adapter->scan_processing = false;
1085 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);
1086 }
Amitkumar Karwar600f5d92011-04-13 17:27:06 -07001087 adapter->cmd_wait_q.status = -1;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001088}
1089
1090/*
1091 * This function sends the sleep confirm command to firmware, if
1092 * possible.
1093 *
1094 * The sleep confirm command cannot be issued if command response,
1095 * data response or event response is awaiting handling, or if we
1096 * are in the middle of sending a command, or expecting a command
1097 * response.
1098 */
1099void
1100mwifiex_check_ps_cond(struct mwifiex_adapter *adapter)
1101{
1102 if (!adapter->cmd_sent &&
1103 !adapter->curr_cmd && !IS_CARD_RX_RCVD(adapter))
1104 mwifiex_dnld_sleep_confirm_cmd(adapter);
1105 else
1106 dev_dbg(adapter->dev,
1107 "cmd: Delay Sleep Confirm (%s%s%s)\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001108 (adapter->cmd_sent) ? "D" : "",
1109 (adapter->curr_cmd) ? "C" : "",
1110 (IS_CARD_RX_RCVD(adapter)) ? "R" : "");
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001111}
1112
1113/*
1114 * This function sends a Host Sleep activated event to applications.
1115 *
1116 * This event is generated by the driver, with a blank event body.
1117 */
1118void
1119mwifiex_hs_activated_event(struct mwifiex_private *priv, u8 activated)
1120{
1121 if (activated) {
1122 if (priv->adapter->is_hs_configured) {
1123 priv->adapter->hs_activated = true;
Avinash Patil2db96c32012-09-27 19:00:10 -07001124 mwifiex_update_rxreor_flags(priv->adapter,
1125 RXREOR_FORCE_NO_DROP);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001126 dev_dbg(priv->adapter->dev, "event: hs_activated\n");
1127 priv->adapter->hs_activate_wait_q_woken = true;
1128 wake_up_interruptible(
1129 &priv->adapter->hs_activate_wait_q);
1130 } else {
1131 dev_dbg(priv->adapter->dev, "event: HS not configured\n");
1132 }
1133 } else {
1134 dev_dbg(priv->adapter->dev, "event: hs_deactivated\n");
1135 priv->adapter->hs_activated = false;
1136 }
1137}
1138
1139/*
1140 * This function handles the command response of a Host Sleep configuration
1141 * command.
1142 *
1143 * Handling includes changing the header fields into CPU format
1144 * and setting the current host sleep activation status in driver.
1145 *
1146 * In case host sleep status change, the function generates an event to
1147 * notify the applications.
1148 */
1149int mwifiex_ret_802_11_hs_cfg(struct mwifiex_private *priv,
1150 struct host_cmd_ds_command *resp)
1151{
1152 struct mwifiex_adapter *adapter = priv->adapter;
1153 struct host_cmd_ds_802_11_hs_cfg_enh *phs_cfg =
1154 &resp->params.opt_hs_cfg;
1155 uint32_t conditions = le32_to_cpu(phs_cfg->params.hs_config.conditions);
1156
Amitkumar Karwara4186ea2012-06-20 19:58:37 -07001157 if (phs_cfg->action == cpu_to_le16(HS_ACTIVATE) &&
1158 adapter->iface_type == MWIFIEX_SDIO) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001159 mwifiex_hs_activated_event(priv, true);
1160 return 0;
1161 } else {
1162 dev_dbg(adapter->dev, "cmd: CMD_RESP: HS_CFG cmd reply"
1163 " result=%#x, conditions=0x%x gpio=0x%x gap=0x%x\n",
1164 resp->result, conditions,
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001165 phs_cfg->params.hs_config.gpio,
1166 phs_cfg->params.hs_config.gap);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001167 }
Amitkumar Karwarcc0b5a62013-03-04 16:27:57 -08001168 if (conditions != HS_CFG_CANCEL) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001169 adapter->is_hs_configured = true;
Amitkumar Karwara4186ea2012-06-20 19:58:37 -07001170 if (adapter->iface_type == MWIFIEX_USB ||
1171 adapter->iface_type == MWIFIEX_PCIE)
1172 mwifiex_hs_activated_event(priv, true);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001173 } else {
1174 adapter->is_hs_configured = false;
1175 if (adapter->hs_activated)
1176 mwifiex_hs_activated_event(priv, false);
1177 }
1178
1179 return 0;
1180}
1181
1182/*
1183 * This function wakes up the adapter and generates a Host Sleep
1184 * cancel event on receiving the power up interrupt.
1185 */
1186void
1187mwifiex_process_hs_config(struct mwifiex_adapter *adapter)
1188{
1189 dev_dbg(adapter->dev, "info: %s: auto cancelling host sleep"
1190 " since there is interrupt from the firmware\n", __func__);
1191
1192 adapter->if_ops.wakeup(adapter);
1193 adapter->hs_activated = false;
1194 adapter->is_hs_configured = false;
Bing Zhao48795422013-05-06 19:46:53 -07001195 adapter->is_suspended = false;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001196 mwifiex_hs_activated_event(mwifiex_get_priv(adapter,
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001197 MWIFIEX_BSS_ROLE_ANY),
1198 false);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001199}
Amitkumar Karwar4daffe32012-04-18 20:08:28 -07001200EXPORT_SYMBOL_GPL(mwifiex_process_hs_config);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001201
1202/*
1203 * This function handles the command response of a sleep confirm command.
1204 *
1205 * The function sets the card state to SLEEP if the response indicates success.
1206 */
1207void
1208mwifiex_process_sleep_confirm_resp(struct mwifiex_adapter *adapter,
1209 u8 *pbuf, u32 upld_len)
1210{
1211 struct host_cmd_ds_command *cmd = (struct host_cmd_ds_command *) pbuf;
1212 struct mwifiex_private *priv =
1213 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1214 uint16_t result = le16_to_cpu(cmd->result);
1215 uint16_t command = le16_to_cpu(cmd->command);
1216 uint16_t seq_num = le16_to_cpu(cmd->seq_num);
1217
1218 if (!upld_len) {
1219 dev_err(adapter->dev, "%s: cmd size is 0\n", __func__);
1220 return;
1221 }
1222
1223 /* Get BSS number and corresponding priv */
1224 priv = mwifiex_get_priv_by_id(adapter, HostCmd_GET_BSS_NO(seq_num),
1225 HostCmd_GET_BSS_TYPE(seq_num));
1226 if (!priv)
1227 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1228
1229 /* Update sequence number */
1230 seq_num = HostCmd_GET_SEQ_NO(seq_num);
1231 /* Clear RET_BIT from HostCmd */
1232 command &= HostCmd_CMD_ID_MASK;
1233
1234 if (command != HostCmd_CMD_802_11_PS_MODE_ENH) {
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001235 dev_err(adapter->dev,
1236 "%s: rcvd unexpected resp for cmd %#x, result = %x\n",
1237 __func__, command, result);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001238 return;
1239 }
1240
1241 if (result) {
1242 dev_err(adapter->dev, "%s: sleep confirm cmd failed\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001243 __func__);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001244 adapter->pm_wakeup_card_req = false;
1245 adapter->ps_state = PS_STATE_AWAKE;
1246 return;
1247 }
1248 adapter->pm_wakeup_card_req = true;
1249 if (adapter->is_hs_configured)
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001250 mwifiex_hs_activated_event(mwifiex_get_priv
1251 (adapter, MWIFIEX_BSS_ROLE_ANY),
1252 true);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001253 adapter->ps_state = PS_STATE_SLEEP;
1254 cmd->command = cpu_to_le16(command);
1255 cmd->seq_num = cpu_to_le16(seq_num);
1256}
1257EXPORT_SYMBOL_GPL(mwifiex_process_sleep_confirm_resp);
1258
1259/*
1260 * This function prepares an enhanced power mode command.
1261 *
1262 * This function can be used to disable power save or to configure
1263 * power save with auto PS or STA PS or auto deep sleep.
1264 *
1265 * Preparation includes -
1266 * - Setting command ID, action and proper size
1267 * - Setting Power Save bitmap, PS parameters TLV, PS mode TLV,
1268 * auto deep sleep TLV (as required)
1269 * - Ensuring correct endian-ness
1270 */
1271int mwifiex_cmd_enh_power_mode(struct mwifiex_private *priv,
1272 struct host_cmd_ds_command *cmd,
1273 u16 cmd_action, uint16_t ps_bitmap,
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -07001274 struct mwifiex_ds_auto_ds *auto_ds)
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001275{
1276 struct host_cmd_ds_802_11_ps_mode_enh *psmode_enh =
1277 &cmd->params.psmode_enh;
Yogesh Ashok Powar270e58e2011-05-03 20:11:46 -07001278 u8 *tlv;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001279 u16 cmd_size = 0;
1280
1281 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_PS_MODE_ENH);
1282 if (cmd_action == DIS_AUTO_PS) {
1283 psmode_enh->action = cpu_to_le16(DIS_AUTO_PS);
1284 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
Marc Yang2b06bdb2011-03-30 18:12:44 -07001285 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(psmode_enh->action) +
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001286 sizeof(psmode_enh->params.ps_bitmap));
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001287 } else if (cmd_action == GET_PS) {
1288 psmode_enh->action = cpu_to_le16(GET_PS);
1289 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
Marc Yang2b06bdb2011-03-30 18:12:44 -07001290 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(psmode_enh->action) +
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001291 sizeof(psmode_enh->params.ps_bitmap));
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001292 } else if (cmd_action == EN_AUTO_PS) {
1293 psmode_enh->action = cpu_to_le16(EN_AUTO_PS);
Marc Yang2b06bdb2011-03-30 18:12:44 -07001294 psmode_enh->params.ps_bitmap = cpu_to_le16(ps_bitmap);
1295 cmd_size = S_DS_GEN + sizeof(psmode_enh->action) +
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001296 sizeof(psmode_enh->params.ps_bitmap);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001297 tlv = (u8 *) cmd + cmd_size;
1298 if (ps_bitmap & BITMAP_STA_PS) {
1299 struct mwifiex_adapter *adapter = priv->adapter;
1300 struct mwifiex_ie_types_ps_param *ps_tlv =
1301 (struct mwifiex_ie_types_ps_param *) tlv;
1302 struct mwifiex_ps_param *ps_mode = &ps_tlv->param;
1303 ps_tlv->header.type = cpu_to_le16(TLV_TYPE_PS_PARAM);
1304 ps_tlv->header.len = cpu_to_le16(sizeof(*ps_tlv) -
1305 sizeof(struct mwifiex_ie_types_header));
1306 cmd_size += sizeof(*ps_tlv);
1307 tlv += sizeof(*ps_tlv);
1308 dev_dbg(adapter->dev, "cmd: PS Command: Enter PS\n");
1309 ps_mode->null_pkt_interval =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001310 cpu_to_le16(adapter->null_pkt_interval);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001311 ps_mode->multiple_dtims =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001312 cpu_to_le16(adapter->multiple_dtim);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001313 ps_mode->bcn_miss_timeout =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001314 cpu_to_le16(adapter->bcn_miss_time_out);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001315 ps_mode->local_listen_interval =
1316 cpu_to_le16(adapter->local_listen_interval);
1317 ps_mode->adhoc_wake_period =
1318 cpu_to_le16(adapter->adhoc_awake_period);
1319 ps_mode->delay_to_ps =
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001320 cpu_to_le16(adapter->delay_to_ps);
1321 ps_mode->mode = cpu_to_le16(adapter->enhanced_ps_mode);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001322
1323 }
1324 if (ps_bitmap & BITMAP_AUTO_DS) {
Marc Yang2b06bdb2011-03-30 18:12:44 -07001325 struct mwifiex_ie_types_auto_ds_param *auto_ds_tlv =
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001326 (struct mwifiex_ie_types_auto_ds_param *) tlv;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001327 u16 idletime = 0;
Marc Yang2b06bdb2011-03-30 18:12:44 -07001328
1329 auto_ds_tlv->header.type =
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001330 cpu_to_le16(TLV_TYPE_AUTO_DS_PARAM);
Marc Yang2b06bdb2011-03-30 18:12:44 -07001331 auto_ds_tlv->header.len =
1332 cpu_to_le16(sizeof(*auto_ds_tlv) -
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001333 sizeof(struct mwifiex_ie_types_header));
Marc Yang2b06bdb2011-03-30 18:12:44 -07001334 cmd_size += sizeof(*auto_ds_tlv);
1335 tlv += sizeof(*auto_ds_tlv);
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -07001336 if (auto_ds)
1337 idletime = auto_ds->idle_time;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001338 dev_dbg(priv->adapter->dev,
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001339 "cmd: PS Command: Enter Auto Deep Sleep\n");
Marc Yang2b06bdb2011-03-30 18:12:44 -07001340 auto_ds_tlv->deep_sleep_timeout = cpu_to_le16(idletime);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001341 }
1342 cmd->size = cpu_to_le16(cmd_size);
1343 }
1344 return 0;
1345}
1346
1347/*
1348 * This function handles the command response of an enhanced power mode
1349 * command.
1350 *
1351 * Handling includes changing the header fields into CPU format
1352 * and setting the current enhanced power mode in driver.
1353 */
1354int mwifiex_ret_enh_power_mode(struct mwifiex_private *priv,
1355 struct host_cmd_ds_command *resp,
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -07001356 struct mwifiex_ds_pm_cfg *pm_cfg)
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001357{
1358 struct mwifiex_adapter *adapter = priv->adapter;
1359 struct host_cmd_ds_802_11_ps_mode_enh *ps_mode =
1360 &resp->params.psmode_enh;
1361 uint16_t action = le16_to_cpu(ps_mode->action);
1362 uint16_t ps_bitmap = le16_to_cpu(ps_mode->params.ps_bitmap);
1363 uint16_t auto_ps_bitmap =
Marc Yang2b06bdb2011-03-30 18:12:44 -07001364 le16_to_cpu(ps_mode->params.ps_bitmap);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001365
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001366 dev_dbg(adapter->dev,
1367 "info: %s: PS_MODE cmd reply result=%#x action=%#X\n",
1368 __func__, resp->result, action);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001369 if (action == EN_AUTO_PS) {
1370 if (auto_ps_bitmap & BITMAP_AUTO_DS) {
1371 dev_dbg(adapter->dev, "cmd: Enabled auto deep sleep\n");
1372 priv->adapter->is_deep_sleep = true;
1373 }
1374 if (auto_ps_bitmap & BITMAP_STA_PS) {
1375 dev_dbg(adapter->dev, "cmd: Enabled STA power save\n");
1376 if (adapter->sleep_period.period)
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001377 dev_dbg(adapter->dev,
1378 "cmd: set to uapsd/pps mode\n");
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001379 }
1380 } else if (action == DIS_AUTO_PS) {
1381 if (ps_bitmap & BITMAP_AUTO_DS) {
1382 priv->adapter->is_deep_sleep = false;
1383 dev_dbg(adapter->dev, "cmd: Disabled auto deep sleep\n");
1384 }
1385 if (ps_bitmap & BITMAP_STA_PS) {
1386 dev_dbg(adapter->dev, "cmd: Disabled STA power save\n");
1387 if (adapter->sleep_period.period) {
1388 adapter->delay_null_pkt = false;
1389 adapter->tx_lock_flag = false;
1390 adapter->pps_uapsd_mode = false;
1391 }
1392 }
1393 } else if (action == GET_PS) {
Marc Yang2b06bdb2011-03-30 18:12:44 -07001394 if (ps_bitmap & BITMAP_STA_PS)
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001395 adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_PSP;
1396 else
1397 adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM;
1398
1399 dev_dbg(adapter->dev, "cmd: ps_bitmap=%#x\n", ps_bitmap);
1400
Amitkumar Karwara5ffddb2011-06-20 15:21:48 -07001401 if (pm_cfg) {
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001402 /* This section is for get power save mode */
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001403 if (ps_bitmap & BITMAP_STA_PS)
1404 pm_cfg->param.ps_mode = 1;
1405 else
1406 pm_cfg->param.ps_mode = 0;
1407 }
1408 }
1409 return 0;
1410}
1411
1412/*
1413 * This function prepares command to get hardware specifications.
1414 *
1415 * Preparation includes -
1416 * - Setting command ID, action and proper size
1417 * - Setting permanent address parameter
1418 * - Ensuring correct endian-ness
1419 */
1420int mwifiex_cmd_get_hw_spec(struct mwifiex_private *priv,
1421 struct host_cmd_ds_command *cmd)
1422{
1423 struct host_cmd_ds_get_hw_spec *hw_spec = &cmd->params.hw_spec;
1424
1425 cmd->command = cpu_to_le16(HostCmd_CMD_GET_HW_SPEC);
1426 cmd->size =
1427 cpu_to_le16(sizeof(struct host_cmd_ds_get_hw_spec) + S_DS_GEN);
1428 memcpy(hw_spec->permanent_addr, priv->curr_addr, ETH_ALEN);
1429
1430 return 0;
1431}
1432
1433/*
1434 * This function handles the command response of get hardware
1435 * specifications.
1436 *
1437 * Handling includes changing the header fields into CPU format
1438 * and saving/updating the following parameters in driver -
1439 * - Firmware capability information
1440 * - Firmware band settings
1441 * - Ad-hoc start band and channel
1442 * - Ad-hoc 11n activation status
1443 * - Firmware release number
1444 * - Number of antennas
1445 * - Hardware address
1446 * - Hardware interface version
1447 * - Firmware version
1448 * - Region code
1449 * - 11n capabilities
1450 * - MCS support fields
1451 * - MP end port
1452 */
1453int mwifiex_ret_get_hw_spec(struct mwifiex_private *priv,
1454 struct host_cmd_ds_command *resp)
1455{
1456 struct host_cmd_ds_get_hw_spec *hw_spec = &resp->params.hw_spec;
1457 struct mwifiex_adapter *adapter = priv->adapter;
1458 int i;
1459
1460 adapter->fw_cap_info = le32_to_cpu(hw_spec->fw_cap_info);
1461
1462 if (IS_SUPPORT_MULTI_BANDS(adapter))
1463 adapter->fw_bands = (u8) GET_FW_DEFAULT_BANDS(adapter);
1464 else
1465 adapter->fw_bands = BAND_B;
1466
1467 adapter->config_bands = adapter->fw_bands;
1468
1469 if (adapter->fw_bands & BAND_A) {
1470 if (adapter->fw_bands & BAND_GN) {
1471 adapter->config_bands |= BAND_AN;
1472 adapter->fw_bands |= BAND_AN;
1473 }
1474 if (adapter->fw_bands & BAND_AN) {
1475 adapter->adhoc_start_band = BAND_A | BAND_AN;
1476 adapter->adhoc_11n_enabled = true;
1477 } else {
1478 adapter->adhoc_start_band = BAND_A;
1479 }
1480 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL_A;
1481 } else if (adapter->fw_bands & BAND_GN) {
1482 adapter->adhoc_start_band = BAND_G | BAND_B | BAND_GN;
1483 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1484 adapter->adhoc_11n_enabled = true;
1485 } else if (adapter->fw_bands & BAND_G) {
1486 adapter->adhoc_start_band = BAND_G | BAND_B;
1487 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1488 } else if (adapter->fw_bands & BAND_B) {
1489 adapter->adhoc_start_band = BAND_B;
1490 priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL;
1491 }
1492
1493 adapter->fw_release_number = le32_to_cpu(hw_spec->fw_release_number);
1494 adapter->number_of_antenna = le16_to_cpu(hw_spec->number_of_antenna);
1495
Yogesh Ashok Powara5f39052013-02-15 21:44:30 -08001496 if (le32_to_cpu(hw_spec->dot_11ac_dev_cap)) {
1497 adapter->is_hw_11ac_capable = true;
1498
1499 /* Copy 11AC cap */
1500 adapter->hw_dot_11ac_dev_cap =
1501 le32_to_cpu(hw_spec->dot_11ac_dev_cap);
1502 adapter->usr_dot_11ac_dev_cap_bg = adapter->hw_dot_11ac_dev_cap;
1503 adapter->usr_dot_11ac_dev_cap_a = adapter->hw_dot_11ac_dev_cap;
1504
1505 /* Copy 11AC mcs */
1506 adapter->hw_dot_11ac_mcs_support =
1507 le32_to_cpu(hw_spec->dot_11ac_mcs_support);
1508 adapter->usr_dot_11ac_mcs_support =
1509 adapter->hw_dot_11ac_mcs_support;
1510 } else {
1511 adapter->is_hw_11ac_capable = false;
1512 }
1513
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001514 dev_dbg(adapter->dev, "info: GET_HW_SPEC: fw_release_number- %#x\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001515 adapter->fw_release_number);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001516 dev_dbg(adapter->dev, "info: GET_HW_SPEC: permanent addr: %pM\n",
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001517 hw_spec->permanent_addr);
1518 dev_dbg(adapter->dev,
1519 "info: GET_HW_SPEC: hw_if_version=%#x version=%#x\n",
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001520 le16_to_cpu(hw_spec->hw_if_version),
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001521 le16_to_cpu(hw_spec->version));
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001522
1523 if (priv->curr_addr[0] == 0xff)
1524 memmove(priv->curr_addr, hw_spec->permanent_addr, ETH_ALEN);
1525
1526 adapter->region_code = le16_to_cpu(hw_spec->region_code);
1527
1528 for (i = 0; i < MWIFIEX_MAX_REGION_CODE; i++)
1529 /* Use the region code to search for the index */
1530 if (adapter->region_code == region_code_index[i])
1531 break;
1532
1533 /* If it's unidentified region code, use the default (USA) */
1534 if (i >= MWIFIEX_MAX_REGION_CODE) {
1535 adapter->region_code = 0x10;
Yogesh Ashok Powaraea07012012-03-13 19:22:35 -07001536 dev_dbg(adapter->dev,
1537 "cmd: unknown region code, use default (USA)\n");
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001538 }
1539
1540 adapter->hw_dot_11n_dev_cap = le32_to_cpu(hw_spec->dot_11n_dev_cap);
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001541 adapter->hw_dev_mcs_support = hw_spec->dev_mcs_support;
Bing Zhao5e6e3a92011-03-21 18:00:50 -07001542
1543 if (adapter->if_ops.update_mp_end_port)
1544 adapter->if_ops.update_mp_end_port(adapter,
1545 le16_to_cpu(hw_spec->mp_end_port));
1546
1547 return 0;
1548}