1 /* 2 * Marvell Wireless LAN device driver: station command response handling 3 * 4 * Copyright (C) 2011-2014, 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 #include "11ac.h" 28 29 30 /* 31 * This function handles the command response error case. 32 * 33 * For scan response error, the function cancels all the pending 34 * scan commands and generates an event to inform the applications 35 * of the scan completion. 36 * 37 * For Power Save command failure, we do not retry enter PS 38 * command in case of Ad-hoc mode. 39 * 40 * For all other response errors, the current command buffer is freed 41 * and returned to the free command queue. 42 */ 43 static void 44 mwifiex_process_cmdresp_error(struct mwifiex_private *priv, 45 struct host_cmd_ds_command *resp) 46 { 47 struct mwifiex_adapter *adapter = priv->adapter; 48 struct host_cmd_ds_802_11_ps_mode_enh *pm; 49 unsigned long flags; 50 51 mwifiex_dbg(adapter, ERROR, 52 "CMD_RESP: cmd %#x error, result=%#x\n", 53 resp->command, resp->result); 54 55 if (adapter->curr_cmd->wait_q_enabled) 56 adapter->cmd_wait_q.status = -1; 57 58 switch (le16_to_cpu(resp->command)) { 59 case HostCmd_CMD_802_11_PS_MODE_ENH: 60 pm = &resp->params.psmode_enh; 61 mwifiex_dbg(adapter, ERROR, 62 "PS_MODE_ENH cmd failed: result=0x%x action=0x%X\n", 63 resp->result, le16_to_cpu(pm->action)); 64 /* We do not re-try enter-ps command in ad-hoc mode. */ 65 if (le16_to_cpu(pm->action) == EN_AUTO_PS && 66 (le16_to_cpu(pm->params.ps_bitmap) & BITMAP_STA_PS) && 67 priv->bss_mode == NL80211_IFTYPE_ADHOC) 68 adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM; 69 70 break; 71 case HostCmd_CMD_802_11_SCAN: 72 case HostCmd_CMD_802_11_SCAN_EXT: 73 mwifiex_cancel_pending_scan_cmd(adapter); 74 75 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags); 76 adapter->scan_processing = false; 77 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags); 78 break; 79 80 case HostCmd_CMD_MAC_CONTROL: 81 break; 82 83 case HostCmd_CMD_SDIO_SP_RX_AGGR_CFG: 84 mwifiex_dbg(adapter, MSG, 85 "SDIO RX single-port aggregation Not support\n"); 86 break; 87 88 default: 89 break; 90 } 91 /* Handling errors here */ 92 mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd); 93 94 spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags); 95 adapter->curr_cmd = NULL; 96 spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags); 97 } 98 99 /* 100 * This function handles the command response of get RSSI info. 101 * 102 * Handling includes changing the header fields into CPU format 103 * and saving the following parameters in driver - 104 * - Last data and beacon RSSI value 105 * - Average data and beacon RSSI value 106 * - Last data and beacon NF value 107 * - Average data and beacon NF value 108 * 109 * The parameters are send to the application as well, along with 110 * calculated SNR values. 111 */ 112 static int mwifiex_ret_802_11_rssi_info(struct mwifiex_private *priv, 113 struct host_cmd_ds_command *resp) 114 { 115 struct host_cmd_ds_802_11_rssi_info_rsp *rssi_info_rsp = 116 &resp->params.rssi_info_rsp; 117 struct mwifiex_ds_misc_subsc_evt *subsc_evt = 118 &priv->async_subsc_evt_storage; 119 120 priv->data_rssi_last = le16_to_cpu(rssi_info_rsp->data_rssi_last); 121 priv->data_nf_last = le16_to_cpu(rssi_info_rsp->data_nf_last); 122 123 priv->data_rssi_avg = le16_to_cpu(rssi_info_rsp->data_rssi_avg); 124 priv->data_nf_avg = le16_to_cpu(rssi_info_rsp->data_nf_avg); 125 126 priv->bcn_rssi_last = le16_to_cpu(rssi_info_rsp->bcn_rssi_last); 127 priv->bcn_nf_last = le16_to_cpu(rssi_info_rsp->bcn_nf_last); 128 129 priv->bcn_rssi_avg = le16_to_cpu(rssi_info_rsp->bcn_rssi_avg); 130 priv->bcn_nf_avg = le16_to_cpu(rssi_info_rsp->bcn_nf_avg); 131 132 if (priv->subsc_evt_rssi_state == EVENT_HANDLED) 133 return 0; 134 135 memset(subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt)); 136 137 /* Resubscribe low and high rssi events with new thresholds */ 138 subsc_evt->events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH; 139 subsc_evt->action = HostCmd_ACT_BITWISE_SET; 140 if (priv->subsc_evt_rssi_state == RSSI_LOW_RECVD) { 141 subsc_evt->bcn_l_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg - 142 priv->cqm_rssi_hyst); 143 subsc_evt->bcn_h_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold); 144 } else if (priv->subsc_evt_rssi_state == RSSI_HIGH_RECVD) { 145 subsc_evt->bcn_l_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold); 146 subsc_evt->bcn_h_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg + 147 priv->cqm_rssi_hyst); 148 } 149 subsc_evt->bcn_l_rssi_cfg.evt_freq = 1; 150 subsc_evt->bcn_h_rssi_cfg.evt_freq = 1; 151 152 priv->subsc_evt_rssi_state = EVENT_HANDLED; 153 154 mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SUBSCRIBE_EVENT, 155 0, 0, subsc_evt, false); 156 157 return 0; 158 } 159 160 /* 161 * This function handles the command response of set/get SNMP 162 * MIB parameters. 163 * 164 * Handling includes changing the header fields into CPU format 165 * and saving the parameter in driver. 166 * 167 * The following parameters are supported - 168 * - Fragmentation threshold 169 * - RTS threshold 170 * - Short retry limit 171 */ 172 static int mwifiex_ret_802_11_snmp_mib(struct mwifiex_private *priv, 173 struct host_cmd_ds_command *resp, 174 u32 *data_buf) 175 { 176 struct host_cmd_ds_802_11_snmp_mib *smib = &resp->params.smib; 177 u16 oid = le16_to_cpu(smib->oid); 178 u16 query_type = le16_to_cpu(smib->query_type); 179 u32 ul_temp; 180 181 mwifiex_dbg(priv->adapter, INFO, 182 "info: SNMP_RESP: oid value = %#x,\t" 183 "query_type = %#x, buf size = %#x\n", 184 oid, query_type, le16_to_cpu(smib->buf_size)); 185 if (query_type == HostCmd_ACT_GEN_GET) { 186 ul_temp = le16_to_cpu(*((__le16 *) (smib->value))); 187 if (data_buf) 188 *data_buf = ul_temp; 189 switch (oid) { 190 case FRAG_THRESH_I: 191 mwifiex_dbg(priv->adapter, INFO, 192 "info: SNMP_RESP: FragThsd =%u\n", 193 ul_temp); 194 break; 195 case RTS_THRESH_I: 196 mwifiex_dbg(priv->adapter, INFO, 197 "info: SNMP_RESP: RTSThsd =%u\n", 198 ul_temp); 199 break; 200 case SHORT_RETRY_LIM_I: 201 mwifiex_dbg(priv->adapter, INFO, 202 "info: SNMP_RESP: TxRetryCount=%u\n", 203 ul_temp); 204 break; 205 case DTIM_PERIOD_I: 206 mwifiex_dbg(priv->adapter, INFO, 207 "info: SNMP_RESP: DTIM period=%u\n", 208 ul_temp); 209 default: 210 break; 211 } 212 } 213 214 return 0; 215 } 216 217 /* 218 * This function handles the command response of get log request 219 * 220 * Handling includes changing the header fields into CPU format 221 * and sending the received parameters to application. 222 */ 223 static int mwifiex_ret_get_log(struct mwifiex_private *priv, 224 struct host_cmd_ds_command *resp, 225 struct mwifiex_ds_get_stats *stats) 226 { 227 struct host_cmd_ds_802_11_get_log *get_log = 228 &resp->params.get_log; 229 230 if (stats) { 231 stats->mcast_tx_frame = le32_to_cpu(get_log->mcast_tx_frame); 232 stats->failed = le32_to_cpu(get_log->failed); 233 stats->retry = le32_to_cpu(get_log->retry); 234 stats->multi_retry = le32_to_cpu(get_log->multi_retry); 235 stats->frame_dup = le32_to_cpu(get_log->frame_dup); 236 stats->rts_success = le32_to_cpu(get_log->rts_success); 237 stats->rts_failure = le32_to_cpu(get_log->rts_failure); 238 stats->ack_failure = le32_to_cpu(get_log->ack_failure); 239 stats->rx_frag = le32_to_cpu(get_log->rx_frag); 240 stats->mcast_rx_frame = le32_to_cpu(get_log->mcast_rx_frame); 241 stats->fcs_error = le32_to_cpu(get_log->fcs_error); 242 stats->tx_frame = le32_to_cpu(get_log->tx_frame); 243 stats->wep_icv_error[0] = 244 le32_to_cpu(get_log->wep_icv_err_cnt[0]); 245 stats->wep_icv_error[1] = 246 le32_to_cpu(get_log->wep_icv_err_cnt[1]); 247 stats->wep_icv_error[2] = 248 le32_to_cpu(get_log->wep_icv_err_cnt[2]); 249 stats->wep_icv_error[3] = 250 le32_to_cpu(get_log->wep_icv_err_cnt[3]); 251 stats->bcn_rcv_cnt = le32_to_cpu(get_log->bcn_rcv_cnt); 252 stats->bcn_miss_cnt = le32_to_cpu(get_log->bcn_miss_cnt); 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, tlv_buf_left; 279 u8 *tlv_buf; 280 u32 i; 281 282 tlv_buf = ((u8 *)rate_cfg) + sizeof(struct host_cmd_ds_tx_rate_cfg); 283 tlv_buf_left = le16_to_cpu(resp->size) - S_DS_GEN - sizeof(*rate_cfg); 284 285 while (tlv_buf_left >= sizeof(*head)) { 286 head = (struct mwifiex_ie_types_header *)tlv_buf; 287 tlv = le16_to_cpu(head->type); 288 tlv_buf_len = le16_to_cpu(head->len); 289 290 if (tlv_buf_left < (sizeof(*head) + tlv_buf_len)) 291 break; 292 293 switch (tlv) { 294 case TLV_TYPE_RATE_SCOPE: 295 rate_scope = (struct mwifiex_rate_scope *) tlv_buf; 296 priv->bitmap_rates[0] = 297 le16_to_cpu(rate_scope->hr_dsss_rate_bitmap); 298 priv->bitmap_rates[1] = 299 le16_to_cpu(rate_scope->ofdm_rate_bitmap); 300 for (i = 0; 301 i < 302 sizeof(rate_scope->ht_mcs_rate_bitmap) / 303 sizeof(u16); i++) 304 priv->bitmap_rates[2 + i] = 305 le16_to_cpu(rate_scope-> 306 ht_mcs_rate_bitmap[i]); 307 308 if (priv->adapter->fw_api_ver == MWIFIEX_FW_V15) { 309 for (i = 0; i < ARRAY_SIZE(rate_scope-> 310 vht_mcs_rate_bitmap); 311 i++) 312 priv->bitmap_rates[10 + i] = 313 le16_to_cpu(rate_scope-> 314 vht_mcs_rate_bitmap[i]); 315 } 316 break; 317 /* Add RATE_DROP tlv here */ 318 } 319 320 tlv_buf += (sizeof(*head) + tlv_buf_len); 321 tlv_buf_left -= (sizeof(*head) + tlv_buf_len); 322 } 323 324 priv->is_data_rate_auto = mwifiex_is_rate_auto(priv); 325 326 if (priv->is_data_rate_auto) 327 priv->data_rate = 0; 328 else 329 return mwifiex_send_cmd(priv, HostCmd_CMD_802_11_TX_RATE_QUERY, 330 HostCmd_ACT_GEN_GET, 0, NULL, false); 331 332 return 0; 333 } 334 335 /* 336 * This function handles the command response of get Tx power level. 337 * 338 * Handling includes saving the maximum and minimum Tx power levels 339 * in driver, as well as sending the values to user. 340 */ 341 static int mwifiex_get_power_level(struct mwifiex_private *priv, void *data_buf) 342 { 343 int length, max_power = -1, min_power = -1; 344 struct mwifiex_types_power_group *pg_tlv_hdr; 345 struct mwifiex_power_group *pg; 346 347 if (!data_buf) 348 return -1; 349 350 pg_tlv_hdr = (struct mwifiex_types_power_group *)((u8 *)data_buf); 351 pg = (struct mwifiex_power_group *) 352 ((u8 *) pg_tlv_hdr + sizeof(struct mwifiex_types_power_group)); 353 length = le16_to_cpu(pg_tlv_hdr->length); 354 355 /* At least one structure required to update power */ 356 if (length < sizeof(struct mwifiex_power_group)) 357 return 0; 358 359 max_power = pg->power_max; 360 min_power = pg->power_min; 361 length -= sizeof(struct mwifiex_power_group); 362 363 while (length >= sizeof(struct mwifiex_power_group)) { 364 pg++; 365 if (max_power < pg->power_max) 366 max_power = pg->power_max; 367 368 if (min_power > pg->power_min) 369 min_power = pg->power_min; 370 371 length -= sizeof(struct mwifiex_power_group); 372 } 373 priv->min_tx_power_level = (u8) min_power; 374 priv->max_tx_power_level = (u8) max_power; 375 376 return 0; 377 } 378 379 /* 380 * This function handles the command response of set/get Tx power 381 * configurations. 382 * 383 * Handling includes changing the header fields into CPU format 384 * and saving the current Tx power level in driver. 385 */ 386 static int mwifiex_ret_tx_power_cfg(struct mwifiex_private *priv, 387 struct host_cmd_ds_command *resp) 388 { 389 struct mwifiex_adapter *adapter = priv->adapter; 390 struct host_cmd_ds_txpwr_cfg *txp_cfg = &resp->params.txp_cfg; 391 struct mwifiex_types_power_group *pg_tlv_hdr; 392 struct mwifiex_power_group *pg; 393 u16 action = le16_to_cpu(txp_cfg->action); 394 u16 tlv_buf_left; 395 396 pg_tlv_hdr = (struct mwifiex_types_power_group *) 397 ((u8 *)txp_cfg + 398 sizeof(struct host_cmd_ds_txpwr_cfg)); 399 400 pg = (struct mwifiex_power_group *) 401 ((u8 *)pg_tlv_hdr + 402 sizeof(struct mwifiex_types_power_group)); 403 404 tlv_buf_left = le16_to_cpu(resp->size) - S_DS_GEN - sizeof(*txp_cfg); 405 if (tlv_buf_left < 406 le16_to_cpu(pg_tlv_hdr->length) + sizeof(*pg_tlv_hdr)) 407 return 0; 408 409 switch (action) { 410 case HostCmd_ACT_GEN_GET: 411 if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING) 412 mwifiex_get_power_level(priv, pg_tlv_hdr); 413 414 priv->tx_power_level = (u16) pg->power_min; 415 break; 416 417 case HostCmd_ACT_GEN_SET: 418 if (!le32_to_cpu(txp_cfg->mode)) 419 break; 420 421 if (pg->power_max == pg->power_min) 422 priv->tx_power_level = (u16) pg->power_min; 423 break; 424 default: 425 mwifiex_dbg(adapter, ERROR, 426 "CMD_RESP: unknown cmd action %d\n", 427 action); 428 return 0; 429 } 430 mwifiex_dbg(adapter, INFO, 431 "info: Current TxPower Level = %d, Max Power=%d, Min Power=%d\n", 432 priv->tx_power_level, priv->max_tx_power_level, 433 priv->min_tx_power_level); 434 435 return 0; 436 } 437 438 /* 439 * This function handles the command response of get RF Tx power. 440 */ 441 static int mwifiex_ret_rf_tx_power(struct mwifiex_private *priv, 442 struct host_cmd_ds_command *resp) 443 { 444 struct host_cmd_ds_rf_tx_pwr *txp = &resp->params.txp; 445 u16 action = le16_to_cpu(txp->action); 446 447 priv->tx_power_level = le16_to_cpu(txp->cur_level); 448 449 if (action == HostCmd_ACT_GEN_GET) { 450 priv->max_tx_power_level = txp->max_power; 451 priv->min_tx_power_level = txp->min_power; 452 } 453 454 mwifiex_dbg(priv->adapter, INFO, 455 "Current TxPower Level=%d, Max Power=%d, Min Power=%d\n", 456 priv->tx_power_level, priv->max_tx_power_level, 457 priv->min_tx_power_level); 458 459 return 0; 460 } 461 462 /* 463 * This function handles the command response of set rf antenna 464 */ 465 static int mwifiex_ret_rf_antenna(struct mwifiex_private *priv, 466 struct host_cmd_ds_command *resp) 467 { 468 struct host_cmd_ds_rf_ant_mimo *ant_mimo = &resp->params.ant_mimo; 469 struct host_cmd_ds_rf_ant_siso *ant_siso = &resp->params.ant_siso; 470 struct mwifiex_adapter *adapter = priv->adapter; 471 472 if (adapter->hw_dev_mcs_support == HT_STREAM_2X2) { 473 priv->tx_ant = le16_to_cpu(ant_mimo->tx_ant_mode); 474 priv->rx_ant = le16_to_cpu(ant_mimo->rx_ant_mode); 475 mwifiex_dbg(adapter, INFO, 476 "RF_ANT_RESP: Tx action = 0x%x, Tx Mode = 0x%04x\t" 477 "Rx action = 0x%x, Rx Mode = 0x%04x\n", 478 le16_to_cpu(ant_mimo->action_tx), 479 le16_to_cpu(ant_mimo->tx_ant_mode), 480 le16_to_cpu(ant_mimo->action_rx), 481 le16_to_cpu(ant_mimo->rx_ant_mode)); 482 } else { 483 priv->tx_ant = le16_to_cpu(ant_siso->ant_mode); 484 priv->rx_ant = le16_to_cpu(ant_siso->ant_mode); 485 mwifiex_dbg(adapter, INFO, 486 "RF_ANT_RESP: action = 0x%x, Mode = 0x%04x\n", 487 le16_to_cpu(ant_siso->action), 488 le16_to_cpu(ant_siso->ant_mode)); 489 } 490 return 0; 491 } 492 493 /* 494 * This function handles the command response of set/get MAC address. 495 * 496 * Handling includes saving the MAC address in driver. 497 */ 498 static int mwifiex_ret_802_11_mac_address(struct mwifiex_private *priv, 499 struct host_cmd_ds_command *resp) 500 { 501 struct host_cmd_ds_802_11_mac_address *cmd_mac_addr = 502 &resp->params.mac_addr; 503 504 memcpy(priv->curr_addr, cmd_mac_addr->mac_addr, ETH_ALEN); 505 506 mwifiex_dbg(priv->adapter, INFO, 507 "info: set mac address: %pM\n", priv->curr_addr); 508 509 return 0; 510 } 511 512 /* 513 * This function handles the command response of set/get MAC multicast 514 * address. 515 */ 516 static int mwifiex_ret_mac_multicast_adr(struct mwifiex_private *priv, 517 struct host_cmd_ds_command *resp) 518 { 519 return 0; 520 } 521 522 /* 523 * This function handles the command response of get Tx rate query. 524 * 525 * Handling includes changing the header fields into CPU format 526 * and saving the Tx rate and HT information parameters in driver. 527 * 528 * Both rate configuration and current data rate can be retrieved 529 * with this request. 530 */ 531 static int mwifiex_ret_802_11_tx_rate_query(struct mwifiex_private *priv, 532 struct host_cmd_ds_command *resp) 533 { 534 priv->tx_rate = resp->params.tx_rate.tx_rate; 535 priv->tx_htinfo = resp->params.tx_rate.ht_info; 536 if (!priv->is_data_rate_auto) 537 priv->data_rate = 538 mwifiex_index_to_data_rate(priv, priv->tx_rate, 539 priv->tx_htinfo); 540 541 return 0; 542 } 543 544 /* 545 * This function handles the command response of a deauthenticate 546 * command. 547 * 548 * If the deauthenticated MAC matches the current BSS MAC, the connection 549 * state is reset. 550 */ 551 static int mwifiex_ret_802_11_deauthenticate(struct mwifiex_private *priv, 552 struct host_cmd_ds_command *resp) 553 { 554 struct mwifiex_adapter *adapter = priv->adapter; 555 556 adapter->dbg.num_cmd_deauth++; 557 if (!memcmp(resp->params.deauth.mac_addr, 558 &priv->curr_bss_params.bss_descriptor.mac_address, 559 sizeof(resp->params.deauth.mac_addr))) 560 mwifiex_reset_connect_state(priv, WLAN_REASON_DEAUTH_LEAVING, 561 false); 562 563 return 0; 564 } 565 566 /* 567 * This function handles the command response of ad-hoc stop. 568 * 569 * The function resets the connection state in driver. 570 */ 571 static int mwifiex_ret_802_11_ad_hoc_stop(struct mwifiex_private *priv, 572 struct host_cmd_ds_command *resp) 573 { 574 mwifiex_reset_connect_state(priv, WLAN_REASON_DEAUTH_LEAVING, false); 575 return 0; 576 } 577 578 /* 579 * This function handles the command response of set/get v1 key material. 580 * 581 * Handling includes updating the driver parameters to reflect the 582 * changes. 583 */ 584 static int mwifiex_ret_802_11_key_material_v1(struct mwifiex_private *priv, 585 struct host_cmd_ds_command *resp) 586 { 587 struct host_cmd_ds_802_11_key_material *key = 588 &resp->params.key_material; 589 590 if (le16_to_cpu(key->action) == HostCmd_ACT_GEN_SET) { 591 if ((le16_to_cpu(key->key_param_set.key_info) & KEY_MCAST)) { 592 mwifiex_dbg(priv->adapter, INFO, 593 "info: key: GTK is set\n"); 594 priv->wpa_is_gtk_set = true; 595 priv->scan_block = false; 596 priv->port_open = true; 597 } 598 } 599 600 memset(priv->aes_key.key_param_set.key, 0, 601 sizeof(key->key_param_set.key)); 602 priv->aes_key.key_param_set.key_len = key->key_param_set.key_len; 603 memcpy(priv->aes_key.key_param_set.key, key->key_param_set.key, 604 le16_to_cpu(priv->aes_key.key_param_set.key_len)); 605 606 return 0; 607 } 608 609 /* 610 * This function handles the command response of set/get v2 key material. 611 * 612 * Handling includes updating the driver parameters to reflect the 613 * changes. 614 */ 615 static int mwifiex_ret_802_11_key_material_v2(struct mwifiex_private *priv, 616 struct host_cmd_ds_command *resp) 617 { 618 struct host_cmd_ds_802_11_key_material_v2 *key_v2; 619 __le16 len; 620 621 key_v2 = &resp->params.key_material_v2; 622 if (le16_to_cpu(key_v2->action) == HostCmd_ACT_GEN_SET) { 623 if ((le16_to_cpu(key_v2->key_param_set.key_info) & KEY_MCAST)) { 624 mwifiex_dbg(priv->adapter, INFO, "info: key: GTK is set\n"); 625 priv->wpa_is_gtk_set = true; 626 priv->scan_block = false; 627 priv->port_open = true; 628 } 629 } 630 631 if (key_v2->key_param_set.key_type != KEY_TYPE_ID_AES) 632 return 0; 633 634 memset(priv->aes_key_v2.key_param_set.key_params.aes.key, 0, 635 WLAN_KEY_LEN_CCMP); 636 priv->aes_key_v2.key_param_set.key_params.aes.key_len = 637 key_v2->key_param_set.key_params.aes.key_len; 638 len = priv->aes_key_v2.key_param_set.key_params.aes.key_len; 639 memcpy(priv->aes_key_v2.key_param_set.key_params.aes.key, 640 key_v2->key_param_set.key_params.aes.key, le16_to_cpu(len)); 641 642 return 0; 643 } 644 645 /* Wrapper function for processing response of key material command */ 646 static int mwifiex_ret_802_11_key_material(struct mwifiex_private *priv, 647 struct host_cmd_ds_command *resp) 648 { 649 if (priv->adapter->key_api_major_ver == KEY_API_VER_MAJOR_V2) 650 return mwifiex_ret_802_11_key_material_v2(priv, resp); 651 else 652 return mwifiex_ret_802_11_key_material_v1(priv, resp); 653 } 654 655 /* 656 * This function handles the command response of get 11d domain information. 657 */ 658 static int mwifiex_ret_802_11d_domain_info(struct mwifiex_private *priv, 659 struct host_cmd_ds_command *resp) 660 { 661 struct host_cmd_ds_802_11d_domain_info_rsp *domain_info = 662 &resp->params.domain_info_resp; 663 struct mwifiex_ietypes_domain_param_set *domain = &domain_info->domain; 664 u16 action = le16_to_cpu(domain_info->action); 665 u8 no_of_triplet; 666 667 no_of_triplet = (u8) ((le16_to_cpu(domain->header.len) 668 - IEEE80211_COUNTRY_STRING_LEN) 669 / sizeof(struct ieee80211_country_ie_triplet)); 670 671 mwifiex_dbg(priv->adapter, INFO, 672 "info: 11D Domain Info Resp: no_of_triplet=%d\n", 673 no_of_triplet); 674 675 if (no_of_triplet > MWIFIEX_MAX_TRIPLET_802_11D) { 676 mwifiex_dbg(priv->adapter, FATAL, 677 "11D: invalid number of triplets %d returned\n", 678 no_of_triplet); 679 return -1; 680 } 681 682 switch (action) { 683 case HostCmd_ACT_GEN_SET: /* Proc Set Action */ 684 break; 685 case HostCmd_ACT_GEN_GET: 686 break; 687 default: 688 mwifiex_dbg(priv->adapter, ERROR, 689 "11D: invalid action:%d\n", domain_info->action); 690 return -1; 691 } 692 693 return 0; 694 } 695 696 /* 697 * This function handles the command response of get extended version. 698 * 699 * Handling includes forming the extended version string and sending it 700 * to application. 701 */ 702 static int mwifiex_ret_ver_ext(struct mwifiex_private *priv, 703 struct host_cmd_ds_command *resp, 704 struct host_cmd_ds_version_ext *version_ext) 705 { 706 struct host_cmd_ds_version_ext *ver_ext = &resp->params.verext; 707 708 if (version_ext) { 709 version_ext->version_str_sel = ver_ext->version_str_sel; 710 memcpy(version_ext->version_str, ver_ext->version_str, 711 sizeof(char) * 128); 712 memcpy(priv->version_str, ver_ext->version_str, 128); 713 } 714 return 0; 715 } 716 717 /* 718 * This function handles the command response of remain on channel. 719 */ 720 static int 721 mwifiex_ret_remain_on_chan(struct mwifiex_private *priv, 722 struct host_cmd_ds_command *resp, 723 struct host_cmd_ds_remain_on_chan *roc_cfg) 724 { 725 struct host_cmd_ds_remain_on_chan *resp_cfg = &resp->params.roc_cfg; 726 727 if (roc_cfg) 728 memcpy(roc_cfg, resp_cfg, sizeof(*roc_cfg)); 729 730 return 0; 731 } 732 733 /* 734 * This function handles the command response of P2P mode cfg. 735 */ 736 static int 737 mwifiex_ret_p2p_mode_cfg(struct mwifiex_private *priv, 738 struct host_cmd_ds_command *resp, 739 void *data_buf) 740 { 741 struct host_cmd_ds_p2p_mode_cfg *mode_cfg = &resp->params.mode_cfg; 742 743 if (data_buf) 744 *((u16 *)data_buf) = le16_to_cpu(mode_cfg->mode); 745 746 return 0; 747 } 748 749 /* This function handles the command response of mem_access command 750 */ 751 static int 752 mwifiex_ret_mem_access(struct mwifiex_private *priv, 753 struct host_cmd_ds_command *resp, void *pioctl_buf) 754 { 755 struct host_cmd_ds_mem_access *mem = (void *)&resp->params.mem; 756 757 priv->mem_rw.addr = le32_to_cpu(mem->addr); 758 priv->mem_rw.value = le32_to_cpu(mem->value); 759 760 return 0; 761 } 762 /* 763 * This function handles the command response of register access. 764 * 765 * The register value and offset are returned to the user. For EEPROM 766 * access, the byte count is also returned. 767 */ 768 static int mwifiex_ret_reg_access(u16 type, struct host_cmd_ds_command *resp, 769 void *data_buf) 770 { 771 struct mwifiex_ds_reg_rw *reg_rw; 772 struct mwifiex_ds_read_eeprom *eeprom; 773 union reg { 774 struct host_cmd_ds_mac_reg_access *mac; 775 struct host_cmd_ds_bbp_reg_access *bbp; 776 struct host_cmd_ds_rf_reg_access *rf; 777 struct host_cmd_ds_pmic_reg_access *pmic; 778 struct host_cmd_ds_802_11_eeprom_access *eeprom; 779 } r; 780 781 if (!data_buf) 782 return 0; 783 784 reg_rw = data_buf; 785 eeprom = data_buf; 786 switch (type) { 787 case HostCmd_CMD_MAC_REG_ACCESS: 788 r.mac = &resp->params.mac_reg; 789 reg_rw->offset = (u32) le16_to_cpu(r.mac->offset); 790 reg_rw->value = le32_to_cpu(r.mac->value); 791 break; 792 case HostCmd_CMD_BBP_REG_ACCESS: 793 r.bbp = &resp->params.bbp_reg; 794 reg_rw->offset = (u32) le16_to_cpu(r.bbp->offset); 795 reg_rw->value = (u32) r.bbp->value; 796 break; 797 798 case HostCmd_CMD_RF_REG_ACCESS: 799 r.rf = &resp->params.rf_reg; 800 reg_rw->offset = (u32) le16_to_cpu(r.rf->offset); 801 reg_rw->value = (u32) r.bbp->value; 802 break; 803 case HostCmd_CMD_PMIC_REG_ACCESS: 804 r.pmic = &resp->params.pmic_reg; 805 reg_rw->offset = (u32) le16_to_cpu(r.pmic->offset); 806 reg_rw->value = (u32) r.pmic->value; 807 break; 808 case HostCmd_CMD_CAU_REG_ACCESS: 809 r.rf = &resp->params.rf_reg; 810 reg_rw->offset = (u32) le16_to_cpu(r.rf->offset); 811 reg_rw->value = (u32) r.rf->value; 812 break; 813 case HostCmd_CMD_802_11_EEPROM_ACCESS: 814 r.eeprom = &resp->params.eeprom; 815 pr_debug("info: EEPROM read len=%x\n", 816 le16_to_cpu(r.eeprom->byte_count)); 817 if (eeprom->byte_count < le16_to_cpu(r.eeprom->byte_count)) { 818 eeprom->byte_count = 0; 819 pr_debug("info: EEPROM read length is too big\n"); 820 return -1; 821 } 822 eeprom->offset = le16_to_cpu(r.eeprom->offset); 823 eeprom->byte_count = le16_to_cpu(r.eeprom->byte_count); 824 if (eeprom->byte_count > 0) 825 memcpy(&eeprom->value, &r.eeprom->value, 826 min((u16)MAX_EEPROM_DATA, eeprom->byte_count)); 827 break; 828 default: 829 return -1; 830 } 831 return 0; 832 } 833 834 /* 835 * This function handles the command response of get IBSS coalescing status. 836 * 837 * If the received BSSID is different than the current one, the current BSSID, 838 * beacon interval, ATIM window and ERP information are updated, along with 839 * changing the ad-hoc state accordingly. 840 */ 841 static int mwifiex_ret_ibss_coalescing_status(struct mwifiex_private *priv, 842 struct host_cmd_ds_command *resp) 843 { 844 struct host_cmd_ds_802_11_ibss_status *ibss_coal_resp = 845 &(resp->params.ibss_coalescing); 846 847 if (le16_to_cpu(ibss_coal_resp->action) == HostCmd_ACT_GEN_SET) 848 return 0; 849 850 mwifiex_dbg(priv->adapter, INFO, 851 "info: new BSSID %pM\n", ibss_coal_resp->bssid); 852 853 /* If rsp has NULL BSSID, Just return..... No Action */ 854 if (is_zero_ether_addr(ibss_coal_resp->bssid)) { 855 mwifiex_dbg(priv->adapter, FATAL, "new BSSID is NULL\n"); 856 return 0; 857 } 858 859 /* If BSSID is diff, modify current BSS parameters */ 860 if (!ether_addr_equal(priv->curr_bss_params.bss_descriptor.mac_address, ibss_coal_resp->bssid)) { 861 /* BSSID */ 862 memcpy(priv->curr_bss_params.bss_descriptor.mac_address, 863 ibss_coal_resp->bssid, ETH_ALEN); 864 865 /* Beacon Interval */ 866 priv->curr_bss_params.bss_descriptor.beacon_period 867 = le16_to_cpu(ibss_coal_resp->beacon_interval); 868 869 /* ERP Information */ 870 priv->curr_bss_params.bss_descriptor.erp_flags = 871 (u8) le16_to_cpu(ibss_coal_resp->use_g_rate_protect); 872 873 priv->adhoc_state = ADHOC_COALESCED; 874 } 875 876 return 0; 877 } 878 static int mwifiex_ret_tdls_oper(struct mwifiex_private *priv, 879 struct host_cmd_ds_command *resp) 880 { 881 struct host_cmd_ds_tdls_oper *cmd_tdls_oper = &resp->params.tdls_oper; 882 u16 reason = le16_to_cpu(cmd_tdls_oper->reason); 883 u16 action = le16_to_cpu(cmd_tdls_oper->tdls_action); 884 struct mwifiex_sta_node *node = 885 mwifiex_get_sta_entry(priv, cmd_tdls_oper->peer_mac); 886 887 switch (action) { 888 case ACT_TDLS_DELETE: 889 if (reason) { 890 if (!node || reason == TDLS_ERR_LINK_NONEXISTENT) 891 mwifiex_dbg(priv->adapter, MSG, 892 "TDLS link delete for %pM failed: reason %d\n", 893 cmd_tdls_oper->peer_mac, reason); 894 else 895 mwifiex_dbg(priv->adapter, ERROR, 896 "TDLS link delete for %pM failed: reason %d\n", 897 cmd_tdls_oper->peer_mac, reason); 898 } else { 899 mwifiex_dbg(priv->adapter, MSG, 900 "TDLS link delete for %pM successful\n", 901 cmd_tdls_oper->peer_mac); 902 } 903 break; 904 case ACT_TDLS_CREATE: 905 if (reason) { 906 mwifiex_dbg(priv->adapter, ERROR, 907 "TDLS link creation for %pM failed: reason %d", 908 cmd_tdls_oper->peer_mac, reason); 909 if (node && reason != TDLS_ERR_LINK_EXISTS) 910 node->tdls_status = TDLS_SETUP_FAILURE; 911 } else { 912 mwifiex_dbg(priv->adapter, MSG, 913 "TDLS link creation for %pM successful", 914 cmd_tdls_oper->peer_mac); 915 } 916 break; 917 case ACT_TDLS_CONFIG: 918 if (reason) { 919 mwifiex_dbg(priv->adapter, ERROR, 920 "TDLS link config for %pM failed, reason %d\n", 921 cmd_tdls_oper->peer_mac, reason); 922 if (node) 923 node->tdls_status = TDLS_SETUP_FAILURE; 924 } else { 925 mwifiex_dbg(priv->adapter, MSG, 926 "TDLS link config for %pM successful\n", 927 cmd_tdls_oper->peer_mac); 928 } 929 break; 930 default: 931 mwifiex_dbg(priv->adapter, ERROR, 932 "Unknown TDLS command action response %d", action); 933 return -1; 934 } 935 936 return 0; 937 } 938 /* 939 * This function handles the command response for subscribe event command. 940 */ 941 static int mwifiex_ret_subsc_evt(struct mwifiex_private *priv, 942 struct host_cmd_ds_command *resp) 943 { 944 struct host_cmd_ds_802_11_subsc_evt *cmd_sub_event = 945 &resp->params.subsc_evt; 946 947 /* For every subscribe event command (Get/Set/Clear), FW reports the 948 * current set of subscribed events*/ 949 mwifiex_dbg(priv->adapter, EVENT, 950 "Bitmap of currently subscribed events: %16x\n", 951 le16_to_cpu(cmd_sub_event->events)); 952 953 return 0; 954 } 955 956 static int mwifiex_ret_uap_sta_list(struct mwifiex_private *priv, 957 struct host_cmd_ds_command *resp) 958 { 959 struct host_cmd_ds_sta_list *sta_list = 960 &resp->params.sta_list; 961 struct mwifiex_ie_types_sta_info *sta_info = (void *)&sta_list->tlv; 962 int i; 963 struct mwifiex_sta_node *sta_node; 964 965 for (i = 0; i < (le16_to_cpu(sta_list->sta_count)); i++) { 966 sta_node = mwifiex_get_sta_entry(priv, sta_info->mac); 967 if (unlikely(!sta_node)) 968 continue; 969 970 sta_node->stats.rssi = sta_info->rssi; 971 sta_info++; 972 } 973 974 return 0; 975 } 976 977 /* This function handles the command response of set_cfg_data */ 978 static int mwifiex_ret_cfg_data(struct mwifiex_private *priv, 979 struct host_cmd_ds_command *resp) 980 { 981 if (resp->result != HostCmd_RESULT_OK) { 982 mwifiex_dbg(priv->adapter, ERROR, "Cal data cmd resp failed\n"); 983 return -1; 984 } 985 986 return 0; 987 } 988 989 /** This Function handles the command response of sdio rx aggr */ 990 static int mwifiex_ret_sdio_rx_aggr_cfg(struct mwifiex_private *priv, 991 struct host_cmd_ds_command *resp) 992 { 993 struct mwifiex_adapter *adapter = priv->adapter; 994 struct host_cmd_sdio_sp_rx_aggr_cfg *cfg = 995 &resp->params.sdio_rx_aggr_cfg; 996 997 adapter->sdio_rx_aggr_enable = cfg->enable; 998 adapter->sdio_rx_block_size = le16_to_cpu(cfg->block_size); 999 1000 return 0; 1001 } 1002 1003 static int mwifiex_ret_robust_coex(struct mwifiex_private *priv, 1004 struct host_cmd_ds_command *resp, 1005 bool *is_timeshare) 1006 { 1007 struct host_cmd_ds_robust_coex *coex = &resp->params.coex; 1008 struct mwifiex_ie_types_robust_coex *coex_tlv; 1009 u16 action = le16_to_cpu(coex->action); 1010 u32 mode; 1011 1012 coex_tlv = (struct mwifiex_ie_types_robust_coex 1013 *)((u8 *)coex + sizeof(struct host_cmd_ds_robust_coex)); 1014 if (action == HostCmd_ACT_GEN_GET) { 1015 mode = le32_to_cpu(coex_tlv->mode); 1016 if (mode == MWIFIEX_COEX_MODE_TIMESHARE) 1017 *is_timeshare = true; 1018 else 1019 *is_timeshare = false; 1020 } 1021 1022 return 0; 1023 } 1024 1025 static struct ieee80211_regdomain * 1026 mwifiex_create_custom_regdomain(struct mwifiex_private *priv, 1027 u8 *buf, u16 buf_len) 1028 { 1029 u16 num_chan = buf_len / 2; 1030 struct ieee80211_regdomain *regd; 1031 struct ieee80211_reg_rule *rule; 1032 bool new_rule; 1033 int regd_size, idx, freq, prev_freq = 0; 1034 u32 bw, prev_bw = 0; 1035 u8 chflags, prev_chflags = 0, valid_rules = 0; 1036 1037 if (WARN_ON_ONCE(num_chan > NL80211_MAX_SUPP_REG_RULES)) 1038 return ERR_PTR(-EINVAL); 1039 1040 regd_size = sizeof(struct ieee80211_regdomain) + 1041 num_chan * sizeof(struct ieee80211_reg_rule); 1042 1043 regd = kzalloc(regd_size, GFP_KERNEL); 1044 if (!regd) 1045 return ERR_PTR(-ENOMEM); 1046 1047 for (idx = 0; idx < num_chan; idx++) { 1048 u8 chan; 1049 enum nl80211_band band; 1050 1051 chan = *buf++; 1052 if (!chan) { 1053 kfree(regd); 1054 return NULL; 1055 } 1056 chflags = *buf++; 1057 band = (chan <= 14) ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ; 1058 freq = ieee80211_channel_to_frequency(chan, band); 1059 new_rule = false; 1060 1061 if (chflags & MWIFIEX_CHANNEL_DISABLED) 1062 continue; 1063 1064 if (band == NL80211_BAND_5GHZ) { 1065 if (!(chflags & MWIFIEX_CHANNEL_NOHT80)) 1066 bw = MHZ_TO_KHZ(80); 1067 else if (!(chflags & MWIFIEX_CHANNEL_NOHT40)) 1068 bw = MHZ_TO_KHZ(40); 1069 else 1070 bw = MHZ_TO_KHZ(20); 1071 } else { 1072 if (!(chflags & MWIFIEX_CHANNEL_NOHT40)) 1073 bw = MHZ_TO_KHZ(40); 1074 else 1075 bw = MHZ_TO_KHZ(20); 1076 } 1077 1078 if (idx == 0 || prev_chflags != chflags || prev_bw != bw || 1079 freq - prev_freq > 20) { 1080 valid_rules++; 1081 new_rule = true; 1082 } 1083 1084 rule = ®d->reg_rules[valid_rules - 1]; 1085 1086 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(freq + 10); 1087 1088 prev_chflags = chflags; 1089 prev_freq = freq; 1090 prev_bw = bw; 1091 1092 if (!new_rule) 1093 continue; 1094 1095 rule->freq_range.start_freq_khz = MHZ_TO_KHZ(freq - 10); 1096 rule->power_rule.max_eirp = DBM_TO_MBM(19); 1097 1098 if (chflags & MWIFIEX_CHANNEL_PASSIVE) 1099 rule->flags = NL80211_RRF_NO_IR; 1100 1101 if (chflags & MWIFIEX_CHANNEL_DFS) 1102 rule->flags = NL80211_RRF_DFS; 1103 1104 rule->freq_range.max_bandwidth_khz = bw; 1105 } 1106 1107 regd->n_reg_rules = valid_rules; 1108 regd->alpha2[0] = '9'; 1109 regd->alpha2[1] = '9'; 1110 1111 return regd; 1112 } 1113 1114 static int mwifiex_ret_chan_region_cfg(struct mwifiex_private *priv, 1115 struct host_cmd_ds_command *resp) 1116 { 1117 struct host_cmd_ds_chan_region_cfg *reg = &resp->params.reg_cfg; 1118 u16 action = le16_to_cpu(reg->action); 1119 u16 tlv, tlv_buf_len, tlv_buf_left; 1120 struct mwifiex_ie_types_header *head; 1121 struct ieee80211_regdomain *regd; 1122 u8 *tlv_buf; 1123 1124 if (action != HostCmd_ACT_GEN_GET) 1125 return 0; 1126 1127 tlv_buf = (u8 *)reg + sizeof(*reg); 1128 tlv_buf_left = le16_to_cpu(resp->size) - S_DS_GEN - sizeof(*reg); 1129 1130 while (tlv_buf_left >= sizeof(*head)) { 1131 head = (struct mwifiex_ie_types_header *)tlv_buf; 1132 tlv = le16_to_cpu(head->type); 1133 tlv_buf_len = le16_to_cpu(head->len); 1134 1135 if (tlv_buf_left < (sizeof(*head) + tlv_buf_len)) 1136 break; 1137 1138 switch (tlv) { 1139 case TLV_TYPE_CHAN_ATTR_CFG: 1140 mwifiex_dbg_dump(priv->adapter, CMD_D, "CHAN:", 1141 (u8 *)head + sizeof(*head), 1142 tlv_buf_len); 1143 regd = mwifiex_create_custom_regdomain(priv, 1144 (u8 *)head + sizeof(*head), tlv_buf_len); 1145 if (!IS_ERR(regd)) 1146 priv->adapter->regd = regd; 1147 break; 1148 } 1149 1150 tlv_buf += (sizeof(*head) + tlv_buf_len); 1151 tlv_buf_left -= (sizeof(*head) + tlv_buf_len); 1152 } 1153 1154 return 0; 1155 } 1156 1157 /* 1158 * This function handles the command responses. 1159 * 1160 * This is a generic function, which calls command specific 1161 * response handlers based on the command ID. 1162 */ 1163 int mwifiex_process_sta_cmdresp(struct mwifiex_private *priv, u16 cmdresp_no, 1164 struct host_cmd_ds_command *resp) 1165 { 1166 int ret = 0; 1167 struct mwifiex_adapter *adapter = priv->adapter; 1168 void *data_buf = adapter->curr_cmd->data_buf; 1169 1170 /* If the command is not successful, cleanup and return failure */ 1171 if (resp->result != HostCmd_RESULT_OK) { 1172 mwifiex_process_cmdresp_error(priv, resp); 1173 return -1; 1174 } 1175 /* Command successful, handle response */ 1176 switch (cmdresp_no) { 1177 case HostCmd_CMD_GET_HW_SPEC: 1178 ret = mwifiex_ret_get_hw_spec(priv, resp); 1179 break; 1180 case HostCmd_CMD_CFG_DATA: 1181 ret = mwifiex_ret_cfg_data(priv, resp); 1182 break; 1183 case HostCmd_CMD_MAC_CONTROL: 1184 break; 1185 case HostCmd_CMD_802_11_MAC_ADDRESS: 1186 ret = mwifiex_ret_802_11_mac_address(priv, resp); 1187 break; 1188 case HostCmd_CMD_MAC_MULTICAST_ADR: 1189 ret = mwifiex_ret_mac_multicast_adr(priv, resp); 1190 break; 1191 case HostCmd_CMD_TX_RATE_CFG: 1192 ret = mwifiex_ret_tx_rate_cfg(priv, resp); 1193 break; 1194 case HostCmd_CMD_802_11_SCAN: 1195 ret = mwifiex_ret_802_11_scan(priv, resp); 1196 adapter->curr_cmd->wait_q_enabled = false; 1197 break; 1198 case HostCmd_CMD_802_11_SCAN_EXT: 1199 ret = mwifiex_ret_802_11_scan_ext(priv, resp); 1200 adapter->curr_cmd->wait_q_enabled = false; 1201 break; 1202 case HostCmd_CMD_802_11_BG_SCAN_QUERY: 1203 ret = mwifiex_ret_802_11_scan(priv, resp); 1204 cfg80211_sched_scan_results(priv->wdev.wiphy); 1205 mwifiex_dbg(adapter, CMD, 1206 "info: CMD_RESP: BG_SCAN result is ready!\n"); 1207 break; 1208 case HostCmd_CMD_802_11_BG_SCAN_CONFIG: 1209 break; 1210 case HostCmd_CMD_TXPWR_CFG: 1211 ret = mwifiex_ret_tx_power_cfg(priv, resp); 1212 break; 1213 case HostCmd_CMD_RF_TX_PWR: 1214 ret = mwifiex_ret_rf_tx_power(priv, resp); 1215 break; 1216 case HostCmd_CMD_RF_ANTENNA: 1217 ret = mwifiex_ret_rf_antenna(priv, resp); 1218 break; 1219 case HostCmd_CMD_802_11_PS_MODE_ENH: 1220 ret = mwifiex_ret_enh_power_mode(priv, resp, data_buf); 1221 break; 1222 case HostCmd_CMD_802_11_HS_CFG_ENH: 1223 ret = mwifiex_ret_802_11_hs_cfg(priv, resp); 1224 break; 1225 case HostCmd_CMD_802_11_ASSOCIATE: 1226 ret = mwifiex_ret_802_11_associate(priv, resp); 1227 break; 1228 case HostCmd_CMD_802_11_DEAUTHENTICATE: 1229 ret = mwifiex_ret_802_11_deauthenticate(priv, resp); 1230 break; 1231 case HostCmd_CMD_802_11_AD_HOC_START: 1232 case HostCmd_CMD_802_11_AD_HOC_JOIN: 1233 ret = mwifiex_ret_802_11_ad_hoc(priv, resp); 1234 break; 1235 case HostCmd_CMD_802_11_AD_HOC_STOP: 1236 ret = mwifiex_ret_802_11_ad_hoc_stop(priv, resp); 1237 break; 1238 case HostCmd_CMD_802_11_GET_LOG: 1239 ret = mwifiex_ret_get_log(priv, resp, data_buf); 1240 break; 1241 case HostCmd_CMD_RSSI_INFO: 1242 ret = mwifiex_ret_802_11_rssi_info(priv, resp); 1243 break; 1244 case HostCmd_CMD_802_11_SNMP_MIB: 1245 ret = mwifiex_ret_802_11_snmp_mib(priv, resp, data_buf); 1246 break; 1247 case HostCmd_CMD_802_11_TX_RATE_QUERY: 1248 ret = mwifiex_ret_802_11_tx_rate_query(priv, resp); 1249 break; 1250 case HostCmd_CMD_VERSION_EXT: 1251 ret = mwifiex_ret_ver_ext(priv, resp, data_buf); 1252 break; 1253 case HostCmd_CMD_REMAIN_ON_CHAN: 1254 ret = mwifiex_ret_remain_on_chan(priv, resp, data_buf); 1255 break; 1256 case HostCmd_CMD_11AC_CFG: 1257 break; 1258 case HostCmd_CMD_P2P_MODE_CFG: 1259 ret = mwifiex_ret_p2p_mode_cfg(priv, resp, data_buf); 1260 break; 1261 case HostCmd_CMD_MGMT_FRAME_REG: 1262 case HostCmd_CMD_FUNC_INIT: 1263 case HostCmd_CMD_FUNC_SHUTDOWN: 1264 break; 1265 case HostCmd_CMD_802_11_KEY_MATERIAL: 1266 ret = mwifiex_ret_802_11_key_material(priv, resp); 1267 break; 1268 case HostCmd_CMD_802_11D_DOMAIN_INFO: 1269 ret = mwifiex_ret_802_11d_domain_info(priv, resp); 1270 break; 1271 case HostCmd_CMD_11N_ADDBA_REQ: 1272 ret = mwifiex_ret_11n_addba_req(priv, resp); 1273 break; 1274 case HostCmd_CMD_11N_DELBA: 1275 ret = mwifiex_ret_11n_delba(priv, resp); 1276 break; 1277 case HostCmd_CMD_11N_ADDBA_RSP: 1278 ret = mwifiex_ret_11n_addba_resp(priv, resp); 1279 break; 1280 case HostCmd_CMD_RECONFIGURE_TX_BUFF: 1281 if (0xffff == (u16)le16_to_cpu(resp->params.tx_buf.buff_size)) { 1282 if (adapter->iface_type == MWIFIEX_USB && 1283 adapter->usb_mc_setup) { 1284 if (adapter->if_ops.multi_port_resync) 1285 adapter->if_ops. 1286 multi_port_resync(adapter); 1287 adapter->usb_mc_setup = false; 1288 adapter->tx_lock_flag = false; 1289 } 1290 break; 1291 } 1292 adapter->tx_buf_size = (u16) le16_to_cpu(resp->params. 1293 tx_buf.buff_size); 1294 adapter->tx_buf_size = (adapter->tx_buf_size 1295 / MWIFIEX_SDIO_BLOCK_SIZE) 1296 * MWIFIEX_SDIO_BLOCK_SIZE; 1297 adapter->curr_tx_buf_size = adapter->tx_buf_size; 1298 mwifiex_dbg(adapter, CMD, "cmd: curr_tx_buf_size=%d\n", 1299 adapter->curr_tx_buf_size); 1300 1301 if (adapter->if_ops.update_mp_end_port) 1302 adapter->if_ops.update_mp_end_port(adapter, 1303 le16_to_cpu(resp->params.tx_buf.mp_end_port)); 1304 break; 1305 case HostCmd_CMD_AMSDU_AGGR_CTRL: 1306 break; 1307 case HostCmd_CMD_WMM_GET_STATUS: 1308 ret = mwifiex_ret_wmm_get_status(priv, resp); 1309 break; 1310 case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS: 1311 ret = mwifiex_ret_ibss_coalescing_status(priv, resp); 1312 break; 1313 case HostCmd_CMD_MEM_ACCESS: 1314 ret = mwifiex_ret_mem_access(priv, resp, data_buf); 1315 break; 1316 case HostCmd_CMD_MAC_REG_ACCESS: 1317 case HostCmd_CMD_BBP_REG_ACCESS: 1318 case HostCmd_CMD_RF_REG_ACCESS: 1319 case HostCmd_CMD_PMIC_REG_ACCESS: 1320 case HostCmd_CMD_CAU_REG_ACCESS: 1321 case HostCmd_CMD_802_11_EEPROM_ACCESS: 1322 ret = mwifiex_ret_reg_access(cmdresp_no, resp, data_buf); 1323 break; 1324 case HostCmd_CMD_SET_BSS_MODE: 1325 break; 1326 case HostCmd_CMD_11N_CFG: 1327 break; 1328 case HostCmd_CMD_PCIE_DESC_DETAILS: 1329 break; 1330 case HostCmd_CMD_802_11_SUBSCRIBE_EVENT: 1331 ret = mwifiex_ret_subsc_evt(priv, resp); 1332 break; 1333 case HostCmd_CMD_UAP_SYS_CONFIG: 1334 break; 1335 case HOST_CMD_APCMD_STA_LIST: 1336 ret = mwifiex_ret_uap_sta_list(priv, resp); 1337 break; 1338 case HostCmd_CMD_UAP_BSS_START: 1339 adapter->tx_lock_flag = false; 1340 adapter->pps_uapsd_mode = false; 1341 adapter->delay_null_pkt = false; 1342 priv->bss_started = 1; 1343 break; 1344 case HostCmd_CMD_UAP_BSS_STOP: 1345 priv->bss_started = 0; 1346 break; 1347 case HostCmd_CMD_UAP_STA_DEAUTH: 1348 break; 1349 case HOST_CMD_APCMD_SYS_RESET: 1350 break; 1351 case HostCmd_CMD_MEF_CFG: 1352 break; 1353 case HostCmd_CMD_COALESCE_CFG: 1354 break; 1355 case HostCmd_CMD_TDLS_OPER: 1356 ret = mwifiex_ret_tdls_oper(priv, resp); 1357 case HostCmd_CMD_MC_POLICY: 1358 break; 1359 case HostCmd_CMD_CHAN_REPORT_REQUEST: 1360 break; 1361 case HostCmd_CMD_SDIO_SP_RX_AGGR_CFG: 1362 ret = mwifiex_ret_sdio_rx_aggr_cfg(priv, resp); 1363 break; 1364 case HostCmd_CMD_HS_WAKEUP_REASON: 1365 ret = mwifiex_ret_wakeup_reason(priv, resp, data_buf); 1366 break; 1367 case HostCmd_CMD_TDLS_CONFIG: 1368 break; 1369 case HostCmd_CMD_ROBUST_COEX: 1370 ret = mwifiex_ret_robust_coex(priv, resp, data_buf); 1371 break; 1372 case HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG: 1373 break; 1374 case HostCmd_CMD_CHAN_REGION_CFG: 1375 ret = mwifiex_ret_chan_region_cfg(priv, resp); 1376 break; 1377 default: 1378 mwifiex_dbg(adapter, ERROR, 1379 "CMD_RESP: unknown cmd response %#x\n", 1380 resp->command); 1381 break; 1382 } 1383 1384 return ret; 1385 } 1386