Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sta_cmdresp.c
Go to the documentation of this file.
1 /*
2  * Marvell Wireless LAN device driver: station command response handling
3  *
4  * Copyright (C) 2011, Marvell International Ltd.
5  *
6  * This software file (the "File") is distributed by Marvell International
7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8  * (the "License"). You may use, redistribute and/or modify this File in
9  * accordance with the terms and conditions of the License, a copy of which
10  * is available by writing to the Free Software Foundation, Inc.,
11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13  *
14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16  * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17  * this warranty disclaimer.
18  */
19 
20 #include "decl.h"
21 #include "ioctl.h"
22 #include "util.h"
23 #include "fw.h"
24 #include "main.h"
25 #include "wmm.h"
26 #include "11n.h"
27 
28 
29 /*
30  * This function handles the command response error case.
31  *
32  * For scan response error, the function cancels all the pending
33  * scan commands and generates an event to inform the applications
34  * of the scan completion.
35  *
36  * For Power Save command failure, we do not retry enter PS
37  * command in case of Ad-hoc mode.
38  *
39  * For all other response errors, the current command buffer is freed
40  * and returned to the free command queue.
41  */
42 static void
43 mwifiex_process_cmdresp_error(struct mwifiex_private *priv,
44  struct host_cmd_ds_command *resp)
45 {
46  struct cmd_ctrl_node *cmd_node = NULL, *tmp_node;
47  struct mwifiex_adapter *adapter = priv->adapter;
49  unsigned long flags;
50 
51  dev_err(adapter->dev, "CMD_RESP: cmd %#x error, result=%#x\n",
52  resp->command, resp->result);
53 
54  if (adapter->curr_cmd->wait_q_enabled)
55  adapter->cmd_wait_q.status = -1;
56 
57  switch (le16_to_cpu(resp->command)) {
59  pm = &resp->params.psmode_enh;
60  dev_err(adapter->dev,
61  "PS_MODE_ENH cmd failed: result=0x%x action=0x%X\n",
62  resp->result, le16_to_cpu(pm->action));
63  /* We do not re-try enter-ps command in ad-hoc mode. */
64  if (le16_to_cpu(pm->action) == EN_AUTO_PS &&
68 
69  break;
71  /* Cancel all pending scan command */
72  spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
73  list_for_each_entry_safe(cmd_node, tmp_node,
74  &adapter->scan_pending_q, list) {
75  list_del(&cmd_node->list);
76  spin_unlock_irqrestore(&adapter->scan_pending_q_lock,
77  flags);
78  mwifiex_insert_cmd_to_free_q(adapter, cmd_node);
79  spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);
80  }
81  spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);
82 
83  spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
84  adapter->scan_processing = false;
85  spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
86  if (priv->report_scan_result)
87  priv->report_scan_result = false;
88  if (priv->scan_pending_on_block) {
89  priv->scan_pending_on_block = false;
90  up(&priv->async_sem);
91  }
92  break;
93 
95  break;
96 
97  default:
98  break;
99  }
100  /* Handling errors here */
101  mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);
102 
103  spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
104  adapter->curr_cmd = NULL;
105  spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);
106 }
107 
108 /*
109  * This function handles the command response of get RSSI info.
110  *
111  * Handling includes changing the header fields into CPU format
112  * and saving the following parameters in driver -
113  * - Last data and beacon RSSI value
114  * - Average data and beacon RSSI value
115  * - Last data and beacon NF value
116  * - Average data and beacon NF value
117  *
118  * The parameters are send to the application as well, along with
119  * calculated SNR values.
120  */
121 static int mwifiex_ret_802_11_rssi_info(struct mwifiex_private *priv,
122  struct host_cmd_ds_command *resp)
123 {
124  struct host_cmd_ds_802_11_rssi_info_rsp *rssi_info_rsp =
125  &resp->params.rssi_info_rsp;
126  struct mwifiex_ds_misc_subsc_evt *subsc_evt =
128 
129  priv->data_rssi_last = le16_to_cpu(rssi_info_rsp->data_rssi_last);
130  priv->data_nf_last = le16_to_cpu(rssi_info_rsp->data_nf_last);
131 
132  priv->data_rssi_avg = le16_to_cpu(rssi_info_rsp->data_rssi_avg);
133  priv->data_nf_avg = le16_to_cpu(rssi_info_rsp->data_nf_avg);
134 
135  priv->bcn_rssi_last = le16_to_cpu(rssi_info_rsp->bcn_rssi_last);
136  priv->bcn_nf_last = le16_to_cpu(rssi_info_rsp->bcn_nf_last);
137 
138  priv->bcn_rssi_avg = le16_to_cpu(rssi_info_rsp->bcn_rssi_avg);
139  priv->bcn_nf_avg = le16_to_cpu(rssi_info_rsp->bcn_nf_avg);
140 
141  if (priv->subsc_evt_rssi_state == EVENT_HANDLED)
142  return 0;
143 
144  memset(subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
145 
146  /* Resubscribe low and high rssi events with new thresholds */
148  subsc_evt->action = HostCmd_ACT_BITWISE_SET;
149  if (priv->subsc_evt_rssi_state == RSSI_LOW_RECVD) {
150  subsc_evt->bcn_l_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg -
151  priv->cqm_rssi_hyst);
152  subsc_evt->bcn_h_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold);
153  } else if (priv->subsc_evt_rssi_state == RSSI_HIGH_RECVD) {
154  subsc_evt->bcn_l_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold);
155  subsc_evt->bcn_h_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg +
156  priv->cqm_rssi_hyst);
157  }
158  subsc_evt->bcn_l_rssi_cfg.evt_freq = 1;
159  subsc_evt->bcn_h_rssi_cfg.evt_freq = 1;
160 
162 
164  0, 0, subsc_evt);
165 
166  return 0;
167 }
168 
169 /*
170  * This function handles the command response of set/get SNMP
171  * MIB parameters.
172  *
173  * Handling includes changing the header fields into CPU format
174  * and saving the parameter in driver.
175  *
176  * The following parameters are supported -
177  * - Fragmentation threshold
178  * - RTS threshold
179  * - Short retry limit
180  */
181 static int mwifiex_ret_802_11_snmp_mib(struct mwifiex_private *priv,
182  struct host_cmd_ds_command *resp,
183  u32 *data_buf)
184 {
185  struct host_cmd_ds_802_11_snmp_mib *smib = &resp->params.smib;
186  u16 oid = le16_to_cpu(smib->oid);
188  u32 ul_temp;
189 
190  dev_dbg(priv->adapter->dev, "info: SNMP_RESP: oid value = %#x,"
191  " query_type = %#x, buf size = %#x\n",
192  oid, query_type, le16_to_cpu(smib->buf_size));
193  if (query_type == HostCmd_ACT_GEN_GET) {
194  ul_temp = le16_to_cpu(*((__le16 *) (smib->value)));
195  if (data_buf)
196  *data_buf = ul_temp;
197  switch (oid) {
198  case FRAG_THRESH_I:
199  dev_dbg(priv->adapter->dev,
200  "info: SNMP_RESP: FragThsd =%u\n", ul_temp);
201  break;
202  case RTS_THRESH_I:
203  dev_dbg(priv->adapter->dev,
204  "info: SNMP_RESP: RTSThsd =%u\n", ul_temp);
205  break;
206  case SHORT_RETRY_LIM_I:
207  dev_dbg(priv->adapter->dev,
208  "info: SNMP_RESP: TxRetryCount=%u\n", ul_temp);
209  break;
210  case DTIM_PERIOD_I:
211  dev_dbg(priv->adapter->dev,
212  "info: SNMP_RESP: DTIM period=%u\n", ul_temp);
213  default:
214  break;
215  }
216  }
217 
218  return 0;
219 }
220 
221 /*
222  * This function handles the command response of get log request
223  *
224  * Handling includes changing the header fields into CPU format
225  * and sending the received parameters to application.
226  */
227 static int mwifiex_ret_get_log(struct mwifiex_private *priv,
228  struct host_cmd_ds_command *resp,
229  struct mwifiex_ds_get_stats *stats)
230 {
231  struct host_cmd_ds_802_11_get_log *get_log =
232  &resp->params.get_log;
233 
234  if (stats) {
235  stats->mcast_tx_frame = le32_to_cpu(get_log->mcast_tx_frame);
236  stats->failed = le32_to_cpu(get_log->failed);
237  stats->retry = le32_to_cpu(get_log->retry);
238  stats->multi_retry = le32_to_cpu(get_log->multi_retry);
239  stats->frame_dup = le32_to_cpu(get_log->frame_dup);
240  stats->rts_success = le32_to_cpu(get_log->rts_success);
241  stats->rts_failure = le32_to_cpu(get_log->rts_failure);
242  stats->ack_failure = le32_to_cpu(get_log->ack_failure);
243  stats->rx_frag = le32_to_cpu(get_log->rx_frag);
244  stats->mcast_rx_frame = le32_to_cpu(get_log->mcast_rx_frame);
245  stats->fcs_error = le32_to_cpu(get_log->fcs_error);
246  stats->tx_frame = le32_to_cpu(get_log->tx_frame);
247  stats->wep_icv_error[0] =
248  le32_to_cpu(get_log->wep_icv_err_cnt[0]);
249  stats->wep_icv_error[1] =
250  le32_to_cpu(get_log->wep_icv_err_cnt[1]);
251  stats->wep_icv_error[2] =
252  le32_to_cpu(get_log->wep_icv_err_cnt[2]);
253  stats->wep_icv_error[3] =
254  le32_to_cpu(get_log->wep_icv_err_cnt[3]);
255  }
256 
257  return 0;
258 }
259 
260 /*
261  * This function handles the command response of set/get Tx rate
262  * configurations.
263  *
264  * Handling includes changing the header fields into CPU format
265  * and saving the following parameters in driver -
266  * - DSSS rate bitmap
267  * - OFDM rate bitmap
268  * - HT MCS rate bitmaps
269  *
270  * Based on the new rate bitmaps, the function re-evaluates if
271  * auto data rate has been activated. If not, it sends another
272  * query to the firmware to get the current Tx data rate.
273  */
274 static int mwifiex_ret_tx_rate_cfg(struct mwifiex_private *priv,
275  struct host_cmd_ds_command *resp)
276 {
277  struct host_cmd_ds_tx_rate_cfg *rate_cfg = &resp->params.tx_rate_cfg;
278  struct mwifiex_rate_scope *rate_scope;
280  u16 tlv, tlv_buf_len;
281  u8 *tlv_buf;
282  u32 i;
283 
284  tlv_buf = ((u8 *)rate_cfg) +
285  sizeof(struct host_cmd_ds_tx_rate_cfg);
286  tlv_buf_len = *(u16 *) (tlv_buf + sizeof(u16));
287 
288  while (tlv_buf && tlv_buf_len > 0) {
289  tlv = (*tlv_buf);
290  tlv = tlv | (*(tlv_buf + 1) << 8);
291 
292  switch (tlv) {
293  case TLV_TYPE_RATE_SCOPE:
294  rate_scope = (struct mwifiex_rate_scope *) tlv_buf;
295  priv->bitmap_rates[0] =
296  le16_to_cpu(rate_scope->hr_dsss_rate_bitmap);
297  priv->bitmap_rates[1] =
298  le16_to_cpu(rate_scope->ofdm_rate_bitmap);
299  for (i = 0;
300  i <
301  sizeof(rate_scope->ht_mcs_rate_bitmap) /
302  sizeof(u16); i++)
303  priv->bitmap_rates[2 + i] =
304  le16_to_cpu(rate_scope->
305  ht_mcs_rate_bitmap[i]);
306  break;
307  /* Add RATE_DROP tlv here */
308  }
309 
310  head = (struct mwifiex_ie_types_header *) tlv_buf;
311  tlv_buf += le16_to_cpu(head->len) + sizeof(*head);
312  tlv_buf_len -= le16_to_cpu(head->len);
313  }
314 
316 
317  if (priv->is_data_rate_auto)
318  priv->data_rate = 0;
319  else
320  return mwifiex_send_cmd_async(priv,
323 
324  return 0;
325 }
326 
327 /*
328  * This function handles the command response of get Tx power level.
329  *
330  * Handling includes saving the maximum and minimum Tx power levels
331  * in driver, as well as sending the values to user.
332  */
333 static int mwifiex_get_power_level(struct mwifiex_private *priv, void *data_buf)
334 {
335  int length, max_power = -1, min_power = -1;
336  struct mwifiex_types_power_group *pg_tlv_hdr;
337  struct mwifiex_power_group *pg;
338 
339  if (!data_buf)
340  return -1;
341 
342  pg_tlv_hdr = (struct mwifiex_types_power_group *)
343  ((u8 *) data_buf + sizeof(struct host_cmd_ds_txpwr_cfg));
344  pg = (struct mwifiex_power_group *)
345  ((u8 *) pg_tlv_hdr + sizeof(struct mwifiex_types_power_group));
346  length = pg_tlv_hdr->length;
347  if (length > 0) {
348  max_power = pg->power_max;
349  min_power = pg->power_min;
350  length -= sizeof(struct mwifiex_power_group);
351  }
352  while (length) {
353  pg++;
354  if (max_power < pg->power_max)
355  max_power = pg->power_max;
356 
357  if (min_power > pg->power_min)
358  min_power = pg->power_min;
359 
360  length -= sizeof(struct mwifiex_power_group);
361  }
362  if (pg_tlv_hdr->length > 0) {
363  priv->min_tx_power_level = (u8) min_power;
364  priv->max_tx_power_level = (u8) max_power;
365  }
366 
367  return 0;
368 }
369 
370 /*
371  * This function handles the command response of set/get Tx power
372  * configurations.
373  *
374  * Handling includes changing the header fields into CPU format
375  * and saving the current Tx power level in driver.
376  */
377 static int mwifiex_ret_tx_power_cfg(struct mwifiex_private *priv,
378  struct host_cmd_ds_command *resp)
379 {
380  struct mwifiex_adapter *adapter = priv->adapter;
381  struct host_cmd_ds_txpwr_cfg *txp_cfg = &resp->params.txp_cfg;
382  struct mwifiex_types_power_group *pg_tlv_hdr;
383  struct mwifiex_power_group *pg;
384  u16 action = le16_to_cpu(txp_cfg->action);
385 
386  switch (action) {
387  case HostCmd_ACT_GEN_GET:
388  pg_tlv_hdr = (struct mwifiex_types_power_group *)
389  ((u8 *) txp_cfg +
390  sizeof(struct host_cmd_ds_txpwr_cfg));
391 
392  pg = (struct mwifiex_power_group *)
393  ((u8 *) pg_tlv_hdr +
394  sizeof(struct mwifiex_types_power_group));
395 
397  mwifiex_get_power_level(priv, txp_cfg);
398 
399  priv->tx_power_level = (u16) pg->power_min;
400  break;
401 
402  case HostCmd_ACT_GEN_SET:
403  if (!le32_to_cpu(txp_cfg->mode))
404  break;
405 
406  pg_tlv_hdr = (struct mwifiex_types_power_group *)
407  ((u8 *) txp_cfg +
408  sizeof(struct host_cmd_ds_txpwr_cfg));
409 
410  pg = (struct mwifiex_power_group *)
411  ((u8 *) pg_tlv_hdr +
412  sizeof(struct mwifiex_types_power_group));
413 
414  if (pg->power_max == pg->power_min)
415  priv->tx_power_level = (u16) pg->power_min;
416  break;
417  default:
418  dev_err(adapter->dev, "CMD_RESP: unknown cmd action %d\n",
419  action);
420  return 0;
421  }
422  dev_dbg(adapter->dev,
423  "info: Current TxPower Level = %d, Max Power=%d, Min Power=%d\n",
424  priv->tx_power_level, priv->max_tx_power_level,
425  priv->min_tx_power_level);
426 
427  return 0;
428 }
429 
430 /*
431  * This function handles the command response of get RF Tx power.
432  */
433 static int mwifiex_ret_rf_tx_power(struct mwifiex_private *priv,
434  struct host_cmd_ds_command *resp)
435 {
436  struct host_cmd_ds_rf_tx_pwr *txp = &resp->params.txp;
437  u16 action = le16_to_cpu(txp->action);
438 
439  priv->tx_power_level = le16_to_cpu(txp->cur_level);
440 
441  if (action == HostCmd_ACT_GEN_GET) {
442  priv->max_tx_power_level = txp->max_power;
443  priv->min_tx_power_level = txp->min_power;
444  }
445 
446  dev_dbg(priv->adapter->dev,
447  "Current TxPower Level=%d, Max Power=%d, Min Power=%d\n",
448  priv->tx_power_level, priv->max_tx_power_level,
449  priv->min_tx_power_level);
450 
451  return 0;
452 }
453 
454 /*
455  * This function handles the command response of set rf antenna
456  */
457 static int mwifiex_ret_rf_antenna(struct mwifiex_private *priv,
458  struct host_cmd_ds_command *resp)
459 {
460  struct host_cmd_ds_rf_ant_mimo *ant_mimo = &resp->params.ant_mimo;
461  struct host_cmd_ds_rf_ant_siso *ant_siso = &resp->params.ant_siso;
462  struct mwifiex_adapter *adapter = priv->adapter;
463 
464  if (adapter->hw_dev_mcs_support == HT_STREAM_2X2)
465  dev_dbg(adapter->dev,
466  "RF_ANT_RESP: Tx action = 0x%x, Tx Mode = 0x%04x"
467  " Rx action = 0x%x, Rx Mode = 0x%04x\n",
468  le16_to_cpu(ant_mimo->action_tx),
469  le16_to_cpu(ant_mimo->tx_ant_mode),
470  le16_to_cpu(ant_mimo->action_rx),
471  le16_to_cpu(ant_mimo->rx_ant_mode));
472  else
473  dev_dbg(adapter->dev,
474  "RF_ANT_RESP: action = 0x%x, Mode = 0x%04x\n",
475  le16_to_cpu(ant_siso->action),
476  le16_to_cpu(ant_siso->ant_mode));
477 
478  return 0;
479 }
480 
481 /*
482  * This function handles the command response of set/get MAC address.
483  *
484  * Handling includes saving the MAC address in driver.
485  */
486 static int mwifiex_ret_802_11_mac_address(struct mwifiex_private *priv,
487  struct host_cmd_ds_command *resp)
488 {
489  struct host_cmd_ds_802_11_mac_address *cmd_mac_addr =
490  &resp->params.mac_addr;
491 
492  memcpy(priv->curr_addr, cmd_mac_addr->mac_addr, ETH_ALEN);
493 
494  dev_dbg(priv->adapter->dev,
495  "info: set mac address: %pM\n", priv->curr_addr);
496 
497  return 0;
498 }
499 
500 /*
501  * This function handles the command response of set/get MAC multicast
502  * address.
503  */
504 static int mwifiex_ret_mac_multicast_adr(struct mwifiex_private *priv,
505  struct host_cmd_ds_command *resp)
506 {
507  return 0;
508 }
509 
510 /*
511  * This function handles the command response of get Tx rate query.
512  *
513  * Handling includes changing the header fields into CPU format
514  * and saving the Tx rate and HT information parameters in driver.
515  *
516  * Both rate configuration and current data rate can be retrieved
517  * with this request.
518  */
519 static int mwifiex_ret_802_11_tx_rate_query(struct mwifiex_private *priv,
520  struct host_cmd_ds_command *resp)
521 {
522  priv->tx_rate = resp->params.tx_rate.tx_rate;
523  priv->tx_htinfo = resp->params.tx_rate.ht_info;
524  if (!priv->is_data_rate_auto)
525  priv->data_rate =
527  priv->tx_htinfo);
528 
529  return 0;
530 }
531 
532 /*
533  * This function handles the command response of a deauthenticate
534  * command.
535  *
536  * If the deauthenticated MAC matches the current BSS MAC, the connection
537  * state is reset.
538  */
539 static int mwifiex_ret_802_11_deauthenticate(struct mwifiex_private *priv,
540  struct host_cmd_ds_command *resp)
541 {
542  struct mwifiex_adapter *adapter = priv->adapter;
543 
544  adapter->dbg.num_cmd_deauth++;
545  if (!memcmp(resp->params.deauth.mac_addr,
546  &priv->curr_bss_params.bss_descriptor.mac_address,
547  sizeof(resp->params.deauth.mac_addr)))
549 
550  return 0;
551 }
552 
553 /*
554  * This function handles the command response of ad-hoc stop.
555  *
556  * The function resets the connection state in driver.
557  */
558 static int mwifiex_ret_802_11_ad_hoc_stop(struct mwifiex_private *priv,
559  struct host_cmd_ds_command *resp)
560 {
562  return 0;
563 }
564 
565 /*
566  * This function handles the command response of set/get key material.
567  *
568  * Handling includes updating the driver parameters to reflect the
569  * changes.
570  */
571 static int mwifiex_ret_802_11_key_material(struct mwifiex_private *priv,
572  struct host_cmd_ds_command *resp)
573 {
575  &resp->params.key_material;
576 
577  if (le16_to_cpu(key->action) == HostCmd_ACT_GEN_SET) {
578  if ((le16_to_cpu(key->key_param_set.key_info) & KEY_MCAST)) {
579  dev_dbg(priv->adapter->dev, "info: key: GTK is set\n");
580  priv->wpa_is_gtk_set = true;
581  priv->scan_block = false;
582  }
583  }
584 
585  memset(priv->aes_key.key_param_set.key, 0,
586  sizeof(key->key_param_set.key));
587  priv->aes_key.key_param_set.key_len = key->key_param_set.key_len;
588  memcpy(priv->aes_key.key_param_set.key, key->key_param_set.key,
589  le16_to_cpu(priv->aes_key.key_param_set.key_len));
590 
591  return 0;
592 }
593 
594 /*
595  * This function handles the command response of get 11d domain information.
596  */
597 static int mwifiex_ret_802_11d_domain_info(struct mwifiex_private *priv,
598  struct host_cmd_ds_command *resp)
599 {
600  struct host_cmd_ds_802_11d_domain_info_rsp *domain_info =
601  &resp->params.domain_info_resp;
602  struct mwifiex_ietypes_domain_param_set *domain = &domain_info->domain;
603  u16 action = le16_to_cpu(domain_info->action);
604  u8 no_of_triplet;
605 
606  no_of_triplet = (u8) ((le16_to_cpu(domain->header.len)
608  / sizeof(struct ieee80211_country_ie_triplet));
609 
610  dev_dbg(priv->adapter->dev,
611  "info: 11D Domain Info Resp: no_of_triplet=%d\n",
612  no_of_triplet);
613 
614  if (no_of_triplet > MWIFIEX_MAX_TRIPLET_802_11D) {
615  dev_warn(priv->adapter->dev,
616  "11D: invalid number of triplets %d returned\n",
617  no_of_triplet);
618  return -1;
619  }
620 
621  switch (action) {
622  case HostCmd_ACT_GEN_SET: /* Proc Set Action */
623  break;
624  case HostCmd_ACT_GEN_GET:
625  break;
626  default:
627  dev_err(priv->adapter->dev,
628  "11D: invalid action:%d\n", domain_info->action);
629  return -1;
630  }
631 
632  return 0;
633 }
634 
635 /*
636  * This function handles the command response of get extended version.
637  *
638  * Handling includes forming the extended version string and sending it
639  * to application.
640  */
641 static int mwifiex_ret_ver_ext(struct mwifiex_private *priv,
642  struct host_cmd_ds_command *resp,
643  struct host_cmd_ds_version_ext *version_ext)
644 {
645  struct host_cmd_ds_version_ext *ver_ext = &resp->params.verext;
646 
647  if (version_ext) {
648  version_ext->version_str_sel = ver_ext->version_str_sel;
649  memcpy(version_ext->version_str, ver_ext->version_str,
650  sizeof(char) * 128);
651  memcpy(priv->version_str, ver_ext->version_str, 128);
652  }
653  return 0;
654 }
655 
656 /*
657  * This function handles the command response of remain on channel.
658  */
659 static int
660 mwifiex_ret_remain_on_chan(struct mwifiex_private *priv,
661  struct host_cmd_ds_command *resp,
662  struct host_cmd_ds_remain_on_chan *roc_cfg)
663 {
664  struct host_cmd_ds_remain_on_chan *resp_cfg = &resp->params.roc_cfg;
665 
666  if (roc_cfg)
667  memcpy(roc_cfg, resp_cfg, sizeof(*roc_cfg));
668 
669  return 0;
670 }
671 
672 /*
673  * This function handles the command response of P2P mode cfg.
674  */
675 static int
676 mwifiex_ret_p2p_mode_cfg(struct mwifiex_private *priv,
677  struct host_cmd_ds_command *resp,
678  void *data_buf)
679 {
680  struct host_cmd_ds_p2p_mode_cfg *mode_cfg = &resp->params.mode_cfg;
681 
682  if (data_buf)
683  *((u16 *)data_buf) = le16_to_cpu(mode_cfg->mode);
684 
685  return 0;
686 }
687 
688 /*
689  * This function handles the command response of register access.
690  *
691  * The register value and offset are returned to the user. For EEPROM
692  * access, the byte count is also returned.
693  */
694 static int mwifiex_ret_reg_access(u16 type, struct host_cmd_ds_command *resp,
695  void *data_buf)
696 {
697  struct mwifiex_ds_reg_rw *reg_rw;
699  union reg {
701  struct host_cmd_ds_bbp_reg_access *bbp;
702  struct host_cmd_ds_rf_reg_access *rf;
703  struct host_cmd_ds_pmic_reg_access *pmic;
704  struct host_cmd_ds_802_11_eeprom_access *eeprom;
705  } r;
706 
707  if (!data_buf)
708  return 0;
709 
710  reg_rw = data_buf;
711  eeprom = data_buf;
712  switch (type) {
714  r.mac = &resp->params.mac_reg;
715  reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.mac->offset));
716  reg_rw->value = r.mac->value;
717  break;
719  r.bbp = &resp->params.bbp_reg;
720  reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.bbp->offset));
721  reg_rw->value = cpu_to_le32((u32) r.bbp->value);
722  break;
723 
725  r.rf = &resp->params.rf_reg;
726  reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.rf->offset));
727  reg_rw->value = cpu_to_le32((u32) r.bbp->value);
728  break;
730  r.pmic = &resp->params.pmic_reg;
731  reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.pmic->offset));
732  reg_rw->value = cpu_to_le32((u32) r.pmic->value);
733  break;
735  r.rf = &resp->params.rf_reg;
736  reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.rf->offset));
737  reg_rw->value = cpu_to_le32((u32) r.rf->value);
738  break;
740  r.eeprom = &resp->params.eeprom;
741  pr_debug("info: EEPROM read len=%x\n", r.eeprom->byte_count);
742  if (le16_to_cpu(eeprom->byte_count) <
743  le16_to_cpu(r.eeprom->byte_count)) {
744  eeprom->byte_count = cpu_to_le16(0);
745  pr_debug("info: EEPROM read length is too big\n");
746  return -1;
747  }
748  eeprom->offset = r.eeprom->offset;
749  eeprom->byte_count = r.eeprom->byte_count;
750  if (le16_to_cpu(eeprom->byte_count) > 0)
751  memcpy(&eeprom->value, &r.eeprom->value,
752  le16_to_cpu(r.eeprom->byte_count));
753 
754  break;
755  default:
756  return -1;
757  }
758  return 0;
759 }
760 
761 /*
762  * This function handles the command response of get IBSS coalescing status.
763  *
764  * If the received BSSID is different than the current one, the current BSSID,
765  * beacon interval, ATIM window and ERP information are updated, along with
766  * changing the ad-hoc state accordingly.
767  */
768 static int mwifiex_ret_ibss_coalescing_status(struct mwifiex_private *priv,
769  struct host_cmd_ds_command *resp)
770 {
771  struct host_cmd_ds_802_11_ibss_status *ibss_coal_resp =
772  &(resp->params.ibss_coalescing);
773 
774  if (le16_to_cpu(ibss_coal_resp->action) == HostCmd_ACT_GEN_SET)
775  return 0;
776 
777  dev_dbg(priv->adapter->dev,
778  "info: new BSSID %pM\n", ibss_coal_resp->bssid);
779 
780  /* If rsp has NULL BSSID, Just return..... No Action */
781  if (is_zero_ether_addr(ibss_coal_resp->bssid)) {
782  dev_warn(priv->adapter->dev, "new BSSID is NULL\n");
783  return 0;
784  }
785 
786  /* If BSSID is diff, modify current BSS parameters */
787  if (memcmp(priv->curr_bss_params.bss_descriptor.mac_address,
788  ibss_coal_resp->bssid, ETH_ALEN)) {
789  /* BSSID */
790  memcpy(priv->curr_bss_params.bss_descriptor.mac_address,
791  ibss_coal_resp->bssid, ETH_ALEN);
792 
793  /* Beacon Interval */
794  priv->curr_bss_params.bss_descriptor.beacon_period
795  = le16_to_cpu(ibss_coal_resp->beacon_interval);
796 
797  /* ERP Information */
798  priv->curr_bss_params.bss_descriptor.erp_flags =
799  (u8) le16_to_cpu(ibss_coal_resp->use_g_rate_protect);
800 
802  }
803 
804  return 0;
805 }
806 
807 /*
808  * This function handles the command response for subscribe event command.
809  */
810 static int mwifiex_ret_subsc_evt(struct mwifiex_private *priv,
811  struct host_cmd_ds_command *resp)
812 {
813  struct host_cmd_ds_802_11_subsc_evt *cmd_sub_event =
814  &resp->params.subsc_evt;
815 
816  /* For every subscribe event command (Get/Set/Clear), FW reports the
817  * current set of subscribed events*/
818  dev_dbg(priv->adapter->dev, "Bitmap of currently subscribed events: %16x\n",
819  le16_to_cpu(cmd_sub_event->events));
820 
821  return 0;
822 }
823 
824 /*
825  * This function handles the command responses.
826  *
827  * This is a generic function, which calls command specific
828  * response handlers based on the command ID.
829  */
830 int mwifiex_process_sta_cmdresp(struct mwifiex_private *priv, u16 cmdresp_no,
831  struct host_cmd_ds_command *resp)
832 {
833  int ret = 0;
834  struct mwifiex_adapter *adapter = priv->adapter;
835  void *data_buf = adapter->curr_cmd->data_buf;
836 
837  /* If the command is not successful, cleanup and return failure */
838  if (resp->result != HostCmd_RESULT_OK) {
839  mwifiex_process_cmdresp_error(priv, resp);
840  return -1;
841  }
842  /* Command successful, handle response */
843  switch (cmdresp_no) {
845  ret = mwifiex_ret_get_hw_spec(priv, resp);
846  break;
848  break;
850  ret = mwifiex_ret_802_11_mac_address(priv, resp);
851  break;
853  ret = mwifiex_ret_mac_multicast_adr(priv, resp);
854  break;
856  ret = mwifiex_ret_tx_rate_cfg(priv, resp);
857  break;
859  ret = mwifiex_ret_802_11_scan(priv, resp);
860  adapter->curr_cmd->wait_q_enabled = false;
861  break;
863  ret = mwifiex_ret_802_11_scan(priv, resp);
864  dev_dbg(adapter->dev,
865  "info: CMD_RESP: BG_SCAN result is ready!\n");
866  break;
868  ret = mwifiex_ret_tx_power_cfg(priv, resp);
869  break;
871  ret = mwifiex_ret_rf_tx_power(priv, resp);
872  break;
874  ret = mwifiex_ret_rf_antenna(priv, resp);
875  break;
877  ret = mwifiex_ret_enh_power_mode(priv, resp, data_buf);
878  break;
880  ret = mwifiex_ret_802_11_hs_cfg(priv, resp);
881  break;
883  ret = mwifiex_ret_802_11_associate(priv, resp);
884  break;
886  ret = mwifiex_ret_802_11_deauthenticate(priv, resp);
887  break;
890  ret = mwifiex_ret_802_11_ad_hoc(priv, resp);
891  break;
893  ret = mwifiex_ret_802_11_ad_hoc_stop(priv, resp);
894  break;
896  ret = mwifiex_ret_get_log(priv, resp, data_buf);
897  break;
899  ret = mwifiex_ret_802_11_rssi_info(priv, resp);
900  break;
902  ret = mwifiex_ret_802_11_snmp_mib(priv, resp, data_buf);
903  break;
905  ret = mwifiex_ret_802_11_tx_rate_query(priv, resp);
906  break;
908  ret = mwifiex_ret_ver_ext(priv, resp, data_buf);
909  break;
911  ret = mwifiex_ret_remain_on_chan(priv, resp, data_buf);
912  break;
914  ret = mwifiex_ret_p2p_mode_cfg(priv, resp, data_buf);
915  break;
919  break;
921  ret = mwifiex_ret_802_11_key_material(priv, resp);
922  break;
924  ret = mwifiex_ret_802_11d_domain_info(priv, resp);
925  break;
927  ret = mwifiex_ret_11n_addba_req(priv, resp);
928  break;
930  ret = mwifiex_ret_11n_delba(priv, resp);
931  break;
933  ret = mwifiex_ret_11n_addba_resp(priv, resp);
934  break;
936  adapter->tx_buf_size = (u16) le16_to_cpu(resp->params.
937  tx_buf.buff_size);
938  adapter->tx_buf_size = (adapter->tx_buf_size
941  adapter->curr_tx_buf_size = adapter->tx_buf_size;
942  dev_dbg(adapter->dev,
943  "cmd: max_tx_buf_size=%d, tx_buf_size=%d\n",
944  adapter->max_tx_buf_size, adapter->tx_buf_size);
945 
946  if (adapter->if_ops.update_mp_end_port)
947  adapter->if_ops.update_mp_end_port(adapter,
948  le16_to_cpu(resp->params.tx_buf.mp_end_port));
949  break;
951  break;
953  ret = mwifiex_ret_wmm_get_status(priv, resp);
954  break;
956  ret = mwifiex_ret_ibss_coalescing_status(priv, resp);
957  break;
964  ret = mwifiex_ret_reg_access(cmdresp_no, resp, data_buf);
965  break;
967  break;
968  case HostCmd_CMD_11N_CFG:
969  break;
971  break;
973  ret = mwifiex_ret_subsc_evt(priv, resp);
974  break;
976  break;
978  priv->bss_started = 1;
979  break;
981  priv->bss_started = 0;
982  break;
983  default:
984  dev_err(adapter->dev, "CMD_RESP: unknown cmd response %#x\n",
985  resp->command);
986  break;
987  }
988 
989  return ret;
990 }