1 /** 2 * Copyright (c) 2014 Redpine Signals Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #include <linux/etherdevice.h> 18 #include "rsi_debugfs.h" 19 #include "rsi_mgmt.h" 20 #include "rsi_sdio.h" 21 #include "rsi_common.h" 22 #include "rsi_ps.h" 23 24 static const struct ieee80211_channel rsi_2ghz_channels[] = { 25 { .band = NL80211_BAND_2GHZ, .center_freq = 2412, 26 .hw_value = 1 }, /* Channel 1 */ 27 { .band = NL80211_BAND_2GHZ, .center_freq = 2417, 28 .hw_value = 2 }, /* Channel 2 */ 29 { .band = NL80211_BAND_2GHZ, .center_freq = 2422, 30 .hw_value = 3 }, /* Channel 3 */ 31 { .band = NL80211_BAND_2GHZ, .center_freq = 2427, 32 .hw_value = 4 }, /* Channel 4 */ 33 { .band = NL80211_BAND_2GHZ, .center_freq = 2432, 34 .hw_value = 5 }, /* Channel 5 */ 35 { .band = NL80211_BAND_2GHZ, .center_freq = 2437, 36 .hw_value = 6 }, /* Channel 6 */ 37 { .band = NL80211_BAND_2GHZ, .center_freq = 2442, 38 .hw_value = 7 }, /* Channel 7 */ 39 { .band = NL80211_BAND_2GHZ, .center_freq = 2447, 40 .hw_value = 8 }, /* Channel 8 */ 41 { .band = NL80211_BAND_2GHZ, .center_freq = 2452, 42 .hw_value = 9 }, /* Channel 9 */ 43 { .band = NL80211_BAND_2GHZ, .center_freq = 2457, 44 .hw_value = 10 }, /* Channel 10 */ 45 { .band = NL80211_BAND_2GHZ, .center_freq = 2462, 46 .hw_value = 11 }, /* Channel 11 */ 47 { .band = NL80211_BAND_2GHZ, .center_freq = 2467, 48 .hw_value = 12 }, /* Channel 12 */ 49 { .band = NL80211_BAND_2GHZ, .center_freq = 2472, 50 .hw_value = 13 }, /* Channel 13 */ 51 { .band = NL80211_BAND_2GHZ, .center_freq = 2484, 52 .hw_value = 14 }, /* Channel 14 */ 53 }; 54 55 static const struct ieee80211_channel rsi_5ghz_channels[] = { 56 { .band = NL80211_BAND_5GHZ, .center_freq = 5180, 57 .hw_value = 36, }, /* Channel 36 */ 58 { .band = NL80211_BAND_5GHZ, .center_freq = 5200, 59 .hw_value = 40, }, /* Channel 40 */ 60 { .band = NL80211_BAND_5GHZ, .center_freq = 5220, 61 .hw_value = 44, }, /* Channel 44 */ 62 { .band = NL80211_BAND_5GHZ, .center_freq = 5240, 63 .hw_value = 48, }, /* Channel 48 */ 64 { .band = NL80211_BAND_5GHZ, .center_freq = 5260, 65 .hw_value = 52, }, /* Channel 52 */ 66 { .band = NL80211_BAND_5GHZ, .center_freq = 5280, 67 .hw_value = 56, }, /* Channel 56 */ 68 { .band = NL80211_BAND_5GHZ, .center_freq = 5300, 69 .hw_value = 60, }, /* Channel 60 */ 70 { .band = NL80211_BAND_5GHZ, .center_freq = 5320, 71 .hw_value = 64, }, /* Channel 64 */ 72 { .band = NL80211_BAND_5GHZ, .center_freq = 5500, 73 .hw_value = 100, }, /* Channel 100 */ 74 { .band = NL80211_BAND_5GHZ, .center_freq = 5520, 75 .hw_value = 104, }, /* Channel 104 */ 76 { .band = NL80211_BAND_5GHZ, .center_freq = 5540, 77 .hw_value = 108, }, /* Channel 108 */ 78 { .band = NL80211_BAND_5GHZ, .center_freq = 5560, 79 .hw_value = 112, }, /* Channel 112 */ 80 { .band = NL80211_BAND_5GHZ, .center_freq = 5580, 81 .hw_value = 116, }, /* Channel 116 */ 82 { .band = NL80211_BAND_5GHZ, .center_freq = 5600, 83 .hw_value = 120, }, /* Channel 120 */ 84 { .band = NL80211_BAND_5GHZ, .center_freq = 5620, 85 .hw_value = 124, }, /* Channel 124 */ 86 { .band = NL80211_BAND_5GHZ, .center_freq = 5640, 87 .hw_value = 128, }, /* Channel 128 */ 88 { .band = NL80211_BAND_5GHZ, .center_freq = 5660, 89 .hw_value = 132, }, /* Channel 132 */ 90 { .band = NL80211_BAND_5GHZ, .center_freq = 5680, 91 .hw_value = 136, }, /* Channel 136 */ 92 { .band = NL80211_BAND_5GHZ, .center_freq = 5700, 93 .hw_value = 140, }, /* Channel 140 */ 94 { .band = NL80211_BAND_5GHZ, .center_freq = 5745, 95 .hw_value = 149, }, /* Channel 149 */ 96 { .band = NL80211_BAND_5GHZ, .center_freq = 5765, 97 .hw_value = 153, }, /* Channel 153 */ 98 { .band = NL80211_BAND_5GHZ, .center_freq = 5785, 99 .hw_value = 157, }, /* Channel 157 */ 100 { .band = NL80211_BAND_5GHZ, .center_freq = 5805, 101 .hw_value = 161, }, /* Channel 161 */ 102 { .band = NL80211_BAND_5GHZ, .center_freq = 5825, 103 .hw_value = 165, }, /* Channel 165 */ 104 }; 105 106 struct ieee80211_rate rsi_rates[12] = { 107 { .bitrate = STD_RATE_01 * 5, .hw_value = RSI_RATE_1 }, 108 { .bitrate = STD_RATE_02 * 5, .hw_value = RSI_RATE_2 }, 109 { .bitrate = STD_RATE_5_5 * 5, .hw_value = RSI_RATE_5_5 }, 110 { .bitrate = STD_RATE_11 * 5, .hw_value = RSI_RATE_11 }, 111 { .bitrate = STD_RATE_06 * 5, .hw_value = RSI_RATE_6 }, 112 { .bitrate = STD_RATE_09 * 5, .hw_value = RSI_RATE_9 }, 113 { .bitrate = STD_RATE_12 * 5, .hw_value = RSI_RATE_12 }, 114 { .bitrate = STD_RATE_18 * 5, .hw_value = RSI_RATE_18 }, 115 { .bitrate = STD_RATE_24 * 5, .hw_value = RSI_RATE_24 }, 116 { .bitrate = STD_RATE_36 * 5, .hw_value = RSI_RATE_36 }, 117 { .bitrate = STD_RATE_48 * 5, .hw_value = RSI_RATE_48 }, 118 { .bitrate = STD_RATE_54 * 5, .hw_value = RSI_RATE_54 }, 119 }; 120 121 const u16 rsi_mcsrates[8] = { 122 RSI_RATE_MCS0, RSI_RATE_MCS1, RSI_RATE_MCS2, RSI_RATE_MCS3, 123 RSI_RATE_MCS4, RSI_RATE_MCS5, RSI_RATE_MCS6, RSI_RATE_MCS7 124 }; 125 126 static const u32 rsi_max_ap_stas[16] = { 127 32, /* 1 - Wi-Fi alone */ 128 0, /* 2 */ 129 0, /* 3 */ 130 0, /* 4 - BT EDR alone */ 131 4, /* 5 - STA + BT EDR */ 132 32, /* 6 - AP + BT EDR */ 133 0, /* 7 */ 134 0, /* 8 - BT LE alone */ 135 4, /* 9 - STA + BE LE */ 136 0, /* 10 */ 137 0, /* 11 */ 138 0, /* 12 */ 139 1, /* 13 - STA + BT Dual */ 140 4, /* 14 - AP + BT Dual */ 141 }; 142 143 static const struct ieee80211_iface_limit rsi_iface_limits[] = { 144 { 145 .max = 1, 146 .types = BIT(NL80211_IFTYPE_STATION), 147 }, 148 { 149 .max = 1, 150 .types = BIT(NL80211_IFTYPE_AP) | 151 BIT(NL80211_IFTYPE_P2P_CLIENT) | 152 BIT(NL80211_IFTYPE_P2P_GO), 153 }, 154 { 155 .max = 1, 156 .types = BIT(NL80211_IFTYPE_P2P_DEVICE), 157 }, 158 }; 159 160 static const struct ieee80211_iface_combination rsi_iface_combinations[] = { 161 { 162 .num_different_channels = 1, 163 .max_interfaces = 3, 164 .limits = rsi_iface_limits, 165 .n_limits = ARRAY_SIZE(rsi_iface_limits), 166 }, 167 }; 168 169 /** 170 * rsi_is_cipher_wep() - This function determines if the cipher is WEP or not. 171 * @common: Pointer to the driver private structure. 172 * 173 * Return: If cipher type is WEP, a value of 1 is returned, else 0. 174 */ 175 176 bool rsi_is_cipher_wep(struct rsi_common *common) 177 { 178 if (((common->secinfo.gtk_cipher == WLAN_CIPHER_SUITE_WEP104) || 179 (common->secinfo.gtk_cipher == WLAN_CIPHER_SUITE_WEP40)) && 180 (!common->secinfo.ptk_cipher)) 181 return true; 182 else 183 return false; 184 } 185 186 /** 187 * rsi_register_rates_channels() - This function registers channels and rates. 188 * @adapter: Pointer to the adapter structure. 189 * @band: Operating band to be set. 190 * 191 * Return: None. 192 */ 193 static void rsi_register_rates_channels(struct rsi_hw *adapter, int band) 194 { 195 struct ieee80211_supported_band *sbands = &adapter->sbands[band]; 196 void *channels = NULL; 197 198 if (band == NL80211_BAND_2GHZ) { 199 channels = kmalloc(sizeof(rsi_2ghz_channels), GFP_KERNEL); 200 memcpy(channels, 201 rsi_2ghz_channels, 202 sizeof(rsi_2ghz_channels)); 203 sbands->band = NL80211_BAND_2GHZ; 204 sbands->n_channels = ARRAY_SIZE(rsi_2ghz_channels); 205 sbands->bitrates = rsi_rates; 206 sbands->n_bitrates = ARRAY_SIZE(rsi_rates); 207 } else { 208 channels = kmalloc(sizeof(rsi_5ghz_channels), GFP_KERNEL); 209 memcpy(channels, 210 rsi_5ghz_channels, 211 sizeof(rsi_5ghz_channels)); 212 sbands->band = NL80211_BAND_5GHZ; 213 sbands->n_channels = ARRAY_SIZE(rsi_5ghz_channels); 214 sbands->bitrates = &rsi_rates[4]; 215 sbands->n_bitrates = ARRAY_SIZE(rsi_rates) - 4; 216 } 217 218 sbands->channels = channels; 219 220 memset(&sbands->ht_cap, 0, sizeof(struct ieee80211_sta_ht_cap)); 221 sbands->ht_cap.ht_supported = true; 222 sbands->ht_cap.cap = (IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 223 IEEE80211_HT_CAP_SGI_20 | 224 IEEE80211_HT_CAP_SGI_40); 225 sbands->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K; 226 sbands->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 227 sbands->ht_cap.mcs.rx_mask[0] = 0xff; 228 sbands->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 229 /* sbands->ht_cap.mcs.rx_highest = 0x82; */ 230 } 231 232 /** 233 * rsi_mac80211_detach() - This function is used to de-initialize the 234 * Mac80211 stack. 235 * @adapter: Pointer to the adapter structure. 236 * 237 * Return: None. 238 */ 239 void rsi_mac80211_detach(struct rsi_hw *adapter) 240 { 241 struct ieee80211_hw *hw = adapter->hw; 242 enum nl80211_band band; 243 244 if (hw) { 245 ieee80211_stop_queues(hw); 246 ieee80211_unregister_hw(hw); 247 ieee80211_free_hw(hw); 248 adapter->hw = NULL; 249 } 250 251 for (band = 0; band < NUM_NL80211_BANDS; band++) { 252 struct ieee80211_supported_band *sband = 253 &adapter->sbands[band]; 254 255 kfree(sband->channels); 256 } 257 258 #ifdef CONFIG_RSI_DEBUGFS 259 rsi_remove_dbgfs(adapter); 260 kfree(adapter->dfsentry); 261 #endif 262 } 263 EXPORT_SYMBOL_GPL(rsi_mac80211_detach); 264 265 /** 266 * rsi_indicate_tx_status() - This function indicates the transmit status. 267 * @adapter: Pointer to the adapter structure. 268 * @skb: Pointer to the socket buffer structure. 269 * @status: Status 270 * 271 * Return: None. 272 */ 273 void rsi_indicate_tx_status(struct rsi_hw *adapter, 274 struct sk_buff *skb, 275 int status) 276 { 277 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 278 struct skb_info *tx_params; 279 280 if (!adapter->hw) { 281 rsi_dbg(ERR_ZONE, "##### No MAC #####\n"); 282 return; 283 } 284 285 if (!status) 286 info->flags |= IEEE80211_TX_STAT_ACK; 287 288 tx_params = (struct skb_info *)info->driver_data; 289 skb_pull(skb, tx_params->internal_hdr_size); 290 memset(info->driver_data, 0, IEEE80211_TX_INFO_DRIVER_DATA_SIZE); 291 292 ieee80211_tx_status_irqsafe(adapter->hw, skb); 293 } 294 295 /** 296 * rsi_mac80211_tx() - This is the handler that 802.11 module calls for each 297 * transmitted frame.SKB contains the buffer starting 298 * from the IEEE 802.11 header. 299 * @hw: Pointer to the ieee80211_hw structure. 300 * @control: Pointer to the ieee80211_tx_control structure 301 * @skb: Pointer to the socket buffer structure. 302 * 303 * Return: None 304 */ 305 static void rsi_mac80211_tx(struct ieee80211_hw *hw, 306 struct ieee80211_tx_control *control, 307 struct sk_buff *skb) 308 { 309 struct rsi_hw *adapter = hw->priv; 310 struct rsi_common *common = adapter->priv; 311 312 rsi_core_xmit(common, skb); 313 } 314 315 /** 316 * rsi_mac80211_start() - This is first handler that 802.11 module calls, since 317 * the driver init is complete by then, just 318 * returns success. 319 * @hw: Pointer to the ieee80211_hw structure. 320 * 321 * Return: 0 as success. 322 */ 323 static int rsi_mac80211_start(struct ieee80211_hw *hw) 324 { 325 struct rsi_hw *adapter = hw->priv; 326 struct rsi_common *common = adapter->priv; 327 328 rsi_dbg(ERR_ZONE, "===> Interface UP <===\n"); 329 mutex_lock(&common->mutex); 330 if (common->hibernate_resume) { 331 common->reinit_hw = true; 332 adapter->host_intf_ops->reinit_device(adapter); 333 wait_for_completion(&adapter->priv->wlan_init_completion); 334 } 335 common->iface_down = false; 336 wiphy_rfkill_start_polling(hw->wiphy); 337 rsi_send_rx_filter_frame(common, 0); 338 mutex_unlock(&common->mutex); 339 340 return 0; 341 } 342 343 /** 344 * rsi_mac80211_stop() - This is the last handler that 802.11 module calls. 345 * @hw: Pointer to the ieee80211_hw structure. 346 * 347 * Return: None. 348 */ 349 static void rsi_mac80211_stop(struct ieee80211_hw *hw) 350 { 351 struct rsi_hw *adapter = hw->priv; 352 struct rsi_common *common = adapter->priv; 353 354 rsi_dbg(ERR_ZONE, "===> Interface DOWN <===\n"); 355 mutex_lock(&common->mutex); 356 common->iface_down = true; 357 wiphy_rfkill_stop_polling(hw->wiphy); 358 359 /* Block all rx frames */ 360 rsi_send_rx_filter_frame(common, 0xffff); 361 362 mutex_unlock(&common->mutex); 363 } 364 365 static int rsi_map_intf_mode(enum nl80211_iftype vif_type) 366 { 367 switch (vif_type) { 368 case NL80211_IFTYPE_STATION: 369 return RSI_OPMODE_STA; 370 case NL80211_IFTYPE_AP: 371 return RSI_OPMODE_AP; 372 case NL80211_IFTYPE_P2P_DEVICE: 373 return RSI_OPMODE_P2P_CLIENT; 374 case NL80211_IFTYPE_P2P_CLIENT: 375 return RSI_OPMODE_P2P_CLIENT; 376 case NL80211_IFTYPE_P2P_GO: 377 return RSI_OPMODE_P2P_GO; 378 default: 379 return RSI_OPMODE_UNSUPPORTED; 380 } 381 } 382 383 /** 384 * rsi_mac80211_add_interface() - This function is called when a netdevice 385 * attached to the hardware is enabled. 386 * @hw: Pointer to the ieee80211_hw structure. 387 * @vif: Pointer to the ieee80211_vif structure. 388 * 389 * Return: ret: 0 on success, negative error code on failure. 390 */ 391 static int rsi_mac80211_add_interface(struct ieee80211_hw *hw, 392 struct ieee80211_vif *vif) 393 { 394 struct rsi_hw *adapter = hw->priv; 395 struct rsi_common *common = adapter->priv; 396 struct vif_priv *vif_info = (struct vif_priv *)vif->drv_priv; 397 enum opmode intf_mode; 398 enum vap_status vap_status; 399 int vap_idx = -1, i; 400 401 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD; 402 mutex_lock(&common->mutex); 403 404 intf_mode = rsi_map_intf_mode(vif->type); 405 if (intf_mode == RSI_OPMODE_UNSUPPORTED) { 406 rsi_dbg(ERR_ZONE, 407 "%s: Interface type %d not supported\n", __func__, 408 vif->type); 409 mutex_unlock(&common->mutex); 410 return -EOPNOTSUPP; 411 } 412 if ((vif->type == NL80211_IFTYPE_P2P_DEVICE) || 413 (vif->type == NL80211_IFTYPE_P2P_CLIENT) || 414 (vif->type == NL80211_IFTYPE_P2P_GO)) 415 common->p2p_enabled = true; 416 417 /* Get free vap index */ 418 for (i = 0; i < RSI_MAX_VIFS; i++) { 419 if (!adapter->vifs[i]) { 420 vap_idx = i; 421 break; 422 } 423 } 424 if (vap_idx < 0) { 425 rsi_dbg(ERR_ZONE, "Reject: Max VAPs reached\n"); 426 mutex_unlock(&common->mutex); 427 return -EOPNOTSUPP; 428 } 429 vif_info->vap_id = vap_idx; 430 adapter->vifs[vap_idx] = vif; 431 adapter->sc_nvifs++; 432 vap_status = VAP_ADD; 433 434 if (rsi_set_vap_capabilities(common, intf_mode, vif->addr, 435 vif_info->vap_id, vap_status)) { 436 rsi_dbg(ERR_ZONE, "Failed to set VAP capabilities\n"); 437 mutex_unlock(&common->mutex); 438 return -EINVAL; 439 } 440 441 if ((vif->type == NL80211_IFTYPE_AP) || 442 (vif->type == NL80211_IFTYPE_P2P_GO)) { 443 rsi_send_rx_filter_frame(common, DISALLOW_BEACONS); 444 common->min_rate = RSI_RATE_AUTO; 445 for (i = 0; i < common->max_stations; i++) 446 common->stations[i].sta = NULL; 447 } 448 449 mutex_unlock(&common->mutex); 450 451 return 0; 452 } 453 454 /** 455 * rsi_mac80211_remove_interface() - This function notifies driver that an 456 * interface is going down. 457 * @hw: Pointer to the ieee80211_hw structure. 458 * @vif: Pointer to the ieee80211_vif structure. 459 * 460 * Return: None. 461 */ 462 static void rsi_mac80211_remove_interface(struct ieee80211_hw *hw, 463 struct ieee80211_vif *vif) 464 { 465 struct rsi_hw *adapter = hw->priv; 466 struct rsi_common *common = adapter->priv; 467 enum opmode opmode; 468 int i; 469 470 rsi_dbg(INFO_ZONE, "Remove Interface Called\n"); 471 472 mutex_lock(&common->mutex); 473 474 if (adapter->sc_nvifs <= 0) { 475 mutex_unlock(&common->mutex); 476 return; 477 } 478 479 opmode = rsi_map_intf_mode(vif->type); 480 if (opmode == RSI_OPMODE_UNSUPPORTED) { 481 rsi_dbg(ERR_ZONE, "Opmode error : %d\n", opmode); 482 mutex_unlock(&common->mutex); 483 return; 484 } 485 for (i = 0; i < RSI_MAX_VIFS; i++) { 486 if (!adapter->vifs[i]) 487 continue; 488 if (vif == adapter->vifs[i]) { 489 rsi_set_vap_capabilities(common, opmode, vif->addr, 490 i, VAP_DELETE); 491 adapter->sc_nvifs--; 492 adapter->vifs[i] = NULL; 493 } 494 } 495 mutex_unlock(&common->mutex); 496 } 497 498 /** 499 * rsi_channel_change() - This function is a performs the checks 500 * required for changing a channel and sets 501 * the channel accordingly. 502 * @hw: Pointer to the ieee80211_hw structure. 503 * 504 * Return: 0 on success, negative error code on failure. 505 */ 506 static int rsi_channel_change(struct ieee80211_hw *hw) 507 { 508 struct rsi_hw *adapter = hw->priv; 509 struct rsi_common *common = adapter->priv; 510 int status = -EOPNOTSUPP; 511 struct ieee80211_channel *curchan = hw->conf.chandef.chan; 512 u16 channel = curchan->hw_value; 513 struct ieee80211_vif *vif; 514 struct ieee80211_bss_conf *bss; 515 bool assoc = false; 516 int i; 517 518 rsi_dbg(INFO_ZONE, 519 "%s: Set channel: %d MHz type: %d channel_no %d\n", 520 __func__, curchan->center_freq, 521 curchan->flags, channel); 522 523 for (i = 0; i < RSI_MAX_VIFS; i++) { 524 vif = adapter->vifs[i]; 525 if (!vif) 526 continue; 527 if (vif->type == NL80211_IFTYPE_STATION) { 528 bss = &vif->bss_conf; 529 if (bss->assoc) { 530 assoc = true; 531 break; 532 } 533 } 534 } 535 if (assoc) { 536 if (!common->hw_data_qs_blocked && 537 (rsi_get_connected_channel(vif) != channel)) { 538 rsi_dbg(INFO_ZONE, "blk data q %d\n", channel); 539 if (!rsi_send_block_unblock_frame(common, true)) 540 common->hw_data_qs_blocked = true; 541 } 542 } 543 544 status = rsi_band_check(common, curchan); 545 if (!status) 546 status = rsi_set_channel(adapter->priv, curchan); 547 548 if (assoc) { 549 if (common->hw_data_qs_blocked && 550 (rsi_get_connected_channel(vif) == channel)) { 551 rsi_dbg(INFO_ZONE, "unblk data q %d\n", channel); 552 if (!rsi_send_block_unblock_frame(common, false)) 553 common->hw_data_qs_blocked = false; 554 } 555 } 556 557 return status; 558 } 559 560 /** 561 * rsi_config_power() - This function configures tx power to device 562 * @hw: Pointer to the ieee80211_hw structure. 563 * 564 * Return: 0 on success, negative error code on failure. 565 */ 566 static int rsi_config_power(struct ieee80211_hw *hw) 567 { 568 struct rsi_hw *adapter = hw->priv; 569 struct rsi_common *common = adapter->priv; 570 struct ieee80211_conf *conf = &hw->conf; 571 572 if (adapter->sc_nvifs <= 0) { 573 rsi_dbg(ERR_ZONE, "%s: No virtual interface found\n", __func__); 574 return -EINVAL; 575 } 576 577 rsi_dbg(INFO_ZONE, 578 "%s: Set tx power: %d dBM\n", __func__, conf->power_level); 579 580 if (conf->power_level == common->tx_power) 581 return 0; 582 583 common->tx_power = conf->power_level; 584 585 return rsi_send_radio_params_update(common); 586 } 587 588 /** 589 * rsi_mac80211_config() - This function is a handler for configuration 590 * requests. The stack calls this function to 591 * change hardware configuration, e.g., channel. 592 * @hw: Pointer to the ieee80211_hw structure. 593 * @changed: Changed flags set. 594 * 595 * Return: 0 on success, negative error code on failure. 596 */ 597 static int rsi_mac80211_config(struct ieee80211_hw *hw, 598 u32 changed) 599 { 600 struct rsi_hw *adapter = hw->priv; 601 struct rsi_common *common = adapter->priv; 602 struct ieee80211_conf *conf = &hw->conf; 603 int status = -EOPNOTSUPP; 604 605 mutex_lock(&common->mutex); 606 607 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) 608 status = rsi_channel_change(hw); 609 610 /* tx power */ 611 if (changed & IEEE80211_CONF_CHANGE_POWER) { 612 rsi_dbg(INFO_ZONE, "%s: Configuring Power\n", __func__); 613 status = rsi_config_power(hw); 614 } 615 616 /* Power save parameters */ 617 if (changed & IEEE80211_CONF_CHANGE_PS) { 618 struct ieee80211_vif *vif, *sta_vif = NULL; 619 unsigned long flags; 620 int i, set_ps = 1; 621 622 for (i = 0; i < RSI_MAX_VIFS; i++) { 623 vif = adapter->vifs[i]; 624 if (!vif) 625 continue; 626 /* Don't go to power save if AP vap exists */ 627 if ((vif->type == NL80211_IFTYPE_AP) || 628 (vif->type == NL80211_IFTYPE_P2P_GO)) { 629 set_ps = 0; 630 break; 631 } 632 if ((vif->type == NL80211_IFTYPE_STATION || 633 vif->type == NL80211_IFTYPE_P2P_CLIENT) && 634 (!sta_vif || vif->bss_conf.assoc)) 635 sta_vif = vif; 636 } 637 if (set_ps && sta_vif) { 638 spin_lock_irqsave(&adapter->ps_lock, flags); 639 if (conf->flags & IEEE80211_CONF_PS) 640 rsi_enable_ps(adapter, sta_vif); 641 else 642 rsi_disable_ps(adapter, sta_vif); 643 spin_unlock_irqrestore(&adapter->ps_lock, flags); 644 } 645 } 646 647 /* RTS threshold */ 648 if (changed & WIPHY_PARAM_RTS_THRESHOLD) { 649 rsi_dbg(INFO_ZONE, "RTS threshold\n"); 650 if ((common->rts_threshold) <= IEEE80211_MAX_RTS_THRESHOLD) { 651 rsi_dbg(INFO_ZONE, 652 "%s: Sending vap updates....\n", __func__); 653 status = rsi_send_vap_dynamic_update(common); 654 } 655 } 656 mutex_unlock(&common->mutex); 657 658 return status; 659 } 660 661 /** 662 * rsi_get_connected_channel() - This function is used to get the current 663 * connected channel number. 664 * @adapter: Pointer to the adapter structure. 665 * 666 * Return: Current connected AP's channel number is returned. 667 */ 668 u16 rsi_get_connected_channel(struct ieee80211_vif *vif) 669 { 670 struct ieee80211_bss_conf *bss; 671 struct ieee80211_channel *channel; 672 673 if (!vif) 674 return 0; 675 676 bss = &vif->bss_conf; 677 channel = bss->chandef.chan; 678 679 if (!channel) 680 return 0; 681 682 return channel->hw_value; 683 } 684 685 static void rsi_switch_channel(struct rsi_hw *adapter, 686 struct ieee80211_vif *vif) 687 { 688 struct rsi_common *common = adapter->priv; 689 struct ieee80211_channel *channel; 690 691 if (common->iface_down) 692 return; 693 if (!vif) 694 return; 695 696 channel = vif->bss_conf.chandef.chan; 697 698 if (!channel) 699 return; 700 701 rsi_band_check(common, channel); 702 rsi_set_channel(common, channel); 703 rsi_dbg(INFO_ZONE, "Switched to channel - %d\n", channel->hw_value); 704 } 705 706 /** 707 * rsi_mac80211_bss_info_changed() - This function is a handler for config 708 * requests related to BSS parameters that 709 * may vary during BSS's lifespan. 710 * @hw: Pointer to the ieee80211_hw structure. 711 * @vif: Pointer to the ieee80211_vif structure. 712 * @bss_conf: Pointer to the ieee80211_bss_conf structure. 713 * @changed: Changed flags set. 714 * 715 * Return: None. 716 */ 717 static void rsi_mac80211_bss_info_changed(struct ieee80211_hw *hw, 718 struct ieee80211_vif *vif, 719 struct ieee80211_bss_conf *bss_conf, 720 u32 changed) 721 { 722 struct rsi_hw *adapter = hw->priv; 723 struct rsi_common *common = adapter->priv; 724 struct ieee80211_bss_conf *bss = &vif->bss_conf; 725 struct ieee80211_conf *conf = &hw->conf; 726 u16 rx_filter_word = 0; 727 728 mutex_lock(&common->mutex); 729 if (changed & BSS_CHANGED_ASSOC) { 730 rsi_dbg(INFO_ZONE, "%s: Changed Association status: %d\n", 731 __func__, bss_conf->assoc); 732 if (bss_conf->assoc) { 733 /* Send the RX filter frame */ 734 rx_filter_word = (ALLOW_DATA_ASSOC_PEER | 735 ALLOW_CTRL_ASSOC_PEER | 736 ALLOW_MGMT_ASSOC_PEER); 737 rsi_send_rx_filter_frame(common, rx_filter_word); 738 } 739 rsi_inform_bss_status(common, 740 RSI_OPMODE_STA, 741 bss_conf->assoc, 742 bss_conf->bssid, 743 bss_conf->qos, 744 bss_conf->aid, 745 NULL, 0, 746 bss_conf->assoc_capability, vif); 747 adapter->ps_info.dtim_interval_duration = bss->dtim_period; 748 adapter->ps_info.listen_interval = conf->listen_interval; 749 750 /* If U-APSD is updated, send ps parameters to firmware */ 751 if (bss->assoc) { 752 if (common->uapsd_bitmap) { 753 rsi_dbg(INFO_ZONE, "Configuring UAPSD\n"); 754 rsi_conf_uapsd(adapter, vif); 755 } 756 } else { 757 common->uapsd_bitmap = 0; 758 } 759 } 760 761 if (changed & BSS_CHANGED_CQM) { 762 common->cqm_info.last_cqm_event_rssi = 0; 763 common->cqm_info.rssi_thold = bss_conf->cqm_rssi_thold; 764 common->cqm_info.rssi_hyst = bss_conf->cqm_rssi_hyst; 765 rsi_dbg(INFO_ZONE, "RSSI throld & hysteresis are: %d %d\n", 766 common->cqm_info.rssi_thold, 767 common->cqm_info.rssi_hyst); 768 } 769 770 if ((changed & BSS_CHANGED_BEACON_ENABLED) && 771 ((vif->type == NL80211_IFTYPE_AP) || 772 (vif->type == NL80211_IFTYPE_P2P_GO))) { 773 if (bss->enable_beacon) { 774 rsi_dbg(INFO_ZONE, "===> BEACON ENABLED <===\n"); 775 common->beacon_enabled = 1; 776 } else { 777 rsi_dbg(INFO_ZONE, "===> BEACON DISABLED <===\n"); 778 common->beacon_enabled = 0; 779 } 780 } 781 782 mutex_unlock(&common->mutex); 783 } 784 785 /** 786 * rsi_mac80211_conf_filter() - This function configure the device's RX filter. 787 * @hw: Pointer to the ieee80211_hw structure. 788 * @changed: Changed flags set. 789 * @total_flags: Total initial flags set. 790 * @multicast: Multicast. 791 * 792 * Return: None. 793 */ 794 static void rsi_mac80211_conf_filter(struct ieee80211_hw *hw, 795 u32 changed_flags, 796 u32 *total_flags, 797 u64 multicast) 798 { 799 /* Not doing much here as of now */ 800 *total_flags &= RSI_SUPP_FILTERS; 801 } 802 803 /** 804 * rsi_mac80211_conf_tx() - This function configures TX queue parameters 805 * (EDCF (aifs, cw_min, cw_max), bursting) 806 * for a hardware TX queue. 807 * @hw: Pointer to the ieee80211_hw structure 808 * @vif: Pointer to the ieee80211_vif structure. 809 * @queue: Queue number. 810 * @params: Pointer to ieee80211_tx_queue_params structure. 811 * 812 * Return: 0 on success, negative error code on failure. 813 */ 814 static int rsi_mac80211_conf_tx(struct ieee80211_hw *hw, 815 struct ieee80211_vif *vif, u16 queue, 816 const struct ieee80211_tx_queue_params *params) 817 { 818 struct rsi_hw *adapter = hw->priv; 819 struct rsi_common *common = adapter->priv; 820 u8 idx = 0; 821 822 if (queue >= IEEE80211_NUM_ACS) 823 return 0; 824 825 rsi_dbg(INFO_ZONE, 826 "%s: Conf queue %d, aifs: %d, cwmin: %d cwmax: %d, txop: %d\n", 827 __func__, queue, params->aifs, 828 params->cw_min, params->cw_max, params->txop); 829 830 mutex_lock(&common->mutex); 831 /* Map into the way the f/w expects */ 832 switch (queue) { 833 case IEEE80211_AC_VO: 834 idx = VO_Q; 835 break; 836 case IEEE80211_AC_VI: 837 idx = VI_Q; 838 break; 839 case IEEE80211_AC_BE: 840 idx = BE_Q; 841 break; 842 case IEEE80211_AC_BK: 843 idx = BK_Q; 844 break; 845 default: 846 idx = BE_Q; 847 break; 848 } 849 850 memcpy(&common->edca_params[idx], 851 params, 852 sizeof(struct ieee80211_tx_queue_params)); 853 854 if (params->uapsd) 855 common->uapsd_bitmap |= idx; 856 else 857 common->uapsd_bitmap &= (~idx); 858 859 mutex_unlock(&common->mutex); 860 861 return 0; 862 } 863 864 /** 865 * rsi_hal_key_config() - This function loads the keys into the firmware. 866 * @hw: Pointer to the ieee80211_hw structure. 867 * @vif: Pointer to the ieee80211_vif structure. 868 * @key: Pointer to the ieee80211_key_conf structure. 869 * 870 * Return: status: 0 on success, negative error codes on failure. 871 */ 872 static int rsi_hal_key_config(struct ieee80211_hw *hw, 873 struct ieee80211_vif *vif, 874 struct ieee80211_key_conf *key, 875 struct ieee80211_sta *sta) 876 { 877 struct rsi_hw *adapter = hw->priv; 878 struct rsi_sta *rsta = NULL; 879 int status; 880 u8 key_type; 881 s16 sta_id = 0; 882 883 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 884 key_type = RSI_PAIRWISE_KEY; 885 else 886 key_type = RSI_GROUP_KEY; 887 888 rsi_dbg(ERR_ZONE, "%s: Cipher 0x%x key_type: %d key_len: %d\n", 889 __func__, key->cipher, key_type, key->keylen); 890 891 if ((vif->type == NL80211_IFTYPE_AP) || 892 (vif->type == NL80211_IFTYPE_P2P_GO)) { 893 if (sta) { 894 rsta = rsi_find_sta(adapter->priv, sta->addr); 895 if (rsta) 896 sta_id = rsta->sta_id; 897 } 898 adapter->priv->key = key; 899 } else { 900 if ((key->cipher == WLAN_CIPHER_SUITE_WEP104) || 901 (key->cipher == WLAN_CIPHER_SUITE_WEP40)) { 902 status = rsi_hal_load_key(adapter->priv, 903 key->key, 904 key->keylen, 905 RSI_PAIRWISE_KEY, 906 key->keyidx, 907 key->cipher, 908 sta_id, 909 vif); 910 if (status) 911 return status; 912 } 913 } 914 915 status = rsi_hal_load_key(adapter->priv, 916 key->key, 917 key->keylen, 918 key_type, 919 key->keyidx, 920 key->cipher, 921 sta_id, 922 vif); 923 if (status) 924 return status; 925 926 if (vif->type == NL80211_IFTYPE_STATION && key->key && 927 (key->cipher == WLAN_CIPHER_SUITE_WEP104 || 928 key->cipher == WLAN_CIPHER_SUITE_WEP40)) { 929 if (!rsi_send_block_unblock_frame(adapter->priv, false)) 930 adapter->priv->hw_data_qs_blocked = false; 931 } 932 933 return 0; 934 } 935 936 /** 937 * rsi_mac80211_set_key() - This function sets type of key to be loaded. 938 * @hw: Pointer to the ieee80211_hw structure. 939 * @cmd: enum set_key_cmd. 940 * @vif: Pointer to the ieee80211_vif structure. 941 * @sta: Pointer to the ieee80211_sta structure. 942 * @key: Pointer to the ieee80211_key_conf structure. 943 * 944 * Return: status: 0 on success, negative error code on failure. 945 */ 946 static int rsi_mac80211_set_key(struct ieee80211_hw *hw, 947 enum set_key_cmd cmd, 948 struct ieee80211_vif *vif, 949 struct ieee80211_sta *sta, 950 struct ieee80211_key_conf *key) 951 { 952 struct rsi_hw *adapter = hw->priv; 953 struct rsi_common *common = adapter->priv; 954 struct security_info *secinfo = &common->secinfo; 955 int status; 956 957 mutex_lock(&common->mutex); 958 switch (cmd) { 959 case SET_KEY: 960 secinfo->security_enable = true; 961 status = rsi_hal_key_config(hw, vif, key, sta); 962 if (status) { 963 mutex_unlock(&common->mutex); 964 return status; 965 } 966 967 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 968 secinfo->ptk_cipher = key->cipher; 969 else 970 secinfo->gtk_cipher = key->cipher; 971 972 key->hw_key_idx = key->keyidx; 973 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 974 975 rsi_dbg(ERR_ZONE, "%s: RSI set_key\n", __func__); 976 break; 977 978 case DISABLE_KEY: 979 if (vif->type == NL80211_IFTYPE_STATION) 980 secinfo->security_enable = false; 981 rsi_dbg(ERR_ZONE, "%s: RSI del key\n", __func__); 982 memset(key, 0, sizeof(struct ieee80211_key_conf)); 983 status = rsi_hal_key_config(hw, vif, key, sta); 984 break; 985 986 default: 987 status = -EOPNOTSUPP; 988 break; 989 } 990 991 mutex_unlock(&common->mutex); 992 return status; 993 } 994 995 /** 996 * rsi_mac80211_ampdu_action() - This function selects the AMPDU action for 997 * the corresponding mlme_action flag and 998 * informs the f/w regarding this. 999 * @hw: Pointer to the ieee80211_hw structure. 1000 * @vif: Pointer to the ieee80211_vif structure. 1001 * @params: Pointer to A-MPDU action parameters 1002 * 1003 * Return: status: 0 on success, negative error code on failure. 1004 */ 1005 static int rsi_mac80211_ampdu_action(struct ieee80211_hw *hw, 1006 struct ieee80211_vif *vif, 1007 struct ieee80211_ampdu_params *params) 1008 { 1009 int status = -EOPNOTSUPP; 1010 struct rsi_hw *adapter = hw->priv; 1011 struct rsi_common *common = adapter->priv; 1012 struct rsi_sta *rsta = NULL; 1013 u16 seq_no = 0, seq_start = 0; 1014 u8 ii = 0; 1015 struct ieee80211_sta *sta = params->sta; 1016 u8 sta_id = 0; 1017 enum ieee80211_ampdu_mlme_action action = params->action; 1018 u16 tid = params->tid; 1019 u16 *ssn = ¶ms->ssn; 1020 u8 buf_size = params->buf_size; 1021 1022 for (ii = 0; ii < RSI_MAX_VIFS; ii++) { 1023 if (vif == adapter->vifs[ii]) 1024 break; 1025 } 1026 1027 mutex_lock(&common->mutex); 1028 1029 if (ssn != NULL) 1030 seq_no = *ssn; 1031 1032 if ((vif->type == NL80211_IFTYPE_AP) || 1033 (vif->type == NL80211_IFTYPE_P2P_GO)) { 1034 rsta = rsi_find_sta(common, sta->addr); 1035 if (!rsta) { 1036 rsi_dbg(ERR_ZONE, "No station mapped\n"); 1037 status = 0; 1038 goto unlock; 1039 } 1040 sta_id = rsta->sta_id; 1041 } 1042 1043 rsi_dbg(INFO_ZONE, 1044 "%s: AMPDU action tid=%d ssn=0x%x, buf_size=%d sta_id=%d\n", 1045 __func__, tid, seq_no, buf_size, sta_id); 1046 1047 switch (action) { 1048 case IEEE80211_AMPDU_RX_START: 1049 status = rsi_send_aggregation_params_frame(common, 1050 tid, 1051 seq_no, 1052 buf_size, 1053 STA_RX_ADDBA_DONE, 1054 sta_id); 1055 break; 1056 1057 case IEEE80211_AMPDU_RX_STOP: 1058 status = rsi_send_aggregation_params_frame(common, 1059 tid, 1060 0, 1061 buf_size, 1062 STA_RX_DELBA, 1063 sta_id); 1064 break; 1065 1066 case IEEE80211_AMPDU_TX_START: 1067 if ((vif->type == NL80211_IFTYPE_STATION) || 1068 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) 1069 common->vif_info[ii].seq_start = seq_no; 1070 else if ((vif->type == NL80211_IFTYPE_AP) || 1071 (vif->type == NL80211_IFTYPE_P2P_GO)) 1072 rsta->seq_start[tid] = seq_no; 1073 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1074 status = 0; 1075 break; 1076 1077 case IEEE80211_AMPDU_TX_STOP_CONT: 1078 case IEEE80211_AMPDU_TX_STOP_FLUSH: 1079 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 1080 status = rsi_send_aggregation_params_frame(common, 1081 tid, 1082 seq_no, 1083 buf_size, 1084 STA_TX_DELBA, 1085 sta_id); 1086 if (!status) 1087 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1088 break; 1089 1090 case IEEE80211_AMPDU_TX_OPERATIONAL: 1091 if ((vif->type == NL80211_IFTYPE_STATION) || 1092 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) 1093 seq_start = common->vif_info[ii].seq_start; 1094 else if ((vif->type == NL80211_IFTYPE_AP) || 1095 (vif->type == NL80211_IFTYPE_P2P_GO)) 1096 seq_start = rsta->seq_start[tid]; 1097 status = rsi_send_aggregation_params_frame(common, 1098 tid, 1099 seq_start, 1100 buf_size, 1101 STA_TX_ADDBA_DONE, 1102 sta_id); 1103 break; 1104 1105 default: 1106 rsi_dbg(ERR_ZONE, "%s: Unknown AMPDU action\n", __func__); 1107 break; 1108 } 1109 1110 unlock: 1111 mutex_unlock(&common->mutex); 1112 return status; 1113 } 1114 1115 /** 1116 * rsi_mac80211_set_rts_threshold() - This function sets rts threshold value. 1117 * @hw: Pointer to the ieee80211_hw structure. 1118 * @value: Rts threshold value. 1119 * 1120 * Return: 0 on success. 1121 */ 1122 static int rsi_mac80211_set_rts_threshold(struct ieee80211_hw *hw, 1123 u32 value) 1124 { 1125 struct rsi_hw *adapter = hw->priv; 1126 struct rsi_common *common = adapter->priv; 1127 1128 mutex_lock(&common->mutex); 1129 common->rts_threshold = value; 1130 mutex_unlock(&common->mutex); 1131 1132 return 0; 1133 } 1134 1135 /** 1136 * rsi_mac80211_set_rate_mask() - This function sets bitrate_mask to be used. 1137 * @hw: Pointer to the ieee80211_hw structure 1138 * @vif: Pointer to the ieee80211_vif structure. 1139 * @mask: Pointer to the cfg80211_bitrate_mask structure. 1140 * 1141 * Return: 0 on success. 1142 */ 1143 static int rsi_mac80211_set_rate_mask(struct ieee80211_hw *hw, 1144 struct ieee80211_vif *vif, 1145 const struct cfg80211_bitrate_mask *mask) 1146 { 1147 struct rsi_hw *adapter = hw->priv; 1148 struct rsi_common *common = adapter->priv; 1149 enum nl80211_band band = hw->conf.chandef.chan->band; 1150 1151 mutex_lock(&common->mutex); 1152 common->fixedrate_mask[band] = 0; 1153 1154 if (mask->control[band].legacy == 0xfff) { 1155 common->fixedrate_mask[band] = 1156 (mask->control[band].ht_mcs[0] << 12); 1157 } else { 1158 common->fixedrate_mask[band] = 1159 mask->control[band].legacy; 1160 } 1161 mutex_unlock(&common->mutex); 1162 1163 return 0; 1164 } 1165 1166 /** 1167 * rsi_perform_cqm() - This function performs cqm. 1168 * @common: Pointer to the driver private structure. 1169 * @bssid: pointer to the bssid. 1170 * @rssi: RSSI value. 1171 */ 1172 static void rsi_perform_cqm(struct rsi_common *common, 1173 u8 *bssid, 1174 s8 rssi, 1175 struct ieee80211_vif *vif) 1176 { 1177 s8 last_event = common->cqm_info.last_cqm_event_rssi; 1178 int thold = common->cqm_info.rssi_thold; 1179 u32 hyst = common->cqm_info.rssi_hyst; 1180 enum nl80211_cqm_rssi_threshold_event event; 1181 1182 if (rssi < thold && (last_event == 0 || rssi < (last_event - hyst))) 1183 event = NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW; 1184 else if (rssi > thold && 1185 (last_event == 0 || rssi > (last_event + hyst))) 1186 event = NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH; 1187 else 1188 return; 1189 1190 common->cqm_info.last_cqm_event_rssi = rssi; 1191 rsi_dbg(INFO_ZONE, "CQM: Notifying event: %d\n", event); 1192 ieee80211_cqm_rssi_notify(vif, event, rssi, GFP_KERNEL); 1193 1194 return; 1195 } 1196 1197 /** 1198 * rsi_fill_rx_status() - This function fills rx status in 1199 * ieee80211_rx_status structure. 1200 * @hw: Pointer to the ieee80211_hw structure. 1201 * @skb: Pointer to the socket buffer structure. 1202 * @common: Pointer to the driver private structure. 1203 * @rxs: Pointer to the ieee80211_rx_status structure. 1204 * 1205 * Return: None. 1206 */ 1207 static void rsi_fill_rx_status(struct ieee80211_hw *hw, 1208 struct sk_buff *skb, 1209 struct rsi_common *common, 1210 struct ieee80211_rx_status *rxs) 1211 { 1212 struct rsi_hw *adapter = common->priv; 1213 struct ieee80211_vif *vif; 1214 struct ieee80211_bss_conf *bss = NULL; 1215 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1216 struct skb_info *rx_params = (struct skb_info *)info->driver_data; 1217 struct ieee80211_hdr *hdr; 1218 char rssi = rx_params->rssi; 1219 u8 hdrlen = 0; 1220 u8 channel = rx_params->channel; 1221 s32 freq; 1222 int i; 1223 1224 hdr = ((struct ieee80211_hdr *)(skb->data)); 1225 hdrlen = ieee80211_hdrlen(hdr->frame_control); 1226 1227 memset(info, 0, sizeof(struct ieee80211_tx_info)); 1228 1229 rxs->signal = -(rssi); 1230 1231 rxs->band = common->band; 1232 1233 freq = ieee80211_channel_to_frequency(channel, rxs->band); 1234 1235 if (freq) 1236 rxs->freq = freq; 1237 1238 if (ieee80211_has_protected(hdr->frame_control)) { 1239 if (rsi_is_cipher_wep(common)) { 1240 memmove(skb->data + 4, skb->data, hdrlen); 1241 skb_pull(skb, 4); 1242 } else { 1243 memmove(skb->data + 8, skb->data, hdrlen); 1244 skb_pull(skb, 8); 1245 rxs->flag |= RX_FLAG_MMIC_STRIPPED; 1246 } 1247 rxs->flag |= RX_FLAG_DECRYPTED; 1248 rxs->flag |= RX_FLAG_IV_STRIPPED; 1249 } 1250 1251 for (i = 0; i < RSI_MAX_VIFS; i++) { 1252 vif = adapter->vifs[i]; 1253 if (!vif) 1254 continue; 1255 if (vif->type == NL80211_IFTYPE_STATION) { 1256 bss = &vif->bss_conf; 1257 break; 1258 } 1259 } 1260 if (!bss) 1261 return; 1262 /* CQM only for connected AP beacons, the RSSI is a weighted avg */ 1263 if (bss->assoc && !(memcmp(bss->bssid, hdr->addr2, ETH_ALEN))) { 1264 if (ieee80211_is_beacon(hdr->frame_control)) 1265 rsi_perform_cqm(common, hdr->addr2, rxs->signal, vif); 1266 } 1267 1268 return; 1269 } 1270 1271 /** 1272 * rsi_indicate_pkt_to_os() - This function sends recieved packet to mac80211. 1273 * @common: Pointer to the driver private structure. 1274 * @skb: Pointer to the socket buffer structure. 1275 * 1276 * Return: None. 1277 */ 1278 void rsi_indicate_pkt_to_os(struct rsi_common *common, 1279 struct sk_buff *skb) 1280 { 1281 struct rsi_hw *adapter = common->priv; 1282 struct ieee80211_hw *hw = adapter->hw; 1283 struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb); 1284 1285 if ((common->iface_down) || (!adapter->sc_nvifs)) { 1286 dev_kfree_skb(skb); 1287 return; 1288 } 1289 1290 /* filling in the ieee80211_rx_status flags */ 1291 rsi_fill_rx_status(hw, skb, common, rx_status); 1292 1293 ieee80211_rx_irqsafe(hw, skb); 1294 } 1295 1296 static void rsi_set_min_rate(struct ieee80211_hw *hw, 1297 struct ieee80211_sta *sta, 1298 struct rsi_common *common) 1299 { 1300 u8 band = hw->conf.chandef.chan->band; 1301 u8 ii; 1302 u32 rate_bitmap; 1303 bool matched = false; 1304 1305 common->bitrate_mask[band] = sta->supp_rates[band]; 1306 1307 rate_bitmap = (common->fixedrate_mask[band] & sta->supp_rates[band]); 1308 1309 if (rate_bitmap & 0xfff) { 1310 /* Find out the min rate */ 1311 for (ii = 0; ii < ARRAY_SIZE(rsi_rates); ii++) { 1312 if (rate_bitmap & BIT(ii)) { 1313 common->min_rate = rsi_rates[ii].hw_value; 1314 matched = true; 1315 break; 1316 } 1317 } 1318 } 1319 1320 common->vif_info[0].is_ht = sta->ht_cap.ht_supported; 1321 1322 if ((common->vif_info[0].is_ht) && (rate_bitmap >> 12)) { 1323 for (ii = 0; ii < ARRAY_SIZE(rsi_mcsrates); ii++) { 1324 if ((rate_bitmap >> 12) & BIT(ii)) { 1325 common->min_rate = rsi_mcsrates[ii]; 1326 matched = true; 1327 break; 1328 } 1329 } 1330 } 1331 1332 if (!matched) 1333 common->min_rate = 0xffff; 1334 } 1335 1336 /** 1337 * rsi_mac80211_sta_add() - This function notifies driver about a peer getting 1338 * connected. 1339 * @hw: pointer to the ieee80211_hw structure. 1340 * @vif: Pointer to the ieee80211_vif structure. 1341 * @sta: Pointer to the ieee80211_sta structure. 1342 * 1343 * Return: 0 on success, negative error codes on failure. 1344 */ 1345 static int rsi_mac80211_sta_add(struct ieee80211_hw *hw, 1346 struct ieee80211_vif *vif, 1347 struct ieee80211_sta *sta) 1348 { 1349 struct rsi_hw *adapter = hw->priv; 1350 struct rsi_common *common = adapter->priv; 1351 bool sta_exist = false; 1352 struct rsi_sta *rsta; 1353 int status = 0; 1354 1355 rsi_dbg(INFO_ZONE, "Station Add: %pM\n", sta->addr); 1356 1357 mutex_lock(&common->mutex); 1358 1359 if ((vif->type == NL80211_IFTYPE_AP) || 1360 (vif->type == NL80211_IFTYPE_P2P_GO)) { 1361 u8 cnt; 1362 int sta_idx = -1; 1363 int free_index = -1; 1364 1365 /* Check if max stations reached */ 1366 if (common->num_stations >= common->max_stations) { 1367 rsi_dbg(ERR_ZONE, "Reject: Max Stations exists\n"); 1368 status = -EOPNOTSUPP; 1369 goto unlock; 1370 } 1371 for (cnt = 0; cnt < common->max_stations; cnt++) { 1372 rsta = &common->stations[cnt]; 1373 1374 if (!rsta->sta) { 1375 if (free_index < 0) 1376 free_index = cnt; 1377 continue; 1378 } 1379 if (!memcmp(rsta->sta->addr, sta->addr, ETH_ALEN)) { 1380 rsi_dbg(INFO_ZONE, "Station exists\n"); 1381 sta_idx = cnt; 1382 sta_exist = true; 1383 break; 1384 } 1385 } 1386 if (!sta_exist) { 1387 if (free_index >= 0) 1388 sta_idx = free_index; 1389 } 1390 if (sta_idx < 0) { 1391 rsi_dbg(ERR_ZONE, 1392 "%s: Some problem reaching here...\n", 1393 __func__); 1394 status = -EINVAL; 1395 goto unlock; 1396 } 1397 rsta = &common->stations[sta_idx]; 1398 rsta->sta = sta; 1399 rsta->sta_id = sta_idx; 1400 for (cnt = 0; cnt < IEEE80211_NUM_TIDS; cnt++) 1401 rsta->start_tx_aggr[cnt] = false; 1402 for (cnt = 0; cnt < IEEE80211_NUM_TIDS; cnt++) 1403 rsta->seq_start[cnt] = 0; 1404 if (!sta_exist) { 1405 rsi_dbg(INFO_ZONE, "New Station\n"); 1406 1407 /* Send peer notify to device */ 1408 rsi_dbg(INFO_ZONE, "Indicate bss status to device\n"); 1409 rsi_inform_bss_status(common, RSI_OPMODE_AP, 1, 1410 sta->addr, sta->wme, sta->aid, 1411 sta, sta_idx, 0, vif); 1412 1413 if (common->key) { 1414 struct ieee80211_key_conf *key = common->key; 1415 1416 if ((key->cipher == WLAN_CIPHER_SUITE_WEP104) || 1417 (key->cipher == WLAN_CIPHER_SUITE_WEP40)) 1418 rsi_hal_load_key(adapter->priv, 1419 key->key, 1420 key->keylen, 1421 RSI_PAIRWISE_KEY, 1422 key->keyidx, 1423 key->cipher, 1424 sta_idx, 1425 vif); 1426 } 1427 1428 common->num_stations++; 1429 } 1430 } 1431 1432 if ((vif->type == NL80211_IFTYPE_STATION) || 1433 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) { 1434 rsi_set_min_rate(hw, sta, common); 1435 if (sta->ht_cap.ht_supported) { 1436 common->vif_info[0].is_ht = true; 1437 common->bitrate_mask[NL80211_BAND_2GHZ] = 1438 sta->supp_rates[NL80211_BAND_2GHZ]; 1439 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) || 1440 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40)) 1441 common->vif_info[0].sgi = true; 1442 ieee80211_start_tx_ba_session(sta, 0, 0); 1443 } 1444 } 1445 1446 unlock: 1447 mutex_unlock(&common->mutex); 1448 1449 return status; 1450 } 1451 1452 /** 1453 * rsi_mac80211_sta_remove() - This function notifies driver about a peer 1454 * getting disconnected. 1455 * @hw: Pointer to the ieee80211_hw structure. 1456 * @vif: Pointer to the ieee80211_vif structure. 1457 * @sta: Pointer to the ieee80211_sta structure. 1458 * 1459 * Return: 0 on success, negative error codes on failure. 1460 */ 1461 static int rsi_mac80211_sta_remove(struct ieee80211_hw *hw, 1462 struct ieee80211_vif *vif, 1463 struct ieee80211_sta *sta) 1464 { 1465 struct rsi_hw *adapter = hw->priv; 1466 struct rsi_common *common = adapter->priv; 1467 struct ieee80211_bss_conf *bss = &vif->bss_conf; 1468 struct rsi_sta *rsta; 1469 1470 rsi_dbg(INFO_ZONE, "Station Remove: %pM\n", sta->addr); 1471 1472 mutex_lock(&common->mutex); 1473 1474 if ((vif->type == NL80211_IFTYPE_AP) || 1475 (vif->type == NL80211_IFTYPE_P2P_GO)) { 1476 u8 sta_idx, cnt; 1477 1478 /* Send peer notify to device */ 1479 rsi_dbg(INFO_ZONE, "Indicate bss status to device\n"); 1480 for (sta_idx = 0; sta_idx < common->max_stations; sta_idx++) { 1481 rsta = &common->stations[sta_idx]; 1482 1483 if (!rsta->sta) 1484 continue; 1485 if (!memcmp(rsta->sta->addr, sta->addr, ETH_ALEN)) { 1486 rsi_inform_bss_status(common, RSI_OPMODE_AP, 0, 1487 sta->addr, sta->wme, 1488 sta->aid, sta, sta_idx, 1489 0, vif); 1490 rsta->sta = NULL; 1491 rsta->sta_id = -1; 1492 for (cnt = 0; cnt < IEEE80211_NUM_TIDS; cnt++) 1493 rsta->start_tx_aggr[cnt] = false; 1494 if (common->num_stations > 0) 1495 common->num_stations--; 1496 break; 1497 } 1498 } 1499 if (sta_idx >= common->max_stations) 1500 rsi_dbg(ERR_ZONE, "%s: No station found\n", __func__); 1501 } 1502 1503 if ((vif->type == NL80211_IFTYPE_STATION) || 1504 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) { 1505 /* Resetting all the fields to default values */ 1506 memcpy((u8 *)bss->bssid, (u8 *)sta->addr, ETH_ALEN); 1507 bss->qos = sta->wme; 1508 common->bitrate_mask[NL80211_BAND_2GHZ] = 0; 1509 common->bitrate_mask[NL80211_BAND_5GHZ] = 0; 1510 common->min_rate = 0xffff; 1511 common->vif_info[0].is_ht = false; 1512 common->vif_info[0].sgi = false; 1513 common->vif_info[0].seq_start = 0; 1514 common->secinfo.ptk_cipher = 0; 1515 common->secinfo.gtk_cipher = 0; 1516 if (!common->iface_down) 1517 rsi_send_rx_filter_frame(common, 0); 1518 } 1519 mutex_unlock(&common->mutex); 1520 1521 return 0; 1522 } 1523 1524 /** 1525 * rsi_mac80211_set_antenna() - This function is used to configure 1526 * tx and rx antennas. 1527 * @hw: Pointer to the ieee80211_hw structure. 1528 * @tx_ant: Bitmap for tx antenna 1529 * @rx_ant: Bitmap for rx antenna 1530 * 1531 * Return: 0 on success, Negative error code on failure. 1532 */ 1533 static int rsi_mac80211_set_antenna(struct ieee80211_hw *hw, 1534 u32 tx_ant, u32 rx_ant) 1535 { 1536 struct rsi_hw *adapter = hw->priv; 1537 struct rsi_common *common = adapter->priv; 1538 u8 antenna = 0; 1539 1540 if (tx_ant > 1 || rx_ant > 1) { 1541 rsi_dbg(ERR_ZONE, 1542 "Invalid antenna selection (tx: %d, rx:%d)\n", 1543 tx_ant, rx_ant); 1544 rsi_dbg(ERR_ZONE, 1545 "Use 0 for int_ant, 1 for ext_ant\n"); 1546 return -EINVAL; 1547 } 1548 1549 rsi_dbg(INFO_ZONE, "%s: Antenna map Tx %x Rx %d\n", 1550 __func__, tx_ant, rx_ant); 1551 1552 mutex_lock(&common->mutex); 1553 1554 antenna = tx_ant ? ANTENNA_SEL_UFL : ANTENNA_SEL_INT; 1555 if (common->ant_in_use != antenna) 1556 if (rsi_set_antenna(common, antenna)) 1557 goto fail_set_antenna; 1558 1559 rsi_dbg(INFO_ZONE, "(%s) Antenna path configured successfully\n", 1560 tx_ant ? "UFL" : "INT"); 1561 1562 common->ant_in_use = antenna; 1563 1564 mutex_unlock(&common->mutex); 1565 1566 return 0; 1567 1568 fail_set_antenna: 1569 rsi_dbg(ERR_ZONE, "%s: Failed.\n", __func__); 1570 mutex_unlock(&common->mutex); 1571 return -EINVAL; 1572 } 1573 1574 /** 1575 * rsi_mac80211_get_antenna() - This function is used to configure 1576 * tx and rx antennas. 1577 * 1578 * @hw: Pointer to the ieee80211_hw structure. 1579 * @tx_ant: Bitmap for tx antenna 1580 * @rx_ant: Bitmap for rx antenna 1581 * 1582 * Return: 0 on success, negative error codes on failure. 1583 */ 1584 static int rsi_mac80211_get_antenna(struct ieee80211_hw *hw, 1585 u32 *tx_ant, u32 *rx_ant) 1586 { 1587 struct rsi_hw *adapter = hw->priv; 1588 struct rsi_common *common = adapter->priv; 1589 1590 mutex_lock(&common->mutex); 1591 1592 *tx_ant = (common->ant_in_use == ANTENNA_SEL_UFL) ? 1 : 0; 1593 *rx_ant = 0; 1594 1595 mutex_unlock(&common->mutex); 1596 1597 return 0; 1598 } 1599 1600 static int rsi_map_region_code(enum nl80211_dfs_regions region_code) 1601 { 1602 switch (region_code) { 1603 case NL80211_DFS_FCC: 1604 return RSI_REGION_FCC; 1605 case NL80211_DFS_ETSI: 1606 return RSI_REGION_ETSI; 1607 case NL80211_DFS_JP: 1608 return RSI_REGION_TELEC; 1609 case NL80211_DFS_UNSET: 1610 return RSI_REGION_WORLD; 1611 } 1612 return RSI_REGION_WORLD; 1613 } 1614 1615 static void rsi_reg_notify(struct wiphy *wiphy, 1616 struct regulatory_request *request) 1617 { 1618 struct ieee80211_supported_band *sband; 1619 struct ieee80211_channel *ch; 1620 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1621 struct rsi_hw * adapter = hw->priv; 1622 struct rsi_common *common = adapter->priv; 1623 int i; 1624 1625 mutex_lock(&common->mutex); 1626 1627 rsi_dbg(INFO_ZONE, "country = %s dfs_region = %d\n", 1628 request->alpha2, request->dfs_region); 1629 1630 if (common->num_supp_bands > 1) { 1631 sband = wiphy->bands[NL80211_BAND_5GHZ]; 1632 1633 for (i = 0; i < sband->n_channels; i++) { 1634 ch = &sband->channels[i]; 1635 if (ch->flags & IEEE80211_CHAN_DISABLED) 1636 continue; 1637 1638 if (ch->flags & IEEE80211_CHAN_RADAR) 1639 ch->flags |= IEEE80211_CHAN_NO_IR; 1640 } 1641 } 1642 adapter->dfs_region = rsi_map_region_code(request->dfs_region); 1643 rsi_dbg(INFO_ZONE, "RSI region code = %d\n", adapter->dfs_region); 1644 1645 adapter->country[0] = request->alpha2[0]; 1646 adapter->country[1] = request->alpha2[1]; 1647 1648 mutex_unlock(&common->mutex); 1649 } 1650 1651 static void rsi_mac80211_rfkill_poll(struct ieee80211_hw *hw) 1652 { 1653 struct rsi_hw *adapter = hw->priv; 1654 struct rsi_common *common = adapter->priv; 1655 1656 mutex_lock(&common->mutex); 1657 if (common->fsm_state != FSM_MAC_INIT_DONE) 1658 wiphy_rfkill_set_hw_state(hw->wiphy, true); 1659 else 1660 wiphy_rfkill_set_hw_state(hw->wiphy, false); 1661 mutex_unlock(&common->mutex); 1662 } 1663 1664 static void rsi_resume_conn_channel(struct rsi_common *common) 1665 { 1666 struct rsi_hw *adapter = common->priv; 1667 struct ieee80211_vif *vif; 1668 int cnt; 1669 1670 for (cnt = 0; cnt < RSI_MAX_VIFS; cnt++) { 1671 vif = adapter->vifs[cnt]; 1672 if (!vif) 1673 continue; 1674 1675 if ((vif->type == NL80211_IFTYPE_AP) || 1676 (vif->type == NL80211_IFTYPE_P2P_GO)) { 1677 rsi_switch_channel(adapter, vif); 1678 break; 1679 } 1680 if (((vif->type == NL80211_IFTYPE_STATION) || 1681 (vif->type == NL80211_IFTYPE_P2P_CLIENT)) && 1682 vif->bss_conf.assoc) { 1683 rsi_switch_channel(adapter, vif); 1684 break; 1685 } 1686 } 1687 } 1688 1689 void rsi_roc_timeout(struct timer_list *t) 1690 { 1691 struct rsi_common *common = from_timer(common, t, roc_timer); 1692 1693 rsi_dbg(INFO_ZONE, "Remain on channel expired\n"); 1694 1695 mutex_lock(&common->mutex); 1696 ieee80211_remain_on_channel_expired(common->priv->hw); 1697 1698 if (timer_pending(&common->roc_timer)) 1699 del_timer(&common->roc_timer); 1700 1701 rsi_resume_conn_channel(common); 1702 mutex_unlock(&common->mutex); 1703 } 1704 1705 static int rsi_mac80211_roc(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1706 struct ieee80211_channel *chan, int duration, 1707 enum ieee80211_roc_type type) 1708 { 1709 struct rsi_hw *adapter = (struct rsi_hw *)hw->priv; 1710 struct rsi_common *common = (struct rsi_common *)adapter->priv; 1711 int status = 0; 1712 1713 rsi_dbg(INFO_ZONE, "***** Remain on channel *****\n"); 1714 1715 mutex_lock(&common->mutex); 1716 rsi_dbg(INFO_ZONE, "%s: channel: %d duration: %dms\n", 1717 __func__, chan->hw_value, duration); 1718 1719 if (timer_pending(&common->roc_timer)) { 1720 rsi_dbg(INFO_ZONE, "Stop on-going ROC\n"); 1721 del_timer(&common->roc_timer); 1722 } 1723 common->roc_timer.expires = msecs_to_jiffies(duration) + jiffies; 1724 add_timer(&common->roc_timer); 1725 1726 /* Configure band */ 1727 if (rsi_band_check(common, chan)) { 1728 rsi_dbg(ERR_ZONE, "Failed to set band\n"); 1729 status = -EINVAL; 1730 goto out; 1731 } 1732 1733 /* Configure channel */ 1734 if (rsi_set_channel(common, chan)) { 1735 rsi_dbg(ERR_ZONE, "Failed to set the channel\n"); 1736 status = -EINVAL; 1737 goto out; 1738 } 1739 1740 common->roc_vif = vif; 1741 ieee80211_ready_on_channel(hw); 1742 rsi_dbg(INFO_ZONE, "%s: Ready on channel :%d\n", 1743 __func__, chan->hw_value); 1744 1745 out: 1746 mutex_unlock(&common->mutex); 1747 1748 return status; 1749 } 1750 1751 static int rsi_mac80211_cancel_roc(struct ieee80211_hw *hw) 1752 { 1753 struct rsi_hw *adapter = hw->priv; 1754 struct rsi_common *common = adapter->priv; 1755 1756 rsi_dbg(INFO_ZONE, "Cancel remain on channel\n"); 1757 1758 mutex_lock(&common->mutex); 1759 if (!timer_pending(&common->roc_timer)) { 1760 mutex_unlock(&common->mutex); 1761 return 0; 1762 } 1763 1764 del_timer(&common->roc_timer); 1765 1766 rsi_resume_conn_channel(common); 1767 mutex_unlock(&common->mutex); 1768 1769 return 0; 1770 } 1771 1772 #ifdef CONFIG_PM 1773 static const struct wiphy_wowlan_support rsi_wowlan_support = { 1774 .flags = WIPHY_WOWLAN_ANY | 1775 WIPHY_WOWLAN_MAGIC_PKT | 1776 WIPHY_WOWLAN_DISCONNECT | 1777 WIPHY_WOWLAN_GTK_REKEY_FAILURE | 1778 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | 1779 WIPHY_WOWLAN_EAP_IDENTITY_REQ | 1780 WIPHY_WOWLAN_4WAY_HANDSHAKE, 1781 }; 1782 1783 static u16 rsi_wow_map_triggers(struct rsi_common *common, 1784 struct cfg80211_wowlan *wowlan) 1785 { 1786 u16 wow_triggers = 0; 1787 1788 rsi_dbg(INFO_ZONE, "Mapping wowlan triggers\n"); 1789 1790 if (wowlan->any) 1791 wow_triggers |= RSI_WOW_ANY; 1792 if (wowlan->magic_pkt) 1793 wow_triggers |= RSI_WOW_MAGIC_PKT; 1794 if (wowlan->disconnect) 1795 wow_triggers |= RSI_WOW_DISCONNECT; 1796 if (wowlan->gtk_rekey_failure || wowlan->eap_identity_req || 1797 wowlan->four_way_handshake) 1798 wow_triggers |= RSI_WOW_GTK_REKEY; 1799 1800 return wow_triggers; 1801 } 1802 1803 int rsi_config_wowlan(struct rsi_hw *adapter, struct cfg80211_wowlan *wowlan) 1804 { 1805 struct rsi_common *common = adapter->priv; 1806 u16 triggers = 0; 1807 u16 rx_filter_word = 0; 1808 struct ieee80211_bss_conf *bss = NULL; 1809 1810 rsi_dbg(INFO_ZONE, "Config WoWLAN to device\n"); 1811 1812 if (!adapter->vifs[0]) 1813 return -EINVAL; 1814 1815 bss = &adapter->vifs[0]->bss_conf; 1816 1817 if (WARN_ON(!wowlan)) { 1818 rsi_dbg(ERR_ZONE, "WoW triggers not enabled\n"); 1819 return -EINVAL; 1820 } 1821 1822 common->wow_flags |= RSI_WOW_ENABLED; 1823 triggers = rsi_wow_map_triggers(common, wowlan); 1824 if (!triggers) { 1825 rsi_dbg(ERR_ZONE, "%s:No valid WoW triggers\n", __func__); 1826 return -EINVAL; 1827 } 1828 if (!bss->assoc) { 1829 rsi_dbg(ERR_ZONE, 1830 "Cannot configure WoWLAN (Station not connected)\n"); 1831 common->wow_flags |= RSI_WOW_NO_CONNECTION; 1832 return 0; 1833 } 1834 rsi_dbg(INFO_ZONE, "TRIGGERS %x\n", triggers); 1835 rsi_send_wowlan_request(common, triggers, 1); 1836 1837 /** 1838 * Increase the beacon_miss threshold & keep-alive timers in 1839 * vap_update frame 1840 */ 1841 rsi_send_vap_dynamic_update(common); 1842 1843 rx_filter_word = (ALLOW_DATA_ASSOC_PEER | DISALLOW_BEACONS); 1844 rsi_send_rx_filter_frame(common, rx_filter_word); 1845 1846 return 0; 1847 } 1848 EXPORT_SYMBOL(rsi_config_wowlan); 1849 1850 static int rsi_mac80211_suspend(struct ieee80211_hw *hw, 1851 struct cfg80211_wowlan *wowlan) 1852 { 1853 struct rsi_hw *adapter = hw->priv; 1854 struct rsi_common *common = adapter->priv; 1855 1856 rsi_dbg(INFO_ZONE, "%s: mac80211 suspend\n", __func__); 1857 mutex_lock(&common->mutex); 1858 if (rsi_config_wowlan(adapter, wowlan)) { 1859 rsi_dbg(ERR_ZONE, "Failed to configure WoWLAN\n"); 1860 mutex_unlock(&common->mutex); 1861 return 1; 1862 } 1863 mutex_unlock(&common->mutex); 1864 1865 return 0; 1866 } 1867 1868 static int rsi_mac80211_resume(struct ieee80211_hw *hw) 1869 { 1870 u16 rx_filter_word = 0; 1871 struct rsi_hw *adapter = hw->priv; 1872 struct rsi_common *common = adapter->priv; 1873 1874 common->wow_flags = 0; 1875 1876 rsi_dbg(INFO_ZONE, "%s: mac80211 resume\n", __func__); 1877 1878 if (common->hibernate_resume) 1879 return 0; 1880 1881 mutex_lock(&common->mutex); 1882 rsi_send_wowlan_request(common, 0, 0); 1883 1884 rx_filter_word = (ALLOW_DATA_ASSOC_PEER | ALLOW_CTRL_ASSOC_PEER | 1885 ALLOW_MGMT_ASSOC_PEER); 1886 rsi_send_rx_filter_frame(common, rx_filter_word); 1887 mutex_unlock(&common->mutex); 1888 1889 return 0; 1890 } 1891 1892 #endif 1893 1894 static const struct ieee80211_ops mac80211_ops = { 1895 .tx = rsi_mac80211_tx, 1896 .start = rsi_mac80211_start, 1897 .stop = rsi_mac80211_stop, 1898 .add_interface = rsi_mac80211_add_interface, 1899 .remove_interface = rsi_mac80211_remove_interface, 1900 .config = rsi_mac80211_config, 1901 .bss_info_changed = rsi_mac80211_bss_info_changed, 1902 .conf_tx = rsi_mac80211_conf_tx, 1903 .configure_filter = rsi_mac80211_conf_filter, 1904 .set_key = rsi_mac80211_set_key, 1905 .set_rts_threshold = rsi_mac80211_set_rts_threshold, 1906 .set_bitrate_mask = rsi_mac80211_set_rate_mask, 1907 .ampdu_action = rsi_mac80211_ampdu_action, 1908 .sta_add = rsi_mac80211_sta_add, 1909 .sta_remove = rsi_mac80211_sta_remove, 1910 .set_antenna = rsi_mac80211_set_antenna, 1911 .get_antenna = rsi_mac80211_get_antenna, 1912 .rfkill_poll = rsi_mac80211_rfkill_poll, 1913 .remain_on_channel = rsi_mac80211_roc, 1914 .cancel_remain_on_channel = rsi_mac80211_cancel_roc, 1915 #ifdef CONFIG_PM 1916 .suspend = rsi_mac80211_suspend, 1917 .resume = rsi_mac80211_resume, 1918 #endif 1919 }; 1920 1921 /** 1922 * rsi_mac80211_attach() - This function is used to initialize Mac80211 stack. 1923 * @common: Pointer to the driver private structure. 1924 * 1925 * Return: 0 on success, negative error codes on failure. 1926 */ 1927 int rsi_mac80211_attach(struct rsi_common *common) 1928 { 1929 int status = 0; 1930 struct ieee80211_hw *hw = NULL; 1931 struct wiphy *wiphy = NULL; 1932 struct rsi_hw *adapter = common->priv; 1933 u8 addr_mask[ETH_ALEN] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x3}; 1934 1935 rsi_dbg(INIT_ZONE, "%s: Performing mac80211 attach\n", __func__); 1936 1937 hw = ieee80211_alloc_hw(sizeof(struct rsi_hw), &mac80211_ops); 1938 if (!hw) { 1939 rsi_dbg(ERR_ZONE, "%s: ieee80211 hw alloc failed\n", __func__); 1940 return -ENOMEM; 1941 } 1942 1943 wiphy = hw->wiphy; 1944 1945 SET_IEEE80211_DEV(hw, adapter->device); 1946 1947 hw->priv = adapter; 1948 adapter->hw = hw; 1949 1950 ieee80211_hw_set(hw, SIGNAL_DBM); 1951 ieee80211_hw_set(hw, HAS_RATE_CONTROL); 1952 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 1953 ieee80211_hw_set(hw, SUPPORTS_PS); 1954 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS); 1955 1956 hw->queues = MAX_HW_QUEUES; 1957 hw->extra_tx_headroom = RSI_NEEDED_HEADROOM; 1958 1959 hw->max_rates = 1; 1960 hw->max_rate_tries = MAX_RETRIES; 1961 hw->uapsd_queues = RSI_IEEE80211_UAPSD_QUEUES; 1962 hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL; 1963 1964 hw->max_tx_aggregation_subframes = RSI_MAX_TX_AGGR_FRMS; 1965 hw->max_rx_aggregation_subframes = RSI_MAX_RX_AGGR_FRMS; 1966 hw->rate_control_algorithm = "AARF"; 1967 1968 SET_IEEE80211_PERM_ADDR(hw, common->mac_addr); 1969 ether_addr_copy(hw->wiphy->addr_mask, addr_mask); 1970 1971 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 1972 BIT(NL80211_IFTYPE_AP) | 1973 BIT(NL80211_IFTYPE_P2P_DEVICE) | 1974 BIT(NL80211_IFTYPE_P2P_CLIENT) | 1975 BIT(NL80211_IFTYPE_P2P_GO); 1976 1977 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 1978 wiphy->retry_short = RETRY_SHORT; 1979 wiphy->retry_long = RETRY_LONG; 1980 wiphy->frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD; 1981 wiphy->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD; 1982 wiphy->flags = 0; 1983 1984 wiphy->available_antennas_rx = 1; 1985 wiphy->available_antennas_tx = 1; 1986 1987 rsi_register_rates_channels(adapter, NL80211_BAND_2GHZ); 1988 wiphy->bands[NL80211_BAND_2GHZ] = 1989 &adapter->sbands[NL80211_BAND_2GHZ]; 1990 if (common->num_supp_bands > 1) { 1991 rsi_register_rates_channels(adapter, NL80211_BAND_5GHZ); 1992 wiphy->bands[NL80211_BAND_5GHZ] = 1993 &adapter->sbands[NL80211_BAND_5GHZ]; 1994 } 1995 1996 /* AP Parameters */ 1997 wiphy->max_ap_assoc_sta = rsi_max_ap_stas[common->oper_mode - 1]; 1998 common->max_stations = wiphy->max_ap_assoc_sta; 1999 rsi_dbg(ERR_ZONE, "Max Stations Allowed = %d\n", common->max_stations); 2000 hw->sta_data_size = sizeof(struct rsi_sta); 2001 wiphy->flags = WIPHY_FLAG_REPORTS_OBSS; 2002 wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 2003 wiphy->features |= NL80211_FEATURE_INACTIVITY_TIMER; 2004 wiphy->reg_notifier = rsi_reg_notify; 2005 2006 #ifdef CONFIG_PM 2007 wiphy->wowlan = &rsi_wowlan_support; 2008 #endif 2009 2010 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 2011 2012 /* Wi-Fi direct parameters */ 2013 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 2014 wiphy->flags |= WIPHY_FLAG_OFFCHAN_TX; 2015 wiphy->max_remain_on_channel_duration = 10000; 2016 hw->max_listen_interval = 10; 2017 wiphy->iface_combinations = rsi_iface_combinations; 2018 wiphy->n_iface_combinations = ARRAY_SIZE(rsi_iface_combinations); 2019 2020 if (common->coex_mode > 1) 2021 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 2022 2023 status = ieee80211_register_hw(hw); 2024 if (status) 2025 return status; 2026 2027 return rsi_init_dbgfs(adapter); 2028 } 2029