Pileus Git - ~andy/linux/blob - drivers/net/wireless/mwifiex/sta_cmdresp.c

   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;
  48         struct host_cmd_ds_802_11_ps_mode_enh *pm;
  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)) {
  58         case HostCmd_CMD_802_11_PS_MODE_ENH:
  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 &&
  65                     (le16_to_cpu(pm->params.ps_bitmap) & BITMAP_STA_PS) &&
  66                     priv->bss_mode == NL80211_IFTYPE_ADHOC)
  67                         adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM;
  68
  69                 break;
  70         case HostCmd_CMD_802_11_SCAN:
  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
  94         case HostCmd_CMD_MAC_CONTROL:
  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;
 127
 128         priv->data_rssi_last = le16_to_cpu(rssi_info_rsp->data_rssi_last);
 129         priv->data_nf_last = le16_to_cpu(rssi_info_rsp->data_nf_last);
 130
 131         priv->data_rssi_avg = le16_to_cpu(rssi_info_rsp->data_rssi_avg);
 132         priv->data_nf_avg = le16_to_cpu(rssi_info_rsp->data_nf_avg);
 133
 134         priv->bcn_rssi_last = le16_to_cpu(rssi_info_rsp->bcn_rssi_last);
 135         priv->bcn_nf_last = le16_to_cpu(rssi_info_rsp->bcn_nf_last);
 136
 137         priv->bcn_rssi_avg = le16_to_cpu(rssi_info_rsp->bcn_rssi_avg);
 138         priv->bcn_nf_avg = le16_to_cpu(rssi_info_rsp->bcn_nf_avg);
 139
 140         if (priv->subsc_evt_rssi_state == EVENT_HANDLED)
 141                 return 0;
 142
 143         /* Resubscribe low and high rssi events with new thresholds */
 144         memset(&subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
 145         subsc_evt.events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
 146         subsc_evt.action = HostCmd_ACT_BITWISE_SET;
 147         if (priv->subsc_evt_rssi_state == RSSI_LOW_RECVD) {
 148                 subsc_evt.bcn_l_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg -
 149                                 priv->cqm_rssi_hyst);
 150                 subsc_evt.bcn_h_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold);
 151         } else if (priv->subsc_evt_rssi_state == RSSI_HIGH_RECVD) {
 152                 subsc_evt.bcn_l_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold);
 153                 subsc_evt.bcn_h_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg +
 154                                 priv->cqm_rssi_hyst);
 155         }
 156         subsc_evt.bcn_l_rssi_cfg.evt_freq = 1;
 157         subsc_evt.bcn_h_rssi_cfg.evt_freq = 1;
 158
 159         priv->subsc_evt_rssi_state = EVENT_HANDLED;
 160
 161         mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
 162                                0, 0, &subsc_evt);
 163
 164         return 0;
 165 }
 166
 167 /*
 168  * This function handles the command response of set/get SNMP
 169  * MIB parameters.
 170  *
 171  * Handling includes changing the header fields into CPU format
 172  * and saving the parameter in driver.
 173  *
 174  * The following parameters are supported -
 175  *      - Fragmentation threshold
 176  *      - RTS threshold
 177  *      - Short retry limit
 178  */
 179 static int mwifiex_ret_802_11_snmp_mib(struct mwifiex_private *priv,
 180                                        struct host_cmd_ds_command *resp,
 181                                        u32 *data_buf)
 182 {
 183         struct host_cmd_ds_802_11_snmp_mib *smib = &resp->params.smib;
 184         u16 oid = le16_to_cpu(smib->oid);
 185         u16 query_type = le16_to_cpu(smib->query_type);
 186         u32 ul_temp;
 187
 188         dev_dbg(priv->adapter->dev, "info: SNMP_RESP: oid value = %#x,"
 189                 " query_type = %#x, buf size = %#x\n",
 190                 oid, query_type, le16_to_cpu(smib->buf_size));
 191         if (query_type == HostCmd_ACT_GEN_GET) {
 192                 ul_temp = le16_to_cpu(*((__le16 *) (smib->value)));
 193                 if (data_buf)
 194                         *data_buf = ul_temp;
 195                 switch (oid) {
 196                 case FRAG_THRESH_I:
 197                         dev_dbg(priv->adapter->dev,
 198                                 "info: SNMP_RESP: FragThsd =%u\n", ul_temp);
 199                         break;
 200                 case RTS_THRESH_I:
 201                         dev_dbg(priv->adapter->dev,
 202                                 "info: SNMP_RESP: RTSThsd =%u\n", ul_temp);
 203                         break;
 204                 case SHORT_RETRY_LIM_I:
 205                         dev_dbg(priv->adapter->dev,
 206                                 "info: SNMP_RESP: TxRetryCount=%u\n", ul_temp);
 207                         break;
 208                 case DTIM_PERIOD_I:
 209                         dev_dbg(priv->adapter->dev,
 210                                 "info: SNMP_RESP: DTIM period=%u\n", ul_temp);
 211                 default:
 212                         break;
 213                 }
 214         }
 215
 216         return 0;
 217 }
 218
 219 /*
 220  * This function handles the command response of get log request
 221  *
 222  * Handling includes changing the header fields into CPU format
 223  * and sending the received parameters to application.
 224  */
 225 static int mwifiex_ret_get_log(struct mwifiex_private *priv,
 226                                struct host_cmd_ds_command *resp,
 227                                struct mwifiex_ds_get_stats *stats)
 228 {
 229         struct host_cmd_ds_802_11_get_log *get_log =
 230                 (struct host_cmd_ds_802_11_get_log *) &resp->params.get_log;
 231
 232         if (stats) {
 233                 stats->mcast_tx_frame = le32_to_cpu(get_log->mcast_tx_frame);
 234                 stats->failed = le32_to_cpu(get_log->failed);
 235                 stats->retry = le32_to_cpu(get_log->retry);
 236                 stats->multi_retry = le32_to_cpu(get_log->multi_retry);
 237                 stats->frame_dup = le32_to_cpu(get_log->frame_dup);
 238                 stats->rts_success = le32_to_cpu(get_log->rts_success);
 239                 stats->rts_failure = le32_to_cpu(get_log->rts_failure);
 240                 stats->ack_failure = le32_to_cpu(get_log->ack_failure);
 241                 stats->rx_frag = le32_to_cpu(get_log->rx_frag);
 242                 stats->mcast_rx_frame = le32_to_cpu(get_log->mcast_rx_frame);
 243                 stats->fcs_error = le32_to_cpu(get_log->fcs_error);
 244                 stats->tx_frame = le32_to_cpu(get_log->tx_frame);
 245                 stats->wep_icv_error[0] =
 246                         le32_to_cpu(get_log->wep_icv_err_cnt[0]);
 247                 stats->wep_icv_error[1] =
 248                         le32_to_cpu(get_log->wep_icv_err_cnt[1]);
 249                 stats->wep_icv_error[2] =
 250                         le32_to_cpu(get_log->wep_icv_err_cnt[2]);
 251                 stats->wep_icv_error[3] =
 252                         le32_to_cpu(get_log->wep_icv_err_cnt[3]);
 253         }
 254
 255         return 0;
 256 }
 257
 258 /*
 259  * This function handles the command response of set/get Tx rate
 260  * configurations.
 261  *
 262  * Handling includes changing the header fields into CPU format
 263  * and saving the following parameters in driver -
 264  *      - DSSS rate bitmap
 265  *      - OFDM rate bitmap
 266  *      - HT MCS rate bitmaps
 267  *
 268  * Based on the new rate bitmaps, the function re-evaluates if
 269  * auto data rate has been activated. If not, it sends another
 270  * query to the firmware to get the current Tx data rate.
 271  */
 272 static int mwifiex_ret_tx_rate_cfg(struct mwifiex_private *priv,
 273                                    struct host_cmd_ds_command *resp)
 274 {
 275         struct host_cmd_ds_tx_rate_cfg *rate_cfg = &resp->params.tx_rate_cfg;
 276         struct mwifiex_rate_scope *rate_scope;
 277         struct mwifiex_ie_types_header *head;
 278         u16 tlv, tlv_buf_len;
 279         u8 *tlv_buf;
 280         u32 i;
 281
 282         tlv_buf = (u8 *) ((u8 *) rate_cfg) +
 283                         sizeof(struct host_cmd_ds_tx_rate_cfg);
 284         tlv_buf_len = *(u16 *) (tlv_buf + sizeof(u16));
 285
 286         while (tlv_buf && tlv_buf_len > 0) {
 287                 tlv = (*tlv_buf);
 288                 tlv = tlv | (*(tlv_buf + 1) << 8);
 289
 290                 switch (tlv) {
 291                 case TLV_TYPE_RATE_SCOPE:
 292                         rate_scope = (struct mwifiex_rate_scope *) tlv_buf;
 293                         priv->bitmap_rates[0] =
 294                                 le16_to_cpu(rate_scope->hr_dsss_rate_bitmap);
 295                         priv->bitmap_rates[1] =
 296                                 le16_to_cpu(rate_scope->ofdm_rate_bitmap);
 297                         for (i = 0;
 298                              i <
 299                              sizeof(rate_scope->ht_mcs_rate_bitmap) /
 300                              sizeof(u16); i++)
 301                                 priv->bitmap_rates[2 + i] =
 302                                         le16_to_cpu(rate_scope->
 303                                                     ht_mcs_rate_bitmap[i]);
 304                         break;
 305                         /* Add RATE_DROP tlv here */
 306                 }
 307
 308                 head = (struct mwifiex_ie_types_header *) tlv_buf;
 309                 tlv_buf += le16_to_cpu(head->len) + sizeof(*head);
 310                 tlv_buf_len -= le16_to_cpu(head->len);
 311         }
 312
 313         priv->is_data_rate_auto = mwifiex_is_rate_auto(priv);
 314
 315         if (priv->is_data_rate_auto)
 316                 priv->data_rate = 0;
 317         else
 318                 return mwifiex_send_cmd_async(priv,
 319                                               HostCmd_CMD_802_11_TX_RATE_QUERY,
 320                                               HostCmd_ACT_GEN_GET, 0, NULL);
 321
 322         return 0;
 323 }
 324
 325 /*
 326  * This function handles the command response of get Tx power level.
 327  *
 328  * Handling includes saving the maximum and minimum Tx power levels
 329  * in driver, as well as sending the values to user.
 330  */
 331 static int mwifiex_get_power_level(struct mwifiex_private *priv, void *data_buf)
 332 {
 333         int length, max_power = -1, min_power = -1;
 334         struct mwifiex_types_power_group *pg_tlv_hdr;
 335         struct mwifiex_power_group *pg;
 336
 337         if (!data_buf)
 338                 return -1;
 339
 340         pg_tlv_hdr = (struct mwifiex_types_power_group *)
 341                 ((u8 *) data_buf + sizeof(struct host_cmd_ds_txpwr_cfg));
 342         pg = (struct mwifiex_power_group *)
 343                 ((u8 *) pg_tlv_hdr + sizeof(struct mwifiex_types_power_group));
 344         length = pg_tlv_hdr->length;
 345         if (length > 0) {
 346                 max_power = pg->power_max;
 347                 min_power = pg->power_min;
 348                 length -= sizeof(struct mwifiex_power_group);
 349         }
 350         while (length) {
 351                 pg++;
 352                 if (max_power < pg->power_max)
 353                         max_power = pg->power_max;
 354
 355                 if (min_power > pg->power_min)
 356                         min_power = pg->power_min;
 357
 358                 length -= sizeof(struct mwifiex_power_group);
 359         }
 360         if (pg_tlv_hdr->length > 0) {
 361                 priv->min_tx_power_level = (u8) min_power;
 362                 priv->max_tx_power_level = (u8) max_power;
 363         }
 364
 365         return 0;
 366 }
 367
 368 /*
 369  * This function handles the command response of set/get Tx power
 370  * configurations.
 371  *
 372  * Handling includes changing the header fields into CPU format
 373  * and saving the current Tx power level in driver.
 374  */
 375 static int mwifiex_ret_tx_power_cfg(struct mwifiex_private *priv,
 376                                     struct host_cmd_ds_command *resp)
 377 {
 378         struct mwifiex_adapter *adapter = priv->adapter;
 379         struct host_cmd_ds_txpwr_cfg *txp_cfg = &resp->params.txp_cfg;
 380         struct mwifiex_types_power_group *pg_tlv_hdr;
 381         struct mwifiex_power_group *pg;
 382         u16 action = le16_to_cpu(txp_cfg->action);
 383
 384         switch (action) {
 385         case HostCmd_ACT_GEN_GET:
 386                 pg_tlv_hdr = (struct mwifiex_types_power_group *)
 387                         ((u8 *) txp_cfg +
 388                          sizeof(struct host_cmd_ds_txpwr_cfg));
 389
 390                 pg = (struct mwifiex_power_group *)
 391                         ((u8 *) pg_tlv_hdr +
 392                          sizeof(struct mwifiex_types_power_group));
 393
 394                 if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING)
 395                         mwifiex_get_power_level(priv, txp_cfg);
 396
 397                 priv->tx_power_level = (u16) pg->power_min;
 398                 break;
 399
 400         case HostCmd_ACT_GEN_SET:
 401                 if (!le32_to_cpu(txp_cfg->mode))
 402                         break;
 403
 404                 pg_tlv_hdr = (struct mwifiex_types_power_group *)
 405                         ((u8 *) txp_cfg +
 406                          sizeof(struct host_cmd_ds_txpwr_cfg));
 407
 408                 pg = (struct mwifiex_power_group *)
 409                         ((u8 *) pg_tlv_hdr +
 410                          sizeof(struct mwifiex_types_power_group));
 411
 412                 if (pg->power_max == pg->power_min)
 413                         priv->tx_power_level = (u16) pg->power_min;
 414                 break;
 415         default:
 416                 dev_err(adapter->dev, "CMD_RESP: unknown cmd action %d\n",
 417                         action);
 418                 return 0;
 419         }
 420         dev_dbg(adapter->dev,
 421                 "info: Current TxPower Level = %d, Max Power=%d, Min Power=%d\n",
 422                priv->tx_power_level, priv->max_tx_power_level,
 423                priv->min_tx_power_level);
 424
 425         return 0;
 426 }
 427
 428 /*
 429  * This function handles the command response of get RF Tx power.
 430  */
 431 static int mwifiex_ret_rf_tx_power(struct mwifiex_private *priv,
 432                                    struct host_cmd_ds_command *resp)
 433 {
 434         struct host_cmd_ds_rf_tx_pwr *txp = &resp->params.txp;
 435         u16 action = le16_to_cpu(txp->action);
 436
 437         priv->tx_power_level = le16_to_cpu(txp->cur_level);
 438
 439         if (action == HostCmd_ACT_GEN_GET) {
 440                 priv->max_tx_power_level = txp->max_power;
 441                 priv->min_tx_power_level = txp->min_power;
 442         }
 443
 444         dev_dbg(priv->adapter->dev,
 445                 "Current TxPower Level=%d, Max Power=%d, Min Power=%d\n",
 446                 priv->tx_power_level, priv->max_tx_power_level,
 447                 priv->min_tx_power_level);
 448
 449         return 0;
 450 }
 451
 452 /*
 453  * This function handles the command response of set rf antenna
 454  */
 455 static int mwifiex_ret_rf_antenna(struct mwifiex_private *priv,
 456                                   struct host_cmd_ds_command *resp)
 457 {
 458         struct host_cmd_ds_rf_ant_mimo *ant_mimo = &resp->params.ant_mimo;
 459         struct host_cmd_ds_rf_ant_siso *ant_siso = &resp->params.ant_siso;
 460         struct mwifiex_adapter *adapter = priv->adapter;
 461
 462         if (adapter->hw_dev_mcs_support == HT_STREAM_2X2)
 463                 dev_dbg(adapter->dev,
 464                         "RF_ANT_RESP: Tx action = 0x%x, Tx Mode = 0x%04x"
 465                         " Rx action = 0x%x, Rx Mode = 0x%04x\n",
 466                         le16_to_cpu(ant_mimo->action_tx),
 467                         le16_to_cpu(ant_mimo->tx_ant_mode),
 468                         le16_to_cpu(ant_mimo->action_rx),
 469                         le16_to_cpu(ant_mimo->rx_ant_mode));
 470         else
 471                 dev_dbg(adapter->dev,
 472                         "RF_ANT_RESP: action = 0x%x, Mode = 0x%04x\n",
 473                         le16_to_cpu(ant_siso->action),
 474                         le16_to_cpu(ant_siso->ant_mode));
 475
 476         return 0;
 477 }
 478
 479 /*
 480  * This function handles the command response of set/get MAC address.
 481  *
 482  * Handling includes saving the MAC address in driver.
 483  */
 484 static int mwifiex_ret_802_11_mac_address(struct mwifiex_private *priv,
 485                                           struct host_cmd_ds_command *resp)
 486 {
 487         struct host_cmd_ds_802_11_mac_address *cmd_mac_addr =
 488                                                         &resp->params.mac_addr;
 489
 490         memcpy(priv->curr_addr, cmd_mac_addr->mac_addr, ETH_ALEN);
 491
 492         dev_dbg(priv->adapter->dev,
 493                 "info: set mac address: %pM\n", priv->curr_addr);
 494
 495         return 0;
 496 }
 497
 498 /*
 499  * This function handles the command response of set/get MAC multicast
 500  * address.
 501  */
 502 static int mwifiex_ret_mac_multicast_adr(struct mwifiex_private *priv,
 503                                          struct host_cmd_ds_command *resp)
 504 {
 505         return 0;
 506 }
 507
 508 /*
 509  * This function handles the command response of get Tx rate query.
 510  *
 511  * Handling includes changing the header fields into CPU format
 512  * and saving the Tx rate and HT information parameters in driver.
 513  *
 514  * Both rate configuration and current data rate can be retrieved
 515  * with this request.
 516  */
 517 static int mwifiex_ret_802_11_tx_rate_query(struct mwifiex_private *priv,
 518                                             struct host_cmd_ds_command *resp)
 519 {
 520         priv->tx_rate = resp->params.tx_rate.tx_rate;
 521         priv->tx_htinfo = resp->params.tx_rate.ht_info;
 522         if (!priv->is_data_rate_auto)
 523                 priv->data_rate =
 524                         mwifiex_index_to_data_rate(priv, priv->tx_rate,
 525                                                    priv->tx_htinfo);
 526
 527         return 0;
 528 }
 529
 530 /*
 531  * This function handles the command response of a deauthenticate
 532  * command.
 533  *
 534  * If the deauthenticated MAC matches the current BSS MAC, the connection
 535  * state is reset.
 536  */
 537 static int mwifiex_ret_802_11_deauthenticate(struct mwifiex_private *priv,
 538                                              struct host_cmd_ds_command *resp)
 539 {
 540         struct mwifiex_adapter *adapter = priv->adapter;
 541
 542         adapter->dbg.num_cmd_deauth++;
 543         if (!memcmp(resp->params.deauth.mac_addr,
 544                     &priv->curr_bss_params.bss_descriptor.mac_address,
 545                     sizeof(resp->params.deauth.mac_addr)))
 546                 mwifiex_reset_connect_state(priv);
 547
 548         return 0;
 549 }
 550
 551 /*
 552  * This function handles the command response of ad-hoc stop.
 553  *
 554  * The function resets the connection state in driver.
 555  */
 556 static int mwifiex_ret_802_11_ad_hoc_stop(struct mwifiex_private *priv,
 557                                           struct host_cmd_ds_command *resp)
 558 {
 559         mwifiex_reset_connect_state(priv);
 560         return 0;
 561 }
 562
 563 /*
 564  * This function handles the command response of set/get key material.
 565  *
 566  * Handling includes updating the driver parameters to reflect the
 567  * changes.
 568  */
 569 static int mwifiex_ret_802_11_key_material(struct mwifiex_private *priv,
 570                                            struct host_cmd_ds_command *resp)
 571 {
 572         struct host_cmd_ds_802_11_key_material *key =
 573                                                 &resp->params.key_material;
 574
 575         if (le16_to_cpu(key->action) == HostCmd_ACT_GEN_SET) {
 576                 if ((le16_to_cpu(key->key_param_set.key_info) & KEY_MCAST)) {
 577                         dev_dbg(priv->adapter->dev, "info: key: GTK is set\n");
 578                         priv->wpa_is_gtk_set = true;
 579                         priv->scan_block = false;
 580                 }
 581         }
 582
 583         memset(priv->aes_key.key_param_set.key, 0,
 584                sizeof(key->key_param_set.key));
 585         priv->aes_key.key_param_set.key_len = key->key_param_set.key_len;
 586         memcpy(priv->aes_key.key_param_set.key, key->key_param_set.key,
 587                le16_to_cpu(priv->aes_key.key_param_set.key_len));
 588
 589         return 0;
 590 }
 591
 592 /*
 593  * This function handles the command response of get 11d domain information.
 594  */
 595 static int mwifiex_ret_802_11d_domain_info(struct mwifiex_private *priv,
 596                                            struct host_cmd_ds_command *resp)
 597 {
 598         struct host_cmd_ds_802_11d_domain_info_rsp *domain_info =
 599                 &resp->params.domain_info_resp;
 600         struct mwifiex_ietypes_domain_param_set *domain = &domain_info->domain;
 601         u16 action = le16_to_cpu(domain_info->action);
 602         u8 no_of_triplet;
 603
 604         no_of_triplet = (u8) ((le16_to_cpu(domain->header.len)
 605                                 - IEEE80211_COUNTRY_STRING_LEN)
 606                               / sizeof(struct ieee80211_country_ie_triplet));
 607
 608         dev_dbg(priv->adapter->dev,
 609                 "info: 11D Domain Info Resp: no_of_triplet=%d\n",
 610                 no_of_triplet);
 611
 612         if (no_of_triplet > MWIFIEX_MAX_TRIPLET_802_11D) {
 613                 dev_warn(priv->adapter->dev,
 614                          "11D: invalid number of triplets %d returned\n",
 615                          no_of_triplet);
 616                 return -1;
 617         }
 618
 619         switch (action) {
 620         case HostCmd_ACT_GEN_SET:  /* Proc Set Action */
 621                 break;
 622         case HostCmd_ACT_GEN_GET:
 623                 break;
 624         default:
 625                 dev_err(priv->adapter->dev,
 626                         "11D: invalid action:%d\n", domain_info->action);
 627                 return -1;
 628         }
 629
 630         return 0;
 631 }
 632
 633 /*
 634  * This function handles the command response of get extended version.
 635  *
 636  * Handling includes forming the extended version string and sending it
 637  * to application.
 638  */
 639 static int mwifiex_ret_ver_ext(struct mwifiex_private *priv,
 640                                struct host_cmd_ds_command *resp,
 641                                struct host_cmd_ds_version_ext *version_ext)
 642 {
 643         struct host_cmd_ds_version_ext *ver_ext = &resp->params.verext;
 644
 645         if (version_ext) {
 646                 version_ext->version_str_sel = ver_ext->version_str_sel;
 647                 memcpy(version_ext->version_str, ver_ext->version_str,
 648                        sizeof(char) * 128);
 649                 memcpy(priv->version_str, ver_ext->version_str, 128);
 650         }
 651         return 0;
 652 }
 653
 654 /*
 655  * This function handles the command response of register access.
 656  *
 657  * The register value and offset are returned to the user. For EEPROM
 658  * access, the byte count is also returned.
 659  */
 660 static int mwifiex_ret_reg_access(u16 type, struct host_cmd_ds_command *resp,
 661                                   void *data_buf)
 662 {
 663         struct mwifiex_ds_reg_rw *reg_rw;
 664         struct mwifiex_ds_read_eeprom *eeprom;
 665         union reg {
 666                 struct host_cmd_ds_mac_reg_access *mac;
 667                 struct host_cmd_ds_bbp_reg_access *bbp;
 668                 struct host_cmd_ds_rf_reg_access *rf;
 669                 struct host_cmd_ds_pmic_reg_access *pmic;
 670                 struct host_cmd_ds_802_11_eeprom_access *eeprom;
 671         } r;
 672
 673         if (!data_buf)
 674                 return 0;
 675
 676         reg_rw = data_buf;
 677         eeprom = data_buf;
 678         switch (type) {
 679         case HostCmd_CMD_MAC_REG_ACCESS:
 680                 r.mac = (struct host_cmd_ds_mac_reg_access *)
 681                         &resp->params.mac_reg;
 682                 reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.mac->offset));
 683                 reg_rw->value = r.mac->value;
 684                 break;
 685         case HostCmd_CMD_BBP_REG_ACCESS:
 686                 r.bbp = (struct host_cmd_ds_bbp_reg_access *)
 687                         &resp->params.bbp_reg;
 688                 reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.bbp->offset));
 689                 reg_rw->value = cpu_to_le32((u32) r.bbp->value);
 690                 break;
 691
 692         case HostCmd_CMD_RF_REG_ACCESS:
 693                 r.rf = (struct host_cmd_ds_rf_reg_access *)
 694                        &resp->params.rf_reg;
 695                 reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.rf->offset));
 696                 reg_rw->value = cpu_to_le32((u32) r.bbp->value);
 697                 break;
 698         case HostCmd_CMD_PMIC_REG_ACCESS:
 699                 r.pmic = (struct host_cmd_ds_pmic_reg_access *)
 700                          &resp->params.pmic_reg;
 701                 reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.pmic->offset));
 702                 reg_rw->value = cpu_to_le32((u32) r.pmic->value);
 703                 break;
 704         case HostCmd_CMD_CAU_REG_ACCESS:
 705                 r.rf = (struct host_cmd_ds_rf_reg_access *)
 706                        &resp->params.rf_reg;
 707                 reg_rw->offset = cpu_to_le32((u32) le16_to_cpu(r.rf->offset));
 708                 reg_rw->value = cpu_to_le32((u32) r.rf->value);
 709                 break;
 710         case HostCmd_CMD_802_11_EEPROM_ACCESS:
 711                 r.eeprom = (struct host_cmd_ds_802_11_eeprom_access *)
 712                            &resp->params.eeprom;
 713                 pr_debug("info: EEPROM read len=%x\n", r.eeprom->byte_count);
 714                 if (le16_to_cpu(eeprom->byte_count) <
 715                     le16_to_cpu(r.eeprom->byte_count)) {
 716                         eeprom->byte_count = cpu_to_le16(0);
 717                         pr_debug("info: EEPROM read length is too big\n");
 718                         return -1;
 719                 }
 720                 eeprom->offset = r.eeprom->offset;
 721                 eeprom->byte_count = r.eeprom->byte_count;
 722                 if (le16_to_cpu(eeprom->byte_count) > 0)
 723                         memcpy(&eeprom->value, &r.eeprom->value,
 724                                le16_to_cpu(r.eeprom->byte_count));
 725
 726                 break;
 727         default:
 728                 return -1;
 729         }
 730         return 0;
 731 }
 732
 733 /*
 734  * This function handles the command response of get IBSS coalescing status.
 735  *
 736  * If the received BSSID is different than the current one, the current BSSID,
 737  * beacon interval, ATIM window and ERP information are updated, along with
 738  * changing the ad-hoc state accordingly.
 739  */
 740 static int mwifiex_ret_ibss_coalescing_status(struct mwifiex_private *priv,
 741                                               struct host_cmd_ds_command *resp)
 742 {
 743         struct host_cmd_ds_802_11_ibss_status *ibss_coal_resp =
 744                                         &(resp->params.ibss_coalescing);
 745         u8 zero_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 746
 747         if (le16_to_cpu(ibss_coal_resp->action) == HostCmd_ACT_GEN_SET)
 748                 return 0;
 749
 750         dev_dbg(priv->adapter->dev,
 751                 "info: new BSSID %pM\n", ibss_coal_resp->bssid);
 752
 753         /* If rsp has NULL BSSID, Just return..... No Action */
 754         if (!memcmp(ibss_coal_resp->bssid, zero_mac, ETH_ALEN)) {
 755                 dev_warn(priv->adapter->dev, "new BSSID is NULL\n");
 756                 return 0;
 757         }
 758
 759         /* If BSSID is diff, modify current BSS parameters */
 760         if (memcmp(priv->curr_bss_params.bss_descriptor.mac_address,
 761                    ibss_coal_resp->bssid, ETH_ALEN)) {
 762                 /* BSSID */
 763                 memcpy(priv->curr_bss_params.bss_descriptor.mac_address,
 764                        ibss_coal_resp->bssid, ETH_ALEN);
 765
 766                 /* Beacon Interval */
 767                 priv->curr_bss_params.bss_descriptor.beacon_period
 768                         = le16_to_cpu(ibss_coal_resp->beacon_interval);
 769
 770                 /* ERP Information */
 771                 priv->curr_bss_params.bss_descriptor.erp_flags =
 772                         (u8) le16_to_cpu(ibss_coal_resp->use_g_rate_protect);
 773
 774                 priv->adhoc_state = ADHOC_COALESCED;
 775         }
 776
 777         return 0;
 778 }
 779
 780 /*
 781  * This function handles the command response for subscribe event command.
 782  */
 783 static int mwifiex_ret_subsc_evt(struct mwifiex_private *priv,
 784                                  struct host_cmd_ds_command *resp,
 785                                  struct mwifiex_ds_misc_subsc_evt *sub_event)
 786 {
 787         struct host_cmd_ds_802_11_subsc_evt *cmd_sub_event =
 788                 (struct host_cmd_ds_802_11_subsc_evt *)&resp->params.subsc_evt;
 789
 790         /* For every subscribe event command (Get/Set/Clear), FW reports the
 791          * current set of subscribed events*/
 792         dev_dbg(priv->adapter->dev, "Bitmap of currently subscribed events: %16x\n",
 793                 le16_to_cpu(cmd_sub_event->events));
 794
 795         /*Return the subscribed event info for a Get request*/
 796         if (sub_event)
 797                 sub_event->events = le16_to_cpu(cmd_sub_event->events);
 798
 799         return 0;
 800 }
 801
 802 /*
 803  * This function handles the command responses.
 804  *
 805  * This is a generic function, which calls command specific
 806  * response handlers based on the command ID.
 807  */
 808 int mwifiex_process_sta_cmdresp(struct mwifiex_private *priv, u16 cmdresp_no,
 809                                 struct host_cmd_ds_command *resp)
 810 {
 811         int ret = 0;
 812         struct mwifiex_adapter *adapter = priv->adapter;
 813         void *data_buf = adapter->curr_cmd->data_buf;
 814
 815         /* If the command is not successful, cleanup and return failure */
 816         if (resp->result != HostCmd_RESULT_OK) {
 817                 mwifiex_process_cmdresp_error(priv, resp);
 818                 return -1;
 819         }
 820         /* Command successful, handle response */
 821         switch (cmdresp_no) {
 822         case HostCmd_CMD_GET_HW_SPEC:
 823                 ret = mwifiex_ret_get_hw_spec(priv, resp);
 824                 break;
 825         case HostCmd_CMD_MAC_CONTROL:
 826                 break;
 827         case HostCmd_CMD_802_11_MAC_ADDRESS:
 828                 ret = mwifiex_ret_802_11_mac_address(priv, resp);
 829                 break;
 830         case HostCmd_CMD_MAC_MULTICAST_ADR:
 831                 ret = mwifiex_ret_mac_multicast_adr(priv, resp);
 832                 break;
 833         case HostCmd_CMD_TX_RATE_CFG:
 834                 ret = mwifiex_ret_tx_rate_cfg(priv, resp);
 835                 break;
 836         case HostCmd_CMD_802_11_SCAN:
 837                 ret = mwifiex_ret_802_11_scan(priv, resp);
 838                 adapter->curr_cmd->wait_q_enabled = false;
 839                 break;
 840         case HostCmd_CMD_802_11_BG_SCAN_QUERY:
 841                 ret = mwifiex_ret_802_11_scan(priv, resp);
 842                 dev_dbg(adapter->dev,
 843                         "info: CMD_RESP: BG_SCAN result is ready!\n");
 844                 break;
 845         case HostCmd_CMD_TXPWR_CFG:
 846                 ret = mwifiex_ret_tx_power_cfg(priv, resp);
 847                 break;
 848         case HostCmd_CMD_RF_TX_PWR:
 849                 ret = mwifiex_ret_rf_tx_power(priv, resp);
 850                 break;
 851         case HostCmd_CMD_RF_ANTENNA:
 852                 ret = mwifiex_ret_rf_antenna(priv, resp);
 853                 break;
 854         case HostCmd_CMD_802_11_PS_MODE_ENH:
 855                 ret = mwifiex_ret_enh_power_mode(priv, resp, data_buf);
 856                 break;
 857         case HostCmd_CMD_802_11_HS_CFG_ENH:
 858                 ret = mwifiex_ret_802_11_hs_cfg(priv, resp);
 859                 break;
 860         case HostCmd_CMD_802_11_ASSOCIATE:
 861                 ret = mwifiex_ret_802_11_associate(priv, resp);
 862                 break;
 863         case HostCmd_CMD_802_11_DEAUTHENTICATE:
 864                 ret = mwifiex_ret_802_11_deauthenticate(priv, resp);
 865                 break;
 866         case HostCmd_CMD_802_11_AD_HOC_START:
 867         case HostCmd_CMD_802_11_AD_HOC_JOIN:
 868                 ret = mwifiex_ret_802_11_ad_hoc(priv, resp);
 869                 break;
 870         case HostCmd_CMD_802_11_AD_HOC_STOP:
 871                 ret = mwifiex_ret_802_11_ad_hoc_stop(priv, resp);
 872                 break;
 873         case HostCmd_CMD_802_11_GET_LOG:
 874                 ret = mwifiex_ret_get_log(priv, resp, data_buf);
 875                 break;
 876         case HostCmd_CMD_RSSI_INFO:
 877                 ret = mwifiex_ret_802_11_rssi_info(priv, resp);
 878                 break;
 879         case HostCmd_CMD_802_11_SNMP_MIB:
 880                 ret = mwifiex_ret_802_11_snmp_mib(priv, resp, data_buf);
 881                 break;
 882         case HostCmd_CMD_802_11_TX_RATE_QUERY:
 883                 ret = mwifiex_ret_802_11_tx_rate_query(priv, resp);
 884                 break;
 885         case HostCmd_CMD_VERSION_EXT:
 886                 ret = mwifiex_ret_ver_ext(priv, resp, data_buf);
 887                 break;
 888         case HostCmd_CMD_FUNC_INIT:
 889         case HostCmd_CMD_FUNC_SHUTDOWN:
 890                 break;
 891         case HostCmd_CMD_802_11_KEY_MATERIAL:
 892                 ret = mwifiex_ret_802_11_key_material(priv, resp);
 893                 break;
 894         case HostCmd_CMD_802_11D_DOMAIN_INFO:
 895                 ret = mwifiex_ret_802_11d_domain_info(priv, resp);
 896                 break;
 897         case HostCmd_CMD_11N_ADDBA_REQ:
 898                 ret = mwifiex_ret_11n_addba_req(priv, resp);
 899                 break;
 900         case HostCmd_CMD_11N_DELBA:
 901                 ret = mwifiex_ret_11n_delba(priv, resp);
 902                 break;
 903         case HostCmd_CMD_11N_ADDBA_RSP:
 904                 ret = mwifiex_ret_11n_addba_resp(priv, resp);
 905                 break;
 906         case HostCmd_CMD_RECONFIGURE_TX_BUFF:
 907                 adapter->tx_buf_size = (u16) le16_to_cpu(resp->params.
 908                                                              tx_buf.buff_size);
 909                 adapter->tx_buf_size = (adapter->tx_buf_size
 910                                         / MWIFIEX_SDIO_BLOCK_SIZE)
 911                                        * MWIFIEX_SDIO_BLOCK_SIZE;
 912                 adapter->curr_tx_buf_size = adapter->tx_buf_size;
 913                 dev_dbg(adapter->dev,
 914                         "cmd: max_tx_buf_size=%d, tx_buf_size=%d\n",
 915                         adapter->max_tx_buf_size, adapter->tx_buf_size);
 916
 917                 if (adapter->if_ops.update_mp_end_port)
 918                         adapter->if_ops.update_mp_end_port(adapter,
 919                                 le16_to_cpu(resp->params.tx_buf.mp_end_port));
 920                 break;
 921         case HostCmd_CMD_AMSDU_AGGR_CTRL:
 922                 ret = mwifiex_ret_amsdu_aggr_ctrl(resp, data_buf);
 923                 break;
 924         case HostCmd_CMD_WMM_GET_STATUS:
 925                 ret = mwifiex_ret_wmm_get_status(priv, resp);
 926                 break;
 927         case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS:
 928                 ret = mwifiex_ret_ibss_coalescing_status(priv, resp);
 929                 break;
 930         case HostCmd_CMD_MAC_REG_ACCESS:
 931         case HostCmd_CMD_BBP_REG_ACCESS:
 932         case HostCmd_CMD_RF_REG_ACCESS:
 933         case HostCmd_CMD_PMIC_REG_ACCESS:
 934         case HostCmd_CMD_CAU_REG_ACCESS:
 935         case HostCmd_CMD_802_11_EEPROM_ACCESS:
 936                 ret = mwifiex_ret_reg_access(cmdresp_no, resp, data_buf);
 937                 break;
 938         case HostCmd_CMD_SET_BSS_MODE:
 939                 break;
 940         case HostCmd_CMD_11N_CFG:
 941                 ret = mwifiex_ret_11n_cfg(resp, data_buf);
 942                 break;
 943         case HostCmd_CMD_PCIE_DESC_DETAILS:
 944                 break;
 945         case HostCmd_CMD_802_11_SUBSCRIBE_EVENT:
 946                 ret = mwifiex_ret_subsc_evt(priv, resp, data_buf);
 947                 break;
 948         case HostCmd_CMD_UAP_SYS_CONFIG:
 949                 break;
 950         case HostCmd_CMD_UAP_BSS_START:
 951                 priv->bss_started = 1;
 952                 break;
 953         case HostCmd_CMD_UAP_BSS_STOP:
 954                 priv->bss_started = 0;
 955                 break;
 956         default:
 957                 dev_err(adapter->dev, "CMD_RESP: unknown cmd response %#x\n",
 958                         resp->command);
 959                 break;
 960         }
 961
 962         return ret;
 963 }