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