1/* 2 * Copyright (c) 2010 Broadcom Corporation 3 * Copyright (c) 2013 Hauke Mehrtens <hauke@hauke-m.de> 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 12 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 14 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 15 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18#define __UNDEF_NO_VERSION__ 19#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 21#include <linux/etherdevice.h> 22#include <linux/sched.h> 23#include <linux/firmware.h> 24#include <linux/interrupt.h> 25#include <linux/module.h> 26#include <linux/bcma/bcma.h> 27#include <net/mac80211.h> 28#include <defs.h> 29#include "phy/phy_int.h" 30#include "d11.h" 31#include "channel.h" 32#include "scb.h" 33#include "pub.h" 34#include "ucode_loader.h" 35#include "mac80211_if.h" 36#include "main.h" 37#include "debug.h" 38#include "led.h" 39 40#define N_TX_QUEUES 4 /* #tx queues on mac80211<->driver interface */ 41#define BRCMS_FLUSH_TIMEOUT 500 /* msec */ 42 43/* Flags we support */ 44#define MAC_FILTERS (FIF_PROMISC_IN_BSS | \ 45 FIF_ALLMULTI | \ 46 FIF_FCSFAIL | \ 47 FIF_CONTROL | \ 48 FIF_OTHER_BSS | \ 49 FIF_BCN_PRBRESP_PROMISC | \ 50 FIF_PSPOLL) 51 52#define CHAN2GHZ(channel, freqency, chflags) { \ 53 .band = IEEE80211_BAND_2GHZ, \ 54 .center_freq = (freqency), \ 55 .hw_value = (channel), \ 56 .flags = chflags, \ 57 .max_antenna_gain = 0, \ 58 .max_power = 19, \ 59} 60 61#define CHAN5GHZ(channel, chflags) { \ 62 .band = IEEE80211_BAND_5GHZ, \ 63 .center_freq = 5000 + 5*(channel), \ 64 .hw_value = (channel), \ 65 .flags = chflags, \ 66 .max_antenna_gain = 0, \ 67 .max_power = 21, \ 68} 69 70#define RATE(rate100m, _flags) { \ 71 .bitrate = (rate100m), \ 72 .flags = (_flags), \ 73 .hw_value = (rate100m / 5), \ 74} 75 76struct firmware_hdr { 77 __le32 offset; 78 __le32 len; 79 __le32 idx; 80}; 81 82static const char * const brcms_firmwares[MAX_FW_IMAGES] = { 83 "brcm/bcm43xx", 84 NULL 85}; 86 87static int n_adapters_found; 88 89MODULE_AUTHOR("Broadcom Corporation"); 90MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver."); 91MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards"); 92MODULE_LICENSE("Dual BSD/GPL"); 93/* This needs to be adjusted when brcms_firmwares changes */ 94MODULE_FIRMWARE("brcm/bcm43xx-0.fw"); 95MODULE_FIRMWARE("brcm/bcm43xx_hdr-0.fw"); 96 97/* recognized BCMA Core IDs */ 98static struct bcma_device_id brcms_coreid_table[] = { 99 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 17, BCMA_ANY_CLASS), 100 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 23, BCMA_ANY_CLASS), 101 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 24, BCMA_ANY_CLASS), 102 {}, 103}; 104MODULE_DEVICE_TABLE(bcma, brcms_coreid_table); 105 106#if defined(CONFIG_BRCMDBG) 107/* 108 * Module parameter for setting the debug message level. Available 109 * flags are specified by the BRCM_DL_* macros in 110 * drivers/net/wireless/brcm80211/include/defs.h. 111 */ 112module_param_named(debug, brcm_msg_level, uint, S_IRUGO | S_IWUSR); 113#endif 114 115static struct ieee80211_channel brcms_2ghz_chantable[] = { 116 CHAN2GHZ(1, 2412, IEEE80211_CHAN_NO_HT40MINUS), 117 CHAN2GHZ(2, 2417, IEEE80211_CHAN_NO_HT40MINUS), 118 CHAN2GHZ(3, 2422, IEEE80211_CHAN_NO_HT40MINUS), 119 CHAN2GHZ(4, 2427, IEEE80211_CHAN_NO_HT40MINUS), 120 CHAN2GHZ(5, 2432, 0), 121 CHAN2GHZ(6, 2437, 0), 122 CHAN2GHZ(7, 2442, 0), 123 CHAN2GHZ(8, 2447, IEEE80211_CHAN_NO_HT40PLUS), 124 CHAN2GHZ(9, 2452, IEEE80211_CHAN_NO_HT40PLUS), 125 CHAN2GHZ(10, 2457, IEEE80211_CHAN_NO_HT40PLUS), 126 CHAN2GHZ(11, 2462, IEEE80211_CHAN_NO_HT40PLUS), 127 CHAN2GHZ(12, 2467, 128 IEEE80211_CHAN_NO_IR | 129 IEEE80211_CHAN_NO_HT40PLUS), 130 CHAN2GHZ(13, 2472, 131 IEEE80211_CHAN_NO_IR | 132 IEEE80211_CHAN_NO_HT40PLUS), 133 CHAN2GHZ(14, 2484, 134 IEEE80211_CHAN_NO_IR | 135 IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS | 136 IEEE80211_CHAN_NO_OFDM) 137}; 138 139static struct ieee80211_channel brcms_5ghz_nphy_chantable[] = { 140 /* UNII-1 */ 141 CHAN5GHZ(36, IEEE80211_CHAN_NO_HT40MINUS), 142 CHAN5GHZ(40, IEEE80211_CHAN_NO_HT40PLUS), 143 CHAN5GHZ(44, IEEE80211_CHAN_NO_HT40MINUS), 144 CHAN5GHZ(48, IEEE80211_CHAN_NO_HT40PLUS), 145 /* UNII-2 */ 146 CHAN5GHZ(52, 147 IEEE80211_CHAN_RADAR | 148 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 149 CHAN5GHZ(56, 150 IEEE80211_CHAN_RADAR | 151 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 152 CHAN5GHZ(60, 153 IEEE80211_CHAN_RADAR | 154 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 155 CHAN5GHZ(64, 156 IEEE80211_CHAN_RADAR | 157 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 158 /* MID */ 159 CHAN5GHZ(100, 160 IEEE80211_CHAN_RADAR | 161 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 162 CHAN5GHZ(104, 163 IEEE80211_CHAN_RADAR | 164 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 165 CHAN5GHZ(108, 166 IEEE80211_CHAN_RADAR | 167 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 168 CHAN5GHZ(112, 169 IEEE80211_CHAN_RADAR | 170 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 171 CHAN5GHZ(116, 172 IEEE80211_CHAN_RADAR | 173 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 174 CHAN5GHZ(120, 175 IEEE80211_CHAN_RADAR | 176 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 177 CHAN5GHZ(124, 178 IEEE80211_CHAN_RADAR | 179 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 180 CHAN5GHZ(128, 181 IEEE80211_CHAN_RADAR | 182 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 183 CHAN5GHZ(132, 184 IEEE80211_CHAN_RADAR | 185 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40MINUS), 186 CHAN5GHZ(136, 187 IEEE80211_CHAN_RADAR | 188 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS), 189 CHAN5GHZ(140, 190 IEEE80211_CHAN_RADAR | 191 IEEE80211_CHAN_NO_IR | IEEE80211_CHAN_NO_HT40PLUS | 192 IEEE80211_CHAN_NO_HT40MINUS), 193 /* UNII-3 */ 194 CHAN5GHZ(149, IEEE80211_CHAN_NO_HT40MINUS), 195 CHAN5GHZ(153, IEEE80211_CHAN_NO_HT40PLUS), 196 CHAN5GHZ(157, IEEE80211_CHAN_NO_HT40MINUS), 197 CHAN5GHZ(161, IEEE80211_CHAN_NO_HT40PLUS), 198 CHAN5GHZ(165, IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS) 199}; 200 201/* 202 * The rate table is used for both 2.4G and 5G rates. The 203 * latter being a subset as it does not support CCK rates. 204 */ 205static struct ieee80211_rate legacy_ratetable[] = { 206 RATE(10, 0), 207 RATE(20, IEEE80211_RATE_SHORT_PREAMBLE), 208 RATE(55, IEEE80211_RATE_SHORT_PREAMBLE), 209 RATE(110, IEEE80211_RATE_SHORT_PREAMBLE), 210 RATE(60, 0), 211 RATE(90, 0), 212 RATE(120, 0), 213 RATE(180, 0), 214 RATE(240, 0), 215 RATE(360, 0), 216 RATE(480, 0), 217 RATE(540, 0), 218}; 219 220static const struct ieee80211_supported_band brcms_band_2GHz_nphy_template = { 221 .band = IEEE80211_BAND_2GHZ, 222 .channels = brcms_2ghz_chantable, 223 .n_channels = ARRAY_SIZE(brcms_2ghz_chantable), 224 .bitrates = legacy_ratetable, 225 .n_bitrates = ARRAY_SIZE(legacy_ratetable), 226 .ht_cap = { 227 /* from include/linux/ieee80211.h */ 228 .cap = IEEE80211_HT_CAP_GRN_FLD | 229 IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40, 230 .ht_supported = true, 231 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, 232 .ampdu_density = AMPDU_DEF_MPDU_DENSITY, 233 .mcs = { 234 /* placeholders for now */ 235 .rx_mask = {0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0}, 236 .rx_highest = cpu_to_le16(500), 237 .tx_params = IEEE80211_HT_MCS_TX_DEFINED} 238 } 239}; 240 241static const struct ieee80211_supported_band brcms_band_5GHz_nphy_template = { 242 .band = IEEE80211_BAND_5GHZ, 243 .channels = brcms_5ghz_nphy_chantable, 244 .n_channels = ARRAY_SIZE(brcms_5ghz_nphy_chantable), 245 .bitrates = legacy_ratetable + BRCMS_LEGACY_5G_RATE_OFFSET, 246 .n_bitrates = ARRAY_SIZE(legacy_ratetable) - 247 BRCMS_LEGACY_5G_RATE_OFFSET, 248 .ht_cap = { 249 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | 250 IEEE80211_HT_CAP_SGI_40, 251 .ht_supported = true, 252 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, 253 .ampdu_density = AMPDU_DEF_MPDU_DENSITY, 254 .mcs = { 255 /* placeholders for now */ 256 .rx_mask = {0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0}, 257 .rx_highest = cpu_to_le16(500), 258 .tx_params = IEEE80211_HT_MCS_TX_DEFINED} 259 } 260}; 261 262/* flags the given rate in rateset as requested */ 263static void brcms_set_basic_rate(struct brcm_rateset *rs, u16 rate, bool is_br) 264{ 265 u32 i; 266 267 for (i = 0; i < rs->count; i++) { 268 if (rate != (rs->rates[i] & 0x7f)) 269 continue; 270 271 if (is_br) 272 rs->rates[i] |= BRCMS_RATE_FLAG; 273 else 274 rs->rates[i] &= BRCMS_RATE_MASK; 275 return; 276 } 277} 278 279/** 280 * This function frees the WL per-device resources. 281 * 282 * This function frees resources owned by the WL device pointed to 283 * by the wl parameter. 284 * 285 * precondition: can both be called locked and unlocked 286 * 287 */ 288static void brcms_free(struct brcms_info *wl) 289{ 290 struct brcms_timer *t, *next; 291 292 /* free ucode data */ 293 if (wl->fw.fw_cnt) 294 brcms_ucode_data_free(&wl->ucode); 295 if (wl->irq) 296 free_irq(wl->irq, wl); 297 298 /* kill dpc */ 299 tasklet_kill(&wl->tasklet); 300 301 if (wl->pub) { 302 brcms_debugfs_detach(wl->pub); 303 brcms_c_module_unregister(wl->pub, "linux", wl); 304 } 305 306 /* free common resources */ 307 if (wl->wlc) { 308 brcms_c_detach(wl->wlc); 309 wl->wlc = NULL; 310 wl->pub = NULL; 311 } 312 313 /* virtual interface deletion is deferred so we cannot spinwait */ 314 315 /* wait for all pending callbacks to complete */ 316 while (atomic_read(&wl->callbacks) > 0) 317 schedule(); 318 319 /* free timers */ 320 for (t = wl->timers; t; t = next) { 321 next = t->next; 322#ifdef DEBUG 323 kfree(t->name); 324#endif 325 kfree(t); 326 } 327} 328 329/* 330* called from both kernel as from this kernel module (error flow on attach) 331* precondition: perimeter lock is not acquired. 332*/ 333static void brcms_remove(struct bcma_device *pdev) 334{ 335 struct ieee80211_hw *hw = bcma_get_drvdata(pdev); 336 struct brcms_info *wl = hw->priv; 337 338 if (wl->wlc) { 339 brcms_led_unregister(wl); 340 wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, false); 341 wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy); 342 ieee80211_unregister_hw(hw); 343 } 344 345 brcms_free(wl); 346 347 bcma_set_drvdata(pdev, NULL); 348 ieee80211_free_hw(hw); 349} 350 351/* 352 * Precondition: Since this function is called in brcms_pci_probe() context, 353 * no locking is required. 354 */ 355static void brcms_release_fw(struct brcms_info *wl) 356{ 357 int i; 358 for (i = 0; i < MAX_FW_IMAGES; i++) { 359 release_firmware(wl->fw.fw_bin[i]); 360 release_firmware(wl->fw.fw_hdr[i]); 361 } 362} 363 364/* 365 * Precondition: Since this function is called in brcms_pci_probe() context, 366 * no locking is required. 367 */ 368static int brcms_request_fw(struct brcms_info *wl, struct bcma_device *pdev) 369{ 370 int status; 371 struct device *device = &pdev->dev; 372 char fw_name[100]; 373 int i; 374 375 memset(&wl->fw, 0, sizeof(struct brcms_firmware)); 376 for (i = 0; i < MAX_FW_IMAGES; i++) { 377 if (brcms_firmwares[i] == NULL) 378 break; 379 sprintf(fw_name, "%s-%d.fw", brcms_firmwares[i], 380 UCODE_LOADER_API_VER); 381 status = request_firmware(&wl->fw.fw_bin[i], fw_name, device); 382 if (status) { 383 wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n", 384 KBUILD_MODNAME, fw_name); 385 return status; 386 } 387 sprintf(fw_name, "%s_hdr-%d.fw", brcms_firmwares[i], 388 UCODE_LOADER_API_VER); 389 status = request_firmware(&wl->fw.fw_hdr[i], fw_name, device); 390 if (status) { 391 wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n", 392 KBUILD_MODNAME, fw_name); 393 return status; 394 } 395 wl->fw.hdr_num_entries[i] = 396 wl->fw.fw_hdr[i]->size / (sizeof(struct firmware_hdr)); 397 } 398 wl->fw.fw_cnt = i; 399 status = brcms_ucode_data_init(wl, &wl->ucode); 400 brcms_release_fw(wl); 401 return status; 402} 403 404static void brcms_ops_tx(struct ieee80211_hw *hw, 405 struct ieee80211_tx_control *control, 406 struct sk_buff *skb) 407{ 408 struct brcms_info *wl = hw->priv; 409 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 410 411 spin_lock_bh(&wl->lock); 412 if (!wl->pub->up) { 413 brcms_err(wl->wlc->hw->d11core, "ops->tx called while down\n"); 414 kfree_skb(skb); 415 goto done; 416 } 417 if (brcms_c_sendpkt_mac80211(wl->wlc, skb, hw)) 418 tx_info->rate_driver_data[0] = control->sta; 419 done: 420 spin_unlock_bh(&wl->lock); 421} 422 423static int brcms_ops_start(struct ieee80211_hw *hw) 424{ 425 struct brcms_info *wl = hw->priv; 426 bool blocked; 427 int err; 428 429 if (!wl->ucode.bcm43xx_bomminor) { 430 err = brcms_request_fw(wl, wl->wlc->hw->d11core); 431 if (err) 432 return -ENOENT; 433 } 434 435 ieee80211_wake_queues(hw); 436 spin_lock_bh(&wl->lock); 437 blocked = brcms_rfkill_set_hw_state(wl); 438 spin_unlock_bh(&wl->lock); 439 if (!blocked) 440 wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy); 441 442 spin_lock_bh(&wl->lock); 443 /* avoid acknowledging frames before a non-monitor device is added */ 444 wl->mute_tx = true; 445 446 if (!wl->pub->up) 447 if (!blocked) 448 err = brcms_up(wl); 449 else 450 err = -ERFKILL; 451 else 452 err = -ENODEV; 453 spin_unlock_bh(&wl->lock); 454 455 if (err != 0) 456 brcms_err(wl->wlc->hw->d11core, "%s: brcms_up() returned %d\n", 457 __func__, err); 458 459 bcma_core_pci_power_save(wl->wlc->hw->d11core->bus, true); 460 return err; 461} 462 463static void brcms_ops_stop(struct ieee80211_hw *hw) 464{ 465 struct brcms_info *wl = hw->priv; 466 int status; 467 468 ieee80211_stop_queues(hw); 469 470 if (wl->wlc == NULL) 471 return; 472 473 spin_lock_bh(&wl->lock); 474 status = brcms_c_chipmatch(wl->wlc->hw->d11core); 475 spin_unlock_bh(&wl->lock); 476 if (!status) { 477 brcms_err(wl->wlc->hw->d11core, 478 "wl: brcms_ops_stop: chipmatch failed\n"); 479 return; 480 } 481 482 bcma_core_pci_power_save(wl->wlc->hw->d11core->bus, false); 483 484 /* put driver in down state */ 485 spin_lock_bh(&wl->lock); 486 brcms_down(wl); 487 spin_unlock_bh(&wl->lock); 488} 489 490static int 491brcms_ops_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 492{ 493 struct brcms_info *wl = hw->priv; 494 495 /* Just STA, AP and ADHOC for now */ 496 if (vif->type != NL80211_IFTYPE_STATION && 497 vif->type != NL80211_IFTYPE_AP && 498 vif->type != NL80211_IFTYPE_ADHOC) { 499 brcms_err(wl->wlc->hw->d11core, 500 "%s: Attempt to add type %d, only STA, AP and AdHoc for now\n", 501 __func__, vif->type); 502 return -EOPNOTSUPP; 503 } 504 505 spin_lock_bh(&wl->lock); 506 wl->mute_tx = false; 507 brcms_c_mute(wl->wlc, false); 508 if (vif->type == NL80211_IFTYPE_STATION) 509 brcms_c_start_station(wl->wlc, vif->addr); 510 else if (vif->type == NL80211_IFTYPE_AP) 511 brcms_c_start_ap(wl->wlc, vif->addr, vif->bss_conf.bssid, 512 vif->bss_conf.ssid, vif->bss_conf.ssid_len); 513 else if (vif->type == NL80211_IFTYPE_ADHOC) 514 brcms_c_start_adhoc(wl->wlc, vif->addr); 515 spin_unlock_bh(&wl->lock); 516 517 return 0; 518} 519 520static void 521brcms_ops_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 522{ 523} 524 525static int brcms_ops_config(struct ieee80211_hw *hw, u32 changed) 526{ 527 struct ieee80211_conf *conf = &hw->conf; 528 struct brcms_info *wl = hw->priv; 529 struct bcma_device *core = wl->wlc->hw->d11core; 530 int err = 0; 531 int new_int; 532 533 spin_lock_bh(&wl->lock); 534 if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) { 535 brcms_c_set_beacon_listen_interval(wl->wlc, 536 conf->listen_interval); 537 } 538 if (changed & IEEE80211_CONF_CHANGE_MONITOR) 539 brcms_dbg_info(core, "%s: change monitor mode: %s\n", 540 __func__, conf->flags & IEEE80211_CONF_MONITOR ? 541 "true" : "false"); 542 if (changed & IEEE80211_CONF_CHANGE_PS) 543 brcms_err(core, "%s: change power-save mode: %s (implement)\n", 544 __func__, conf->flags & IEEE80211_CONF_PS ? 545 "true" : "false"); 546 547 if (changed & IEEE80211_CONF_CHANGE_POWER) { 548 err = brcms_c_set_tx_power(wl->wlc, conf->power_level); 549 if (err < 0) { 550 brcms_err(core, "%s: Error setting power_level\n", 551 __func__); 552 goto config_out; 553 } 554 new_int = brcms_c_get_tx_power(wl->wlc); 555 if (new_int != conf->power_level) 556 brcms_err(core, 557 "%s: Power level req != actual, %d %d\n", 558 __func__, conf->power_level, 559 new_int); 560 } 561 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 562 if (conf->chandef.width == NL80211_CHAN_WIDTH_20 || 563 conf->chandef.width == NL80211_CHAN_WIDTH_20_NOHT) 564 err = brcms_c_set_channel(wl->wlc, 565 conf->chandef.chan->hw_value); 566 else 567 err = -ENOTSUPP; 568 } 569 if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) 570 err = brcms_c_set_rate_limit(wl->wlc, 571 conf->short_frame_max_tx_count, 572 conf->long_frame_max_tx_count); 573 574 config_out: 575 spin_unlock_bh(&wl->lock); 576 return err; 577} 578 579static void 580brcms_ops_bss_info_changed(struct ieee80211_hw *hw, 581 struct ieee80211_vif *vif, 582 struct ieee80211_bss_conf *info, u32 changed) 583{ 584 struct brcms_info *wl = hw->priv; 585 struct bcma_device *core = wl->wlc->hw->d11core; 586 587 if (changed & BSS_CHANGED_ASSOC) { 588 /* association status changed (associated/disassociated) 589 * also implies a change in the AID. 590 */ 591 brcms_err(core, "%s: %s: %sassociated\n", KBUILD_MODNAME, 592 __func__, info->assoc ? "" : "dis"); 593 spin_lock_bh(&wl->lock); 594 brcms_c_associate_upd(wl->wlc, info->assoc); 595 spin_unlock_bh(&wl->lock); 596 } 597 if (changed & BSS_CHANGED_ERP_SLOT) { 598 s8 val; 599 600 /* slot timing changed */ 601 if (info->use_short_slot) 602 val = 1; 603 else 604 val = 0; 605 spin_lock_bh(&wl->lock); 606 brcms_c_set_shortslot_override(wl->wlc, val); 607 spin_unlock_bh(&wl->lock); 608 } 609 610 if (changed & BSS_CHANGED_HT) { 611 /* 802.11n parameters changed */ 612 u16 mode = info->ht_operation_mode; 613 614 spin_lock_bh(&wl->lock); 615 brcms_c_protection_upd(wl->wlc, BRCMS_PROT_N_CFG, 616 mode & IEEE80211_HT_OP_MODE_PROTECTION); 617 brcms_c_protection_upd(wl->wlc, BRCMS_PROT_N_NONGF, 618 mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT); 619 brcms_c_protection_upd(wl->wlc, BRCMS_PROT_N_OBSS, 620 mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT); 621 spin_unlock_bh(&wl->lock); 622 } 623 if (changed & BSS_CHANGED_BASIC_RATES) { 624 struct ieee80211_supported_band *bi; 625 u32 br_mask, i; 626 u16 rate; 627 struct brcm_rateset rs; 628 int error; 629 630 /* retrieve the current rates */ 631 spin_lock_bh(&wl->lock); 632 brcms_c_get_current_rateset(wl->wlc, &rs); 633 spin_unlock_bh(&wl->lock); 634 635 br_mask = info->basic_rates; 636 bi = hw->wiphy->bands[brcms_c_get_curband(wl->wlc)]; 637 for (i = 0; i < bi->n_bitrates; i++) { 638 /* convert to internal rate value */ 639 rate = (bi->bitrates[i].bitrate << 1) / 10; 640 641 /* set/clear basic rate flag */ 642 brcms_set_basic_rate(&rs, rate, br_mask & 1); 643 br_mask >>= 1; 644 } 645 646 /* update the rate set */ 647 spin_lock_bh(&wl->lock); 648 error = brcms_c_set_rateset(wl->wlc, &rs); 649 spin_unlock_bh(&wl->lock); 650 if (error) 651 brcms_err(core, "changing basic rates failed: %d\n", 652 error); 653 } 654 if (changed & BSS_CHANGED_BEACON_INT) { 655 /* Beacon interval changed */ 656 spin_lock_bh(&wl->lock); 657 brcms_c_set_beacon_period(wl->wlc, info->beacon_int); 658 spin_unlock_bh(&wl->lock); 659 } 660 if (changed & BSS_CHANGED_BSSID) { 661 /* BSSID changed, for whatever reason (IBSS and managed mode) */ 662 spin_lock_bh(&wl->lock); 663 brcms_c_set_addrmatch(wl->wlc, RCM_BSSID_OFFSET, info->bssid); 664 spin_unlock_bh(&wl->lock); 665 } 666 if (changed & BSS_CHANGED_SSID) { 667 /* BSSID changed, for whatever reason (IBSS and managed mode) */ 668 spin_lock_bh(&wl->lock); 669 brcms_c_set_ssid(wl->wlc, info->ssid, info->ssid_len); 670 spin_unlock_bh(&wl->lock); 671 } 672 if (changed & BSS_CHANGED_BEACON) { 673 /* Beacon data changed, retrieve new beacon (beaconing modes) */ 674 struct sk_buff *beacon; 675 u16 tim_offset = 0; 676 677 spin_lock_bh(&wl->lock); 678 beacon = ieee80211_beacon_get_tim(hw, vif, &tim_offset, NULL); 679 brcms_c_set_new_beacon(wl->wlc, beacon, tim_offset, 680 info->dtim_period); 681 spin_unlock_bh(&wl->lock); 682 } 683 684 if (changed & BSS_CHANGED_AP_PROBE_RESP) { 685 struct sk_buff *probe_resp; 686 687 spin_lock_bh(&wl->lock); 688 probe_resp = ieee80211_proberesp_get(hw, vif); 689 brcms_c_set_new_probe_resp(wl->wlc, probe_resp); 690 spin_unlock_bh(&wl->lock); 691 } 692 693 if (changed & BSS_CHANGED_BEACON_ENABLED) { 694 /* Beaconing should be enabled/disabled (beaconing modes) */ 695 brcms_err(core, "%s: Beacon enabled: %s\n", __func__, 696 info->enable_beacon ? "true" : "false"); 697 if (info->enable_beacon && 698 hw->wiphy->flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) { 699 brcms_c_enable_probe_resp(wl->wlc, true); 700 } else { 701 brcms_c_enable_probe_resp(wl->wlc, false); 702 } 703 } 704 705 if (changed & BSS_CHANGED_CQM) { 706 /* Connection quality monitor config changed */ 707 brcms_err(core, "%s: cqm change: threshold %d, hys %d " 708 " (implement)\n", __func__, info->cqm_rssi_thold, 709 info->cqm_rssi_hyst); 710 } 711 712 if (changed & BSS_CHANGED_IBSS) { 713 /* IBSS join status changed */ 714 brcms_err(core, "%s: IBSS joined: %s (implement)\n", 715 __func__, info->ibss_joined ? "true" : "false"); 716 } 717 718 if (changed & BSS_CHANGED_ARP_FILTER) { 719 /* Hardware ARP filter address list or state changed */ 720 brcms_err(core, "%s: arp filtering: %d addresses" 721 " (implement)\n", __func__, info->arp_addr_cnt); 722 } 723 724 if (changed & BSS_CHANGED_QOS) { 725 /* 726 * QoS for this association was enabled/disabled. 727 * Note that it is only ever disabled for station mode. 728 */ 729 brcms_err(core, "%s: qos enabled: %s (implement)\n", 730 __func__, info->qos ? "true" : "false"); 731 } 732 return; 733} 734 735static void 736brcms_ops_configure_filter(struct ieee80211_hw *hw, 737 unsigned int changed_flags, 738 unsigned int *total_flags, u64 multicast) 739{ 740 struct brcms_info *wl = hw->priv; 741 struct bcma_device *core = wl->wlc->hw->d11core; 742 743 changed_flags &= MAC_FILTERS; 744 *total_flags &= MAC_FILTERS; 745 746 if (changed_flags & FIF_PROMISC_IN_BSS) 747 brcms_dbg_info(core, "FIF_PROMISC_IN_BSS\n"); 748 if (changed_flags & FIF_ALLMULTI) 749 brcms_dbg_info(core, "FIF_ALLMULTI\n"); 750 if (changed_flags & FIF_FCSFAIL) 751 brcms_dbg_info(core, "FIF_FCSFAIL\n"); 752 if (changed_flags & FIF_CONTROL) 753 brcms_dbg_info(core, "FIF_CONTROL\n"); 754 if (changed_flags & FIF_OTHER_BSS) 755 brcms_dbg_info(core, "FIF_OTHER_BSS\n"); 756 if (changed_flags & FIF_PSPOLL) 757 brcms_dbg_info(core, "FIF_PSPOLL\n"); 758 if (changed_flags & FIF_BCN_PRBRESP_PROMISC) 759 brcms_dbg_info(core, "FIF_BCN_PRBRESP_PROMISC\n"); 760 761 spin_lock_bh(&wl->lock); 762 brcms_c_mac_promisc(wl->wlc, *total_flags); 763 spin_unlock_bh(&wl->lock); 764 return; 765} 766 767static void brcms_ops_sw_scan_start(struct ieee80211_hw *hw, 768 struct ieee80211_vif *vif, 769 const u8 *mac_addr) 770{ 771 struct brcms_info *wl = hw->priv; 772 spin_lock_bh(&wl->lock); 773 brcms_c_scan_start(wl->wlc); 774 spin_unlock_bh(&wl->lock); 775 return; 776} 777 778static void brcms_ops_sw_scan_complete(struct ieee80211_hw *hw, 779 struct ieee80211_vif *vif) 780{ 781 struct brcms_info *wl = hw->priv; 782 spin_lock_bh(&wl->lock); 783 brcms_c_scan_stop(wl->wlc); 784 spin_unlock_bh(&wl->lock); 785 return; 786} 787 788static int 789brcms_ops_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue, 790 const struct ieee80211_tx_queue_params *params) 791{ 792 struct brcms_info *wl = hw->priv; 793 794 spin_lock_bh(&wl->lock); 795 brcms_c_wme_setparams(wl->wlc, queue, params, true); 796 spin_unlock_bh(&wl->lock); 797 798 return 0; 799} 800 801static int 802brcms_ops_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 803 struct ieee80211_sta *sta) 804{ 805 struct brcms_info *wl = hw->priv; 806 struct scb *scb = &wl->wlc->pri_scb; 807 808 brcms_c_init_scb(scb); 809 810 wl->pub->global_ampdu = &(scb->scb_ampdu); 811 wl->pub->global_ampdu->scb = scb; 812 wl->pub->global_ampdu->max_pdu = 16; 813 814 /* 815 * minstrel_ht initiates addBA on our behalf by calling 816 * ieee80211_start_tx_ba_session() 817 */ 818 return 0; 819} 820 821static int 822brcms_ops_ampdu_action(struct ieee80211_hw *hw, 823 struct ieee80211_vif *vif, 824 enum ieee80211_ampdu_mlme_action action, 825 struct ieee80211_sta *sta, u16 tid, u16 *ssn, 826 u8 buf_size) 827{ 828 struct brcms_info *wl = hw->priv; 829 struct scb *scb = &wl->wlc->pri_scb; 830 int status; 831 832 if (WARN_ON(scb->magic != SCB_MAGIC)) 833 return -EIDRM; 834 switch (action) { 835 case IEEE80211_AMPDU_RX_START: 836 break; 837 case IEEE80211_AMPDU_RX_STOP: 838 break; 839 case IEEE80211_AMPDU_TX_START: 840 spin_lock_bh(&wl->lock); 841 status = brcms_c_aggregatable(wl->wlc, tid); 842 spin_unlock_bh(&wl->lock); 843 if (!status) { 844 brcms_err(wl->wlc->hw->d11core, 845 "START: tid %d is not agg\'able\n", tid); 846 return -EINVAL; 847 } 848 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 849 break; 850 851 case IEEE80211_AMPDU_TX_STOP_CONT: 852 case IEEE80211_AMPDU_TX_STOP_FLUSH: 853 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 854 spin_lock_bh(&wl->lock); 855 brcms_c_ampdu_flush(wl->wlc, sta, tid); 856 spin_unlock_bh(&wl->lock); 857 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 858 break; 859 case IEEE80211_AMPDU_TX_OPERATIONAL: 860 /* 861 * BA window size from ADDBA response ('buf_size') defines how 862 * many outstanding MPDUs are allowed for the BA stream by 863 * recipient and traffic class. 'ampdu_factor' gives maximum 864 * AMPDU size. 865 */ 866 spin_lock_bh(&wl->lock); 867 brcms_c_ampdu_tx_operational(wl->wlc, tid, buf_size, 868 (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 869 sta->ht_cap.ampdu_factor)) - 1); 870 spin_unlock_bh(&wl->lock); 871 /* Power save wakeup */ 872 break; 873 default: 874 brcms_err(wl->wlc->hw->d11core, 875 "%s: Invalid command, ignoring\n", __func__); 876 } 877 878 return 0; 879} 880 881static void brcms_ops_rfkill_poll(struct ieee80211_hw *hw) 882{ 883 struct brcms_info *wl = hw->priv; 884 bool blocked; 885 886 spin_lock_bh(&wl->lock); 887 blocked = brcms_c_check_radio_disabled(wl->wlc); 888 spin_unlock_bh(&wl->lock); 889 890 wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, blocked); 891} 892 893static bool brcms_tx_flush_completed(struct brcms_info *wl) 894{ 895 bool result; 896 897 spin_lock_bh(&wl->lock); 898 result = brcms_c_tx_flush_completed(wl->wlc); 899 spin_unlock_bh(&wl->lock); 900 return result; 901} 902 903static void brcms_ops_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 904 u32 queues, bool drop) 905{ 906 struct brcms_info *wl = hw->priv; 907 int ret; 908 909 no_printk("%s: drop = %s\n", __func__, drop ? "true" : "false"); 910 911 ret = wait_event_timeout(wl->tx_flush_wq, 912 brcms_tx_flush_completed(wl), 913 msecs_to_jiffies(BRCMS_FLUSH_TIMEOUT)); 914 915 brcms_dbg_mac80211(wl->wlc->hw->d11core, 916 "ret=%d\n", jiffies_to_msecs(ret)); 917} 918 919static u64 brcms_ops_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 920{ 921 struct brcms_info *wl = hw->priv; 922 u64 tsf; 923 924 spin_lock_bh(&wl->lock); 925 tsf = brcms_c_tsf_get(wl->wlc); 926 spin_unlock_bh(&wl->lock); 927 928 return tsf; 929} 930 931static void brcms_ops_set_tsf(struct ieee80211_hw *hw, 932 struct ieee80211_vif *vif, u64 tsf) 933{ 934 struct brcms_info *wl = hw->priv; 935 936 spin_lock_bh(&wl->lock); 937 brcms_c_tsf_set(wl->wlc, tsf); 938 spin_unlock_bh(&wl->lock); 939} 940 941static const struct ieee80211_ops brcms_ops = { 942 .tx = brcms_ops_tx, 943 .start = brcms_ops_start, 944 .stop = brcms_ops_stop, 945 .add_interface = brcms_ops_add_interface, 946 .remove_interface = brcms_ops_remove_interface, 947 .config = brcms_ops_config, 948 .bss_info_changed = brcms_ops_bss_info_changed, 949 .configure_filter = brcms_ops_configure_filter, 950 .sw_scan_start = brcms_ops_sw_scan_start, 951 .sw_scan_complete = brcms_ops_sw_scan_complete, 952 .conf_tx = brcms_ops_conf_tx, 953 .sta_add = brcms_ops_sta_add, 954 .ampdu_action = brcms_ops_ampdu_action, 955 .rfkill_poll = brcms_ops_rfkill_poll, 956 .flush = brcms_ops_flush, 957 .get_tsf = brcms_ops_get_tsf, 958 .set_tsf = brcms_ops_set_tsf, 959}; 960 961void brcms_dpc(unsigned long data) 962{ 963 struct brcms_info *wl; 964 965 wl = (struct brcms_info *) data; 966 967 spin_lock_bh(&wl->lock); 968 969 /* call the common second level interrupt handler */ 970 if (wl->pub->up) { 971 if (wl->resched) { 972 unsigned long flags; 973 974 spin_lock_irqsave(&wl->isr_lock, flags); 975 brcms_c_intrsupd(wl->wlc); 976 spin_unlock_irqrestore(&wl->isr_lock, flags); 977 } 978 979 wl->resched = brcms_c_dpc(wl->wlc, true); 980 } 981 982 /* brcms_c_dpc() may bring the driver down */ 983 if (!wl->pub->up) 984 goto done; 985 986 /* re-schedule dpc */ 987 if (wl->resched) 988 tasklet_schedule(&wl->tasklet); 989 else 990 /* re-enable interrupts */ 991 brcms_intrson(wl); 992 993 done: 994 spin_unlock_bh(&wl->lock); 995 wake_up(&wl->tx_flush_wq); 996} 997 998static irqreturn_t brcms_isr(int irq, void *dev_id) 999{ 1000 struct brcms_info *wl; 1001 irqreturn_t ret = IRQ_NONE; 1002 1003 wl = (struct brcms_info *) dev_id; 1004 1005 spin_lock(&wl->isr_lock); 1006 1007 /* call common first level interrupt handler */ 1008 if (brcms_c_isr(wl->wlc)) { 1009 /* schedule second level handler */ 1010 tasklet_schedule(&wl->tasklet); 1011 ret = IRQ_HANDLED; 1012 } 1013 1014 spin_unlock(&wl->isr_lock); 1015 1016 return ret; 1017} 1018 1019/* 1020 * is called in brcms_pci_probe() context, therefore no locking required. 1021 */ 1022static int ieee_hw_rate_init(struct ieee80211_hw *hw) 1023{ 1024 struct brcms_info *wl = hw->priv; 1025 struct brcms_c_info *wlc = wl->wlc; 1026 struct ieee80211_supported_band *band; 1027 int has_5g = 0; 1028 u16 phy_type; 1029 1030 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL; 1031 hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL; 1032 1033 phy_type = brcms_c_get_phy_type(wl->wlc, 0); 1034 if (phy_type == PHY_TYPE_N || phy_type == PHY_TYPE_LCN) { 1035 band = &wlc->bandstate[BAND_2G_INDEX]->band; 1036 *band = brcms_band_2GHz_nphy_template; 1037 if (phy_type == PHY_TYPE_LCN) { 1038 /* Single stream */ 1039 band->ht_cap.mcs.rx_mask[1] = 0; 1040 band->ht_cap.mcs.rx_highest = cpu_to_le16(72); 1041 } 1042 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band; 1043 } else { 1044 return -EPERM; 1045 } 1046 1047 /* Assume all bands use the same phy. True for 11n devices. */ 1048 if (wl->pub->_nbands > 1) { 1049 has_5g++; 1050 if (phy_type == PHY_TYPE_N || phy_type == PHY_TYPE_LCN) { 1051 band = &wlc->bandstate[BAND_5G_INDEX]->band; 1052 *band = brcms_band_5GHz_nphy_template; 1053 hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band; 1054 } else { 1055 return -EPERM; 1056 } 1057 } 1058 return 0; 1059} 1060 1061/* 1062 * is called in brcms_pci_probe() context, therefore no locking required. 1063 */ 1064static int ieee_hw_init(struct ieee80211_hw *hw) 1065{ 1066 hw->flags = IEEE80211_HW_SIGNAL_DBM 1067 /* | IEEE80211_HW_CONNECTION_MONITOR What is this? */ 1068 | IEEE80211_HW_REPORTS_TX_ACK_STATUS 1069 | IEEE80211_HW_AMPDU_AGGREGATION; 1070 1071 hw->extra_tx_headroom = brcms_c_get_header_len(); 1072 hw->queues = N_TX_QUEUES; 1073 hw->max_rates = 2; /* Primary rate and 1 fallback rate */ 1074 1075 /* channel change time is dependent on chip and band */ 1076 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 1077 BIT(NL80211_IFTYPE_AP) | 1078 BIT(NL80211_IFTYPE_ADHOC); 1079 1080 /* 1081 * deactivate sending probe responses by ucude, because this will 1082 * cause problems when WPS is used. 1083 * 1084 * hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 1085 */ 1086 1087 hw->rate_control_algorithm = "minstrel_ht"; 1088 1089 hw->sta_data_size = 0; 1090 return ieee_hw_rate_init(hw); 1091} 1092 1093/** 1094 * attach to the WL device. 1095 * 1096 * Attach to the WL device identified by vendor and device parameters. 1097 * regs is a host accessible memory address pointing to WL device registers. 1098 * 1099 * is called in brcms_bcma_probe() context, therefore no locking required. 1100 */ 1101static struct brcms_info *brcms_attach(struct bcma_device *pdev) 1102{ 1103 struct brcms_info *wl = NULL; 1104 int unit, err; 1105 struct ieee80211_hw *hw; 1106 u8 perm[ETH_ALEN]; 1107 1108 unit = n_adapters_found; 1109 err = 0; 1110 1111 if (unit < 0) 1112 return NULL; 1113 1114 /* allocate private info */ 1115 hw = bcma_get_drvdata(pdev); 1116 if (hw != NULL) 1117 wl = hw->priv; 1118 if (WARN_ON(hw == NULL) || WARN_ON(wl == NULL)) 1119 return NULL; 1120 wl->wiphy = hw->wiphy; 1121 1122 atomic_set(&wl->callbacks, 0); 1123 1124 init_waitqueue_head(&wl->tx_flush_wq); 1125 1126 /* setup the bottom half handler */ 1127 tasklet_init(&wl->tasklet, brcms_dpc, (unsigned long) wl); 1128 1129 spin_lock_init(&wl->lock); 1130 spin_lock_init(&wl->isr_lock); 1131 1132 /* common load-time initialization */ 1133 wl->wlc = brcms_c_attach((void *)wl, pdev, unit, false, &err); 1134 if (!wl->wlc) { 1135 wiphy_err(wl->wiphy, "%s: attach() failed with code %d\n", 1136 KBUILD_MODNAME, err); 1137 goto fail; 1138 } 1139 wl->pub = brcms_c_pub(wl->wlc); 1140 1141 wl->pub->ieee_hw = hw; 1142 1143 /* register our interrupt handler */ 1144 if (request_irq(pdev->irq, brcms_isr, 1145 IRQF_SHARED, KBUILD_MODNAME, wl)) { 1146 wiphy_err(wl->wiphy, "wl%d: request_irq() failed\n", unit); 1147 goto fail; 1148 } 1149 wl->irq = pdev->irq; 1150 1151 /* register module */ 1152 brcms_c_module_register(wl->pub, "linux", wl, NULL); 1153 1154 if (ieee_hw_init(hw)) { 1155 wiphy_err(wl->wiphy, "wl%d: %s: ieee_hw_init failed!\n", unit, 1156 __func__); 1157 goto fail; 1158 } 1159 1160 brcms_c_regd_init(wl->wlc); 1161 1162 memcpy(perm, &wl->pub->cur_etheraddr, ETH_ALEN); 1163 if (WARN_ON(!is_valid_ether_addr(perm))) 1164 goto fail; 1165 SET_IEEE80211_PERM_ADDR(hw, perm); 1166 1167 err = ieee80211_register_hw(hw); 1168 if (err) 1169 wiphy_err(wl->wiphy, "%s: ieee80211_register_hw failed, status" 1170 "%d\n", __func__, err); 1171 1172 if (wl->pub->srom_ccode[0] && 1173 regulatory_hint(wl->wiphy, wl->pub->srom_ccode)) 1174 wiphy_err(wl->wiphy, "%s: regulatory hint failed\n", __func__); 1175 1176 brcms_debugfs_attach(wl->pub); 1177 brcms_debugfs_create_files(wl->pub); 1178 n_adapters_found++; 1179 return wl; 1180 1181fail: 1182 brcms_free(wl); 1183 return NULL; 1184} 1185 1186 1187 1188/** 1189 * determines if a device is a WL device, and if so, attaches it. 1190 * 1191 * This function determines if a device pointed to by pdev is a WL device, 1192 * and if so, performs a brcms_attach() on it. 1193 * 1194 * Perimeter lock is initialized in the course of this function. 1195 */ 1196static int brcms_bcma_probe(struct bcma_device *pdev) 1197{ 1198 struct brcms_info *wl; 1199 struct ieee80211_hw *hw; 1200 1201 dev_info(&pdev->dev, "mfg %x core %x rev %d class %d irq %d\n", 1202 pdev->id.manuf, pdev->id.id, pdev->id.rev, pdev->id.class, 1203 pdev->irq); 1204 1205 if ((pdev->id.manuf != BCMA_MANUF_BCM) || 1206 (pdev->id.id != BCMA_CORE_80211)) 1207 return -ENODEV; 1208 1209 hw = ieee80211_alloc_hw(sizeof(struct brcms_info), &brcms_ops); 1210 if (!hw) { 1211 pr_err("%s: ieee80211_alloc_hw failed\n", __func__); 1212 return -ENOMEM; 1213 } 1214 1215 SET_IEEE80211_DEV(hw, &pdev->dev); 1216 1217 bcma_set_drvdata(pdev, hw); 1218 1219 memset(hw->priv, 0, sizeof(*wl)); 1220 1221 wl = brcms_attach(pdev); 1222 if (!wl) { 1223 pr_err("%s: brcms_attach failed!\n", __func__); 1224 return -ENODEV; 1225 } 1226 brcms_led_register(wl); 1227 1228 return 0; 1229} 1230 1231static int brcms_suspend(struct bcma_device *pdev) 1232{ 1233 struct brcms_info *wl; 1234 struct ieee80211_hw *hw; 1235 1236 hw = bcma_get_drvdata(pdev); 1237 wl = hw->priv; 1238 if (!wl) { 1239 pr_err("%s: %s: no driver private struct!\n", KBUILD_MODNAME, 1240 __func__); 1241 return -ENODEV; 1242 } 1243 1244 /* only need to flag hw is down for proper resume */ 1245 spin_lock_bh(&wl->lock); 1246 wl->pub->hw_up = false; 1247 spin_unlock_bh(&wl->lock); 1248 1249 brcms_dbg_info(wl->wlc->hw->d11core, "brcms_suspend ok\n"); 1250 1251 return 0; 1252} 1253 1254static int brcms_resume(struct bcma_device *pdev) 1255{ 1256 return 0; 1257} 1258 1259static struct bcma_driver brcms_bcma_driver = { 1260 .name = KBUILD_MODNAME, 1261 .probe = brcms_bcma_probe, 1262 .suspend = brcms_suspend, 1263 .resume = brcms_resume, 1264 .remove = brcms_remove, 1265 .id_table = brcms_coreid_table, 1266}; 1267 1268/** 1269 * This is the main entry point for the brcmsmac driver. 1270 * 1271 * This function is scheduled upon module initialization and 1272 * does the driver registration, which result in brcms_bcma_probe() 1273 * call resulting in the driver bringup. 1274 */ 1275static void brcms_driver_init(struct work_struct *work) 1276{ 1277 int error; 1278 1279 error = bcma_driver_register(&brcms_bcma_driver); 1280 if (error) 1281 pr_err("%s: register returned %d\n", __func__, error); 1282} 1283 1284static DECLARE_WORK(brcms_driver_work, brcms_driver_init); 1285 1286static int __init brcms_module_init(void) 1287{ 1288 brcms_debugfs_init(); 1289 if (!schedule_work(&brcms_driver_work)) 1290 return -EBUSY; 1291 1292 return 0; 1293} 1294 1295/** 1296 * This function unloads the brcmsmac driver from the system. 1297 * 1298 * This function unconditionally unloads the brcmsmac driver module from the 1299 * system. 1300 * 1301 */ 1302static void __exit brcms_module_exit(void) 1303{ 1304 cancel_work_sync(&brcms_driver_work); 1305 bcma_driver_unregister(&brcms_bcma_driver); 1306 brcms_debugfs_exit(); 1307} 1308 1309module_init(brcms_module_init); 1310module_exit(brcms_module_exit); 1311 1312/* 1313 * precondition: perimeter lock has been acquired 1314 */ 1315void brcms_txflowcontrol(struct brcms_info *wl, struct brcms_if *wlif, 1316 bool state, int prio) 1317{ 1318 brcms_err(wl->wlc->hw->d11core, "Shouldn't be here %s\n", __func__); 1319} 1320 1321/* 1322 * precondition: perimeter lock has been acquired 1323 */ 1324void brcms_init(struct brcms_info *wl) 1325{ 1326 brcms_dbg_info(wl->wlc->hw->d11core, "Initializing wl%d\n", 1327 wl->pub->unit); 1328 brcms_reset(wl); 1329 brcms_c_init(wl->wlc, wl->mute_tx); 1330} 1331 1332/* 1333 * precondition: perimeter lock has been acquired 1334 */ 1335uint brcms_reset(struct brcms_info *wl) 1336{ 1337 brcms_dbg_info(wl->wlc->hw->d11core, "Resetting wl%d\n", wl->pub->unit); 1338 brcms_c_reset(wl->wlc); 1339 1340 /* dpc will not be rescheduled */ 1341 wl->resched = false; 1342 1343 /* inform publicly that interface is down */ 1344 wl->pub->up = false; 1345 1346 return 0; 1347} 1348 1349void brcms_fatal_error(struct brcms_info *wl) 1350{ 1351 brcms_err(wl->wlc->hw->d11core, "wl%d: fatal error, reinitializing\n", 1352 wl->wlc->pub->unit); 1353 brcms_reset(wl); 1354 ieee80211_restart_hw(wl->pub->ieee_hw); 1355} 1356 1357/* 1358 * These are interrupt on/off entry points. Disable interrupts 1359 * during interrupt state transition. 1360 */ 1361void brcms_intrson(struct brcms_info *wl) 1362{ 1363 unsigned long flags; 1364 1365 spin_lock_irqsave(&wl->isr_lock, flags); 1366 brcms_c_intrson(wl->wlc); 1367 spin_unlock_irqrestore(&wl->isr_lock, flags); 1368} 1369 1370u32 brcms_intrsoff(struct brcms_info *wl) 1371{ 1372 unsigned long flags; 1373 u32 status; 1374 1375 spin_lock_irqsave(&wl->isr_lock, flags); 1376 status = brcms_c_intrsoff(wl->wlc); 1377 spin_unlock_irqrestore(&wl->isr_lock, flags); 1378 return status; 1379} 1380 1381void brcms_intrsrestore(struct brcms_info *wl, u32 macintmask) 1382{ 1383 unsigned long flags; 1384 1385 spin_lock_irqsave(&wl->isr_lock, flags); 1386 brcms_c_intrsrestore(wl->wlc, macintmask); 1387 spin_unlock_irqrestore(&wl->isr_lock, flags); 1388} 1389 1390/* 1391 * precondition: perimeter lock has been acquired 1392 */ 1393int brcms_up(struct brcms_info *wl) 1394{ 1395 int error = 0; 1396 1397 if (wl->pub->up) 1398 return 0; 1399 1400 error = brcms_c_up(wl->wlc); 1401 1402 return error; 1403} 1404 1405/* 1406 * precondition: perimeter lock has been acquired 1407 */ 1408void brcms_down(struct brcms_info *wl) 1409{ 1410 uint callbacks, ret_val = 0; 1411 1412 /* call common down function */ 1413 ret_val = brcms_c_down(wl->wlc); 1414 callbacks = atomic_read(&wl->callbacks) - ret_val; 1415 1416 /* wait for down callbacks to complete */ 1417 spin_unlock_bh(&wl->lock); 1418 1419 /* For HIGH_only driver, it's important to actually schedule other work, 1420 * not just spin wait since everything runs at schedule level 1421 */ 1422 SPINWAIT((atomic_read(&wl->callbacks) > callbacks), 100 * 1000); 1423 1424 spin_lock_bh(&wl->lock); 1425} 1426 1427/* 1428* precondition: perimeter lock is not acquired 1429 */ 1430static void _brcms_timer(struct work_struct *work) 1431{ 1432 struct brcms_timer *t = container_of(work, struct brcms_timer, 1433 dly_wrk.work); 1434 1435 spin_lock_bh(&t->wl->lock); 1436 1437 if (t->set) { 1438 if (t->periodic) { 1439 atomic_inc(&t->wl->callbacks); 1440 ieee80211_queue_delayed_work(t->wl->pub->ieee_hw, 1441 &t->dly_wrk, 1442 msecs_to_jiffies(t->ms)); 1443 } else { 1444 t->set = false; 1445 } 1446 1447 t->fn(t->arg); 1448 } 1449 1450 atomic_dec(&t->wl->callbacks); 1451 1452 spin_unlock_bh(&t->wl->lock); 1453} 1454 1455/* 1456 * Adds a timer to the list. Caller supplies a timer function. 1457 * Is called from wlc. 1458 * 1459 * precondition: perimeter lock has been acquired 1460 */ 1461struct brcms_timer *brcms_init_timer(struct brcms_info *wl, 1462 void (*fn) (void *arg), 1463 void *arg, const char *name) 1464{ 1465 struct brcms_timer *t; 1466 1467 t = kzalloc(sizeof(struct brcms_timer), GFP_ATOMIC); 1468 if (!t) 1469 return NULL; 1470 1471 INIT_DELAYED_WORK(&t->dly_wrk, _brcms_timer); 1472 t->wl = wl; 1473 t->fn = fn; 1474 t->arg = arg; 1475 t->next = wl->timers; 1476 wl->timers = t; 1477 1478#ifdef DEBUG 1479 t->name = kmalloc(strlen(name) + 1, GFP_ATOMIC); 1480 if (t->name) 1481 strcpy(t->name, name); 1482#endif 1483 1484 return t; 1485} 1486 1487/* 1488 * adds only the kernel timer since it's going to be more accurate 1489 * as well as it's easier to make it periodic 1490 * 1491 * precondition: perimeter lock has been acquired 1492 */ 1493void brcms_add_timer(struct brcms_timer *t, uint ms, int periodic) 1494{ 1495 struct ieee80211_hw *hw = t->wl->pub->ieee_hw; 1496 1497#ifdef DEBUG 1498 if (t->set) 1499 brcms_dbg_info(t->wl->wlc->hw->d11core, 1500 "%s: Already set. Name: %s, per %d\n", 1501 __func__, t->name, periodic); 1502#endif 1503 t->ms = ms; 1504 t->periodic = (bool) periodic; 1505 if (!t->set) { 1506 t->set = true; 1507 atomic_inc(&t->wl->callbacks); 1508 } 1509 1510 ieee80211_queue_delayed_work(hw, &t->dly_wrk, msecs_to_jiffies(ms)); 1511} 1512 1513/* 1514 * return true if timer successfully deleted, false if still pending 1515 * 1516 * precondition: perimeter lock has been acquired 1517 */ 1518bool brcms_del_timer(struct brcms_timer *t) 1519{ 1520 if (t->set) { 1521 t->set = false; 1522 if (!cancel_delayed_work(&t->dly_wrk)) 1523 return false; 1524 1525 atomic_dec(&t->wl->callbacks); 1526 } 1527 1528 return true; 1529} 1530 1531/* 1532 * precondition: perimeter lock has been acquired 1533 */ 1534void brcms_free_timer(struct brcms_timer *t) 1535{ 1536 struct brcms_info *wl = t->wl; 1537 struct brcms_timer *tmp; 1538 1539 /* delete the timer in case it is active */ 1540 brcms_del_timer(t); 1541 1542 if (wl->timers == t) { 1543 wl->timers = wl->timers->next; 1544#ifdef DEBUG 1545 kfree(t->name); 1546#endif 1547 kfree(t); 1548 return; 1549 1550 } 1551 1552 tmp = wl->timers; 1553 while (tmp) { 1554 if (tmp->next == t) { 1555 tmp->next = t->next; 1556#ifdef DEBUG 1557 kfree(t->name); 1558#endif 1559 kfree(t); 1560 return; 1561 } 1562 tmp = tmp->next; 1563 } 1564 1565} 1566 1567/* 1568 * precondition: perimeter lock has been acquired 1569 */ 1570int brcms_ucode_init_buf(struct brcms_info *wl, void **pbuf, u32 idx) 1571{ 1572 int i, entry; 1573 const u8 *pdata; 1574 struct firmware_hdr *hdr; 1575 for (i = 0; i < wl->fw.fw_cnt; i++) { 1576 hdr = (struct firmware_hdr *)wl->fw.fw_hdr[i]->data; 1577 for (entry = 0; entry < wl->fw.hdr_num_entries[i]; 1578 entry++, hdr++) { 1579 u32 len = le32_to_cpu(hdr->len); 1580 if (le32_to_cpu(hdr->idx) == idx) { 1581 pdata = wl->fw.fw_bin[i]->data + 1582 le32_to_cpu(hdr->offset); 1583 *pbuf = kmemdup(pdata, len, GFP_ATOMIC); 1584 if (*pbuf == NULL) 1585 goto fail; 1586 1587 return 0; 1588 } 1589 } 1590 } 1591 brcms_err(wl->wlc->hw->d11core, 1592 "ERROR: ucode buf tag:%d can not be found!\n", idx); 1593 *pbuf = NULL; 1594fail: 1595 return -ENODATA; 1596} 1597 1598/* 1599 * Precondition: Since this function is called in brcms_bcma_probe() context, 1600 * no locking is required. 1601 */ 1602int brcms_ucode_init_uint(struct brcms_info *wl, size_t *n_bytes, u32 idx) 1603{ 1604 int i, entry; 1605 const u8 *pdata; 1606 struct firmware_hdr *hdr; 1607 for (i = 0; i < wl->fw.fw_cnt; i++) { 1608 hdr = (struct firmware_hdr *)wl->fw.fw_hdr[i]->data; 1609 for (entry = 0; entry < wl->fw.hdr_num_entries[i]; 1610 entry++, hdr++) { 1611 if (le32_to_cpu(hdr->idx) == idx) { 1612 pdata = wl->fw.fw_bin[i]->data + 1613 le32_to_cpu(hdr->offset); 1614 if (le32_to_cpu(hdr->len) != 4) { 1615 brcms_err(wl->wlc->hw->d11core, 1616 "ERROR: fw hdr len\n"); 1617 return -ENOMSG; 1618 } 1619 *n_bytes = le32_to_cpu(*((__le32 *) pdata)); 1620 return 0; 1621 } 1622 } 1623 } 1624 brcms_err(wl->wlc->hw->d11core, 1625 "ERROR: ucode tag:%d can not be found!\n", idx); 1626 return -ENOMSG; 1627} 1628 1629/* 1630 * precondition: can both be called locked and unlocked 1631 */ 1632void brcms_ucode_free_buf(void *p) 1633{ 1634 kfree(p); 1635} 1636 1637/* 1638 * checks validity of all firmware images loaded from user space 1639 * 1640 * Precondition: Since this function is called in brcms_bcma_probe() context, 1641 * no locking is required. 1642 */ 1643int brcms_check_firmwares(struct brcms_info *wl) 1644{ 1645 int i; 1646 int entry; 1647 int rc = 0; 1648 const struct firmware *fw; 1649 const struct firmware *fw_hdr; 1650 struct firmware_hdr *ucode_hdr; 1651 for (i = 0; i < MAX_FW_IMAGES && rc == 0; i++) { 1652 fw = wl->fw.fw_bin[i]; 1653 fw_hdr = wl->fw.fw_hdr[i]; 1654 if (fw == NULL && fw_hdr == NULL) { 1655 break; 1656 } else if (fw == NULL || fw_hdr == NULL) { 1657 wiphy_err(wl->wiphy, "%s: invalid bin/hdr fw\n", 1658 __func__); 1659 rc = -EBADF; 1660 } else if (fw_hdr->size % sizeof(struct firmware_hdr)) { 1661 wiphy_err(wl->wiphy, "%s: non integral fw hdr file " 1662 "size %zu/%zu\n", __func__, fw_hdr->size, 1663 sizeof(struct firmware_hdr)); 1664 rc = -EBADF; 1665 } else if (fw->size < MIN_FW_SIZE || fw->size > MAX_FW_SIZE) { 1666 wiphy_err(wl->wiphy, "%s: out of bounds fw file size %zu\n", 1667 __func__, fw->size); 1668 rc = -EBADF; 1669 } else { 1670 /* check if ucode section overruns firmware image */ 1671 ucode_hdr = (struct firmware_hdr *)fw_hdr->data; 1672 for (entry = 0; entry < wl->fw.hdr_num_entries[i] && 1673 !rc; entry++, ucode_hdr++) { 1674 if (le32_to_cpu(ucode_hdr->offset) + 1675 le32_to_cpu(ucode_hdr->len) > 1676 fw->size) { 1677 wiphy_err(wl->wiphy, 1678 "%s: conflicting bin/hdr\n", 1679 __func__); 1680 rc = -EBADF; 1681 } 1682 } 1683 } 1684 } 1685 if (rc == 0 && wl->fw.fw_cnt != i) { 1686 wiphy_err(wl->wiphy, "%s: invalid fw_cnt=%d\n", __func__, 1687 wl->fw.fw_cnt); 1688 rc = -EBADF; 1689 } 1690 return rc; 1691} 1692 1693/* 1694 * precondition: perimeter lock has been acquired 1695 */ 1696bool brcms_rfkill_set_hw_state(struct brcms_info *wl) 1697{ 1698 bool blocked = brcms_c_check_radio_disabled(wl->wlc); 1699 1700 spin_unlock_bh(&wl->lock); 1701 wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, blocked); 1702 if (blocked) 1703 wiphy_rfkill_start_polling(wl->pub->ieee_hw->wiphy); 1704 spin_lock_bh(&wl->lock); 1705 return blocked; 1706} 1707