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