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                 /* XXX: 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         /* FIXME: this doesn't seem to be used properly in minstrel_ht.
1093          * mac80211/status.c:ieee80211_tx_status() checks this value,
1094          * but mac80211/rc80211_minstrel_ht.c:minstrel_ht_get_rate()
1095          * appears to always set 3 rates
1096          */
1097         hw->max_rates = 2;      /* Primary rate and 1 fallback rate */
1098
1099         hw->channel_change_time = 7 * 1000;     /* channel change time is dependent on chip and band  */
1100         hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1101
1102         hw->rate_control_algorithm = "minstrel_ht";
1103
1104         hw->sta_data_size = sizeof(struct scb);
1105         return ieee_hw_rate_init(hw);
1106 }
1107
1108 /**
1109  * determines if a device is a WL device, and if so, attaches it.
1110  *
1111  * This function determines if a device pointed to by pdev is a WL device,
1112  * and if so, performs a brcms_attach() on it.
1113  *
1114  * Perimeter lock is initialized in the course of this function.
1115  */
1116 static int __devinit
1117 brcms_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1118 {
1119         int rc;
1120         struct brcms_info *wl;
1121         struct ieee80211_hw *hw;
1122         u32 val;
1123
1124         dev_info(&pdev->dev, "bus %d slot %d func %d irq %d\n",
1125                pdev->bus->number, PCI_SLOT(pdev->devfn),
1126                PCI_FUNC(pdev->devfn), pdev->irq);
1127
1128         if ((pdev->vendor != PCI_VENDOR_ID_BROADCOM) ||
1129             ((pdev->device != 0x0576) &&
1130              ((pdev->device & 0xff00) != 0x4300) &&
1131              ((pdev->device & 0xff00) != 0x4700) &&
1132              ((pdev->device < 43000) || (pdev->device > 43999))))
1133                 return -ENODEV;
1134
1135         rc = pci_enable_device(pdev);
1136         if (rc) {
1137                 pr_err("%s: Cannot enable device %d-%d_%d\n",
1138                        __func__, pdev->bus->number, PCI_SLOT(pdev->devfn),
1139                        PCI_FUNC(pdev->devfn));
1140                 return -ENODEV;
1141         }
1142         pci_set_master(pdev);
1143
1144         pci_read_config_dword(pdev, 0x40, &val);
1145         if ((val & 0x0000ff00) != 0)
1146                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
1147
1148         hw = ieee80211_alloc_hw(sizeof(struct brcms_info), &brcms_ops);
1149         if (!hw) {
1150                 pr_err("%s: ieee80211_alloc_hw failed\n", __func__);
1151                 return -ENOMEM;
1152         }
1153
1154         SET_IEEE80211_DEV(hw, &pdev->dev);
1155
1156         pci_set_drvdata(pdev, hw);
1157
1158         memset(hw->priv, 0, sizeof(*wl));
1159
1160         wl = brcms_attach(pdev->vendor, pdev->device,
1161                           pci_resource_start(pdev, 0), PCI_BUS, pdev,
1162                           pdev->irq);
1163
1164         if (!wl) {
1165                 pr_err("%s: %s: brcms_attach failed!\n", KBUILD_MODNAME,
1166                        __func__);
1167                 return -ENODEV;
1168         }
1169         return 0;
1170 }
1171
1172 static int brcms_suspend(struct pci_dev *pdev, pm_message_t state)
1173 {
1174         struct brcms_info *wl;
1175         struct ieee80211_hw *hw;
1176
1177         hw = pci_get_drvdata(pdev);
1178         wl = HW_TO_WL(hw);
1179         if (!wl) {
1180                 wiphy_err(wl->wiphy,
1181                           "brcms_suspend: pci_get_drvdata failed\n");
1182                 return -ENODEV;
1183         }
1184
1185         /* only need to flag hw is down for proper resume */
1186         LOCK(wl);
1187         wl->pub->hw_up = false;
1188         UNLOCK(wl);
1189
1190         pci_save_state(pdev);
1191         pci_disable_device(pdev);
1192         return pci_set_power_state(pdev, PCI_D3hot);
1193 }
1194
1195 static int brcms_resume(struct pci_dev *pdev)
1196 {
1197         struct brcms_info *wl;
1198         struct ieee80211_hw *hw;
1199         int err = 0;
1200         u32 val;
1201
1202         hw = pci_get_drvdata(pdev);
1203         wl = HW_TO_WL(hw);
1204         if (!wl) {
1205                 wiphy_err(wl->wiphy,
1206                           "wl: brcms_resume: pci_get_drvdata failed\n");
1207                 return -ENODEV;
1208         }
1209
1210         err = pci_set_power_state(pdev, PCI_D0);
1211         if (err)
1212                 return err;
1213
1214         pci_restore_state(pdev);
1215
1216         err = pci_enable_device(pdev);
1217         if (err)
1218                 return err;
1219
1220         pci_set_master(pdev);
1221
1222         pci_read_config_dword(pdev, 0x40, &val);
1223         if ((val & 0x0000ff00) != 0)
1224                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
1225
1226         /*
1227         *  done. driver will be put in up state
1228         *  in brcms_ops_add_interface() call.
1229         */
1230         return err;
1231 }
1232
1233 /*
1234 * called from both kernel as from this kernel module.
1235 * precondition: perimeter lock is not acquired.
1236 */
1237 static void brcms_remove(struct pci_dev *pdev)
1238 {
1239         struct brcms_info *wl;
1240         struct ieee80211_hw *hw;
1241         int status;
1242
1243         hw = pci_get_drvdata(pdev);
1244         wl = HW_TO_WL(hw);
1245         if (!wl) {
1246                 pr_err("wl: brcms_remove: pci_get_drvdata failed\n");
1247                 return;
1248         }
1249
1250         LOCK(wl);
1251         status = brcms_c_chipmatch(pdev->vendor, pdev->device);
1252         UNLOCK(wl);
1253         if (!status) {
1254                 wiphy_err(wl->wiphy, "wl: brcms_remove: chipmatch "
1255                                      "failed\n");
1256                 return;
1257         }
1258         if (wl->wlc) {
1259                 wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, false);
1260                 wiphy_rfkill_stop_polling(wl->pub->ieee_hw->wiphy);
1261                 ieee80211_unregister_hw(hw);
1262                 LOCK(wl);
1263                 brcms_down(wl);
1264                 UNLOCK(wl);
1265         }
1266         pci_disable_device(pdev);
1267
1268         brcms_free(wl);
1269
1270         pci_set_drvdata(pdev, NULL);
1271         ieee80211_free_hw(hw);
1272 }
1273
1274 static struct pci_driver brcms_pci_driver = {
1275         .name     = KBUILD_MODNAME,
1276         .probe    = brcms_pci_probe,
1277         .suspend  = brcms_suspend,
1278         .resume   = brcms_resume,
1279         .remove   = __devexit_p(brcms_remove),
1280         .id_table = brcms_pci_id_table,
1281 };
1282
1283 /**
1284  * This is the main entry point for the WL driver.
1285  *
1286  * This function determines if a device pointed to by pdev is a WL device,
1287  * and if so, performs a brcms_attach() on it.
1288  *
1289  */
1290 static int __init brcms_module_init(void)
1291 {
1292         int error = -ENODEV;
1293
1294 #ifdef BCMDBG
1295         if (msglevel != 0xdeadbeef)
1296                 brcm_msg_level = msglevel;
1297         if (phymsglevel != 0xdeadbeef)
1298                 phyhal_msg_level = phymsglevel;
1299 #endif                          /* BCMDBG */
1300
1301         error = pci_register_driver(&brcms_pci_driver);
1302         if (!error)
1303                 return 0;
1304
1305
1306
1307         return error;
1308 }
1309
1310 /**
1311  * This function unloads the WL driver from the system.
1312  *
1313  * This function unconditionally unloads the WL driver module from the
1314  * system.
1315  *
1316  */
1317 static void __exit brcms_module_exit(void)
1318 {
1319         pci_unregister_driver(&brcms_pci_driver);
1320
1321 }
1322
1323 module_init(brcms_module_init);
1324 module_exit(brcms_module_exit);
1325
1326 /**
1327  * This function frees the WL per-device resources.
1328  *
1329  * This function frees resources owned by the WL device pointed to
1330  * by the wl parameter.
1331  *
1332  * precondition: can both be called locked and unlocked
1333  *
1334  */
1335 static void brcms_free(struct brcms_info *wl)
1336 {
1337         struct brcms_timer *t, *next;
1338
1339         /* free ucode data */
1340         if (wl->fw.fw_cnt)
1341                 brcms_ucode_data_free();
1342         if (wl->irq)
1343                 free_irq(wl->irq, wl);
1344
1345         /* kill dpc */
1346         tasklet_kill(&wl->tasklet);
1347
1348         if (wl->pub) {
1349                 brcms_c_module_unregister(wl->pub, "linux", wl);
1350         }
1351
1352         /* free common resources */
1353         if (wl->wlc) {
1354                 brcms_c_detach(wl->wlc);
1355                 wl->wlc = NULL;
1356                 wl->pub = NULL;
1357         }
1358
1359         /* virtual interface deletion is deferred so we cannot spinwait */
1360
1361         /* wait for all pending callbacks to complete */
1362         while (atomic_read(&wl->callbacks) > 0)
1363                 schedule();
1364
1365         /* free timers */
1366         for (t = wl->timers; t; t = next) {
1367                 next = t->next;
1368 #ifdef BCMDBG
1369                 kfree(t->name);
1370 #endif
1371                 kfree(t);
1372         }
1373
1374         /*
1375          * unregister_netdev() calls get_stats() which may read chip registers
1376          * so we cannot unmap the chip registers until after calling unregister_netdev() .
1377          */
1378         if (wl->regsva && wl->bcm_bustype != SDIO_BUS &&
1379             wl->bcm_bustype != JTAG_BUS) {
1380                 iounmap((void *)wl->regsva);
1381         }
1382         wl->regsva = NULL;
1383 }
1384
1385 /* flags the given rate in rateset as requested */
1386 static void brcms_set_basic_rate(struct wl_rateset *rs, u16 rate, bool is_br)
1387 {
1388         u32 i;
1389
1390         for (i = 0; i < rs->count; i++) {
1391                 if (rate != (rs->rates[i] & 0x7f))
1392                         continue;
1393
1394                 if (is_br)
1395                         rs->rates[i] |= WLC_RATE_FLAG;
1396                 else
1397                         rs->rates[i] &= WLC_RATE_MASK;
1398                 return;
1399         }
1400 }
1401
1402 /*
1403  * precondition: perimeter lock has been acquired
1404  */
1405 void brcms_txflowcontrol(struct brcms_info *wl, struct brcms_if *wlif,
1406                          bool state, int prio)
1407 {
1408         wiphy_err(wl->wiphy, "Shouldn't be here %s\n", __func__);
1409 }
1410
1411 /*
1412  * precondition: perimeter lock has been acquired
1413  */
1414 void brcms_init(struct brcms_info *wl)
1415 {
1416         BCMMSG(WL_TO_HW(wl)->wiphy, "wl%d\n", wl->pub->unit);
1417         brcms_reset(wl);
1418
1419         brcms_c_init(wl->wlc);
1420 }
1421
1422 /*
1423  * precondition: perimeter lock has been acquired
1424  */
1425 uint brcms_reset(struct brcms_info *wl)
1426 {
1427         BCMMSG(WL_TO_HW(wl)->wiphy, "wl%d\n", wl->pub->unit);
1428         brcms_c_reset(wl->wlc);
1429
1430         /* dpc will not be rescheduled */
1431         wl->resched = 0;
1432
1433         return 0;
1434 }
1435
1436 /*
1437  * These are interrupt on/off entry points. Disable interrupts
1438  * during interrupt state transition.
1439  */
1440 void brcms_intrson(struct brcms_info *wl)
1441 {
1442         unsigned long flags;
1443
1444         INT_LOCK(wl, flags);
1445         brcms_c_intrson(wl->wlc);
1446         INT_UNLOCK(wl, flags);
1447 }
1448
1449 /*
1450  * precondition: perimeter lock has been acquired
1451  */
1452 bool wl_alloc_dma_resources(struct brcms_info *wl, uint addrwidth)
1453 {
1454         return true;
1455 }
1456
1457 u32 brcms_intrsoff(struct brcms_info *wl)
1458 {
1459         unsigned long flags;
1460         u32 status;
1461
1462         INT_LOCK(wl, flags);
1463         status = brcms_c_intrsoff(wl->wlc);
1464         INT_UNLOCK(wl, flags);
1465         return status;
1466 }
1467
1468 void brcms_intrsrestore(struct brcms_info *wl, u32 macintmask)
1469 {
1470         unsigned long flags;
1471
1472         INT_LOCK(wl, flags);
1473         brcms_c_intrsrestore(wl->wlc, macintmask);
1474         INT_UNLOCK(wl, flags);
1475 }
1476
1477 /*
1478  * precondition: perimeter lock has been acquired
1479  */
1480 int brcms_up(struct brcms_info *wl)
1481 {
1482         int error = 0;
1483
1484         if (wl->pub->up)
1485                 return 0;
1486
1487         error = brcms_c_up(wl->wlc);
1488
1489         return error;
1490 }
1491
1492 /*
1493  * precondition: perimeter lock has been acquired
1494  */
1495 void brcms_down(struct brcms_info *wl)
1496 {
1497         uint callbacks, ret_val = 0;
1498
1499         /* call common down function */
1500         ret_val = brcms_c_down(wl->wlc);
1501         callbacks = atomic_read(&wl->callbacks) - ret_val;
1502
1503         /* wait for down callbacks to complete */
1504         UNLOCK(wl);
1505
1506         /* For HIGH_only driver, it's important to actually schedule other work,
1507          * not just spin wait since everything runs at schedule level
1508          */
1509         SPINWAIT((atomic_read(&wl->callbacks) > callbacks), 100 * 1000);
1510
1511         LOCK(wl);
1512 }
1513
1514 static irqreturn_t brcms_isr(int irq, void *dev_id)
1515 {
1516         struct brcms_info *wl;
1517         bool ours, wantdpc;
1518         unsigned long flags;
1519
1520         wl = (struct brcms_info *) dev_id;
1521
1522         ISR_LOCK(wl, flags);
1523
1524         /* call common first level interrupt handler */
1525         ours = brcms_c_isr(wl->wlc, &wantdpc);
1526         if (ours) {
1527                 /* if more to do... */
1528                 if (wantdpc) {
1529
1530                         /* ...and call the second level interrupt handler */
1531                         /* schedule dpc */
1532                         tasklet_schedule(&wl->tasklet);
1533                 }
1534         }
1535
1536         ISR_UNLOCK(wl, flags);
1537
1538         return IRQ_RETVAL(ours);
1539 }
1540
1541 static void brcms_dpc(unsigned long data)
1542 {
1543         struct brcms_info *wl;
1544
1545         wl = (struct brcms_info *) data;
1546
1547         LOCK(wl);
1548
1549         /* call the common second level interrupt handler */
1550         if (wl->pub->up) {
1551                 if (wl->resched) {
1552                         unsigned long flags;
1553
1554                         INT_LOCK(wl, flags);
1555                         brcms_c_intrsupd(wl->wlc);
1556                         INT_UNLOCK(wl, flags);
1557                 }
1558
1559                 wl->resched = brcms_c_dpc(wl->wlc, true);
1560         }
1561
1562         /* brcms_c_dpc() may bring the driver down */
1563         if (!wl->pub->up)
1564                 goto done;
1565
1566         /* re-schedule dpc */
1567         if (wl->resched)
1568                 tasklet_schedule(&wl->tasklet);
1569         else {
1570                 /* re-enable interrupts */
1571                 brcms_intrson(wl);
1572         }
1573
1574  done:
1575         UNLOCK(wl);
1576 }
1577
1578 /*
1579  * is called by the kernel from software irq context
1580  */
1581 static void brcms_timer(unsigned long data)
1582 {
1583         _brcms_timer((struct brcms_timer *) data);
1584 }
1585
1586 /*
1587 * precondition: perimeter lock is not acquired
1588  */
1589 static void _brcms_timer(struct brcms_timer *t)
1590 {
1591         LOCK(t->wl);
1592
1593         if (t->set) {
1594                 if (t->periodic) {
1595                         t->timer.expires = jiffies + t->ms * HZ / 1000;
1596                         atomic_inc(&t->wl->callbacks);
1597                         add_timer(&t->timer);
1598                         t->set = true;
1599                 } else
1600                         t->set = false;
1601
1602                 t->fn(t->arg);
1603         }
1604
1605         atomic_dec(&t->wl->callbacks);
1606
1607         UNLOCK(t->wl);
1608 }
1609
1610 /*
1611  * Adds a timer to the list. Caller supplies a timer function.
1612  * Is called from wlc.
1613  *
1614  * precondition: perimeter lock has been acquired
1615  */
1616 struct brcms_timer *brcms_init_timer(struct brcms_info *wl,
1617                                      void (*fn) (void *arg),
1618                                      void *arg, const char *name)
1619 {
1620         struct brcms_timer *t;
1621
1622         t = kzalloc(sizeof(struct brcms_timer), GFP_ATOMIC);
1623         if (!t) {
1624                 wiphy_err(wl->wiphy, "wl%d: brcms_init_timer: out of memory\n",
1625                           wl->pub->unit);
1626                 return 0;
1627         }
1628
1629         init_timer(&t->timer);
1630         t->timer.data = (unsigned long) t;
1631         t->timer.function = brcms_timer;
1632         t->wl = wl;
1633         t->fn = fn;
1634         t->arg = arg;
1635         t->next = wl->timers;
1636         wl->timers = t;
1637
1638 #ifdef BCMDBG
1639         t->name = kmalloc(strlen(name) + 1, GFP_ATOMIC);
1640         if (t->name)
1641                 strcpy(t->name, name);
1642 #endif
1643
1644         return t;
1645 }
1646
1647 /* BMAC_NOTE: Add timer adds only the kernel timer since it's going to be more accurate
1648  * as well as it's easier to make it periodic
1649  *
1650  * precondition: perimeter lock has been acquired
1651  */
1652 void brcms_add_timer(struct brcms_info *wl, struct brcms_timer *t, uint ms,
1653                      int periodic)
1654 {
1655 #ifdef BCMDBG
1656         if (t->set) {
1657                 wiphy_err(wl->wiphy, "%s: Already set. Name: %s, per %d\n",
1658                           __func__, t->name, periodic);
1659         }
1660 #endif
1661         t->ms = ms;
1662         t->periodic = (bool) periodic;
1663         t->set = true;
1664         t->timer.expires = jiffies + ms * HZ / 1000;
1665
1666         atomic_inc(&wl->callbacks);
1667         add_timer(&t->timer);
1668 }
1669
1670 /*
1671  * return true if timer successfully deleted, false if still pending
1672  *
1673  * precondition: perimeter lock has been acquired
1674  */
1675 bool brcms_del_timer(struct brcms_info *wl, struct brcms_timer *t)
1676 {
1677         if (t->set) {
1678                 t->set = false;
1679                 if (!del_timer(&t->timer)) {
1680                         return false;
1681                 }
1682                 atomic_dec(&wl->callbacks);
1683         }
1684
1685         return true;
1686 }
1687
1688 /*
1689  * precondition: perimeter lock has been acquired
1690  */
1691 void brcms_free_timer(struct brcms_info *wl, struct brcms_timer *t)
1692 {
1693         struct brcms_timer *tmp;
1694
1695         /* delete the timer in case it is active */
1696         brcms_del_timer(wl, t);
1697
1698         if (wl->timers == t) {
1699                 wl->timers = wl->timers->next;
1700 #ifdef BCMDBG
1701                 kfree(t->name);
1702 #endif
1703                 kfree(t);
1704                 return;
1705
1706         }
1707
1708         tmp = wl->timers;
1709         while (tmp) {
1710                 if (tmp->next == t) {
1711                         tmp->next = t->next;
1712 #ifdef BCMDBG
1713                         kfree(t->name);
1714 #endif
1715                         kfree(t);
1716                         return;
1717                 }
1718                 tmp = tmp->next;
1719         }
1720
1721 }
1722
1723 /*
1724  * runs in software irq context
1725  *
1726  * precondition: perimeter lock is not acquired
1727  */
1728 static int wl_linux_watchdog(void *ctx)
1729 {
1730         return 0;
1731 }
1732
1733 struct firmware_hdr {
1734         u32 offset;
1735         u32 len;
1736         u32 idx;
1737 };
1738
1739 char *brcms_firmwares[MAX_FW_IMAGES] = {
1740         "brcm/bcm43xx",
1741         NULL
1742 };
1743
1744 /*
1745  * precondition: perimeter lock has been acquired
1746  */
1747 int brcms_ucode_init_buf(struct brcms_info *wl, void **pbuf, u32 idx)
1748 {
1749         int i, entry;
1750         const u8 *pdata;
1751         struct firmware_hdr *hdr;
1752         for (i = 0; i < wl->fw.fw_cnt; i++) {
1753                 hdr = (struct firmware_hdr *)wl->fw.fw_hdr[i]->data;
1754                 for (entry = 0; entry < wl->fw.hdr_num_entries[i];
1755                      entry++, hdr++) {
1756                         if (hdr->idx == idx) {
1757                                 pdata = wl->fw.fw_bin[i]->data + hdr->offset;
1758                                 *pbuf = kmalloc(hdr->len, GFP_ATOMIC);
1759                                 if (*pbuf == NULL) {
1760                                         wiphy_err(wl->wiphy, "fail to alloc %d"
1761                                                   " bytes\n", hdr->len);
1762                                         goto fail;
1763                                 }
1764                                 memcpy(*pbuf, pdata, hdr->len);
1765                                 return 0;
1766                         }
1767                 }
1768         }
1769         wiphy_err(wl->wiphy, "ERROR: ucode buf tag:%d can not be found!\n",
1770                   idx);
1771         *pbuf = NULL;
1772 fail:
1773         return -ENODATA;
1774 }
1775
1776 /*
1777  * Precondition: Since this function is called in brcms_pci_probe() context,
1778  * no locking is required.
1779  */
1780 int brcms_ucode_init_uint(struct brcms_info *wl, u32 *data, u32 idx)
1781 {
1782         int i, entry;
1783         const u8 *pdata;
1784         struct firmware_hdr *hdr;
1785         for (i = 0; i < wl->fw.fw_cnt; i++) {
1786                 hdr = (struct firmware_hdr *)wl->fw.fw_hdr[i]->data;
1787                 for (entry = 0; entry < wl->fw.hdr_num_entries[i];
1788                      entry++, hdr++) {
1789                         if (hdr->idx == idx) {
1790                                 pdata = wl->fw.fw_bin[i]->data + hdr->offset;
1791                                 if (hdr->len != 4) {
1792                                         wiphy_err(wl->wiphy,
1793                                                   "ERROR: fw hdr len\n");
1794                                         return -ENOMSG;
1795                                 }
1796                                 *data = *((u32 *) pdata);
1797                                 return 0;
1798                         }
1799                 }
1800         }
1801         wiphy_err(wl->wiphy, "ERROR: ucode tag:%d can not be found!\n", idx);
1802         return -ENOMSG;
1803 }
1804
1805 /*
1806  * Precondition: Since this function is called in brcms_pci_probe() context,
1807  * no locking is required.
1808  */
1809 static int brcms_request_fw(struct brcms_info *wl, struct pci_dev *pdev)
1810 {
1811         int status;
1812         struct device *device = &pdev->dev;
1813         char fw_name[100];
1814         int i;
1815
1816         memset((void *)&wl->fw, 0, sizeof(struct brcms_firmware));
1817         for (i = 0; i < MAX_FW_IMAGES; i++) {
1818                 if (brcms_firmwares[i] == NULL)
1819                         break;
1820                 sprintf(fw_name, "%s-%d.fw", brcms_firmwares[i],
1821                         UCODE_LOADER_API_VER);
1822                 status = request_firmware(&wl->fw.fw_bin[i], fw_name, device);
1823                 if (status) {
1824                         wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n",
1825                                   KBUILD_MODNAME, fw_name);
1826                         return status;
1827                 }
1828                 sprintf(fw_name, "%s_hdr-%d.fw", brcms_firmwares[i],
1829                         UCODE_LOADER_API_VER);
1830                 status = request_firmware(&wl->fw.fw_hdr[i], fw_name, device);
1831                 if (status) {
1832                         wiphy_err(wl->wiphy, "%s: fail to load firmware %s\n",
1833                                   KBUILD_MODNAME, fw_name);
1834                         return status;
1835                 }
1836                 wl->fw.hdr_num_entries[i] =
1837                     wl->fw.fw_hdr[i]->size / (sizeof(struct firmware_hdr));
1838         }
1839         wl->fw.fw_cnt = i;
1840         return brcms_ucode_data_init(wl);
1841 }
1842
1843 /*
1844  * precondition: can both be called locked and unlocked
1845  */
1846 void brcms_ucode_free_buf(void *p)
1847 {
1848         kfree(p);
1849 }
1850
1851 /*
1852  * Precondition: Since this function is called in brcms_pci_probe() context,
1853  * no locking is required.
1854  */
1855 static void brcms_release_fw(struct brcms_info *wl)
1856 {
1857         int i;
1858         for (i = 0; i < MAX_FW_IMAGES; i++) {
1859                 release_firmware(wl->fw.fw_bin[i]);
1860                 release_firmware(wl->fw.fw_hdr[i]);
1861         }
1862 }
1863
1864
1865 /*
1866  * checks validity of all firmware images loaded from user space
1867  *
1868  * Precondition: Since this function is called in brcms_pci_probe() context,
1869  * no locking is required.
1870  */
1871 int brcms_check_firmwares(struct brcms_info *wl)
1872 {
1873         int i;
1874         int entry;
1875         int rc = 0;
1876         const struct firmware *fw;
1877         const struct firmware *fw_hdr;
1878         struct firmware_hdr *ucode_hdr;
1879         for (i = 0; i < MAX_FW_IMAGES && rc == 0; i++) {
1880                 fw =  wl->fw.fw_bin[i];
1881                 fw_hdr = wl->fw.fw_hdr[i];
1882                 if (fw == NULL && fw_hdr == NULL) {
1883                         break;
1884                 } else if (fw == NULL || fw_hdr == NULL) {
1885                         wiphy_err(wl->wiphy, "%s: invalid bin/hdr fw\n",
1886                                   __func__);
1887                         rc = -EBADF;
1888                 } else if (fw_hdr->size % sizeof(struct firmware_hdr)) {
1889                         wiphy_err(wl->wiphy, "%s: non integral fw hdr file "
1890                                 "size %zu/%zu\n", __func__, fw_hdr->size,
1891                                 sizeof(struct firmware_hdr));
1892                         rc = -EBADF;
1893                 } else if (fw->size < MIN_FW_SIZE || fw->size > MAX_FW_SIZE) {
1894                         wiphy_err(wl->wiphy, "%s: out of bounds fw file size "
1895                                   "%zu\n", __func__, fw->size);
1896                         rc = -EBADF;
1897                 } else {
1898                         /* check if ucode section overruns firmware image */
1899                         ucode_hdr = (struct firmware_hdr *)fw_hdr->data;
1900                         for (entry = 0; entry < wl->fw.hdr_num_entries[i] &&
1901                              !rc; entry++, ucode_hdr++) {
1902                                 if (ucode_hdr->offset + ucode_hdr->len >
1903                                     fw->size) {
1904                                         wiphy_err(wl->wiphy,
1905                                                   "%s: conflicting bin/hdr\n",
1906                                                   __func__);
1907                                         rc = -EBADF;
1908                                 }
1909                         }
1910                 }
1911         }
1912         if (rc == 0 && wl->fw.fw_cnt != i) {
1913                 wiphy_err(wl->wiphy, "%s: invalid fw_cnt=%d\n", __func__,
1914                         wl->fw.fw_cnt);
1915                 rc = -EBADF;
1916         }
1917         return rc;
1918 }
1919
1920 /*
1921  * precondition: perimeter lock has been acquired
1922  */
1923 bool brcms_rfkill_set_hw_state(struct brcms_info *wl)
1924 {
1925         bool blocked = brcms_c_check_radio_disabled(wl->wlc);
1926
1927         UNLOCK(wl);
1928         wiphy_rfkill_set_hw_state(wl->pub->ieee_hw->wiphy, blocked);
1929         if (blocked)
1930                 wiphy_rfkill_start_polling(wl->pub->ieee_hw->wiphy);
1931         LOCK(wl);
1932         return blocked;
1933 }
1934
1935 /*
1936  * precondition: perimeter lock has been acquired
1937  */
1938 void brcms_msleep(struct brcms_info *wl, uint ms)
1939 {
1940         UNLOCK(wl);
1941         msleep(ms);
1942         LOCK(wl);
1943 }