drivers/staging/brcm80211/brcmsmac/mac80211_if.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   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 ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #define __UNDEF_NO_VERSION__
  18
  19 #include <linux/etherdevice.h>
  20 #include <linux/pci.h>
  21 #include <linux/sched.h>
  22 #include <linux/firmware.h>
  23 #include <net/mac80211.h>
  24 #include <defs.h>
  25 #include "nicpci.h"
  26 #include "phy/phy_int.h"
  27 #include "d11.h"
  28 #include "channel.h"
  29 #include "scb.h"
  30 #include "pub.h"
  31 #include "ucode_loader.h"
  32 #include "mac80211_if.h"
  33
  34 #define N_TX_QUEUES     4 /* #tx queues on mac80211<->driver interface */
  35
  36 #define LOCK(wl)        spin_lock_bh(&(wl)->lock)
  37 #define UNLOCK(wl)      spin_unlock_bh(&(wl)->lock)
  38
  39 /* locking from inside brcms_isr */
  40 #define ISR_LOCK(wl, flags)\
  41         do {\
  42                 spin_lock(&(wl)->isr_lock);\
  43                 (void)(flags); } \
  44         while (0)
  45
  46 #define ISR_UNLOCK(wl, flags)\
  47         do {\
  48                 spin_unlock(&(wl)->isr_lock);\
  49                 (void)(flags); } \
  50         while (0)
  51
  52 /* locking under LOCK() to synchronize with brcms_isr */
  53 #define INT_LOCK(wl, flags)     spin_lock_irqsave(&(wl)->isr_lock, flags)
  54 #define INT_UNLOCK(wl, flags)   spin_unlock_irqrestore(&(wl)->isr_lock, flags)
  55
  56 static void brcms_timer(unsigned long data);
  57 static void _brcms_timer(struct brcms_timer *t);
  58
  59
  60 static int ieee_hw_init(struct ieee80211_hw *hw);
  61 static int ieee_hw_rate_init(struct ieee80211_hw *hw);
  62
  63 static int wl_linux_watchdog(void *ctx);
  64
  65 /* Flags we support */
  66 #define MAC_FILTERS (FIF_PROMISC_IN_BSS | \
  67         FIF_ALLMULTI | \
  68         FIF_FCSFAIL | \
  69         FIF_PLCPFAIL | \
  70         FIF_CONTROL | \
  71         FIF_OTHER_BSS | \
  72         FIF_BCN_PRBRESP_PROMISC)
  73
  74 static int n_adapters_found;
  75
  76 static int brcms_request_fw(struct brcms_info *wl, struct pci_dev *pdev);
  77 static void brcms_release_fw(struct brcms_info *wl);
  78
  79 /* local prototypes */
  80 static void brcms_dpc(unsigned long data);
  81 static irqreturn_t brcms_isr(int irq, void *dev_id);
  82
  83 static int __devinit brcms_pci_probe(struct pci_dev *pdev,
  84                                   const struct pci_device_id *ent);
  85 static void brcms_remove(struct pci_dev *pdev);
  86 static void brcms_free(struct brcms_info *wl);
  87 static void brcms_set_basic_rate(struct wl_rateset *rs, u16 rate, bool is_br);
  88
  89 MODULE_AUTHOR("Broadcom Corporation");
  90 MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver.");
  91 MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
  92 MODULE_LICENSE("Dual BSD/GPL");
  93
  94 /* recognized PCI IDs */
  95 static DEFINE_PCI_DEVICE_TABLE(brcms_pci_id_table) = {
  96         {PCI_VENDOR_ID_BROADCOM, 0x4357, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},      /* 43225 2G */
  97         {PCI_VENDOR_ID_BROADCOM, 0x4353, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},      /* 43224 DUAL */
  98         {PCI_VENDOR_ID_BROADCOM, 0x4727, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},      /* 4313 DUAL */
  99         /* 43224 Ven */
 100         {PCI_VENDOR_ID_BROADCOM, 0x0576, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
 101         {0}
 102 };
 103
 104 MODULE_DEVICE_TABLE(pci, brcms_pci_id_table);
 105
 106 #ifdef BCMDBG
 107 static int msglevel = 0xdeadbeef;
 108 module_param(msglevel, int, 0);
 109 static int phymsglevel = 0xdeadbeef;
 110 module_param(phymsglevel, int, 0);
 111 #endif                          /* BCMDBG */
 112
 113 #define HW_TO_WL(hw)     (hw->priv)
 114 #define WL_TO_HW(wl)      (wl->pub->ieee_hw)
 115
 116 /* MAC80211 callback functions */
 117 static int brcms_ops_start(struct ieee80211_hw *hw);
 118 static void brcms_ops_stop(struct ieee80211_hw *hw);
 119 static int brcms_ops_add_interface(struct ieee80211_hw *hw,
 120                                 struct ieee80211_vif *vif);
 121 static void brcms_ops_remove_interface(struct ieee80211_hw *hw,
 122                                     struct ieee80211_vif *vif);
 123 static int brcms_ops_config(struct ieee80211_hw *hw, u32 changed);
 124 static void brcms_ops_bss_info_changed(struct ieee80211_hw *hw,
 125                                     struct ieee80211_vif *vif,
 126                                     struct ieee80211_bss_conf *info,
 127                                     u32 changed);
 128 static void brcms_ops_configure_filter(struct ieee80211_hw *hw,
 129                                     unsigned int changed_flags,
 130                                     unsigned int *total_flags, u64 multicast);
 131 static int brcms_ops_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
 132                           bool set);
 133 static void brcms_ops_sw_scan_start(struct ieee80211_hw *hw);
 134 static void brcms_ops_sw_scan_complete(struct ieee80211_hw *hw);
 135 static void brcms_ops_set_tsf(struct ieee80211_hw *hw, u64 tsf);
 136 static int brcms_ops_get_stats(struct ieee80211_hw *hw,
 137                             struct ieee80211_low_level_stats *stats);
 138 static void brcms_ops_sta_notify(struct ieee80211_hw *hw,
 139                               struct ieee80211_vif *vif,
 140                               enum sta_notify_cmd cmd,
 141                               struct ieee80211_sta *sta);
 142 static int brcms_ops_conf_tx(struct ieee80211_hw *hw, u16 queue,
 143                           const struct ieee80211_tx_queue_params *params);
 144 static u64 brcms_ops_get_tsf(struct ieee80211_hw *hw);
 145 static int brcms_ops_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 146                       struct ieee80211_sta *sta);
 147 static int brcms_ops_sta_remove(struct ieee80211_hw *hw,
 148                                 struct ieee80211_vif *vif,
 149                                 struct ieee80211_sta *sta);
 150 static int brcms_ops_ampdu_action(struct ieee80211_hw *hw,
 151                                struct ieee80211_vif *vif,
 152                                enum ieee80211_ampdu_mlme_action action,
 153                                struct ieee80211_sta *sta, u16 tid, u16 *ssn,
 154                                u8 buf_size);
 155 static void brcms_ops_rfkill_poll(struct ieee80211_hw *hw);
 156 static void brcms_ops_flush(struct ieee80211_hw *hw, bool drop);
 157
 158 static void brcms_ops_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 159 {
 160         struct brcms_info *wl = hw->priv;
 161
 162         LOCK(wl);
 163         if (!wl->pub->up) {
 164                 wiphy_err(wl->wiphy, "ops->tx called while down\n");
 165                 kfree_skb(skb);
 166                 goto done;
 167         }
 168         brcms_c_sendpkt_mac80211(wl->wlc, skb, hw);
 169  done:
 170         UNLOCK(wl);
 171 }
 172
 173 static int brcms_ops_start(struct ieee80211_hw *hw)
 174 {
 175         struct brcms_info *wl = hw->priv;
 176         bool blocked;
 177         /*
 178           struct ieee80211_channel *curchan = hw->conf.channel;
 179         */
 180
 181         ieee80211_wake_queues(hw);
 182         LOCK(wl);
 183         blocked = brcms_rfkill_set_hw_state(wl);
 184         UNLOCK(wl);
 185         if (!blocked)
 186                 wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy);
 187
 188         return 0;
 189 }
 190
 191 static void brcms_ops_stop(struct ieee80211_hw *hw)
 192 {
 193         ieee80211_stop_queues(hw);
 194 }
 195
 196 static int
 197 brcms_ops_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 198 {
 199         struct brcms_info *wl;
 200         int err;
 201
 202         /* Just STA for now */
 203         if (vif->type != NL80211_IFTYPE_AP &&
 204             vif->type != NL80211_IFTYPE_MESH_POINT &&
 205             vif->type != NL80211_IFTYPE_STATION &&
 206             vif->type != NL80211_IFTYPE_WDS &&
 207             vif->type != NL80211_IFTYPE_ADHOC) {
 208                 wiphy_err(hw->wiphy, "%s: Attempt to add type %d, only"
 209                           " STA for now\n", __func__, vif->type);
 210                 return -EOPNOTSUPP;
 211         }
 212
 213         wl = HW_TO_WL(hw);
 214         LOCK(wl);
 215         err = brcms_up(wl);
 216         UNLOCK(wl);
 217
 218         if (err != 0) {
 219                 wiphy_err(hw->wiphy, "%s: brcms_up() returned %d\n", __func__,
 220                           err);
 221         }
 222         return err;
 223 }
 224
 225 static void
 226 brcms_ops_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 227 {
 228         struct brcms_info *wl;
 229
 230         wl = HW_TO_WL(hw);
 231
 232         /* put driver in down state */
 233         LOCK(wl);
 234         brcms_down(wl);
 235         UNLOCK(wl);
 236 }
 237
 238 /*
 239  * precondition: perimeter lock has been acquired
 240  */
 241 static int
 242 ieee_set_channel(struct ieee80211_hw *hw, struct ieee80211_channel *chan,
 243                  enum nl80211_channel_type type)
 244 {
 245         struct brcms_info *wl = HW_TO_WL(hw);
 246         int err = 0;
 247
 248         switch (type) {
 249         case NL80211_CHAN_HT20:
 250         case NL80211_CHAN_NO_HT:
 251                 err = brcms_c_set(wl->wlc, WLC_SET_CHANNEL, chan->hw_value);
 252                 break;
 253         case NL80211_CHAN_HT40MINUS:
 254         case NL80211_CHAN_HT40PLUS:
 255                 wiphy_err(hw->wiphy,
 256                           "%s: Need to implement 40 Mhz Channels!\n", __func__);
 257                 err = 1;
 258                 break;
 259         }
 260
 261         if (err)
 262                 return -EIO;
 263         return err;
 264 }
 265
 266 static int brcms_ops_config(struct ieee80211_hw *hw, u32 changed)
 267 {
 268         struct ieee80211_conf *conf = &hw->conf;
 269         struct brcms_info *wl = HW_TO_WL(hw);
 270         int err = 0;
 271         int new_int;
 272         struct wiphy *wiphy = hw->wiphy;
 273
 274         LOCK(wl);
 275         if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
 276                 if (brcms_c_set_par(wl->wlc, IOV_BCN_LI_BCN,
 277                                     conf->listen_interval) < 0) {
 278                         wiphy_err(wiphy, "%s: Error setting listen_interval\n",
 279                                   __func__);
 280                         err = -EIO;
 281                         goto config_out;
 282                 }
 283                 brcms_c_get_par(wl->wlc, IOV_BCN_LI_BCN, &new_int);
 284         }
 285         if (changed & IEEE80211_CONF_CHANGE_MONITOR)
 286                 wiphy_err(wiphy, "%s: change monitor mode: %s (implement)\n",
 287                           __func__, conf->flags & IEEE80211_CONF_MONITOR ?
 288                           "true" : "false");
 289         if (changed & IEEE80211_CONF_CHANGE_PS)
 290                 wiphy_err(wiphy, "%s: change power-save mode: %s (implement)\n",
 291                           __func__, conf->flags & IEEE80211_CONF_PS ?
 292                           "true" : "false");
 293
 294         if (changed & IEEE80211_CONF_CHANGE_POWER) {
 295                 if (brcms_c_set_par(wl->wlc, IOV_QTXPOWER,
 296                                     conf->power_level * 4) < 0) {
 297                         wiphy_err(wiphy, "%s: Error setting power_level\n",
 298                                   __func__);
 299                         err = -EIO;
 300                         goto config_out;
 301                 }
 302                 brcms_c_get_par(wl->wlc, IOV_QTXPOWER, &new_int);
 303                 if (new_int != (conf->power_level * 4))
 304                         wiphy_err(wiphy, "%s: Power level req != actual, %d %d"
 305                                   "\n", __func__, conf->power_level * 4,
 306                                   new_int);
 307         }
 308         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
 309                 err = ieee_set_channel(hw, conf->channel, conf->channel_type);
 310         }
 311         if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
 312                 if (brcms_c_set
 313                     (wl->wlc, WLC_SET_SRL,
 314                      conf->short_frame_max_tx_count) < 0) {
 315                         wiphy_err(wiphy, "%s: Error setting srl\n", __func__);
 316                         err = -EIO;
 317                         goto config_out;
 318                 }
 319                 if (brcms_c_set(wl->wlc, WLC_SET_LRL,
 320                                 conf->long_frame_max_tx_count) < 0) {
 321                         wiphy_err(wiphy, "%s: Error setting lrl\n", __func__);
 322                         err = -EIO;
 323                         goto config_out;
 324                 }
 325         }
 326
 327  config_out:
 328         UNLOCK(wl);
 329         return err;
 330 }
 331
 332 static void
 333 brcms_ops_bss_info_changed(struct ieee80211_hw *hw,
 334                         struct ieee80211_vif *vif,
 335                         struct ieee80211_bss_conf *info, u32 changed)
 336 {
 337         struct brcms_info *wl = HW_TO_WL(hw);
 338         struct wiphy *wiphy = hw->wiphy;
 339         int val;
 340
 341         if (changed & BSS_CHANGED_ASSOC) {
 342                 /* association status changed (associated/disassociated)
 343                  * also implies a change in the AID.
 344                  */
 345                 wiphy_err(wiphy, "%s: %s: %sassociated\n", KBUILD_MODNAME,
 346                           __func__, info->assoc ? "" : "dis");
 347                 LOCK(wl);
 348                 brcms_c_associate_upd(wl->wlc, info->assoc);
 349                 UNLOCK(wl);
 350         }
 351         if (changed & BSS_CHANGED_ERP_SLOT) {
 352                 /* slot timing changed */
 353                 if (info->use_short_slot)
 354                         val = 1;
 355                 else
 356                         val = 0;
 357                 LOCK(wl);
 358                 brcms_c_set(wl->wlc, WLC_SET_SHORTSLOT_OVERRIDE, val);
 359                 UNLOCK(wl);
 360         }
 361
 362         if (changed & BSS_CHANGED_HT) {
 363                 /* 802.11n parameters changed */
 364                 u16 mode = info->ht_operation_mode;
 365
 366                 LOCK(wl);
 367                 brcms_c_protection_upd(wl->wlc, WLC_PROT_N_CFG,
 368                         mode & IEEE80211_HT_OP_MODE_PROTECTION);
 369                 brcms_c_protection_upd(wl->wlc, WLC_PROT_N_NONGF,
 370                         mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
 371                 brcms_c_protection_upd(wl->wlc, WLC_PROT_N_OBSS,
 372                         mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT);
 373                 UNLOCK(wl);
 374         }
 375         if (changed & BSS_CHANGED_BASIC_RATES) {
 376                 struct ieee80211_supported_band *bi;
 377                 u32 br_mask, i;
 378                 u16 rate;
 379                 struct wl_rateset rs;
 380                 int error;
 381
 382                 /* retrieve the current rates */
 383                 LOCK(wl);
 384                 error = brcms_c_ioctl(wl->wlc, WLC_GET_CURR_RATESET,
 385                                   &rs, sizeof(rs), NULL);
 386                 UNLOCK(wl);
 387                 if (error) {
 388                         wiphy_err(wiphy, "%s: retrieve rateset failed: %d\n",
 389                                   __func__, error);
 390                         return;
 391                 }
 392                 br_mask = info->basic_rates;
 393                 bi = hw->wiphy->bands[brcms_c_get_curband(wl->wlc)];
 394                 for (i = 0; i < bi->n_bitrates; i++) {
 395                         /* convert to internal rate value */
 396                         rate = (bi->bitrates[i].bitrate << 1) / 10;
 397
 398                         /* set/clear basic rate flag */
 399                         brcms_set_basic_rate(&rs, rate, br_mask & 1);
 400                         br_mask >>= 1;
 401                 }
 402
 403                 /* update the rate set */
 404                 LOCK(wl);
 405                 brcms_c_ioctl(wl->wlc, WLC_SET_RATESET, &rs, sizeof(rs), NULL);
 406                 UNLOCK(wl);
 407         }
 408         if (changed & BSS_CHANGED_BEACON_INT) {
 409                 /* Beacon interval changed */
 410                 LOCK(wl);
 411                 brcms_c_set(wl->wlc, WLC_SET_BCNPRD, info->beacon_int);
 412                 UNLOCK(wl);
 413         }
 414         if (changed & BSS_CHANGED_BSSID) {
 415                 /* BSSID changed, for whatever reason (IBSS and managed mode) */
 416                 LOCK(wl);
 417                 brcms_c_set_addrmatch(wl->wlc, RCM_BSSID_OFFSET,
 418                                   info->bssid);
 419                 UNLOCK(wl);
 420         }
 421         if (changed & BSS_CHANGED_BEACON) {
 422                 /* Beacon data changed, retrieve new beacon (beaconing modes) */
 423                 wiphy_err(wiphy, "%s: beacon changed\n", __func__);
 424         }
 425         if (changed & BSS_CHANGED_BEACON_ENABLED) {
 426                 /* Beaconing should be enabled/disabled (beaconing modes) */
 427                 wiphy_err(wiphy, "%s: Beacon enabled: %s\n", __func__,
 428                           info->enable_beacon ? "true" : "false");
 429         }
 430         if (changed & BSS_CHANGED_CQM) {
 431                 /* Connection quality monitor config changed */
 432                 wiphy_err(wiphy, "%s: cqm change: threshold %d, hys %d "
 433                           " (implement)\n", __func__, info->cqm_rssi_thold,
 434                           info->cqm_rssi_hyst);
 435         }
 436         if (changed & BSS_CHANGED_IBSS) {
 437                 /* IBSS join status changed */
 438                 wiphy_err(wiphy, "%s: IBSS joined: %s (implement)\n", __func__,
 439                           info->ibss_joined ? "true" : "false");
 440         }
 441         if (changed & BSS_CHANGED_ARP_FILTER) {
 442                 /* Hardware ARP filter address list or state changed */
 443                 wiphy_err(wiphy, "%s: arp filtering: enabled %s, count %d"
 444                           " (implement)\n", __func__, info->arp_filter_enabled ?
 445                           "true" : "false", info->arp_addr_cnt);
 446         }
 447         if (changed & BSS_CHANGED_QOS) {
 448                 /*
 449                  * QoS for this association was enabled/disabled.
 450                  * Note that it is only ever disabled for station mode.
 451                  */
 452                 wiphy_err(wiphy, "%s: qos enabled: %s (implement)\n", __func__,
 453                           info->qos ? "true" : "false");
 454         }
 455         if (changed & BSS_CHANGED_IDLE) {
 456                 /* Idle changed for this BSS/interface */
 457                 wiphy_err(wiphy, "%s: BSS idle: %s (implement)\n", __func__,
 458                           info->idle ? "true" : "false");
 459         }
 460         return;
 461 }
 462
 463 static void
 464 brcms_ops_configure_filter(struct ieee80211_hw *hw,
 465                         unsigned int changed_flags,
 466                         unsigned int *total_flags, u64 multicast)
 467 {
 468         struct brcms_info *wl = hw->priv;
 469         struct wiphy *wiphy = hw->wiphy;
 470
 471         changed_flags &= MAC_FILTERS;
 472         *total_flags &= MAC_FILTERS;
 473         if (changed_flags & FIF_PROMISC_IN_BSS)
 474                 wiphy_err(wiphy, "FIF_PROMISC_IN_BSS\n");
 475         if (changed_flags & FIF_ALLMULTI)
 476                 wiphy_err(wiphy, "FIF_ALLMULTI\n");
 477         if (changed_flags & FIF_FCSFAIL)
 478                 wiphy_err(wiphy, "FIF_FCSFAIL\n");
 479         if (changed_flags & FIF_PLCPFAIL)
 480                 wiphy_err(wiphy, "FIF_PLCPFAIL\n");
 481         if (changed_flags & FIF_CONTROL)
 482                 wiphy_err(wiphy, "FIF_CONTROL\n");
 483         if (changed_flags & FIF_OTHER_BSS)
 484                 wiphy_err(wiphy, "FIF_OTHER_BSS\n");
 485         if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
 486                 LOCK(wl);
 487                 if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
 488                         wl->pub->mac80211_state |= MAC80211_PROMISC_BCNS;
 489                         brcms_c_mac_bcn_promisc_change(wl->wlc, 1);
 490                 } else {
 491                         brcms_c_mac_bcn_promisc_change(wl->wlc, 0);
 492                         wl->pub->mac80211_state &= ~MAC80211_PROMISC_BCNS;
 493                 }
 494                 UNLOCK(wl);
 495         }
 496         return;
 497 }
 498
 499 static int
 500 brcms_ops_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, bool set)
 501 {
 502         return 0;
 503 }
 504
 505 static void brcms_ops_sw_scan_start(struct ieee80211_hw *hw)
 506 {
 507         struct brcms_info *wl = hw->priv;
 508         LOCK(wl);
 509         brcms_c_scan_start(wl->wlc);
 510         UNLOCK(wl);
 511         return;
 512 }
 513
 514 static void brcms_ops_sw_scan_complete(struct ieee80211_hw *hw)
 515 {
 516         struct brcms_info *wl = hw->priv;
 517         LOCK(wl);
 518         brcms_c_scan_stop(wl->wlc);
 519         UNLOCK(wl);
 520         return;
 521 }
 522
 523 static void brcms_ops_set_tsf(struct ieee80211_hw *hw, u64 tsf)
 524 {
 525         wiphy_err(hw->wiphy, "%s: Enter\n", __func__);
 526         return;
 527 }
 528
 529 static int
 530 brcms_ops_get_stats(struct ieee80211_hw *hw,
 531                  struct ieee80211_low_level_stats *stats)
 532 {
 533         struct brcms_info *wl = hw->priv;
 534         struct wl_cnt *cnt;
 535
 536         LOCK(wl);
 537         cnt = wl->pub->_cnt;
 538         stats->dot11ACKFailureCount = 0;
 539         stats->dot11RTSFailureCount = 0;
 540         stats->dot11FCSErrorCount = 0;
 541         stats->dot11RTSSuccessCount = 0;
 542         UNLOCK(wl);
 543         return 0;
 544 }
 545
 546 static void
 547 brcms_ops_sta_notify(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 548                   enum sta_notify_cmd cmd, struct ieee80211_sta *sta)
 549 {
 550         switch (cmd) {
 551         default:
 552                 wiphy_err(hw->wiphy, "%s: Unknown cmd = %d\n", __func__,
 553                           cmd);
 554                 break;
 555         }
 556         return;
 557 }
 558
 559 static int
 560 brcms_ops_conf_tx(struct ieee80211_hw *hw, u16 queue,
 561                const struct ieee80211_tx_queue_params *params)
 562 {
 563         struct brcms_info *wl = hw->priv;
 564
 565         LOCK(wl);
 566         brcms_c_wme_setparams(wl->wlc, queue, params, true);
 567         UNLOCK(wl);
 568
 569         return 0;
 570 }
 571
 572 static u64 brcms_ops_get_tsf(struct ieee80211_hw *hw)
 573 {
 574         wiphy_err(hw->wiphy, "%s: Enter\n", __func__);
 575         return 0;
 576 }
 577
 578 static int
 579 brcms_ops_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 580                struct ieee80211_sta *sta)
 581 {
 582         struct scb *scb;
 583
 584         int i;
 585         struct brcms_info *wl = hw->priv;
 586
 587         /* Init the scb */
 588         scb = (struct scb *)sta->drv_priv;
 589         memset(scb, 0, sizeof(struct scb));
 590         for (i = 0; i < NUMPRIO; i++)
 591                 scb->seqctl[i] = 0xFFFF;
 592         scb->seqctl_nonqos = 0xFFFF;
 593         scb->magic = SCB_MAGIC;
 594
 595         wl->pub->global_scb = scb;
 596         wl->pub->global_ampdu = &(scb->scb_ampdu);
 597         wl->pub->global_ampdu->scb = scb;
 598         wl->pub->global_ampdu->max_pdu = 16;
 599         brcmu_pktq_init(&scb->scb_ampdu.txq, AMPDU_MAX_SCB_TID,
 600                   AMPDU_MAX_SCB_TID * PKTQ_LEN_DEFAULT);
 601
 602         sta->ht_cap.ht_supported = true;
 603         sta->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
 604         sta->ht_cap.ampdu_density = AMPDU_DEF_MPDU_DENSITY;
 605         sta->ht_cap.cap = IEEE80211_HT_CAP_GRN_FLD |
 606             IEEE80211_HT_CAP_SGI_20 |
 607             IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_40MHZ_INTOLERANT;
 608
 609         /* minstrel_ht initiates addBA on our behalf by calling ieee80211_start_tx_ba_session() */
 610         return 0;
 611 }
 612
 613 static int
 614 brcms_ops_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 615                   struct ieee80211_sta *sta)
 616 {
 617         return 0;
 618 }
 619
 620 static int
 621 brcms_ops_ampdu_action(struct ieee80211_hw *hw,
 622                     struct ieee80211_vif *vif,
 623                     enum ieee80211_ampdu_mlme_action action,
 624                     struct ieee80211_sta *sta, u16 tid, u16 *ssn,
 625                     u8 buf_size)
 626 {
 627         struct scb *scb = (struct scb *)sta->drv_priv;
 628         struct brcms_info *wl = hw->priv;
 629         int status;
 630
 631         if (WARN_ON(scb->magic != SCB_MAGIC))
 632                 return -EIDRM;
 633         switch (action) {
 634         case IEEE80211_AMPDU_RX_START:
 635                 break;
 636         case IEEE80211_AMPDU_RX_STOP:
 637                 break;
 638         case IEEE80211_AMPDU_TX_START:
 639                 LOCK(wl);
 640                 status = brcms_c_aggregatable(wl->wlc, tid);
 641                 UNLOCK(wl);
 642                 if (!status) {
 643                         wiphy_err(wl->wiphy, "START: tid %d is not agg\'able\n",
 644                                   tid);
 645                         return -EINVAL;
 646                 }
 647                 /* Future improvement: Use the starting sequence number provided ... */
 648                 *ssn = 0;
 649                 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
 650                 break;
 651
 652         case IEEE80211_AMPDU_TX_STOP:
 653                 LOCK(wl);
 654                 brcms_c_ampdu_flush(wl->wlc, sta, tid);
 655                 UNLOCK(wl);
 656                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
 657                 break;
 658         case IEEE80211_AMPDU_TX_OPERATIONAL:
 659                 /*
 660                  * BA window size from ADDBA response ('buf_size') defines how
 661                  * many outstanding MPDUs are allowed for the BA stream by
 662                  * recipient and traffic class. 'ampdu_factor' gives maximum
 663                  * AMPDU size.
 664                  */
 665                 LOCK(wl);
 666                 brcms_c_ampdu_tx_operational(wl->wlc, tid, buf_size,
 667                         (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
 668                          sta->ht_cap.ampdu_factor)) - 1);
 669                 UNLOCK(wl);
 670                 /* Power save wakeup */
 671                 break;
 672         default:
 673                 wiphy_err(wl->wiphy, "%s: Invalid command, ignoring\n",
 674                           __func__);
 675         }
 676
 677         return 0;
 678 }
 679
 680 static void brcms_ops_rfkill_poll(struct ieee80211_hw *hw)
 681 {
 682         struct brcms_info *wl = HW_TO_WL(hw);
 683         bool blocked;
 684
 685         LOCK(wl);
 686         blocked = brcms_c_check_radio_disabled(wl->wlc);
 687         UNLOCK(wl);
 688
 689         wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, blocked);
 690 }
 691
 692 static void brcms_ops_flush(struct ieee80211_hw *hw, bool drop)
 693 {
 694         struct brcms_info *wl = HW_TO_WL(hw);
 695
 696         no_printk("%s: drop = %s\n", __func__, drop ? "true" : "false");
 697
 698         /* wait for packet queue and dma fifos to run empty */
 699         LOCK(wl);
 700         brcms_c_wait_for_tx_completion(wl->wlc, drop);
 701         UNLOCK(wl);
 702 }
 703
 704 static const struct ieee80211_ops brcms_ops = {
 705         .tx = brcms_ops_tx,
 706         .start = brcms_ops_start,
 707         .stop = brcms_ops_stop,
 708         .add_interface = brcms_ops_add_interface,
 709         .remove_interface = brcms_ops_remove_interface,
 710         .config = brcms_ops_config,
 711         .bss_info_changed = brcms_ops_bss_info_changed,
 712         .configure_filter = brcms_ops_configure_filter,
 713         .set_tim = brcms_ops_set_tim,
 714         .sw_scan_start = brcms_ops_sw_scan_start,
 715         .sw_scan_complete = brcms_ops_sw_scan_complete,
 716         .set_tsf = brcms_ops_set_tsf,
 717         .get_stats = brcms_ops_get_stats,
 718         .sta_notify = brcms_ops_sta_notify,
 719         .conf_tx = brcms_ops_conf_tx,
 720         .get_tsf = brcms_ops_get_tsf,
 721         .sta_add = brcms_ops_sta_add,
 722         .sta_remove = brcms_ops_sta_remove,
 723         .ampdu_action = brcms_ops_ampdu_action,
 724         .rfkill_poll = brcms_ops_rfkill_poll,
 725         .flush = brcms_ops_flush,
 726 };
 727
 728 /*
 729  * is called in brcms_pci_probe() context, therefore no locking required.
 730  */
 731 static int brcms_set_hint(struct brcms_info *wl, char *abbrev)
 732 {
 733         return regulatory_hint(wl->pub->ieee_hw->wiphy, abbrev);
 734 }
 735
 736 /**
 737  * attach to the WL device.
 738  *
 739  * Attach to the WL device identified by vendor and device parameters.
 740  * regs is a host accessible memory address pointing to WL device registers.
 741  *
 742  * brcms_attach is not defined as static because in the case where no bus
 743  * is defined, wl_attach will never be called, and thus, gcc will issue
 744  * a warning that this function is defined but not used if we declare
 745  * it as static.
 746  *
 747  *
 748  * is called in brcms_pci_probe() context, therefore no locking required.
 749  */
 750 static struct brcms_info *brcms_attach(u16 vendor, u16 device,
 751                                        unsigned long regs,
 752                             uint bustype, void *btparam, uint irq)
 753 {
 754         struct brcms_info *wl = NULL;
 755         int unit, err;
 756         unsigned long base_addr;
 757         struct ieee80211_hw *hw;
 758         u8 perm[ETH_ALEN];
 759
 760         unit = n_adapters_found;
 761         err = 0;
 762
 763         if (unit < 0) {
 764                 return NULL;
 765         }
 766
 767         /* allocate private info */
 768         hw = pci_get_drvdata(btparam);  /* btparam == pdev */
 769         if (hw != NULL)
 770                 wl = hw->priv;
 771         if (WARN_ON(hw == NULL) || WARN_ON(wl == NULL))
 772                 return NULL;
 773         wl->wiphy = hw->wiphy;
 774
 775         atomic_set(&wl->callbacks, 0);
 776
 777         /* setup the bottom half handler */
 778         tasklet_init(&wl->tasklet, brcms_dpc, (unsigned long) wl);
 779
 780
 781
 782         base_addr = regs;
 783
 784         if (bustype == PCI_BUS || bustype == RPC_BUS) {
 785                 /* Do nothing */
 786         } else {
 787                 bustype = PCI_BUS;
 788                 BCMMSG(wl->wiphy, "force to PCI\n");
 789         }
 790         wl->bcm_bustype = bustype;
 791
 792         wl->regsva = ioremap_nocache(base_addr, PCI_BAR0_WINSZ);
 793         if (wl->regsva == NULL) {
 794                 wiphy_err(wl->wiphy, "wl%d: ioremap() failed\n", unit);
 795                 goto fail;
 796         }
 797         spin_lock_init(&wl->lock);
 798         spin_lock_init(&wl->isr_lock);
 799
 800         /* prepare ucode */
 801         if (brcms_request_fw(wl, (struct pci_dev *)btparam) < 0) {
 802                 wiphy_err(wl->wiphy, "%s: Failed to find firmware usually in "
 803                           "%s\n", KBUILD_MODNAME, "/lib/firmware/brcm");
 804                 brcms_release_fw(wl);
 805                 brcms_remove((struct pci_dev *)btparam);
 806                 return NULL;
 807         }
 808
 809         /* common load-time initialization */
 810         wl->wlc = brcms_c_attach((void *)wl, vendor, device, unit, false,
 811                              wl->regsva, wl->bcm_bustype, btparam, &err);
 812         brcms_release_fw(wl);
 813         if (!wl->wlc) {
 814                 wiphy_err(wl->wiphy, "%s: attach() failed with code %d\n",
 815                           KBUILD_MODNAME, err);
 816                 goto fail;
 817         }
 818         wl->pub = brcms_c_pub(wl->wlc);
 819
 820         wl->pub->ieee_hw = hw;
 821
 822         if (brcms_c_set_par(wl->wlc, IOV_MPC, 0) < 0) {
 823                 wiphy_err(wl->wiphy, "wl%d: Error setting MPC variable to 0\n",
 824                           unit);
 825         }
 826
 827         /* register our interrupt handler */
 828         if (request_irq(irq, brcms_isr, IRQF_SHARED, KBUILD_MODNAME, wl)) {
 829                 wiphy_err(wl->wiphy, "wl%d: request_irq() failed\n", unit);
 830                 goto fail;
 831         }
 832         wl->irq = irq;
 833
 834         /* register module */
 835         brcms_c_module_register(wl->pub, "linux", wl, wl_linux_watchdog, NULL);
 836
 837         if (ieee_hw_init(hw)) {
 838                 wiphy_err(wl->wiphy, "wl%d: %s: ieee_hw_init failed!\n", unit,
 839                           __func__);
 840                 goto fail;
 841         }
 842
 843         memcpy(perm, &wl->pub->cur_etheraddr, ETH_ALEN);
 844         if (WARN_ON(!is_valid_ether_addr(perm)))
 845                 goto fail;
 846         SET_IEEE80211_PERM_ADDR(hw, perm);
 847
 848         err = ieee80211_register_hw(hw);
 849         if (err) {
 850                 wiphy_err(wl->wiphy, "%s: ieee80211_register_hw failed, status"
 851                           "%d\n", __func__, err);
 852         }
 853
 854         if (wl->pub->srom_ccode[0])
 855                 err = brcms_set_hint(wl, wl->pub->srom_ccode);
 856         else
 857                 err = brcms_set_hint(wl, "US");
 858         if (err) {
 859                 wiphy_err(wl->wiphy, "%s: regulatory_hint failed, status %d\n",
 860                           __func__, err);
 861         }
 862
 863         n_adapters_found++;
 864         return wl;
 865
 866 fail:
 867         brcms_free(wl);
 868         return NULL;
 869 }
 870
 871
 872
 873 #define CHAN2GHZ(channel, freqency, chflags)  { \
 874         .band = IEEE80211_BAND_2GHZ, \
 875         .center_freq = (freqency), \
 876         .hw_value = (channel), \
 877         .flags = chflags, \
 878         .max_antenna_gain = 0, \
 879         .max_power = 19, \
 880 }
 881
 882 static struct ieee80211_channel brcms_2ghz_chantable[] = {
 883         CHAN2GHZ(1, 2412, IEEE80211_CHAN_NO_HT40MINUS),
 884         CHAN2GHZ(2, 2417, IEEE80211_CHAN_NO_HT40MINUS),
 885         CHAN2GHZ(3, 2422, IEEE80211_CHAN_NO_HT40MINUS),
 886         CHAN2GHZ(4, 2427, IEEE80211_CHAN_NO_HT40MINUS),
 887         CHAN2GHZ(5, 2432, 0),
 888         CHAN2GHZ(6, 2437, 0),
 889         CHAN2GHZ(7, 2442, 0),
 890         CHAN2GHZ(8, 2447, IEEE80211_CHAN_NO_HT40PLUS),
 891         CHAN2GHZ(9, 2452, IEEE80211_CHAN_NO_HT40PLUS),
 892         CHAN2GHZ(10, 2457, IEEE80211_CHAN_NO_HT40PLUS),
 893         CHAN2GHZ(11, 2462, IEEE80211_CHAN_NO_HT40PLUS),
 894         CHAN2GHZ(12, 2467,
 895                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
 896                  IEEE80211_CHAN_NO_HT40PLUS),
 897         CHAN2GHZ(13, 2472,
 898                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
 899                  IEEE80211_CHAN_NO_HT40PLUS),
 900         CHAN2GHZ(14, 2484,
 901                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_IBSS |
 902                  IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)
 903 };
 904
 905 #define CHAN5GHZ(channel, chflags)  { \
 906         .band = IEEE80211_BAND_5GHZ, \
 907         .center_freq = 5000 + 5*(channel), \
 908         .hw_value = (channel), \
 909         .flags = chflags, \
 910         .max_antenna_gain = 0, \
 911         .max_power = 21, \
 912 }
 913
 914 static struct ieee80211_channel brcms_5ghz_nphy_chantable[] = {
 915         /* UNII-1 */
 916         CHAN5GHZ(36, IEEE80211_CHAN_NO_HT40MINUS),
 917         CHAN5GHZ(40, IEEE80211_CHAN_NO_HT40PLUS),
 918         CHAN5GHZ(44, IEEE80211_CHAN_NO_HT40MINUS),
 919         CHAN5GHZ(48, IEEE80211_CHAN_NO_HT40PLUS),
 920         /* UNII-2 */
 921         CHAN5GHZ(52,
 922                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 923                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 924         CHAN5GHZ(56,
 925                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 926                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 927         CHAN5GHZ(60,
 928                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 929                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 930         CHAN5GHZ(64,
 931                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 932                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 933         /* MID */
 934         CHAN5GHZ(100,
 935                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 936                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 937         CHAN5GHZ(104,
 938                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 939                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 940         CHAN5GHZ(108,
 941                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 942                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 943         CHAN5GHZ(112,
 944                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 945                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 946         CHAN5GHZ(116,
 947                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 948                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 949         CHAN5GHZ(120,
 950                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 951                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 952         CHAN5GHZ(124,
 953                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 954                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 955         CHAN5GHZ(128,
 956                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 957                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 958         CHAN5GHZ(132,
 959                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 960                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40MINUS),
 961         CHAN5GHZ(136,
 962                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 963                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS),
 964         CHAN5GHZ(140,
 965                  IEEE80211_CHAN_RADAR | IEEE80211_CHAN_NO_IBSS |
 966                  IEEE80211_CHAN_PASSIVE_SCAN | IEEE80211_CHAN_NO_HT40PLUS |
 967                  IEEE80211_CHAN_NO_HT40MINUS),
 968         /* UNII-3 */
 969         CHAN5GHZ(149, IEEE80211_CHAN_NO_HT40MINUS),
 970         CHAN5GHZ(153, IEEE80211_CHAN_NO_HT40PLUS),
 971         CHAN5GHZ(157, IEEE80211_CHAN_NO_HT40MINUS),
 972         CHAN5GHZ(161, IEEE80211_CHAN_NO_HT40PLUS),
 973         CHAN5GHZ(165, IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)
 974 };
 975
 976 #define RATE(rate100m, _flags) { \
 977         .bitrate = (rate100m), \
 978         .flags = (_flags), \
 979         .hw_value = (rate100m / 5), \
 980 }
 981
 982 static struct ieee80211_rate legacy_ratetable[] = {
 983         RATE(10, 0),
 984         RATE(20, IEEE80211_RATE_SHORT_PREAMBLE),
 985         RATE(55, IEEE80211_RATE_SHORT_PREAMBLE),
 986         RATE(110, IEEE80211_RATE_SHORT_PREAMBLE),
 987         RATE(60, 0),
 988         RATE(90, 0),
 989         RATE(120, 0),
 990         RATE(180, 0),
 991         RATE(240, 0),
 992         RATE(360, 0),
 993         RATE(480, 0),
 994         RATE(540, 0),
 995 };
 996
 997 static struct ieee80211_supported_band brcms_band_2GHz_nphy = {
 998         .band = IEEE80211_BAND_2GHZ,
 999         .channels = brcms_2ghz_chantable,
1000         .n_channels = ARRAY_SIZE(brcms_2ghz_chantable),
1001         .bitrates = legacy_ratetable,
1002         .n_bitrates = ARRAY_SIZE(legacy_ratetable),
1003         .ht_cap = {
1004                    /* from include/linux/ieee80211.h */
1005                    .cap = IEEE80211_HT_CAP_GRN_FLD |
1006                    IEEE80211_HT_CAP_SGI_20 |
1007                    IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_40MHZ_INTOLERANT,
1008                    .ht_supported = true,
1009                    .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K,
1010                    .ampdu_density = AMPDU_DEF_MPDU_DENSITY,
1011                    .mcs = {
1012                            /* placeholders for now */
1013                            .rx_mask = {0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0},
1014                            .rx_highest = 500,
1015                            .tx_params = IEEE80211_HT_MCS_TX_DEFINED}
1016                    }
1017 };
1018
1019 static struct ieee80211_supported_band brcms_band_5GHz_nphy = {
1020         .band = IEEE80211_BAND_5GHZ,
1021         .channels = brcms_5ghz_nphy_chantable,
1022         .n_channels = ARRAY_SIZE(brcms_5ghz_nphy_chantable),
1023         .bitrates = legacy_ratetable + 4,
1024         .n_bitrates = ARRAY_SIZE(legacy_ratetable) - 4,
1025         .ht_cap = {
1026                    /* use IEEE80211_HT_CAP_* from include/linux/ieee80211.h */
1027                    .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_40MHZ_INTOLERANT,     /* No 40 mhz yet */
1028                    .ht_supported = true,
1029                    .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K,
1030                    .ampdu_density = AMPDU_DEF_MPDU_DENSITY,
1031                    .mcs = {
1032                            /* placeholders for now */
1033                            .rx_mask = {0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0},
1034                            .rx_highest = 500,
1035                            .tx_params = IEEE80211_HT_MCS_TX_DEFINED}
1036                    }
1037 };
1038
1039 /*
1040  * is called in brcms_pci_probe() context, therefore no locking required.
1041  */
1042 static int ieee_hw_rate_init(struct ieee80211_hw *hw)
1043 {
1044         struct brcms_info *wl = HW_TO_WL(hw);
1045         int has_5g;
1046         char phy_list[4];
1047
1048         has_5g = 0;
1049
1050         hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
1051         hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
1052
1053         if (brcms_c_get(wl->wlc, WLC_GET_PHYLIST, (int *)&phy_list) < 0)
1054                 wiphy_err(hw->wiphy, "Phy list failed\n");
1055
1056         if (phy_list[0] == 'n' || phy_list[0] == 'c') {
1057                 if (phy_list[0] == 'c') {
1058                         /* Single stream */
1059                         brcms_band_2GHz_nphy.ht_cap.mcs.rx_mask[1] = 0;
1060                         brcms_band_2GHz_nphy.ht_cap.mcs.rx_highest = 72;
1061                 }
1062                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &brcms_band_2GHz_nphy;
1063         } else {
1064                 return -EPERM;
1065         }
1066
1067         /* Assume all bands use the same phy.  True for 11n devices. */
1068         if (NBANDS_PUB(wl->pub) > 1) {
1069                 has_5g++;
1070                 if (phy_list[0] == 'n' || phy_list[0] == 'c') {
1071                         hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1072                             &brcms_band_5GHz_nphy;
1073                 } else {
1074                         return -EPERM;
1075                 }
1076         }
1077         return 0;
1078 }
1079
1080 /*
1081  * is called in brcms_pci_probe() context, therefore no locking required.
1082  */
1083 static int ieee_hw_init(struct ieee80211_hw *hw)
1084 {
1085         hw->flags = IEEE80211_HW_SIGNAL_DBM
1086             /* | IEEE80211_HW_CONNECTION_MONITOR  What is this? */
1087             | IEEE80211_HW_REPORTS_TX_ACK_STATUS
1088             | IEEE80211_HW_AMPDU_AGGREGATION;
1089
1090         hw->extra_tx_headroom = brcms_c_get_header_len();
1091         hw->queues = N_TX_QUEUES;
1092         hw->max_rates = 2;      /* Primary rate and 1 fallback rate */
1093
1094         hw->channel_change_time = 7 * 1000;     /* channel change time is dependent on chip and band  */
1095         hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1096
1097         hw->rate_control_algorithm = "minstrel_ht";
1098
1099         hw->sta_data_size = sizeof(struct scb);
1100         return ieee_hw_rate_init(hw);
1101 }
1102
1103 /**
1104  * determines if a device is a WL device, and if so, attaches it.
1105  *
1106  * This function determines if a device pointed to by pdev is a WL device,
1107  * and if so, performs a brcms_attach() on it.
1108  *
1109  * Perimeter lock is initialized in the course of this function.
1110  */
1111 static int __devinit
1112 brcms_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1113 {
1114         int rc;
1115         struct brcms_info *wl;
1116         struct ieee80211_hw *hw;
1117         u32 val;
1118
1119         dev_info(&pdev->dev, "bus %d slot %d func %d irq %d\n",
1120                pdev->bus->number, PCI_SLOT(pdev->devfn),
1121                PCI_FUNC(pdev->devfn), pdev->irq);
1122
1123         if ((pdev->vendor != PCI_VENDOR_ID_BROADCOM) ||
1124             ((pdev->device != 0x0576) &&
1125              ((pdev->device & 0xff00) != 0x4300) &&
1126              ((pdev->device & 0xff00) != 0x4700) &&
1127              ((pdev->device < 43000) || (pdev->device > 43999))))
1128                 return -ENODEV;
1129
1130         rc = pci_enable_device(pdev);
1131         if (rc) {
1132                 pr_err("%s: Cannot enable device %d-%d_%d\n",
1133                        __func__, pdev->bus->number, PCI_SLOT(pdev->devfn),
1134                        PCI_FUNC(pdev->devfn));
1135                 return -ENODEV;
1136         }
1137         pci_set_master(pdev);
1138
1139         pci_read_config_dword(pdev, 0x40, &val);
1140         if ((val & 0x0000ff00) != 0)
1141                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
1142
1143         hw = ieee80211_alloc_hw(sizeof(struct brcms_info), &brcms_ops);
1144         if (!hw) {
1145                 pr_err("%s: ieee80211_alloc_hw failed\n", __func__);
1146                 return -ENOMEM;
1147         }
1148
1149         SET_IEEE80211_DEV(hw, &pdev->dev);
1150
1151         pci_set_drvdata(pdev, hw);
1152
1153         memset(hw->priv, 0, sizeof(*wl));
1154
1155         wl = brcms_attach(pdev->vendor, pdev->device,
1156                           pci_resource_start(pdev, 0), PCI_BUS, pdev,
1157                           pdev->irq);
1158
1159         if (!wl) {
1160                 pr_err("%s: %s: brcms_attach failed!\n", KBUILD_MODNAME,
1161                        __func__);
1162                 return -ENODEV;
1163         }
1164         return 0;
1165 }
1166
1167 static int brcms_suspend(struct pci_dev *pdev, pm_message_t state)
1168 {
1169         struct brcms_info *wl;
1170         struct ieee80211_hw *hw;
1171
1172         hw = pci_get_drvdata(pdev);
1173         wl = HW_TO_WL(hw);
1174         if (!wl) {
1175                 wiphy_err(wl->wiphy,
1176                           "brcms_suspend: pci_get_drvdata failed\n");
1177                 return -ENODEV;
1178         }
1179
1180         /* only need to flag hw is down for proper resume */
1181         LOCK(wl);
1182         wl->pub->hw_up = false;
1183         UNLOCK(wl);
1184
1185         pci_save_state(pdev);
1186         pci_disable_device(pdev);
1187         return pci_set_power_state(pdev, PCI_D3hot);
1188 }
1189
1190 static int brcms_resume(struct pci_dev *pdev)
1191 {
1192         struct brcms_info *wl;
1193         struct ieee80211_hw *hw;
1194         int err = 0;
1195         u32 val;
1196
1197         hw = pci_get_drvdata(pdev);
1198         wl = HW_TO_WL(hw);
1199         if (!wl) {
1200                 wiphy_err(wl->wiphy,
1201                           "wl: brcms_resume: pci_get_drvdata failed\n");
1202                 return -ENODEV;
1203         }
1204
1205         err = pci_set_power_state(pdev, PCI_D0);
1206         if (err)
1207                 return err;
1208
1209         pci_restore_state(pdev);
1210
1211         err = pci_enable_device(pdev);
1212         if (err)
1213                 return err;
1214
1215         pci_set_master(pdev);
1216
1217         pci_read_config_dword(pdev, 0x40, &val);
1218         if ((val & 0x0000ff00) != 0)
1219                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
1220
1221         /*
1222         *  done. driver will be put in up state
1223         *  in brcms_ops_add_interface() call.
1224         */
1225         return err;
1226 }
1227
1228 /*
1229 * called from both kernel as from this kernel module.
1230 * precondition: perimeter lock is not acquired.
1231 */
1232 static void brcms_remove(struct pci_dev *pdev)
1233 {
1234         struct brcms_info *wl;
1235         struct ieee80211_hw *hw;
1236         int status;
1237
1238         hw = pci_get_drvdata(pdev);
1239         wl = HW_TO_WL(hw);
1240         if (!wl) {
1241                 pr_err("wl: brcms_remove: pci_get_drvdata failed\n");
1242                 return;
1243         }
1244
1245         LOCK(wl);
1246         status = brcms_c_chipmatch(pdev->vendor, pdev->device);
1247         UNLOCK(wl);
1248         if (!status) {
1249                 wiphy_err(wl->wiphy, "wl: brcms_remove: chipmatch "
1250                                      "failed\n");
1251                 return;
1252         }
1253         if (wl->wlc) {
1254                 wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, false);
1255                 wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy);
1256                 ieee80211_unregister_hw(hw);
1257                 LOCK(wl);
1258                 brcms_down(wl);
1259                 UNLOCK(wl);
1260         }
1261         pci_disable_device(pdev);
1262
1263         brcms_free(wl);
1264
1265         pci_set_drvdata(pdev, NULL);
1266         ieee80211_free_hw(hw);
1267 }
1268
1269 static struct pci_driver brcms_pci_driver = {
1270         .name     = KBUILD_MODNAME,
1271         .probe    = brcms_pci_probe,
1272         .suspend  = brcms_suspend,
1273         .resume   = brcms_resume,
1274         .remove   = __devexit_p(brcms_remove),
1275         .id_table = brcms_pci_id_table,
1276 };
1277
1278 /**
1279  * This is the main entry point for the WL driver.
1280  *
1281  * This function determines if a device pointed to by pdev is a WL device,
1282  * and if so, performs a brcms_attach() on it.
1283  *
1284  */
1285 static int __init brcms_module_init(void)
1286 {
1287         int error = -ENODEV;
1288
1289 #ifdef BCMDBG
1290         if (msglevel != 0xdeadbeef)
1291                 brcm_msg_level = msglevel;
1292         if (phymsglevel != 0xdeadbeef)
1293                 phyhal_msg_level = phymsglevel;
1294 #endif                          /* BCMDBG */
1295
1296         error = pci_register_driver(&brcms_pci_driver);
1297         if (!error)
1298                 return 0;
1299
1300
1301
1302         return error;
1303 }
1304
1305 /**
1306  * This function unloads the WL driver from the system.
1307  *
1308  * This function unconditionally unloads the WL driver module from the
1309  * system.
1310  *
1311  */
1312 static void __exit brcms_module_exit(void)
1313 {
1314         pci_unregister_driver(&brcms_pci_driver);
1315
1316 }
1317
1318 module_init(brcms_module_init);
1319 module_exit(brcms_module_exit);
1320
1321 /**
1322  * This function frees the WL per-device resources.
1323  *
1324  * This function frees resources owned by the WL device pointed to
1325  * by the wl parameter.
1326  *
1327  * precondition: can both be called locked and unlocked
1328  *
1329  */
1330 static void brcms_free(struct brcms_info *wl)
1331 {
1332         struct brcms_timer *t, *next;
1333
1334         /* free ucode data */
1335         if (wl->fw.fw_cnt)
1336                 brcms_ucode_data_free();
1337         if (wl->irq)
1338                 free_irq(wl->irq, wl);
1339
1340         /* kill dpc */
1341         tasklet_kill(&wl->tasklet);
1342
1343         if (wl->pub) {
1344                 brcms_c_module_unregister(wl->pub, "linux", wl);
1345         }
1346
1347         /* free common resources */
1348         if (wl->wlc) {
1349                 brcms_c_detach(wl->wlc);
1350                 wl->wlc = NULL;
1351                 wl->pub = NULL;
1352         }
1353
1354         /* virtual interface deletion is deferred so we cannot spinwait */
1355
1356         /* wait for all pending callbacks to complete */
1357         while (atomic_read(&wl->callbacks) > 0)
1358                 schedule();
1359
1360         /* free timers */
1361         for (t = wl->timers; t; t = next) {
1362                 next = t->next;
1363 #ifdef BCMDBG
1364                 kfree(t->name);
1365 #endif
1366                 kfree(t);
1367         }
1368
1369         /*
1370          * unregister_netdev() calls get_stats() which may read chip registers
1371          * so we cannot unmap the chip registers until after calling unregister_netdev() .
1372          */
1373         if (wl->regsva && wl->bcm_bustype != SDIO_BUS &&
1374             wl->bcm_bustype != JTAG_BUS) {
1375                 iounmap((void *)wl->regsva);
1376         }
1377         wl->regsva = NULL;
1378 }
1379
1380 /* flags the given rate in rateset as requested */
1381 static void brcms_set_basic_rate(struct wl_rateset *rs, u16 rate, bool is_br)
1382 {
1383         u32 i;
1384
1385         for (i = 0; i < rs->count; i++) {
1386                 if (rate != (rs->rates[i] & 0x7f))
1387                         continue;
1388
1389                 if (is_br)
1390                         rs->rates[i] |= WLC_RATE_FLAG;
1391                 else
1392                         rs->rates[i] &= WLC_RATE_MASK;
1393                 return;
1394         }
1395 }
1396
1397 /*
1398  * precondition: perimeter lock has been acquired
1399  */
1400 void brcms_txflowcontrol(struct brcms_info *wl, struct brcms_if *wlif,
1401                          bool state, int prio)
1402 {
1403         wiphy_err(wl->wiphy, "Shouldn't be here %s\n", __func__);
1404 }
1405
1406 /*
1407  * precondition: perimeter lock has been acquired
1408  */
1409 void brcms_init(struct brcms_info *wl)
1410 {
1411         BCMMSG(WL_TO_HW(wl)->wiphy, "wl%d\n", wl->pub->unit);
1412         brcms_reset(wl);
1413
1414         brcms_c_init(wl->wlc);
1415 }
1416
1417 /*
1418  * precondition: perimeter lock has been acquired
1419  */
1420 uint brcms_reset(struct brcms_info *wl)
1421 {
1422         BCMMSG(WL_TO_HW(wl)->wiphy, "wl%d\n", wl->pub->unit);
1423         brcms_c_reset(wl->wlc);
1424
1425         /* dpc will not be rescheduled */
1426         wl->resched = 0;
1427
1428         return 0;
1429 }
1430
1431 /*
1432  * These are interrupt on/off entry points. Disable interrupts
1433  * during interrupt state transition.
1434  */
1435 void brcms_intrson(struct brcms_info *wl)
1436 {
1437         unsigned long flags;
1438
1439         INT_LOCK(wl, flags);
1440         brcms_c_intrson(wl->wlc);
1441         INT_UNLOCK(wl, flags);
1442 }
1443
1444 /*
1445  * precondition: perimeter lock has been acquired
1446  */
1447 bool wl_alloc_dma_resources(struct brcms_info *wl, uint addrwidth)
1448 {
1449         return true;
1450 }
1451
1452 u32 brcms_intrsoff(struct brcms_info *wl)
1453 {
1454         unsigned long flags;
1455         u32 status;
1456
1457         INT_LOCK(wl, flags);
1458         status = brcms_c_intrsoff(wl->wlc);
1459         INT_UNLOCK(wl, flags);
1460         return status;
1461 }
1462
1463 void brcms_intrsrestore(struct brcms_info *wl, u32 macintmask)
1464 {
1465         unsigned long flags;
1466
1467         INT_LOCK(wl, flags);
1468         brcms_c_intrsrestore(wl->wlc, macintmask);
1469         INT_UNLOCK(wl, flags);
1470 }
1471
1472 /*
1473  * precondition: perimeter lock has been acquired
1474  */
1475 int brcms_up(struct brcms_info *wl)
1476 {
1477         int error = 0;
1478
1479         if (wl->pub->up)
1480                 return 0;
1481
1482         error = brcms_c_up(wl->wlc);
1483
1484         return error;
1485 }
1486
1487 /*
1488  * precondition: perimeter lock has been acquired
1489  */
1490 void brcms_down(struct brcms_info *wl)
1491 {
1492         uint callbacks, ret_val = 0;
1493
1494         /* call common down function */
1495         ret_val = brcms_c_down(wl->wlc);
1496         callbacks = atomic_read(&wl->callbacks) - ret_val;
1497
1498         /* wait for down callbacks to complete */
1499         UNLOCK(wl);
1500
1501         /* For HIGH_only driver, it's important to actually schedule other work,
1502          * not just spin wait since everything runs at schedule level
1503          */
1504         SPINWAIT((atomic_read(&wl->callbacks) > callbacks), 100 * 1000);
1505
1506         LOCK(wl);
1507 }
1508
1509 static irqreturn_t brcms_isr(int irq, void *dev_id)
1510 {
1511         struct brcms_info *wl;
1512         bool ours, wantdpc;
1513         unsigned long flags;
1514
1515         wl = (struct brcms_info *) dev_id;
1516
1517         ISR_LOCK(wl, flags);
1518
1519         /* call common first level interrupt handler */
1520         ours = brcms_c_isr(wl->wlc, &wantdpc);
1521         if (ours) {
1522                 /* if more to do... */
1523                 if (wantdpc) {
1524
1525                         /* ...and call the second level interrupt handler */
1526                         /* schedule dpc */
1527                         tasklet_schedule(&wl->tasklet);
1528                 }
1529         }
1530
1531         ISR_UNLOCK(wl, flags);
1532
1533         return IRQ_RETVAL(ours);
1534 }
1535
1536 static void brcms_dpc(unsigned long data)
1537 {
1538         struct brcms_info *wl;
1539
1540         wl = (struct brcms_info *) data;
1541
1542         LOCK(wl);
1543
1544         /* call the common second level interrupt handler */
1545         if (wl->pub->up) {
1546                 if (wl->resched) {
1547                         unsigned long flags;
1548
1549                         INT_LOCK(wl, flags);
1550                         brcms_c_intrsupd(wl->wlc);
1551                         INT_UNLOCK(wl, flags);
1552                 }
1553
1554                 wl->resched = brcms_c_dpc(wl->wlc, true);
1555         }
1556
1557         /* brcms_c_dpc() may bring the driver down */
1558         if (!wl->pub->up)
1559                 goto done;
1560
1561         /* re-schedule dpc */
1562         if (wl->resched)
1563                 tasklet_schedule(&wl->tasklet);
1564         else {
1565                 /* re-enable interrupts */
1566                 brcms_intrson(wl);
1567         }
1568
1569  done:
1570         UNLOCK(wl);
1571 }
1572
1573 /*
1574  * is called by the kernel from software irq context
1575  */
1576 static void brcms_timer(unsigned long data)
1577 {
1578         _brcms_timer((struct brcms_timer *) data);
1579 }
1580
1581 /*
1582 * precondition: perimeter lock is not acquired
1583  */
1584 static void _brcms_timer(struct brcms_timer *t)
1585 {
1586         LOCK(t->wl);
1587
1588         if (t->set) {
1589                 if (t->periodic) {
1590                         t->timer.expires = jiffies + t->ms * HZ / 1000;
1591                         atomic_inc(&t->wl->callbacks);
1592                         add_timer(&t->timer);
1593                         t->set = true;
1594                 } else
1595                         t->set = false;
1596
1597                 t->fn(t->arg);
1598         }
1599
1600         atomic_dec(&t->wl->callbacks);
1601
1602         UNLOCK(t->wl);
1603 }
1604
1605 /*
1606  * Adds a timer to the list. Caller supplies a timer function.
1607  * Is called from wlc.
1608  *
1609  * precondition: perimeter lock has been acquired
1610  */
1611 struct brcms_timer *brcms_init_timer(struct brcms_info *wl,
1612                                      void (*fn) (void *arg),
1613                                      void *arg, const char *name)
1614 {
1615         struct brcms_timer *t;
1616
1617         t = kzalloc(sizeof(struct brcms_timer), GFP_ATOMIC);
1618         if (!t) {
1619                 wiphy_err(wl->wiphy, "wl%d: brcms_init_timer: out of memory\n",
1620                           wl->pub->unit);
1621                 return 0;
1622         }
1623
1624         init_timer(&t->timer);
1625         t->timer.data = (unsigned long) t;
1626         t->timer.function = brcms_timer;
1627         t->wl = wl;
1628         t->fn = fn;
1629         t->arg = arg;
1630         t->next = wl->timers;
1631         wl->timers = t;
1632
1633 #ifdef BCMDBG
1634         t->name = kmalloc(strlen(name) + 1, GFP_ATOMIC);
1635         if (t->name)
1636                 strcpy(t->name, name);
1637 #endif
1638
1639         return t;
1640 }
1641
1642 /* BMAC_NOTE: Add timer adds only the kernel timer since it's going to be more accurate
1643  * as well as it's easier to make it periodic
1644  *
1645  * precondition: perimeter lock has been acquired
1646  */
1647 void brcms_add_timer(struct brcms_info *wl, struct brcms_timer *t, uint ms,
1648                      int periodic)
1649 {
1650 #ifdef BCMDBG
1651         if (t->set) {
1652                 wiphy_err(wl->wiphy, "%s: Already set. Name: %s, per %d\n",
1653                           __func__, t->name, periodic);
1654         }
1655 #endif
1656         t->ms = ms;
1657         t->periodic = (bool) periodic;
1658         t->set = true;
1659         t->timer.expires = jiffies + ms * HZ / 1000;
1660
1661         atomic_inc(&wl->callbacks);
1662         add_timer(&t->timer);
1663 }
1664
1665 /*
1666  * return true if timer successfully deleted, false if still pending
1667  *
1668  * precondition: perimeter lock has been acquired
1669  */
1670 bool brcms_del_timer(struct brcms_info *wl, struct brcms_timer *t)
1671 {
1672         if (t->set) {
1673                 t->set = false;
1674                 if (!del_timer(&t->timer)) {
1675                         return false;
1676                 }
1677                 atomic_dec(&wl->callbacks);
1678         }
1679
1680         return true;
1681 }
1682
1683 /*
1684  * precondition: perimeter lock has been acquired
1685  */
1686 void brcms_free_timer(struct brcms_info *wl, struct brcms_timer *t)
1687 {
1688         struct brcms_timer *tmp;
1689
1690         /* delete the timer in case it is active */
1691         brcms_del_timer(wl, t);
1692
1693         if (wl->timers == t) {
1694                 wl->timers = wl->timers->next;
1695 #ifdef BCMDBG
1696                 kfree(t->name);
1697 #endif
1698                 kfree(t);
1699                 return;
1700
1701         }
1702
1703         tmp = wl->timers;
1704         while (tmp) {
1705                 if (tmp->next == t) {
1706                         tmp->next = t->next;
1707 #ifdef BCMDBG
1708                         kfree(t->name);
1709 #endif
1710                         kfree(t);
1711                         return;
1712                 }
1713                 tmp = tmp->next;
1714         }
1715
1716 }
1717
1718 /*
1719  * runs in software irq context
1720  *
1721  * precondition: perimeter lock is not acquired
1722  */
1723 static int wl_linux_watchdog(void *ctx)
1724 {
1725         return 0;
1726 }
1727
1728 struct firmware_hdr {
1729         u32 offset;
1730         u32 len;
1731         u32 idx;
1732 };
1733
1734 char *brcms_firmwares[MAX_FW_IMAGES] = {
1735         "brcm/bcm43xx",
1736         NULL
1737 };
1738
1739 /*
1740  * precondition: perimeter lock has been acquired
1741  */
1742 int brcms_ucode_init_buf(struct brcms_info *wl, void **pbuf, u32 idx)
1743 {
1744         int i, entry;
1745         const u8 *pdata;
1746         struct firmware_hdr *hdr;
1747         for (i = 0; i < wl->fw.fw_cnt; i++) {
1748                 hdr = (struct firmware_hdr *)wl->fw.fw_hdr[i]->data;
1749                 for (entry = 0; entry < wl->fw.hdr_num_entries[i];
1750                      entry++, hdr++) {
1751                         if (hdr->idx == idx) {
1752                                 pdata = wl->fw.fw_bin[i]->data + hdr->offset;
1753                                 *pbuf = kmalloc(hdr->len, GFP_ATOMIC);
1754                                 if (*pbuf == NULL) {
1755                                         wiphy_err(wl->wiphy, "fail to alloc %d"
1756                                                   " bytes\n", hdr->len);
1757                                         goto fail;
1758                                 }
1759                                 memcpy(*pbuf, pdata, hdr->len);
1760                                 return 0;
1761                         }
1762                 }
1763         }
1764         wiphy_err(wl->wiphy, "ERROR: ucode buf tag:%d can not be found!\n",
1765                   idx);
1766         *pbuf = NULL;
1767 fail:
1768         return -ENODATA;
1769 }
1770
1771 /*
1772  * Precondition: Since this function is called in brcms_pci_probe() context,
1773  * no locking is required.
1774  */
1775 int brcms_ucode_init_uint(struct brcms_info *wl, u32 *data, u32 idx)
1776 {
1777         int i, entry;
1778         const u8 *pdata;
1779         struct firmware_hdr *hdr;
1780         for (i = 0; i < wl->fw.fw_cnt; i++) {
1781                 hdr = (struct firmware_hdr *)wl->fw.fw_hdr[i]->data;
1782                 for (entry = 0; entry < wl->fw.hdr_num_entries[i];
1783                      entry++, hdr++) {
1784                         if (hdr->idx == idx) {
1785                                 pdata = wl->fw.fw_bin[i]->data + hdr->offset;
1786                                 if (hdr->len != 4) {
1787                                         wiphy_err(wl->wiphy,
1788                                                   "ERROR: fw hdr len\n");
1789                                         return -ENOMSG;
1790                                 }
1791                                 *data = *((u32 *) pdata);
1792                                 return 0;
1793                         }
1794                 }
1795         }
1796         wiphy_err(wl->wiphy, "ERROR: ucode tag:%d can not be found!\n", idx);
1797         return -ENOMSG;
1798 }
1799
1800 /*
1801  * Precondition: Since this function is called in brcms_pci_probe() context,
1802  * no locking is required.
1803  */
1804 static int brcms_request_fw(struct brcms_info *wl, struct pci_dev *pdev)
1805 {
1806         int status;
1807         struct device *device = &pdev->dev;
1808         char fw_name[100];
1809         int i;
1810
1811         memset((void *)&wl->fw, 0, sizeof(struct brcms_firmware));
1812         for (i = 0; i < MAX_FW_IMAGES; i++) {
1813                 if (brcms_firmwares[i] == NULL)
1814                         break;
1815                 sprintf(fw_name, "%s-%d.fw", brcms_firmwares[i],
1816                         UCODE_LOADER_API_VER);
1817                 status = request_firmware(&wl->fw.fw_bin[i], fw_name, device);
1818                 if (status) {
1819                         wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n",
1820                                   KBUILD_MODNAME, fw_name);
1821                         return status;
1822                 }
1823                 sprintf(fw_name, "%s_hdr-%d.fw", brcms_firmwares[i],
1824                         UCODE_LOADER_API_VER);
1825                 status = request_firmware(&wl->fw.fw_hdr[i], fw_name, device);
1826                 if (status) {
1827                         wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n",
1828                                   KBUILD_MODNAME, fw_name);
1829                         return status;
1830                 }
1831                 wl->fw.hdr_num_entries[i] =
1832                     wl->fw.fw_hdr[i]->size / (sizeof(struct firmware_hdr));
1833         }
1834         wl->fw.fw_cnt = i;
1835         return brcms_ucode_data_init(wl);
1836 }
1837
1838 /*
1839  * precondition: can both be called locked and unlocked
1840  */
1841 void brcms_ucode_free_buf(void *p)
1842 {
1843         kfree(p);
1844 }
1845
1846 /*
1847  * Precondition: Since this function is called in brcms_pci_probe() context,
1848  * no locking is required.
1849  */
1850 static void brcms_release_fw(struct brcms_info *wl)
1851 {
1852         int i;
1853         for (i = 0; i < MAX_FW_IMAGES; i++) {
1854                 release_firmware(wl->fw.fw_bin[i]);
1855                 release_firmware(wl->fw.fw_hdr[i]);
1856         }
1857 }
1858
1859
1860 /*
1861  * checks validity of all firmware images loaded from user space
1862  *
1863  * Precondition: Since this function is called in brcms_pci_probe() context,
1864  * no locking is required.
1865  */
1866 int brcms_check_firmwares(struct brcms_info *wl)
1867 {
1868         int i;
1869         int entry;
1870         int rc = 0;
1871         const struct firmware *fw;
1872         const struct firmware *fw_hdr;
1873         struct firmware_hdr *ucode_hdr;
1874         for (i = 0; i < MAX_FW_IMAGES && rc == 0; i++) {
1875                 fw =  wl->fw.fw_bin[i];
1876                 fw_hdr = wl->fw.fw_hdr[i];
1877                 if (fw == NULL && fw_hdr == NULL) {
1878                         break;
1879                 } else if (fw == NULL || fw_hdr == NULL) {
1880                         wiphy_err(wl->wiphy, "%s: invalid bin/hdr fw\n",
1881                                   __func__);
1882                         rc = -EBADF;
1883                 } else if (fw_hdr->size % sizeof(struct firmware_hdr)) {
1884                         wiphy_err(wl->wiphy, "%s: non integral fw hdr file "
1885                                 "size %zu/%zu\n", __func__, fw_hdr->size,
1886                                 sizeof(struct firmware_hdr));
1887                         rc = -EBADF;
1888                 } else if (fw->size < MIN_FW_SIZE || fw->size > MAX_FW_SIZE) {
1889                         wiphy_err(wl->wiphy, "%s: out of bounds fw file size "
1890                                   "%zu\n", __func__, fw->size);
1891                         rc = -EBADF;
1892                 } else {
1893                         /* check if ucode section overruns firmware image */
1894                         ucode_hdr = (struct firmware_hdr *)fw_hdr->data;
1895                         for (entry = 0; entry < wl->fw.hdr_num_entries[i] &&
1896                              !rc; entry++, ucode_hdr++) {
1897                                 if (ucode_hdr->offset + ucode_hdr->len >
1898                                     fw->size) {
1899                                         wiphy_err(wl->wiphy,
1900                                                   "%s: conflicting bin/hdr\n",
1901                                                   __func__);
1902                                         rc = -EBADF;
1903                                 }
1904                         }
1905                 }
1906         }
1907         if (rc == 0 && wl->fw.fw_cnt != i) {
1908                 wiphy_err(wl->wiphy, "%s: invalid fw_cnt=%d\n", __func__,
1909                         wl->fw.fw_cnt);
1910                 rc = -EBADF;
1911         }
1912         return rc;
1913 }
1914
1915 /*
1916  * precondition: perimeter lock has been acquired
1917  */
1918 bool brcms_rfkill_set_hw_state(struct brcms_info *wl)
1919 {
1920         bool blocked = brcms_c_check_radio_disabled(wl->wlc);
1921
1922         UNLOCK(wl);
1923         wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, blocked);
1924         if (blocked)
1925                 wiphy_rfkill_start_polling(wl->pub->ieee_hw->wiphy);
1926         LOCK(wl);
1927         return blocked;
1928 }
1929
1930 /*
1931  * precondition: perimeter lock has been acquired
1932  */
1933 void brcms_msleep(struct brcms_info *wl, uint ms)
1934 {
1935         UNLOCK(wl);
1936         msleep(ms);
1937         LOCK(wl);
1938 }