drivers/net/wireless/ti/wlcore/main.c

   1
   2 /*
   3  * This file is part of wl1271
   4  *
   5  * Copyright (C) 2008-2010 Nokia Corporation
   6  *
   7  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * version 2 as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/firmware.h>
  27 #include <linux/delay.h>
  28 #include <linux/spi/spi.h>
  29 #include <linux/crc32.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/vmalloc.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/slab.h>
  34 #include <linux/wl12xx.h>
  35 #include <linux/sched.h>
  36 #include <linux/interrupt.h>
  37
  38 #include "wlcore.h"
  39 #include "debug.h"
  40 #include "wl12xx_80211.h"
  41 #include "io.h"
  42 #include "event.h"
  43 #include "tx.h"
  44 #include "rx.h"
  45 #include "ps.h"
  46 #include "init.h"
  47 #include "debugfs.h"
  48 #include "cmd.h"
  49 #include "boot.h"
  50 #include "testmode.h"
  51 #include "scan.h"
  52 #include "hw_ops.h"
  53
  54 #define WL1271_BOOT_RETRIES 3
  55
  56 #define WL1271_BOOT_RETRIES 3
  57
  58 static char *fwlog_param;
  59 static int bug_on_recovery = -1;
  60 static int no_recovery     = -1;
  61
  62 static void __wl1271_op_remove_interface(struct wl1271 *wl,
  63                                          struct ieee80211_vif *vif,
  64                                          bool reset_tx_queues);
  65 static void wlcore_op_stop_locked(struct wl1271 *wl);
  66 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
  67
  68 static int wl12xx_set_authorized(struct wl1271 *wl,
  69                                  struct wl12xx_vif *wlvif)
  70 {
  71         int ret;
  72
  73         if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
  74                 return -EINVAL;
  75
  76         if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
  77                 return 0;
  78
  79         if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
  80                 return 0;
  81
  82         ret = wl12xx_cmd_set_peer_state(wl, wlvif, wlvif->sta.hlid);
  83         if (ret < 0)
  84                 return ret;
  85
  86         wl1271_info("Association completed.");
  87         return 0;
  88 }
  89
  90 static void wl1271_reg_notify(struct wiphy *wiphy,
  91                               struct regulatory_request *request)
  92 {
  93         struct ieee80211_supported_band *band;
  94         struct ieee80211_channel *ch;
  95         int i;
  96         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
  97         struct wl1271 *wl = hw->priv;
  98
  99         band = wiphy->bands[IEEE80211_BAND_5GHZ];
 100         for (i = 0; i < band->n_channels; i++) {
 101                 ch = &band->channels[i];
 102                 if (ch->flags & IEEE80211_CHAN_DISABLED)
 103                         continue;
 104
 105                 if (ch->flags & IEEE80211_CHAN_RADAR)
 106                         ch->flags |= IEEE80211_CHAN_NO_IBSS |
 107                                      IEEE80211_CHAN_PASSIVE_SCAN;
 108
 109         }
 110
 111         if (likely(wl->state == WLCORE_STATE_ON))
 112                 wlcore_regdomain_config(wl);
 113 }
 114
 115 static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
 116                                    bool enable)
 117 {
 118         int ret = 0;
 119
 120         /* we should hold wl->mutex */
 121         ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
 122         if (ret < 0)
 123                 goto out;
 124
 125         if (enable)
 126                 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
 127         else
 128                 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
 129 out:
 130         return ret;
 131 }
 132
 133 /*
 134  * this function is being called when the rx_streaming interval
 135  * has beed changed or rx_streaming should be disabled
 136  */
 137 int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 138 {
 139         int ret = 0;
 140         int period = wl->conf.rx_streaming.interval;
 141
 142         /* don't reconfigure if rx_streaming is disabled */
 143         if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
 144                 goto out;
 145
 146         /* reconfigure/disable according to new streaming_period */
 147         if (period &&
 148             test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
 149             (wl->conf.rx_streaming.always ||
 150              test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
 151                 ret = wl1271_set_rx_streaming(wl, wlvif, true);
 152         else {
 153                 ret = wl1271_set_rx_streaming(wl, wlvif, false);
 154                 /* don't cancel_work_sync since we might deadlock */
 155                 del_timer_sync(&wlvif->rx_streaming_timer);
 156         }
 157 out:
 158         return ret;
 159 }
 160
 161 static void wl1271_rx_streaming_enable_work(struct work_struct *work)
 162 {
 163         int ret;
 164         struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
 165                                                 rx_streaming_enable_work);
 166         struct wl1271 *wl = wlvif->wl;
 167
 168         mutex_lock(&wl->mutex);
 169
 170         if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
 171             !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
 172             (!wl->conf.rx_streaming.always &&
 173              !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
 174                 goto out;
 175
 176         if (!wl->conf.rx_streaming.interval)
 177                 goto out;
 178
 179         ret = wl1271_ps_elp_wakeup(wl);
 180         if (ret < 0)
 181                 goto out;
 182
 183         ret = wl1271_set_rx_streaming(wl, wlvif, true);
 184         if (ret < 0)
 185                 goto out_sleep;
 186
 187         /* stop it after some time of inactivity */
 188         mod_timer(&wlvif->rx_streaming_timer,
 189                   jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
 190
 191 out_sleep:
 192         wl1271_ps_elp_sleep(wl);
 193 out:
 194         mutex_unlock(&wl->mutex);
 195 }
 196
 197 static void wl1271_rx_streaming_disable_work(struct work_struct *work)
 198 {
 199         int ret;
 200         struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
 201                                                 rx_streaming_disable_work);
 202         struct wl1271 *wl = wlvif->wl;
 203
 204         mutex_lock(&wl->mutex);
 205
 206         if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
 207                 goto out;
 208
 209         ret = wl1271_ps_elp_wakeup(wl);
 210         if (ret < 0)
 211                 goto out;
 212
 213         ret = wl1271_set_rx_streaming(wl, wlvif, false);
 214         if (ret)
 215                 goto out_sleep;
 216
 217 out_sleep:
 218         wl1271_ps_elp_sleep(wl);
 219 out:
 220         mutex_unlock(&wl->mutex);
 221 }
 222
 223 static void wl1271_rx_streaming_timer(unsigned long data)
 224 {
 225         struct wl12xx_vif *wlvif = (struct wl12xx_vif *)data;
 226         struct wl1271 *wl = wlvif->wl;
 227         ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
 228 }
 229
 230 /* wl->mutex must be taken */
 231 void wl12xx_rearm_tx_watchdog_locked(struct wl1271 *wl)
 232 {
 233         /* if the watchdog is not armed, don't do anything */
 234         if (wl->tx_allocated_blocks == 0)
 235                 return;
 236
 237         cancel_delayed_work(&wl->tx_watchdog_work);
 238         ieee80211_queue_delayed_work(wl->hw, &wl->tx_watchdog_work,
 239                 msecs_to_jiffies(wl->conf.tx.tx_watchdog_timeout));
 240 }
 241
 242 static void wl12xx_tx_watchdog_work(struct work_struct *work)
 243 {
 244         struct delayed_work *dwork;
 245         struct wl1271 *wl;
 246
 247         dwork = container_of(work, struct delayed_work, work);
 248         wl = container_of(dwork, struct wl1271, tx_watchdog_work);
 249
 250         mutex_lock(&wl->mutex);
 251
 252         if (unlikely(wl->state != WLCORE_STATE_ON))
 253                 goto out;
 254
 255         /* Tx went out in the meantime - everything is ok */
 256         if (unlikely(wl->tx_allocated_blocks == 0))
 257                 goto out;
 258
 259         /*
 260          * if a ROC is in progress, we might not have any Tx for a long
 261          * time (e.g. pending Tx on the non-ROC channels)
 262          */
 263         if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
 264                 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
 265                              wl->conf.tx.tx_watchdog_timeout);
 266                 wl12xx_rearm_tx_watchdog_locked(wl);
 267                 goto out;
 268         }
 269
 270         /*
 271          * if a scan is in progress, we might not have any Tx for a long
 272          * time
 273          */
 274         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
 275                 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
 276                              wl->conf.tx.tx_watchdog_timeout);
 277                 wl12xx_rearm_tx_watchdog_locked(wl);
 278                 goto out;
 279         }
 280
 281         /*
 282         * AP might cache a frame for a long time for a sleeping station,
 283         * so rearm the timer if there's an AP interface with stations. If
 284         * Tx is genuinely stuck we will most hopefully discover it when all
 285         * stations are removed due to inactivity.
 286         */
 287         if (wl->active_sta_count) {
 288                 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
 289                              " %d stations",
 290                               wl->conf.tx.tx_watchdog_timeout,
 291                               wl->active_sta_count);
 292                 wl12xx_rearm_tx_watchdog_locked(wl);
 293                 goto out;
 294         }
 295
 296         wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
 297                      wl->conf.tx.tx_watchdog_timeout);
 298         wl12xx_queue_recovery_work(wl);
 299
 300 out:
 301         mutex_unlock(&wl->mutex);
 302 }
 303
 304 static void wlcore_adjust_conf(struct wl1271 *wl)
 305 {
 306         /* Adjust settings according to optional module parameters */
 307
 308         if (fwlog_param) {
 309                 if (!strcmp(fwlog_param, "continuous")) {
 310                         wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
 311                 } else if (!strcmp(fwlog_param, "ondemand")) {
 312                         wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
 313                 } else if (!strcmp(fwlog_param, "dbgpins")) {
 314                         wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
 315                         wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
 316                 } else if (!strcmp(fwlog_param, "disable")) {
 317                         wl->conf.fwlog.mem_blocks = 0;
 318                         wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
 319                 } else {
 320                         wl1271_error("Unknown fwlog parameter %s", fwlog_param);
 321                 }
 322         }
 323
 324         if (bug_on_recovery != -1)
 325                 wl->conf.recovery.bug_on_recovery = (u8) bug_on_recovery;
 326
 327         if (no_recovery != -1)
 328                 wl->conf.recovery.no_recovery = (u8) no_recovery;
 329 }
 330
 331 static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
 332                                         struct wl12xx_vif *wlvif,
 333                                         u8 hlid, u8 tx_pkts)
 334 {
 335         bool fw_ps, single_link;
 336
 337         fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
 338         single_link = (wl->active_link_count == 1);
 339
 340         /*
 341          * Wake up from high level PS if the STA is asleep with too little
 342          * packets in FW or if the STA is awake.
 343          */
 344         if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
 345                 wl12xx_ps_link_end(wl, wlvif, hlid);
 346
 347         /*
 348          * Start high-level PS if the STA is asleep with enough blocks in FW.
 349          * Make an exception if this is the only connected link. In this
 350          * case FW-memory congestion is less of a problem.
 351          */
 352         else if (!single_link && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
 353                 wl12xx_ps_link_start(wl, wlvif, hlid, true);
 354 }
 355
 356 static void wl12xx_irq_update_links_status(struct wl1271 *wl,
 357                                            struct wl12xx_vif *wlvif,
 358                                            struct wl_fw_status_2 *status)
 359 {
 360         u32 cur_fw_ps_map;
 361         u8 hlid;
 362
 363         cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
 364         if (wl->ap_fw_ps_map != cur_fw_ps_map) {
 365                 wl1271_debug(DEBUG_PSM,
 366                              "link ps prev 0x%x cur 0x%x changed 0x%x",
 367                              wl->ap_fw_ps_map, cur_fw_ps_map,
 368                              wl->ap_fw_ps_map ^ cur_fw_ps_map);
 369
 370                 wl->ap_fw_ps_map = cur_fw_ps_map;
 371         }
 372
 373         for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, WL12XX_MAX_LINKS)
 374                 wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
 375                                             wl->links[hlid].allocated_pkts);
 376 }
 377
 378 static int wlcore_fw_status(struct wl1271 *wl,
 379                             struct wl_fw_status_1 *status_1,
 380                             struct wl_fw_status_2 *status_2)
 381 {
 382         struct wl12xx_vif *wlvif;
 383         struct timespec ts;
 384         u32 old_tx_blk_count = wl->tx_blocks_available;
 385         int avail, freed_blocks;
 386         int i;
 387         size_t status_len;
 388         int ret;
 389         struct wl1271_link *lnk;
 390
 391         status_len = WLCORE_FW_STATUS_1_LEN(wl->num_rx_desc) +
 392                 sizeof(*status_2) + wl->fw_status_priv_len;
 393
 394         ret = wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR, status_1,
 395                                    status_len, false);
 396         if (ret < 0)
 397                 return ret;
 398
 399         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
 400                      "drv_rx_counter = %d, tx_results_counter = %d)",
 401                      status_1->intr,
 402                      status_1->fw_rx_counter,
 403                      status_1->drv_rx_counter,
 404                      status_1->tx_results_counter);
 405
 406         for (i = 0; i < NUM_TX_QUEUES; i++) {
 407                 /* prevent wrap-around in freed-packets counter */
 408                 wl->tx_allocated_pkts[i] -=
 409                                 (status_2->counters.tx_released_pkts[i] -
 410                                 wl->tx_pkts_freed[i]) & 0xff;
 411
 412                 wl->tx_pkts_freed[i] = status_2->counters.tx_released_pkts[i];
 413         }
 414
 415
 416         for_each_set_bit(i, wl->links_map, WL12XX_MAX_LINKS) {
 417                 lnk = &wl->links[i];
 418                 /* prevent wrap-around in freed-packets counter */
 419                 lnk->allocated_pkts -=
 420                         (status_2->counters.tx_lnk_free_pkts[i] -
 421                          lnk->prev_freed_pkts) & 0xff;
 422
 423                 lnk->prev_freed_pkts = status_2->counters.tx_lnk_free_pkts[i];
 424         }
 425
 426         /* prevent wrap-around in total blocks counter */
 427         if (likely(wl->tx_blocks_freed <=
 428                    le32_to_cpu(status_2->total_released_blks)))
 429                 freed_blocks = le32_to_cpu(status_2->total_released_blks) -
 430                                wl->tx_blocks_freed;
 431         else
 432                 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
 433                                le32_to_cpu(status_2->total_released_blks);
 434
 435         wl->tx_blocks_freed = le32_to_cpu(status_2->total_released_blks);
 436
 437         wl->tx_allocated_blocks -= freed_blocks;
 438
 439         /*
 440          * If the FW freed some blocks:
 441          * If we still have allocated blocks - re-arm the timer, Tx is
 442          * not stuck. Otherwise, cancel the timer (no Tx currently).
 443          */
 444         if (freed_blocks) {
 445                 if (wl->tx_allocated_blocks)
 446                         wl12xx_rearm_tx_watchdog_locked(wl);
 447                 else
 448                         cancel_delayed_work(&wl->tx_watchdog_work);
 449         }
 450
 451         avail = le32_to_cpu(status_2->tx_total) - wl->tx_allocated_blocks;
 452
 453         /*
 454          * The FW might change the total number of TX memblocks before
 455          * we get a notification about blocks being released. Thus, the
 456          * available blocks calculation might yield a temporary result
 457          * which is lower than the actual available blocks. Keeping in
 458          * mind that only blocks that were allocated can be moved from
 459          * TX to RX, tx_blocks_available should never decrease here.
 460          */
 461         wl->tx_blocks_available = max((int)wl->tx_blocks_available,
 462                                       avail);
 463
 464         /* if more blocks are available now, tx work can be scheduled */
 465         if (wl->tx_blocks_available > old_tx_blk_count)
 466                 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
 467
 468         /* for AP update num of allocated TX blocks per link and ps status */
 469         wl12xx_for_each_wlvif_ap(wl, wlvif) {
 470                 wl12xx_irq_update_links_status(wl, wlvif, status_2);
 471         }
 472
 473         /* update the host-chipset time offset */
 474         getnstimeofday(&ts);
 475         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
 476                 (s64)le32_to_cpu(status_2->fw_localtime);
 477
 478         wl->fw_fast_lnk_map = le32_to_cpu(status_2->link_fast_bitmap);
 479
 480         return 0;
 481 }
 482
 483 static void wl1271_flush_deferred_work(struct wl1271 *wl)
 484 {
 485         struct sk_buff *skb;
 486
 487         /* Pass all received frames to the network stack */
 488         while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
 489                 ieee80211_rx_ni(wl->hw, skb);
 490
 491         /* Return sent skbs to the network stack */
 492         while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
 493                 ieee80211_tx_status_ni(wl->hw, skb);
 494 }
 495
 496 static void wl1271_netstack_work(struct work_struct *work)
 497 {
 498         struct wl1271 *wl =
 499                 container_of(work, struct wl1271, netstack_work);
 500
 501         do {
 502                 wl1271_flush_deferred_work(wl);
 503         } while (skb_queue_len(&wl->deferred_rx_queue));
 504 }
 505
 506 #define WL1271_IRQ_MAX_LOOPS 256
 507
 508 static int wlcore_irq_locked(struct wl1271 *wl)
 509 {
 510         int ret = 0;
 511         u32 intr;
 512         int loopcount = WL1271_IRQ_MAX_LOOPS;
 513         bool done = false;
 514         unsigned int defer_count;
 515         unsigned long flags;
 516
 517         /*
 518          * In case edge triggered interrupt must be used, we cannot iterate
 519          * more than once without introducing race conditions with the hardirq.
 520          */
 521         if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
 522                 loopcount = 1;
 523
 524         wl1271_debug(DEBUG_IRQ, "IRQ work");
 525
 526         if (unlikely(wl->state != WLCORE_STATE_ON))
 527                 goto out;
 528
 529         ret = wl1271_ps_elp_wakeup(wl);
 530         if (ret < 0)
 531                 goto out;
 532
 533         while (!done && loopcount--) {
 534                 /*
 535                  * In order to avoid a race with the hardirq, clear the flag
 536                  * before acknowledging the chip. Since the mutex is held,
 537                  * wl1271_ps_elp_wakeup cannot be called concurrently.
 538                  */
 539                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 540                 smp_mb__after_clear_bit();
 541
 542                 ret = wlcore_fw_status(wl, wl->fw_status_1, wl->fw_status_2);
 543                 if (ret < 0)
 544                         goto out;
 545
 546                 wlcore_hw_tx_immediate_compl(wl);
 547
 548                 intr = le32_to_cpu(wl->fw_status_1->intr);
 549                 intr &= WLCORE_ALL_INTR_MASK;
 550                 if (!intr) {
 551                         done = true;
 552                         continue;
 553                 }
 554
 555                 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
 556                         wl1271_error("HW watchdog interrupt received! starting recovery.");
 557                         wl->watchdog_recovery = true;
 558                         ret = -EIO;
 559
 560                         /* restarting the chip. ignore any other interrupt. */
 561                         goto out;
 562                 }
 563
 564                 if (unlikely(intr & WL1271_ACX_SW_INTR_WATCHDOG)) {
 565                         wl1271_error("SW watchdog interrupt received! "
 566                                      "starting recovery.");
 567                         wl->watchdog_recovery = true;
 568                         ret = -EIO;
 569
 570                         /* restarting the chip. ignore any other interrupt. */
 571                         goto out;
 572                 }
 573
 574                 if (likely(intr & WL1271_ACX_INTR_DATA)) {
 575                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
 576
 577                         ret = wlcore_rx(wl, wl->fw_status_1);
 578                         if (ret < 0)
 579                                 goto out;
 580
 581                         /* Check if any tx blocks were freed */
 582                         spin_lock_irqsave(&wl->wl_lock, flags);
 583                         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
 584                             wl1271_tx_total_queue_count(wl) > 0) {
 585                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 586                                 /*
 587                                  * In order to avoid starvation of the TX path,
 588                                  * call the work function directly.
 589                                  */
 590                                 ret = wlcore_tx_work_locked(wl);
 591                                 if (ret < 0)
 592                                         goto out;
 593                         } else {
 594                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
 595                         }
 596
 597                         /* check for tx results */
 598                         ret = wlcore_hw_tx_delayed_compl(wl);
 599                         if (ret < 0)
 600                                 goto out;
 601
 602                         /* Make sure the deferred queues don't get too long */
 603                         defer_count = skb_queue_len(&wl->deferred_tx_queue) +
 604                                       skb_queue_len(&wl->deferred_rx_queue);
 605                         if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
 606                                 wl1271_flush_deferred_work(wl);
 607                 }
 608
 609                 if (intr & WL1271_ACX_INTR_EVENT_A) {
 610                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
 611                         ret = wl1271_event_handle(wl, 0);
 612                         if (ret < 0)
 613                                 goto out;
 614                 }
 615
 616                 if (intr & WL1271_ACX_INTR_EVENT_B) {
 617                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
 618                         ret = wl1271_event_handle(wl, 1);
 619                         if (ret < 0)
 620                                 goto out;
 621                 }
 622
 623                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
 624                         wl1271_debug(DEBUG_IRQ,
 625                                      "WL1271_ACX_INTR_INIT_COMPLETE");
 626
 627                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
 628                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
 629         }
 630
 631         wl1271_ps_elp_sleep(wl);
 632
 633 out:
 634         return ret;
 635 }
 636
 637 static irqreturn_t wlcore_irq(int irq, void *cookie)
 638 {
 639         int ret;
 640         unsigned long flags;
 641         struct wl1271 *wl = cookie;
 642
 643         /* TX might be handled here, avoid redundant work */
 644         set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 645         cancel_work_sync(&wl->tx_work);
 646
 647         mutex_lock(&wl->mutex);
 648
 649         ret = wlcore_irq_locked(wl);
 650         if (ret)
 651                 wl12xx_queue_recovery_work(wl);
 652
 653         spin_lock_irqsave(&wl->wl_lock, flags);
 654         /* In case TX was not handled here, queue TX work */
 655         clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 656         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
 657             wl1271_tx_total_queue_count(wl) > 0)
 658                 ieee80211_queue_work(wl->hw, &wl->tx_work);
 659         spin_unlock_irqrestore(&wl->wl_lock, flags);
 660
 661         mutex_unlock(&wl->mutex);
 662
 663         return IRQ_HANDLED;
 664 }
 665
 666 struct vif_counter_data {
 667         u8 counter;
 668
 669         struct ieee80211_vif *cur_vif;
 670         bool cur_vif_running;
 671 };
 672
 673 static void wl12xx_vif_count_iter(void *data, u8 *mac,
 674                                   struct ieee80211_vif *vif)
 675 {
 676         struct vif_counter_data *counter = data;
 677
 678         counter->counter++;
 679         if (counter->cur_vif == vif)
 680                 counter->cur_vif_running = true;
 681 }
 682
 683 /* caller must not hold wl->mutex, as it might deadlock */
 684 static void wl12xx_get_vif_count(struct ieee80211_hw *hw,
 685                                struct ieee80211_vif *cur_vif,
 686                                struct vif_counter_data *data)
 687 {
 688         memset(data, 0, sizeof(*data));
 689         data->cur_vif = cur_vif;
 690
 691         ieee80211_iterate_active_interfaces(hw, IEEE80211_IFACE_ITER_RESUME_ALL,
 692                                             wl12xx_vif_count_iter, data);
 693 }
 694
 695 static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
 696 {
 697         const struct firmware *fw;
 698         const char *fw_name;
 699         enum wl12xx_fw_type fw_type;
 700         int ret;
 701
 702         if (plt) {
 703                 fw_type = WL12XX_FW_TYPE_PLT;
 704                 fw_name = wl->plt_fw_name;
 705         } else {
 706                 /*
 707                  * we can't call wl12xx_get_vif_count() here because
 708                  * wl->mutex is taken, so use the cached last_vif_count value
 709                  */
 710                 if (wl->last_vif_count > 1 && wl->mr_fw_name) {
 711                         fw_type = WL12XX_FW_TYPE_MULTI;
 712                         fw_name = wl->mr_fw_name;
 713                 } else {
 714                         fw_type = WL12XX_FW_TYPE_NORMAL;
 715                         fw_name = wl->sr_fw_name;
 716                 }
 717         }
 718
 719         if (wl->fw_type == fw_type)
 720                 return 0;
 721
 722         wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
 723
 724         ret = request_firmware(&fw, fw_name, wl->dev);
 725
 726         if (ret < 0) {
 727                 wl1271_error("could not get firmware %s: %d", fw_name, ret);
 728                 return ret;
 729         }
 730
 731         if (fw->size % 4) {
 732                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
 733                              fw->size);
 734                 ret = -EILSEQ;
 735                 goto out;
 736         }
 737
 738         vfree(wl->fw);
 739         wl->fw_type = WL12XX_FW_TYPE_NONE;
 740         wl->fw_len = fw->size;
 741         wl->fw = vmalloc(wl->fw_len);
 742
 743         if (!wl->fw) {
 744                 wl1271_error("could not allocate memory for the firmware");
 745                 ret = -ENOMEM;
 746                 goto out;
 747         }
 748
 749         memcpy(wl->fw, fw->data, wl->fw_len);
 750         ret = 0;
 751         wl->fw_type = fw_type;
 752 out:
 753         release_firmware(fw);
 754
 755         return ret;
 756 }
 757
 758 void wl12xx_queue_recovery_work(struct wl1271 *wl)
 759 {
 760         WARN_ON(!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
 761
 762         /* Avoid a recursive recovery */
 763         if (wl->state == WLCORE_STATE_ON) {
 764                 wl->state = WLCORE_STATE_RESTARTING;
 765                 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
 766                 wlcore_disable_interrupts_nosync(wl);
 767                 ieee80211_queue_work(wl->hw, &wl->recovery_work);
 768         }
 769 }
 770
 771 size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
 772 {
 773         size_t len = 0;
 774
 775         /* The FW log is a length-value list, find where the log end */
 776         while (len < maxlen) {
 777                 if (memblock[len] == 0)
 778                         break;
 779                 if (len + memblock[len] + 1 > maxlen)
 780                         break;
 781                 len += memblock[len] + 1;
 782         }
 783
 784         /* Make sure we have enough room */
 785         len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
 786
 787         /* Fill the FW log file, consumed by the sysfs fwlog entry */
 788         memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
 789         wl->fwlog_size += len;
 790
 791         return len;
 792 }
 793
 794 #define WLCORE_FW_LOG_END 0x2000000
 795
 796 static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
 797 {
 798         u32 addr;
 799         u32 offset;
 800         u32 end_of_log;
 801         u8 *block;
 802         int ret;
 803
 804         if ((wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
 805             (wl->conf.fwlog.mem_blocks == 0))
 806                 return;
 807
 808         wl1271_info("Reading FW panic log");
 809
 810         block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
 811         if (!block)
 812                 return;
 813
 814         /*
 815          * Make sure the chip is awake and the logger isn't active.
 816          * Do not send a stop fwlog command if the fw is hanged or if
 817          * dbgpins are used (due to some fw bug).
 818          */
 819         if (wl1271_ps_elp_wakeup(wl))
 820                 goto out;
 821         if (!wl->watchdog_recovery &&
 822             wl->conf.fwlog.output != WL12XX_FWLOG_OUTPUT_DBG_PINS)
 823                 wl12xx_cmd_stop_fwlog(wl);
 824
 825         /* Read the first memory block address */
 826         ret = wlcore_fw_status(wl, wl->fw_status_1, wl->fw_status_2);
 827         if (ret < 0)
 828                 goto out;
 829
 830         addr = le32_to_cpu(wl->fw_status_2->log_start_addr);
 831         if (!addr)
 832                 goto out;
 833
 834         if (wl->conf.fwlog.mode == WL12XX_FWLOG_CONTINUOUS) {
 835                 offset = sizeof(addr) + sizeof(struct wl1271_rx_descriptor);
 836                 end_of_log = WLCORE_FW_LOG_END;
 837         } else {
 838                 offset = sizeof(addr);
 839                 end_of_log = addr;
 840         }
 841
 842         /* Traverse the memory blocks linked list */
 843         do {
 844                 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
 845                 ret = wlcore_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
 846                                          false);
 847                 if (ret < 0)
 848                         goto out;
 849
 850                 /*
 851                  * Memory blocks are linked to one another. The first 4 bytes
 852                  * of each memory block hold the hardware address of the next
 853                  * one. The last memory block points to the first one in
 854                  * on demand mode and is equal to 0x2000000 in continuous mode.
 855                  */
 856                 addr = le32_to_cpup((__le32 *)block);
 857                 if (!wl12xx_copy_fwlog(wl, block + offset,
 858                                        WL12XX_HW_BLOCK_SIZE - offset))
 859                         break;
 860         } while (addr && (addr != end_of_log));
 861
 862         wake_up_interruptible(&wl->fwlog_waitq);
 863
 864 out:
 865         kfree(block);
 866 }
 867
 868 static void wlcore_print_recovery(struct wl1271 *wl)
 869 {
 870         u32 pc = 0;
 871         u32 hint_sts = 0;
 872         int ret;
 873
 874         wl1271_info("Hardware recovery in progress. FW ver: %s",
 875                     wl->chip.fw_ver_str);
 876
 877         /* change partitions momentarily so we can read the FW pc */
 878         ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
 879         if (ret < 0)
 880                 return;
 881
 882         ret = wlcore_read_reg(wl, REG_PC_ON_RECOVERY, &pc);
 883         if (ret < 0)
 884                 return;
 885
 886         ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &hint_sts);
 887         if (ret < 0)
 888                 return;
 889
 890         wl1271_info("pc: 0x%x, hint_sts: 0x%08x count: %d",
 891                                 pc, hint_sts, ++wl->recovery_count);
 892
 893         wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
 894 }
 895
 896
 897 static void wl1271_recovery_work(struct work_struct *work)
 898 {
 899         struct wl1271 *wl =
 900                 container_of(work, struct wl1271, recovery_work);
 901         struct wl12xx_vif *wlvif;
 902         struct ieee80211_vif *vif;
 903
 904         mutex_lock(&wl->mutex);
 905
 906         if (wl->state == WLCORE_STATE_OFF || wl->plt)
 907                 goto out_unlock;
 908
 909         if (!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags)) {
 910                 wl12xx_read_fwlog_panic(wl);
 911                 wlcore_print_recovery(wl);
 912         }
 913
 914         BUG_ON(wl->conf.recovery.bug_on_recovery &&
 915                !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
 916
 917         if (wl->conf.recovery.no_recovery) {
 918                 wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
 919                 goto out_unlock;
 920         }
 921
 922         /*
 923          * Advance security sequence number to overcome potential progress
 924          * in the firmware during recovery. This doens't hurt if the network is
 925          * not encrypted.
 926          */
 927         wl12xx_for_each_wlvif(wl, wlvif) {
 928                 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
 929                     test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
 930                         wlvif->tx_security_seq +=
 931                                 WL1271_TX_SQN_POST_RECOVERY_PADDING;
 932         }
 933
 934         /* Prevent spurious TX during FW restart */
 935         wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
 936
 937         /* reboot the chipset */
 938         while (!list_empty(&wl->wlvif_list)) {
 939                 wlvif = list_first_entry(&wl->wlvif_list,
 940                                        struct wl12xx_vif, list);
 941                 vif = wl12xx_wlvif_to_vif(wlvif);
 942                 __wl1271_op_remove_interface(wl, vif, false);
 943         }
 944
 945         wlcore_op_stop_locked(wl);
 946
 947         ieee80211_restart_hw(wl->hw);
 948
 949         /*
 950          * Its safe to enable TX now - the queues are stopped after a request
 951          * to restart the HW.
 952          */
 953         wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
 954
 955 out_unlock:
 956         wl->watchdog_recovery = false;
 957         clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
 958         mutex_unlock(&wl->mutex);
 959 }
 960
 961 static int wlcore_fw_wakeup(struct wl1271 *wl)
 962 {
 963         return wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
 964 }
 965
 966 static int wl1271_setup(struct wl1271 *wl)
 967 {
 968         wl->fw_status_1 = kmalloc(WLCORE_FW_STATUS_1_LEN(wl->num_rx_desc) +
 969                                   sizeof(*wl->fw_status_2) +
 970                                   wl->fw_status_priv_len, GFP_KERNEL);
 971         if (!wl->fw_status_1)
 972                 return -ENOMEM;
 973
 974         wl->fw_status_2 = (struct wl_fw_status_2 *)
 975                                 (((u8 *) wl->fw_status_1) +
 976                                 WLCORE_FW_STATUS_1_LEN(wl->num_rx_desc));
 977
 978         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
 979         if (!wl->tx_res_if) {
 980                 kfree(wl->fw_status_1);
 981                 return -ENOMEM;
 982         }
 983
 984         return 0;
 985 }
 986
 987 static int wl12xx_set_power_on(struct wl1271 *wl)
 988 {
 989         int ret;
 990
 991         msleep(WL1271_PRE_POWER_ON_SLEEP);
 992         ret = wl1271_power_on(wl);
 993         if (ret < 0)
 994                 goto out;
 995         msleep(WL1271_POWER_ON_SLEEP);
 996         wl1271_io_reset(wl);
 997         wl1271_io_init(wl);
 998
 999         ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
1000         if (ret < 0)
1001                 goto fail;
1002
1003         /* ELP module wake up */
1004         ret = wlcore_fw_wakeup(wl);
1005         if (ret < 0)
1006                 goto fail;
1007
1008 out:
1009         return ret;
1010
1011 fail:
1012         wl1271_power_off(wl);
1013         return ret;
1014 }
1015
1016 static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
1017 {
1018         int ret = 0;
1019
1020         ret = wl12xx_set_power_on(wl);
1021         if (ret < 0)
1022                 goto out;
1023
1024         /*
1025          * For wl127x based devices we could use the default block
1026          * size (512 bytes), but due to a bug in the sdio driver, we
1027          * need to set it explicitly after the chip is powered on.  To
1028          * simplify the code and since the performance impact is
1029          * negligible, we use the same block size for all different
1030          * chip types.
1031          *
1032          * Check if the bus supports blocksize alignment and, if it
1033          * doesn't, make sure we don't have the quirk.
1034          */
1035         if (!wl1271_set_block_size(wl))
1036                 wl->quirks &= ~WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN;
1037
1038         /* TODO: make sure the lower driver has set things up correctly */
1039
1040         ret = wl1271_setup(wl);
1041         if (ret < 0)
1042                 goto out;
1043
1044         ret = wl12xx_fetch_firmware(wl, plt);
1045         if (ret < 0)
1046                 goto out;
1047
1048 out:
1049         return ret;
1050 }
1051
1052 int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode)
1053 {
1054         int retries = WL1271_BOOT_RETRIES;
1055         struct wiphy *wiphy = wl->hw->wiphy;
1056
1057         static const char* const PLT_MODE[] = {
1058                 "PLT_OFF",
1059                 "PLT_ON",
1060                 "PLT_FEM_DETECT"
1061         };
1062
1063         int ret;
1064
1065         mutex_lock(&wl->mutex);
1066
1067         wl1271_notice("power up");
1068
1069         if (wl->state != WLCORE_STATE_OFF) {
1070                 wl1271_error("cannot go into PLT state because not "
1071                              "in off state: %d", wl->state);
1072                 ret = -EBUSY;
1073                 goto out;
1074         }
1075
1076         /* Indicate to lower levels that we are now in PLT mode */
1077         wl->plt = true;
1078         wl->plt_mode = plt_mode;
1079
1080         while (retries) {
1081                 retries--;
1082                 ret = wl12xx_chip_wakeup(wl, true);
1083                 if (ret < 0)
1084                         goto power_off;
1085
1086                 ret = wl->ops->plt_init(wl);
1087                 if (ret < 0)
1088                         goto power_off;
1089
1090                 wl->state = WLCORE_STATE_ON;
1091                 wl1271_notice("firmware booted in PLT mode %s (%s)",
1092                               PLT_MODE[plt_mode],
1093                               wl->chip.fw_ver_str);
1094
1095                 /* update hw/fw version info in wiphy struct */
1096                 wiphy->hw_version = wl->chip.id;
1097                 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1098                         sizeof(wiphy->fw_version));
1099
1100                 goto out;
1101
1102 power_off:
1103                 wl1271_power_off(wl);
1104         }
1105
1106         wl->plt = false;
1107         wl->plt_mode = PLT_OFF;
1108
1109         wl1271_error("firmware boot in PLT mode failed despite %d retries",
1110                      WL1271_BOOT_RETRIES);
1111 out:
1112         mutex_unlock(&wl->mutex);
1113
1114         return ret;
1115 }
1116
1117 int wl1271_plt_stop(struct wl1271 *wl)
1118 {
1119         int ret = 0;
1120
1121         wl1271_notice("power down");
1122
1123         /*
1124          * Interrupts must be disabled before setting the state to OFF.
1125          * Otherwise, the interrupt handler might be called and exit without
1126          * reading the interrupt status.
1127          */
1128         wlcore_disable_interrupts(wl);
1129         mutex_lock(&wl->mutex);
1130         if (!wl->plt) {
1131                 mutex_unlock(&wl->mutex);
1132
1133                 /*
1134                  * This will not necessarily enable interrupts as interrupts
1135                  * may have been disabled when op_stop was called. It will,
1136                  * however, balance the above call to disable_interrupts().
1137                  */
1138                 wlcore_enable_interrupts(wl);
1139
1140                 wl1271_error("cannot power down because not in PLT "
1141                              "state: %d", wl->state);
1142                 ret = -EBUSY;
1143                 goto out;
1144         }
1145
1146         mutex_unlock(&wl->mutex);
1147
1148         wl1271_flush_deferred_work(wl);
1149         cancel_work_sync(&wl->netstack_work);
1150         cancel_work_sync(&wl->recovery_work);
1151         cancel_delayed_work_sync(&wl->elp_work);
1152         cancel_delayed_work_sync(&wl->tx_watchdog_work);
1153
1154         mutex_lock(&wl->mutex);
1155         wl1271_power_off(wl);
1156         wl->flags = 0;
1157         wl->sleep_auth = WL1271_PSM_ILLEGAL;
1158         wl->state = WLCORE_STATE_OFF;
1159         wl->plt = false;
1160         wl->plt_mode = PLT_OFF;
1161         wl->rx_counter = 0;
1162         mutex_unlock(&wl->mutex);
1163
1164 out:
1165         return ret;
1166 }
1167
1168 static void wl1271_op_tx(struct ieee80211_hw *hw,
1169                          struct ieee80211_tx_control *control,
1170                          struct sk_buff *skb)
1171 {
1172         struct wl1271 *wl = hw->priv;
1173         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1174         struct ieee80211_vif *vif = info->control.vif;
1175         struct wl12xx_vif *wlvif = NULL;
1176         unsigned long flags;
1177         int q, mapping;
1178         u8 hlid;
1179
1180         if (!vif) {
1181                 wl1271_debug(DEBUG_TX, "DROP skb with no vif");
1182                 ieee80211_free_txskb(hw, skb);
1183                 return;
1184         }
1185
1186         wlvif = wl12xx_vif_to_data(vif);
1187         mapping = skb_get_queue_mapping(skb);
1188         q = wl1271_tx_get_queue(mapping);
1189
1190         hlid = wl12xx_tx_get_hlid(wl, wlvif, skb, control->sta);
1191
1192         spin_lock_irqsave(&wl->wl_lock, flags);
1193
1194         /*
1195          * drop the packet if the link is invalid or the queue is stopped
1196          * for any reason but watermark. Watermark is a "soft"-stop so we
1197          * allow these packets through.
1198          */
1199         if (hlid == WL12XX_INVALID_LINK_ID ||
1200             (!test_bit(hlid, wlvif->links_map)) ||
1201              (wlcore_is_queue_stopped_locked(wl, wlvif, q) &&
1202               !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
1203                         WLCORE_QUEUE_STOP_REASON_WATERMARK))) {
1204                 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
1205                 ieee80211_free_txskb(hw, skb);
1206                 goto out;
1207         }
1208
1209         wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
1210                      hlid, q, skb->len);
1211         skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1212
1213         wl->tx_queue_count[q]++;
1214         wlvif->tx_queue_count[q]++;
1215
1216         /*
1217          * The workqueue is slow to process the tx_queue and we need stop
1218          * the queue here, otherwise the queue will get too long.
1219          */
1220         if (wlvif->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK &&
1221             !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
1222                                         WLCORE_QUEUE_STOP_REASON_WATERMARK)) {
1223                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1224                 wlcore_stop_queue_locked(wl, wlvif, q,
1225                                          WLCORE_QUEUE_STOP_REASON_WATERMARK);
1226         }
1227
1228         /*
1229          * The chip specific setup must run before the first TX packet -
1230          * before that, the tx_work will not be initialized!
1231          */
1232
1233         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1234             !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1235                 ieee80211_queue_work(wl->hw, &wl->tx_work);
1236
1237 out:
1238         spin_unlock_irqrestore(&wl->wl_lock, flags);
1239 }
1240
1241 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1242 {
1243         unsigned long flags;
1244         int q;
1245
1246         /* no need to queue a new dummy packet if one is already pending */
1247         if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1248                 return 0;
1249
1250         q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1251
1252         spin_lock_irqsave(&wl->wl_lock, flags);
1253         set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1254         wl->tx_queue_count[q]++;
1255         spin_unlock_irqrestore(&wl->wl_lock, flags);
1256
1257         /* The FW is low on RX memory blocks, so send the dummy packet asap */
1258         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1259                 return wlcore_tx_work_locked(wl);
1260
1261         /*
1262          * If the FW TX is busy, TX work will be scheduled by the threaded
1263          * interrupt handler function
1264          */
1265         return 0;
1266 }
1267
1268 /*
1269  * The size of the dummy packet should be at least 1400 bytes. However, in
1270  * order to minimize the number of bus transactions, aligning it to 512 bytes
1271  * boundaries could be beneficial, performance wise
1272  */
1273 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1274
1275 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1276 {
1277         struct sk_buff *skb;
1278         struct ieee80211_hdr_3addr *hdr;
1279         unsigned int dummy_packet_size;
1280
1281         dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1282                             sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1283
1284         skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1285         if (!skb) {
1286                 wl1271_warning("Failed to allocate a dummy packet skb");
1287                 return NULL;
1288         }
1289
1290         skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1291
1292         hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1293         memset(hdr, 0, sizeof(*hdr));
1294         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1295                                          IEEE80211_STYPE_NULLFUNC |
1296                                          IEEE80211_FCTL_TODS);
1297
1298         memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1299
1300         /* Dummy packets require the TID to be management */
1301         skb->priority = WL1271_TID_MGMT;
1302
1303         /* Initialize all fields that might be used */
1304         skb_set_queue_mapping(skb, 0);
1305         memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1306
1307         return skb;
1308 }
1309
1310
1311 #ifdef CONFIG_PM
1312 static int
1313 wl1271_validate_wowlan_pattern(struct cfg80211_wowlan_trig_pkt_pattern *p)
1314 {
1315         int num_fields = 0, in_field = 0, fields_size = 0;
1316         int i, pattern_len = 0;
1317
1318         if (!p->mask) {
1319                 wl1271_warning("No mask in WoWLAN pattern");
1320                 return -EINVAL;
1321         }
1322
1323         /*
1324          * The pattern is broken up into segments of bytes at different offsets
1325          * that need to be checked by the FW filter. Each segment is called
1326          * a field in the FW API. We verify that the total number of fields
1327          * required for this pattern won't exceed FW limits (8)
1328          * as well as the total fields buffer won't exceed the FW limit.
1329          * Note that if there's a pattern which crosses Ethernet/IP header
1330          * boundary a new field is required.
1331          */
1332         for (i = 0; i < p->pattern_len; i++) {
1333                 if (test_bit(i, (unsigned long *)p->mask)) {
1334                         if (!in_field) {
1335                                 in_field = 1;
1336                                 pattern_len = 1;
1337                         } else {
1338                                 if (i == WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1339                                         num_fields++;
1340                                         fields_size += pattern_len +
1341                                                 RX_FILTER_FIELD_OVERHEAD;
1342                                         pattern_len = 1;
1343                                 } else
1344                                         pattern_len++;
1345                         }
1346                 } else {
1347                         if (in_field) {
1348                                 in_field = 0;
1349                                 fields_size += pattern_len +
1350                                         RX_FILTER_FIELD_OVERHEAD;
1351                                 num_fields++;
1352                         }
1353                 }
1354         }
1355
1356         if (in_field) {
1357                 fields_size += pattern_len + RX_FILTER_FIELD_OVERHEAD;
1358                 num_fields++;
1359         }
1360
1361         if (num_fields > WL1271_RX_FILTER_MAX_FIELDS) {
1362                 wl1271_warning("RX Filter too complex. Too many segments");
1363                 return -EINVAL;
1364         }
1365
1366         if (fields_size > WL1271_RX_FILTER_MAX_FIELDS_SIZE) {
1367                 wl1271_warning("RX filter pattern is too big");
1368                 return -E2BIG;
1369         }
1370
1371         return 0;
1372 }
1373
1374 struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void)
1375 {
1376         return kzalloc(sizeof(struct wl12xx_rx_filter), GFP_KERNEL);
1377 }
1378
1379 void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter)
1380 {
1381         int i;
1382
1383         if (filter == NULL)
1384                 return;
1385
1386         for (i = 0; i < filter->num_fields; i++)
1387                 kfree(filter->fields[i].pattern);
1388
1389         kfree(filter);
1390 }
1391
1392 int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
1393                                  u16 offset, u8 flags,
1394                                  u8 *pattern, u8 len)
1395 {
1396         struct wl12xx_rx_filter_field *field;
1397
1398         if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {
1399                 wl1271_warning("Max fields per RX filter. can't alloc another");
1400                 return -EINVAL;
1401         }
1402
1403         field = &filter->fields[filter->num_fields];
1404
1405         field->pattern = kzalloc(len, GFP_KERNEL);
1406         if (!field->pattern) {
1407                 wl1271_warning("Failed to allocate RX filter pattern");
1408                 return -ENOMEM;
1409         }
1410
1411         filter->num_fields++;
1412
1413         field->offset = cpu_to_le16(offset);
1414         field->flags = flags;
1415         field->len = len;
1416         memcpy(field->pattern, pattern, len);
1417
1418         return 0;
1419 }
1420
1421 int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter)
1422 {
1423         int i, fields_size = 0;
1424
1425         for (i = 0; i < filter->num_fields; i++)
1426                 fields_size += filter->fields[i].len +
1427                         sizeof(struct wl12xx_rx_filter_field) -
1428                         sizeof(u8 *);
1429
1430         return fields_size;
1431 }
1432
1433 void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
1434                                     u8 *buf)
1435 {
1436         int i;
1437         struct wl12xx_rx_filter_field *field;
1438
1439         for (i = 0; i < filter->num_fields; i++) {
1440                 field = (struct wl12xx_rx_filter_field *)buf;
1441
1442                 field->offset = filter->fields[i].offset;
1443                 field->flags = filter->fields[i].flags;
1444                 field->len = filter->fields[i].len;
1445
1446                 memcpy(&field->pattern, filter->fields[i].pattern, field->len);
1447                 buf += sizeof(struct wl12xx_rx_filter_field) -
1448                         sizeof(u8 *) + field->len;
1449         }
1450 }
1451
1452 /*
1453  * Allocates an RX filter returned through f
1454  * which needs to be freed using rx_filter_free()
1455  */
1456 static int wl1271_convert_wowlan_pattern_to_rx_filter(
1457         struct cfg80211_wowlan_trig_pkt_pattern *p,
1458         struct wl12xx_rx_filter **f)
1459 {
1460         int i, j, ret = 0;
1461         struct wl12xx_rx_filter *filter;
1462         u16 offset;
1463         u8 flags, len;
1464
1465         filter = wl1271_rx_filter_alloc();
1466         if (!filter) {
1467                 wl1271_warning("Failed to alloc rx filter");
1468                 ret = -ENOMEM;
1469                 goto err;
1470         }
1471
1472         i = 0;
1473         while (i < p->pattern_len) {
1474                 if (!test_bit(i, (unsigned long *)p->mask)) {
1475                         i++;
1476                         continue;
1477                 }
1478
1479                 for (j = i; j < p->pattern_len; j++) {
1480                         if (!test_bit(j, (unsigned long *)p->mask))
1481                                 break;
1482
1483                         if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE &&
1484                             j >= WL1271_RX_FILTER_ETH_HEADER_SIZE)
1485                                 break;
1486                 }
1487
1488                 if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1489                         offset = i;
1490                         flags = WL1271_RX_FILTER_FLAG_ETHERNET_HEADER;
1491                 } else {
1492                         offset = i - WL1271_RX_FILTER_ETH_HEADER_SIZE;
1493                         flags = WL1271_RX_FILTER_FLAG_IP_HEADER;
1494                 }
1495
1496                 len = j - i;
1497
1498                 ret = wl1271_rx_filter_alloc_field(filter,
1499                                                    offset,
1500                                                    flags,
1501                                                    &p->pattern[i], len);
1502                 if (ret)
1503                         goto err;
1504
1505                 i = j;
1506         }
1507
1508         filter->action = FILTER_SIGNAL;
1509
1510         *f = filter;
1511         return 0;
1512
1513 err:
1514         wl1271_rx_filter_free(filter);
1515         *f = NULL;
1516
1517         return ret;
1518 }
1519
1520 static int wl1271_configure_wowlan(struct wl1271 *wl,
1521                                    struct cfg80211_wowlan *wow)
1522 {
1523         int i, ret;
1524
1525         if (!wow || wow->any || !wow->n_patterns) {
1526                 ret = wl1271_acx_default_rx_filter_enable(wl, 0,
1527                                                           FILTER_SIGNAL);
1528                 if (ret)
1529                         goto out;
1530
1531                 ret = wl1271_rx_filter_clear_all(wl);
1532                 if (ret)
1533                         goto out;
1534
1535                 return 0;
1536         }
1537
1538         if (WARN_ON(wow->n_patterns > WL1271_MAX_RX_FILTERS))
1539                 return -EINVAL;
1540
1541         /* Validate all incoming patterns before clearing current FW state */
1542         for (i = 0; i < wow->n_patterns; i++) {
1543                 ret = wl1271_validate_wowlan_pattern(&wow->patterns[i]);
1544                 if (ret) {
1545                         wl1271_warning("Bad wowlan pattern %d", i);
1546                         return ret;
1547                 }
1548         }
1549
1550         ret = wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
1551         if (ret)
1552                 goto out;
1553
1554         ret = wl1271_rx_filter_clear_all(wl);
1555         if (ret)
1556                 goto out;
1557
1558         /* Translate WoWLAN patterns into filters */
1559         for (i = 0; i < wow->n_patterns; i++) {
1560                 struct cfg80211_wowlan_trig_pkt_pattern *p;
1561                 struct wl12xx_rx_filter *filter = NULL;
1562
1563                 p = &wow->patterns[i];
1564
1565                 ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);
1566                 if (ret) {
1567                         wl1271_warning("Failed to create an RX filter from "
1568                                        "wowlan pattern %d", i);
1569                         goto out;
1570                 }
1571
1572                 ret = wl1271_rx_filter_enable(wl, i, 1, filter);
1573
1574                 wl1271_rx_filter_free(filter);
1575                 if (ret)
1576                         goto out;
1577         }
1578
1579         ret = wl1271_acx_default_rx_filter_enable(wl, 1, FILTER_DROP);
1580
1581 out:
1582         return ret;
1583 }
1584
1585 static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1586                                         struct wl12xx_vif *wlvif,
1587                                         struct cfg80211_wowlan *wow)
1588 {
1589         int ret = 0;
1590
1591         if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1592                 goto out;
1593
1594         ret = wl1271_ps_elp_wakeup(wl);
1595         if (ret < 0)
1596                 goto out;
1597
1598         ret = wl1271_configure_wowlan(wl, wow);
1599         if (ret < 0)
1600                 goto out_sleep;
1601
1602         if ((wl->conf.conn.suspend_wake_up_event ==
1603              wl->conf.conn.wake_up_event) &&
1604             (wl->conf.conn.suspend_listen_interval ==
1605              wl->conf.conn.listen_interval))
1606                 goto out_sleep;
1607
1608         ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1609                                     wl->conf.conn.suspend_wake_up_event,
1610                                     wl->conf.conn.suspend_listen_interval);
1611
1612         if (ret < 0)
1613                 wl1271_error("suspend: set wake up conditions failed: %d", ret);
1614
1615 out_sleep:
1616         wl1271_ps_elp_sleep(wl);
1617 out:
1618         return ret;
1619
1620 }
1621
1622 static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1623                                        struct wl12xx_vif *wlvif)
1624 {
1625         int ret = 0;
1626
1627         if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1628                 goto out;
1629
1630         ret = wl1271_ps_elp_wakeup(wl);
1631         if (ret < 0)
1632                 goto out;
1633
1634         ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
1635
1636         wl1271_ps_elp_sleep(wl);
1637 out:
1638         return ret;
1639
1640 }
1641
1642 static int wl1271_configure_suspend(struct wl1271 *wl,
1643                                     struct wl12xx_vif *wlvif,
1644                                     struct cfg80211_wowlan *wow)
1645 {
1646         if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1647                 return wl1271_configure_suspend_sta(wl, wlvif, wow);
1648         if (wlvif->bss_type == BSS_TYPE_AP_BSS)
1649                 return wl1271_configure_suspend_ap(wl, wlvif);
1650         return 0;
1651 }
1652
1653 static void wl1271_configure_resume(struct wl1271 *wl,
1654                                     struct wl12xx_vif *wlvif)
1655 {
1656         int ret = 0;
1657         bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1658         bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1659
1660         if ((!is_ap) && (!is_sta))
1661                 return;
1662
1663         if (is_sta && !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1664                 return;
1665
1666         ret = wl1271_ps_elp_wakeup(wl);
1667         if (ret < 0)
1668                 return;
1669
1670         if (is_sta) {
1671                 wl1271_configure_wowlan(wl, NULL);
1672
1673                 if ((wl->conf.conn.suspend_wake_up_event ==
1674                      wl->conf.conn.wake_up_event) &&
1675                     (wl->conf.conn.suspend_listen_interval ==
1676                      wl->conf.conn.listen_interval))
1677                         goto out_sleep;
1678
1679                 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1680                                     wl->conf.conn.wake_up_event,
1681                                     wl->conf.conn.listen_interval);
1682
1683                 if (ret < 0)
1684                         wl1271_error("resume: wake up conditions failed: %d",
1685                                      ret);
1686
1687         } else if (is_ap) {
1688                 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
1689         }
1690
1691 out_sleep:
1692         wl1271_ps_elp_sleep(wl);
1693 }
1694
1695 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1696                             struct cfg80211_wowlan *wow)
1697 {
1698         struct wl1271 *wl = hw->priv;
1699         struct wl12xx_vif *wlvif;
1700         int ret;
1701
1702         wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1703         WARN_ON(!wow);
1704
1705         /* we want to perform the recovery before suspending */
1706         if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
1707                 wl1271_warning("postponing suspend to perform recovery");
1708                 return -EBUSY;
1709         }
1710
1711         wl1271_tx_flush(wl);
1712
1713         mutex_lock(&wl->mutex);
1714         wl->wow_enabled = true;
1715         wl12xx_for_each_wlvif(wl, wlvif) {
1716                 ret = wl1271_configure_suspend(wl, wlvif, wow);
1717                 if (ret < 0) {
1718                         mutex_unlock(&wl->mutex);
1719                         wl1271_warning("couldn't prepare device to suspend");
1720                         return ret;
1721                 }
1722         }
1723         mutex_unlock(&wl->mutex);
1724         /* flush any remaining work */
1725         wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1726
1727         /*
1728          * disable and re-enable interrupts in order to flush
1729          * the threaded_irq
1730          */
1731         wlcore_disable_interrupts(wl);
1732
1733         /*
1734          * set suspended flag to avoid triggering a new threaded_irq
1735          * work. no need for spinlock as interrupts are disabled.
1736          */
1737         set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1738
1739         wlcore_enable_interrupts(wl);
1740         flush_work(&wl->tx_work);
1741         flush_delayed_work(&wl->elp_work);
1742
1743         return 0;
1744 }
1745
1746 static int wl1271_op_resume(struct ieee80211_hw *hw)
1747 {
1748         struct wl1271 *wl = hw->priv;
1749         struct wl12xx_vif *wlvif;
1750         unsigned long flags;
1751         bool run_irq_work = false, pending_recovery;
1752         int ret;
1753
1754         wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1755                      wl->wow_enabled);
1756         WARN_ON(!wl->wow_enabled);
1757
1758         /*
1759          * re-enable irq_work enqueuing, and call irq_work directly if
1760          * there is a pending work.
1761          */
1762         spin_lock_irqsave(&wl->wl_lock, flags);
1763         clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1764         if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1765                 run_irq_work = true;
1766         spin_unlock_irqrestore(&wl->wl_lock, flags);
1767
1768         mutex_lock(&wl->mutex);
1769
1770         /* test the recovery flag before calling any SDIO functions */
1771         pending_recovery = test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
1772                                     &wl->flags);
1773
1774         if (run_irq_work) {
1775                 wl1271_debug(DEBUG_MAC80211,
1776                              "run postponed irq_work directly");
1777
1778                 /* don't talk to the HW if recovery is pending */
1779                 if (!pending_recovery) {
1780                         ret = wlcore_irq_locked(wl);
1781                         if (ret)
1782                                 wl12xx_queue_recovery_work(wl);
1783                 }
1784
1785                 wlcore_enable_interrupts(wl);
1786         }
1787
1788         if (pending_recovery) {
1789                 wl1271_warning("queuing forgotten recovery on resume");
1790                 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1791                 goto out;
1792         }
1793
1794         wl12xx_for_each_wlvif(wl, wlvif) {
1795                 wl1271_configure_resume(wl, wlvif);
1796         }
1797
1798 out:
1799         wl->wow_enabled = false;
1800         mutex_unlock(&wl->mutex);
1801
1802         return 0;
1803 }
1804 #endif
1805
1806 static int wl1271_op_start(struct ieee80211_hw *hw)
1807 {
1808         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1809
1810         /*
1811          * We have to delay the booting of the hardware because
1812          * we need to know the local MAC address before downloading and
1813          * initializing the firmware. The MAC address cannot be changed
1814          * after boot, and without the proper MAC address, the firmware
1815          * will not function properly.
1816          *
1817          * The MAC address is first known when the corresponding interface
1818          * is added. That is where we will initialize the hardware.
1819          */
1820
1821         return 0;
1822 }
1823
1824 static void wlcore_op_stop_locked(struct wl1271 *wl)
1825 {
1826         int i;
1827
1828         if (wl->state == WLCORE_STATE_OFF) {
1829                 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
1830                                         &wl->flags))
1831                         wlcore_enable_interrupts(wl);
1832
1833                 return;
1834         }
1835
1836         /*
1837          * this must be before the cancel_work calls below, so that the work
1838          * functions don't perform further work.
1839          */
1840         wl->state = WLCORE_STATE_OFF;
1841
1842         /*
1843          * Use the nosync variant to disable interrupts, so the mutex could be
1844          * held while doing so without deadlocking.
1845          */
1846         wlcore_disable_interrupts_nosync(wl);
1847
1848         mutex_unlock(&wl->mutex);
1849
1850         wlcore_synchronize_interrupts(wl);
1851         if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1852                 cancel_work_sync(&wl->recovery_work);
1853         wl1271_flush_deferred_work(wl);
1854         cancel_delayed_work_sync(&wl->scan_complete_work);
1855         cancel_work_sync(&wl->netstack_work);
1856         cancel_work_sync(&wl->tx_work);
1857         cancel_delayed_work_sync(&wl->elp_work);
1858         cancel_delayed_work_sync(&wl->tx_watchdog_work);
1859
1860         /* let's notify MAC80211 about the remaining pending TX frames */
1861         mutex_lock(&wl->mutex);
1862         wl12xx_tx_reset(wl);
1863
1864         wl1271_power_off(wl);
1865         /*
1866          * In case a recovery was scheduled, interrupts were disabled to avoid
1867          * an interrupt storm. Now that the power is down, it is safe to
1868          * re-enable interrupts to balance the disable depth
1869          */
1870         if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1871                 wlcore_enable_interrupts(wl);
1872
1873         wl->band = IEEE80211_BAND_2GHZ;
1874
1875         wl->rx_counter = 0;
1876         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1877         wl->channel_type = NL80211_CHAN_NO_HT;
1878         wl->tx_blocks_available = 0;
1879         wl->tx_allocated_blocks = 0;
1880         wl->tx_results_count = 0;
1881         wl->tx_packets_count = 0;
1882         wl->time_offset = 0;
1883         wl->ap_fw_ps_map = 0;
1884         wl->ap_ps_map = 0;
1885         wl->sleep_auth = WL1271_PSM_ILLEGAL;
1886         memset(wl->roles_map, 0, sizeof(wl->roles_map));
1887         memset(wl->links_map, 0, sizeof(wl->links_map));
1888         memset(wl->roc_map, 0, sizeof(wl->roc_map));
1889         memset(wl->session_ids, 0, sizeof(wl->session_ids));
1890         wl->active_sta_count = 0;
1891         wl->active_link_count = 0;
1892
1893         /* The system link is always allocated */
1894         wl->links[WL12XX_SYSTEM_HLID].allocated_pkts = 0;
1895         wl->links[WL12XX_SYSTEM_HLID].prev_freed_pkts = 0;
1896         __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1897
1898         /*
1899          * this is performed after the cancel_work calls and the associated
1900          * mutex_lock, so that wl1271_op_add_interface does not accidentally
1901          * get executed before all these vars have been reset.
1902          */
1903         wl->flags = 0;
1904
1905         wl->tx_blocks_freed = 0;
1906
1907         for (i = 0; i < NUM_TX_QUEUES; i++) {
1908                 wl->tx_pkts_freed[i] = 0;
1909                 wl->tx_allocated_pkts[i] = 0;
1910         }
1911
1912         wl1271_debugfs_reset(wl);
1913
1914         kfree(wl->fw_status_1);
1915         wl->fw_status_1 = NULL;
1916         wl->fw_status_2 = NULL;
1917         kfree(wl->tx_res_if);
1918         wl->tx_res_if = NULL;
1919         kfree(wl->target_mem_map);
1920         wl->target_mem_map = NULL;
1921
1922         /*
1923          * FW channels must be re-calibrated after recovery,
1924          * clear the last Reg-Domain channel configuration.
1925          */
1926         memset(wl->reg_ch_conf_last, 0, sizeof(wl->reg_ch_conf_last));
1927 }
1928
1929 static void wlcore_op_stop(struct ieee80211_hw *hw)
1930 {
1931         struct wl1271 *wl = hw->priv;
1932
1933         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1934
1935         mutex_lock(&wl->mutex);
1936
1937         wlcore_op_stop_locked(wl);
1938
1939         mutex_unlock(&wl->mutex);
1940 }
1941
1942 static void wlcore_channel_switch_work(struct work_struct *work)
1943 {
1944         struct delayed_work *dwork;
1945         struct wl1271 *wl;
1946         struct ieee80211_vif *vif;
1947         struct wl12xx_vif *wlvif;
1948         int ret;
1949
1950         dwork = container_of(work, struct delayed_work, work);
1951         wlvif = container_of(dwork, struct wl12xx_vif, channel_switch_work);
1952         wl = wlvif->wl;
1953
1954         wl1271_info("channel switch failed (role_id: %d).", wlvif->role_id);
1955
1956         mutex_lock(&wl->mutex);
1957
1958         if (unlikely(wl->state != WLCORE_STATE_ON))
1959                 goto out;
1960
1961         /* check the channel switch is still ongoing */
1962         if (!test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags))
1963                 goto out;
1964
1965         vif = wl12xx_wlvif_to_vif(wlvif);
1966         ieee80211_chswitch_done(vif, false);
1967
1968         ret = wl1271_ps_elp_wakeup(wl);
1969         if (ret < 0)
1970                 goto out;
1971
1972         wl12xx_cmd_stop_channel_switch(wl, wlvif);
1973
1974         wl1271_ps_elp_sleep(wl);
1975 out:
1976         mutex_unlock(&wl->mutex);
1977 }
1978
1979 static void wlcore_connection_loss_work(struct work_struct *work)
1980 {
1981         struct delayed_work *dwork;
1982         struct wl1271 *wl;
1983         struct ieee80211_vif *vif;
1984         struct wl12xx_vif *wlvif;
1985
1986         dwork = container_of(work, struct delayed_work, work);
1987         wlvif = container_of(dwork, struct wl12xx_vif, connection_loss_work);
1988         wl = wlvif->wl;
1989
1990         wl1271_info("Connection loss work (role_id: %d).", wlvif->role_id);
1991
1992         mutex_lock(&wl->mutex);
1993
1994         if (unlikely(wl->state != WLCORE_STATE_ON))
1995                 goto out;
1996
1997         /* Call mac80211 connection loss */
1998         if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1999                 goto out;
2000
2001         vif = wl12xx_wlvif_to_vif(wlvif);
2002         ieee80211_connection_loss(vif);
2003 out:
2004         mutex_unlock(&wl->mutex);
2005 }
2006
2007 static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
2008 {
2009         u8 policy = find_first_zero_bit(wl->rate_policies_map,
2010                                         WL12XX_MAX_RATE_POLICIES);
2011         if (policy >= WL12XX_MAX_RATE_POLICIES)
2012                 return -EBUSY;
2013
2014         __set_bit(policy, wl->rate_policies_map);
2015         *idx = policy;
2016         return 0;
2017 }
2018
2019 static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
2020 {
2021         if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
2022                 return;
2023
2024         __clear_bit(*idx, wl->rate_policies_map);
2025         *idx = WL12XX_MAX_RATE_POLICIES;
2026 }
2027
2028 static int wlcore_allocate_klv_template(struct wl1271 *wl, u8 *idx)
2029 {
2030         u8 policy = find_first_zero_bit(wl->klv_templates_map,
2031                                         WLCORE_MAX_KLV_TEMPLATES);
2032         if (policy >= WLCORE_MAX_KLV_TEMPLATES)
2033                 return -EBUSY;
2034
2035         __set_bit(policy, wl->klv_templates_map);
2036         *idx = policy;
2037         return 0;
2038 }
2039
2040 static void wlcore_free_klv_template(struct wl1271 *wl, u8 *idx)
2041 {
2042         if (WARN_ON(*idx >= WLCORE_MAX_KLV_TEMPLATES))
2043                 return;
2044
2045         __clear_bit(*idx, wl->klv_templates_map);
2046         *idx = WLCORE_MAX_KLV_TEMPLATES;
2047 }
2048
2049 static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2050 {
2051         switch (wlvif->bss_type) {
2052         case BSS_TYPE_AP_BSS:
2053                 if (wlvif->p2p)
2054                         return WL1271_ROLE_P2P_GO;
2055                 else
2056                         return WL1271_ROLE_AP;
2057
2058         case BSS_TYPE_STA_BSS:
2059                 if (wlvif->p2p)
2060                         return WL1271_ROLE_P2P_CL;
2061                 else
2062                         return WL1271_ROLE_STA;
2063
2064         case BSS_TYPE_IBSS:
2065                 return WL1271_ROLE_IBSS;
2066
2067         default:
2068                 wl1271_error("invalid bss_type: %d", wlvif->bss_type);
2069         }
2070         return WL12XX_INVALID_ROLE_TYPE;
2071 }
2072
2073 static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
2074 {
2075         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2076         int i;
2077
2078         /* clear everything but the persistent data */
2079         memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
2080
2081         switch (ieee80211_vif_type_p2p(vif)) {
2082         case NL80211_IFTYPE_P2P_CLIENT:
2083                 wlvif->p2p = 1;
2084                 /* fall-through */
2085         case NL80211_IFTYPE_STATION:
2086                 wlvif->bss_type = BSS_TYPE_STA_BSS;
2087                 break;
2088         case NL80211_IFTYPE_ADHOC:
2089                 wlvif->bss_type = BSS_TYPE_IBSS;
2090                 break;
2091         case NL80211_IFTYPE_P2P_GO:
2092                 wlvif->p2p = 1;
2093                 /* fall-through */
2094         case NL80211_IFTYPE_AP:
2095                 wlvif->bss_type = BSS_TYPE_AP_BSS;
2096                 break;
2097         default:
2098                 wlvif->bss_type = MAX_BSS_TYPE;
2099                 return -EOPNOTSUPP;
2100         }
2101
2102         wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2103         wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2104         wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2105
2106         if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2107             wlvif->bss_type == BSS_TYPE_IBSS) {
2108                 /* init sta/ibss data */
2109                 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2110                 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2111                 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2112                 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2113                 wlcore_allocate_klv_template(wl, &wlvif->sta.klv_template_id);
2114                 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2115                 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
2116                 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
2117         } else {
2118                 /* init ap data */
2119                 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2120                 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2121                 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2122                 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2123                 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2124                         wl12xx_allocate_rate_policy(wl,
2125                                                 &wlvif->ap.ucast_rate_idx[i]);
2126                 wlvif->basic_rate_set = CONF_TX_ENABLED_RATES;
2127                 /*
2128                  * TODO: check if basic_rate shouldn't be
2129                  * wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2130                  * instead (the same thing for STA above).
2131                 */
2132                 wlvif->basic_rate = CONF_TX_ENABLED_RATES;
2133                 /* TODO: this seems to be used only for STA, check it */
2134                 wlvif->rate_set = CONF_TX_ENABLED_RATES;
2135         }
2136
2137         wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
2138         wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
2139         wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
2140
2141         /*
2142          * mac80211 configures some values globally, while we treat them
2143          * per-interface. thus, on init, we have to copy them from wl
2144          */
2145         wlvif->band = wl->band;
2146         wlvif->channel = wl->channel;
2147         wlvif->power_level = wl->power_level;
2148         wlvif->channel_type = wl->channel_type;
2149
2150         INIT_WORK(&wlvif->rx_streaming_enable_work,
2151                   wl1271_rx_streaming_enable_work);
2152         INIT_WORK(&wlvif->rx_streaming_disable_work,
2153                   wl1271_rx_streaming_disable_work);
2154         INIT_DELAYED_WORK(&wlvif->channel_switch_work,
2155                           wlcore_channel_switch_work);
2156         INIT_DELAYED_WORK(&wlvif->connection_loss_work,
2157                           wlcore_connection_loss_work);
2158         INIT_LIST_HEAD(&wlvif->list);
2159
2160         setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
2161                     (unsigned long) wlvif);
2162         return 0;
2163 }
2164
2165 static int wl12xx_init_fw(struct wl1271 *wl)
2166 {
2167         int retries = WL1271_BOOT_RETRIES;
2168         bool booted = false;
2169         struct wiphy *wiphy = wl->hw->wiphy;
2170         int ret;
2171
2172         while (retries) {
2173                 retries--;
2174                 ret = wl12xx_chip_wakeup(wl, false);
2175                 if (ret < 0)
2176                         goto power_off;
2177
2178                 ret = wl->ops->boot(wl);
2179                 if (ret < 0)
2180                         goto power_off;
2181
2182                 ret = wl1271_hw_init(wl);
2183                 if (ret < 0)
2184                         goto irq_disable;
2185
2186                 booted = true;
2187                 break;
2188
2189 irq_disable:
2190                 mutex_unlock(&wl->mutex);
2191                 /* Unlocking the mutex in the middle of handling is
2192                    inherently unsafe. In this case we deem it safe to do,
2193                    because we need to let any possibly pending IRQ out of
2194                    the system (and while we are WLCORE_STATE_OFF the IRQ
2195                    work function will not do anything.) Also, any other
2196                    possible concurrent operations will fail due to the
2197                    current state, hence the wl1271 struct should be safe. */
2198                 wlcore_disable_interrupts(wl);
2199                 wl1271_flush_deferred_work(wl);
2200                 cancel_work_sync(&wl->netstack_work);
2201                 mutex_lock(&wl->mutex);
2202 power_off:
2203                 wl1271_power_off(wl);
2204         }
2205
2206         if (!booted) {
2207                 wl1271_error("firmware boot failed despite %d retries",
2208                              WL1271_BOOT_RETRIES);
2209                 goto out;
2210         }
2211
2212         wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
2213
2214         /* update hw/fw version info in wiphy struct */
2215         wiphy->hw_version = wl->chip.id;
2216         strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
2217                 sizeof(wiphy->fw_version));
2218
2219         /*
2220          * Now we know if 11a is supported (info from the NVS), so disable
2221          * 11a channels if not supported
2222          */
2223         if (!wl->enable_11a)
2224                 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
2225
2226         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2227                      wl->enable_11a ? "" : "not ");
2228
2229         wl->state = WLCORE_STATE_ON;
2230 out:
2231         return ret;
2232 }
2233
2234 static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
2235 {
2236         return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
2237 }
2238
2239 /*
2240  * Check whether a fw switch (i.e. moving from one loaded
2241  * fw to another) is needed. This function is also responsible
2242  * for updating wl->last_vif_count, so it must be called before
2243  * loading a non-plt fw (so the correct fw (single-role/multi-role)
2244  * will be used).
2245  */
2246 static bool wl12xx_need_fw_change(struct wl1271 *wl,
2247                                   struct vif_counter_data vif_counter_data,
2248                                   bool add)
2249 {
2250         enum wl12xx_fw_type current_fw = wl->fw_type;
2251         u8 vif_count = vif_counter_data.counter;
2252
2253         if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags))
2254                 return false;
2255
2256         /* increase the vif count if this is a new vif */
2257         if (add && !vif_counter_data.cur_vif_running)
2258                 vif_count++;
2259
2260         wl->last_vif_count = vif_count;
2261
2262         /* no need for fw change if the device is OFF */
2263         if (wl->state == WLCORE_STATE_OFF)
2264                 return false;
2265
2266         /* no need for fw change if a single fw is used */
2267         if (!wl->mr_fw_name)
2268                 return false;
2269
2270         if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL)
2271                 return true;
2272         if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI)
2273                 return true;
2274
2275         return false;
2276 }
2277
2278 /*
2279  * Enter "forced psm". Make sure the sta is in psm against the ap,
2280  * to make the fw switch a bit more disconnection-persistent.
2281  */
2282 static void wl12xx_force_active_psm(struct wl1271 *wl)
2283 {
2284         struct wl12xx_vif *wlvif;
2285
2286         wl12xx_for_each_wlvif_sta(wl, wlvif) {
2287                 wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE);
2288         }
2289 }
2290
2291 struct wlcore_hw_queue_iter_data {
2292         unsigned long hw_queue_map[BITS_TO_LONGS(WLCORE_NUM_MAC_ADDRESSES)];
2293         /* current vif */
2294         struct ieee80211_vif *vif;
2295         /* is the current vif among those iterated */
2296         bool cur_running;
2297 };
2298
2299 static void wlcore_hw_queue_iter(void *data, u8 *mac,
2300                                  struct ieee80211_vif *vif)
2301 {
2302         struct wlcore_hw_queue_iter_data *iter_data = data;
2303
2304         if (WARN_ON_ONCE(vif->hw_queue[0] == IEEE80211_INVAL_HW_QUEUE))
2305                 return;
2306
2307         if (iter_data->cur_running || vif == iter_data->vif) {
2308                 iter_data->cur_running = true;
2309                 return;
2310         }
2311
2312         __set_bit(vif->hw_queue[0] / NUM_TX_QUEUES, iter_data->hw_queue_map);
2313 }
2314
2315 static int wlcore_allocate_hw_queue_base(struct wl1271 *wl,
2316                                          struct wl12xx_vif *wlvif)
2317 {
2318         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2319         struct wlcore_hw_queue_iter_data iter_data = {};
2320         int i, q_base;
2321
2322         iter_data.vif = vif;
2323
2324         /* mark all bits taken by active interfaces */
2325         ieee80211_iterate_active_interfaces_atomic(wl->hw,
2326                                         IEEE80211_IFACE_ITER_RESUME_ALL,
2327                                         wlcore_hw_queue_iter, &iter_data);
2328
2329         /* the current vif is already running in mac80211 (resume/recovery) */
2330         if (iter_data.cur_running) {
2331                 wlvif->hw_queue_base = vif->hw_queue[0];
2332                 wl1271_debug(DEBUG_MAC80211,
2333                              "using pre-allocated hw queue base %d",
2334                              wlvif->hw_queue_base);
2335
2336                 /* interface type might have changed type */
2337                 goto adjust_cab_queue;
2338         }
2339
2340         q_base = find_first_zero_bit(iter_data.hw_queue_map,
2341                                      WLCORE_NUM_MAC_ADDRESSES);
2342         if (q_base >= WLCORE_NUM_MAC_ADDRESSES)
2343                 return -EBUSY;
2344
2345         wlvif->hw_queue_base = q_base * NUM_TX_QUEUES;
2346         wl1271_debug(DEBUG_MAC80211, "allocating hw queue base: %d",
2347                      wlvif->hw_queue_base);
2348
2349         for (i = 0; i < NUM_TX_QUEUES; i++) {
2350                 wl->queue_stop_reasons[wlvif->hw_queue_base + i] = 0;
2351                 /* register hw queues in mac80211 */
2352                 vif->hw_queue[i] = wlvif->hw_queue_base + i;
2353         }
2354
2355 adjust_cab_queue:
2356         /* the last places are reserved for cab queues per interface */
2357         if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2358                 vif->cab_queue = NUM_TX_QUEUES * WLCORE_NUM_MAC_ADDRESSES +
2359                                  wlvif->hw_queue_base / NUM_TX_QUEUES;
2360         else
2361                 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
2362
2363         return 0;
2364 }
2365
2366 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2367                                    struct ieee80211_vif *vif)
2368 {
2369         struct wl1271 *wl = hw->priv;
2370         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2371         struct vif_counter_data vif_count;
2372         int ret = 0;
2373         u8 role_type;
2374
2375         vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
2376                              IEEE80211_VIF_SUPPORTS_CQM_RSSI;
2377
2378         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2379                      ieee80211_vif_type_p2p(vif), vif->addr);
2380
2381         wl12xx_get_vif_count(hw, vif, &vif_count);
2382
2383         mutex_lock(&wl->mutex);
2384         ret = wl1271_ps_elp_wakeup(wl);
2385         if (ret < 0)
2386                 goto out_unlock;
2387
2388         /*
2389          * in some very corner case HW recovery scenarios its possible to
2390          * get here before __wl1271_op_remove_interface is complete, so
2391          * opt out if that is the case.
2392          */
2393         if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2394             test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2395                 ret = -EBUSY;
2396                 goto out;
2397         }
2398
2399
2400         ret = wl12xx_init_vif_data(wl, vif);
2401         if (ret < 0)
2402                 goto out;
2403
2404         wlvif->wl = wl;
2405         role_type = wl12xx_get_role_type(wl, wlvif);
2406         if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2407                 ret = -EINVAL;
2408                 goto out;
2409         }
2410
2411         ret = wlcore_allocate_hw_queue_base(wl, wlvif);
2412         if (ret < 0)
2413                 goto out;
2414
2415         if (wl12xx_need_fw_change(wl, vif_count, true)) {
2416                 wl12xx_force_active_psm(wl);
2417                 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2418                 mutex_unlock(&wl->mutex);
2419                 wl1271_recovery_work(&wl->recovery_work);
2420                 return 0;
2421         }
2422
2423         /*
2424          * TODO: after the nvs issue will be solved, move this block
2425          * to start(), and make sure here the driver is ON.
2426          */
2427         if (wl->state == WLCORE_STATE_OFF) {
2428                 /*
2429                  * we still need this in order to configure the fw
2430                  * while uploading the nvs
2431                  */
2432                 memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
2433
2434                 ret = wl12xx_init_fw(wl);
2435                 if (ret < 0)
2436                         goto out;
2437         }
2438
2439         ret = wl12xx_cmd_role_enable(wl, vif->addr,
2440                                      role_type, &wlvif->role_id);
2441         if (ret < 0)
2442                 goto out;
2443
2444         ret = wl1271_init_vif_specific(wl, vif);
2445         if (ret < 0)
2446                 goto out;
2447
2448         list_add(&wlvif->list, &wl->wlvif_list);
2449         set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2450
2451         if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2452                 wl->ap_count++;
2453         else
2454                 wl->sta_count++;
2455 out:
2456         wl1271_ps_elp_sleep(wl);
2457 out_unlock:
2458         mutex_unlock(&wl->mutex);
2459
2460         return ret;
2461 }
2462
2463 static void __wl1271_op_remove_interface(struct wl1271 *wl,
2464                                          struct ieee80211_vif *vif,
2465                                          bool reset_tx_queues)
2466 {
2467         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2468         int i, ret;
2469         bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2470
2471         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
2472
2473         if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2474                 return;
2475
2476         /* because of hardware recovery, we may get here twice */
2477         if (wl->state == WLCORE_STATE_OFF)
2478                 return;
2479
2480         wl1271_info("down");
2481
2482         if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2483             wl->scan_wlvif == wlvif) {
2484                 /*
2485                  * Rearm the tx watchdog just before idling scan. This
2486                  * prevents just-finished scans from triggering the watchdog
2487                  */
2488                 wl12xx_rearm_tx_watchdog_locked(wl);
2489
2490                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2491                 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2492                 wl->scan_wlvif = NULL;
2493                 wl->scan.req = NULL;
2494                 ieee80211_scan_completed(wl->hw, true);
2495         }
2496
2497         if (wl->sched_vif == wlvif) {
2498                 ieee80211_sched_scan_stopped(wl->hw);
2499                 wl->sched_vif = NULL;
2500         }
2501
2502         if (wl->roc_vif == vif) {
2503                 wl->roc_vif = NULL;
2504                 ieee80211_remain_on_channel_expired(wl->hw);
2505         }
2506
2507         if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2508                 /* disable active roles */
2509                 ret = wl1271_ps_elp_wakeup(wl);
2510                 if (ret < 0)
2511                         goto deinit;
2512
2513                 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2514                     wlvif->bss_type == BSS_TYPE_IBSS) {
2515                         if (wl12xx_dev_role_started(wlvif))
2516                                 wl12xx_stop_dev(wl, wlvif);
2517                 }
2518
2519                 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
2520                 if (ret < 0)
2521                         goto deinit;
2522
2523                 wl1271_ps_elp_sleep(wl);
2524         }
2525 deinit:
2526         /* clear all hlids (except system_hlid) */
2527         wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2528
2529         if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2530             wlvif->bss_type == BSS_TYPE_IBSS) {
2531                 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2532                 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2533                 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2534                 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2535                 wlcore_free_klv_template(wl, &wlvif->sta.klv_template_id);
2536         } else {
2537                 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2538                 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2539                 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2540                 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2541                 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2542                         wl12xx_free_rate_policy(wl,
2543                                                 &wlvif->ap.ucast_rate_idx[i]);
2544                 wl1271_free_ap_keys(wl, wlvif);
2545         }
2546
2547         dev_kfree_skb(wlvif->probereq);
2548         wlvif->probereq = NULL;
2549         wl12xx_tx_reset_wlvif(wl, wlvif);
2550         if (wl->last_wlvif == wlvif)
2551                 wl->last_wlvif = NULL;
2552         list_del(&wlvif->list);
2553         memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
2554         wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2555         wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2556
2557         if (is_ap)
2558                 wl->ap_count--;
2559         else
2560                 wl->sta_count--;
2561
2562         /*
2563          * Last AP, have more stations. Configure sleep auth according to STA.
2564          * Don't do thin on unintended recovery.
2565          */
2566         if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) &&
2567             !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags))
2568                 goto unlock;
2569
2570         if (wl->ap_count == 0 && is_ap && wl->sta_count) {
2571                 u8 sta_auth = wl->conf.conn.sta_sleep_auth;
2572                 /* Configure for power according to debugfs */
2573                 if (sta_auth != WL1271_PSM_ILLEGAL)
2574                         wl1271_acx_sleep_auth(wl, sta_auth);
2575                 /* Configure for ELP power saving */
2576                 else
2577                         wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
2578         }
2579
2580 unlock:
2581         mutex_unlock(&wl->mutex);
2582
2583         del_timer_sync(&wlvif->rx_streaming_timer);
2584         cancel_work_sync(&wlvif->rx_streaming_enable_work);
2585         cancel_work_sync(&wlvif->rx_streaming_disable_work);
2586         cancel_delayed_work_sync(&wlvif->connection_loss_work);
2587
2588         mutex_lock(&wl->mutex);
2589 }
2590
2591 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2592                                        struct ieee80211_vif *vif)
2593 {
2594         struct wl1271 *wl = hw->priv;
2595         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2596         struct wl12xx_vif *iter;
2597         struct vif_counter_data vif_count;
2598
2599         wl12xx_get_vif_count(hw, vif, &vif_count);
2600         mutex_lock(&wl->mutex);
2601
2602         if (wl->state == WLCORE_STATE_OFF ||
2603             !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2604                 goto out;
2605
2606         /*
2607          * wl->vif can be null here if someone shuts down the interface
2608          * just when hardware recovery has been started.
2609          */
2610         wl12xx_for_each_wlvif(wl, iter) {
2611                 if (iter != wlvif)
2612                         continue;
2613
2614                 __wl1271_op_remove_interface(wl, vif, true);
2615                 break;
2616         }
2617         WARN_ON(iter != wlvif);
2618         if (wl12xx_need_fw_change(wl, vif_count, false)) {
2619                 wl12xx_force_active_psm(wl);
2620                 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2621                 wl12xx_queue_recovery_work(wl);
2622         }
2623 out:
2624         mutex_unlock(&wl->mutex);
2625 }
2626
2627 static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
2628                                       struct ieee80211_vif *vif,
2629                                       enum nl80211_iftype new_type, bool p2p)
2630 {
2631         struct wl1271 *wl = hw->priv;
2632         int ret;
2633
2634         set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2635         wl1271_op_remove_interface(hw, vif);
2636
2637         vif->type = new_type;
2638         vif->p2p = p2p;
2639         ret = wl1271_op_add_interface(hw, vif);
2640
2641         clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2642         return ret;
2643 }
2644
2645 static int wlcore_join(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2646 {
2647         int ret;
2648         bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2649
2650         /*
2651          * One of the side effects of the JOIN command is that is clears
2652          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2653          * to a WPA/WPA2 access point will therefore kill the data-path.
2654          * Currently the only valid scenario for JOIN during association
2655          * is on roaming, in which case we will also be given new keys.
2656          * Keep the below message for now, unless it starts bothering
2657          * users who really like to roam a lot :)
2658          */
2659         if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2660                 wl1271_info("JOIN while associated.");
2661
2662         /* clear encryption type */
2663         wlvif->encryption_type = KEY_NONE;
2664
2665         if (is_ibss)
2666                 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
2667         else {
2668                 if (wl->quirks & WLCORE_QUIRK_START_STA_FAILS) {
2669                         /*
2670                          * TODO: this is an ugly workaround for wl12xx fw
2671                          * bug - we are not able to tx/rx after the first
2672                          * start_sta, so make dummy start+stop calls,
2673                          * and then call start_sta again.
2674                          * this should be fixed in the fw.
2675                          */
2676                         wl12xx_cmd_role_start_sta(wl, wlvif);
2677                         wl12xx_cmd_role_stop_sta(wl, wlvif);
2678                 }
2679
2680                 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
2681         }
2682
2683         return ret;
2684 }
2685
2686 static int wl1271_ssid_set(struct wl12xx_vif *wlvif, struct sk_buff *skb,
2687                             int offset)
2688 {
2689         u8 ssid_len;
2690         const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2691                                          skb->len - offset);
2692
2693         if (!ptr) {
2694                 wl1271_error("No SSID in IEs!");
2695                 return -ENOENT;
2696         }
2697
2698         ssid_len = ptr[1];
2699         if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2700                 wl1271_error("SSID is too long!");
2701                 return -EINVAL;
2702         }
2703
2704         wlvif->ssid_len = ssid_len;
2705         memcpy(wlvif->ssid, ptr+2, ssid_len);
2706         return 0;
2707 }
2708
2709 static int wlcore_set_ssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2710 {
2711         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2712         struct sk_buff *skb;
2713         int ieoffset;
2714
2715         /* we currently only support setting the ssid from the ap probe req */
2716         if (wlvif->bss_type != BSS_TYPE_STA_BSS)
2717                 return -EINVAL;
2718
2719         skb = ieee80211_ap_probereq_get(wl->hw, vif);
2720         if (!skb)
2721                 return -EINVAL;
2722
2723         ieoffset = offsetof(struct ieee80211_mgmt,
2724                             u.probe_req.variable);
2725         wl1271_ssid_set(wlvif, skb, ieoffset);
2726         dev_kfree_skb(skb);
2727
2728         return 0;
2729 }
2730
2731 static int wlcore_set_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2732                             struct ieee80211_bss_conf *bss_conf,
2733                             u32 sta_rate_set)
2734 {
2735         int ieoffset;
2736         int ret;
2737
2738         wlvif->aid = bss_conf->aid;
2739         wlvif->channel_type = cfg80211_get_chandef_type(&bss_conf->chandef);
2740         wlvif->beacon_int = bss_conf->beacon_int;
2741         wlvif->wmm_enabled = bss_conf->qos;
2742
2743         set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2744
2745         /*
2746          * with wl1271, we don't need to update the
2747          * beacon_int and dtim_period, because the firmware
2748          * updates it by itself when the first beacon is
2749          * received after a join.
2750          */
2751         ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
2752         if (ret < 0)
2753                 return ret;
2754
2755         /*
2756          * Get a template for hardware connection maintenance
2757          */
2758         dev_kfree_skb(wlvif->probereq);
2759         wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
2760                                                         wlvif,
2761                                                         NULL);
2762         ieoffset = offsetof(struct ieee80211_mgmt,
2763                             u.probe_req.variable);
2764         wl1271_ssid_set(wlvif, wlvif->probereq, ieoffset);
2765
2766         /* enable the connection monitoring feature */
2767         ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
2768         if (ret < 0)
2769                 return ret;
2770
2771         /*
2772          * The join command disable the keep-alive mode, shut down its process,
2773          * and also clear the template config, so we need to reset it all after
2774          * the join. The acx_aid starts the keep-alive process, and the order
2775          * of the commands below is relevant.
2776          */
2777         ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2778         if (ret < 0)
2779                 return ret;
2780
2781         ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2782         if (ret < 0)
2783                 return ret;
2784
2785         ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2786         if (ret < 0)
2787                 return ret;
2788
2789         ret = wl1271_acx_keep_alive_config(wl, wlvif,
2790                                            wlvif->sta.klv_template_id,
2791                                            ACX_KEEP_ALIVE_TPL_VALID);
2792         if (ret < 0)
2793                 return ret;
2794
2795         /*
2796          * The default fw psm configuration is AUTO, while mac80211 default
2797          * setting is off (ACTIVE), so sync the fw with the correct value.
2798          */
2799         ret = wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE);
2800         if (ret < 0)
2801                 return ret;
2802
2803         if (sta_rate_set) {
2804                 wlvif->rate_set =
2805                         wl1271_tx_enabled_rates_get(wl,
2806                                                     sta_rate_set,
2807                                                     wlvif->band);
2808                 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2809                 if (ret < 0)
2810                         return ret;
2811         }
2812
2813         return ret;
2814 }
2815
2816 static int wlcore_unset_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2817 {
2818         int ret;
2819         bool sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
2820
2821         /* make sure we are connected (sta) joined */
2822         if (sta &&
2823             !test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2824                 return false;
2825
2826         /* make sure we are joined (ibss) */
2827         if (!sta &&
2828             test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags))
2829                 return false;
2830
2831         if (sta) {
2832                 /* use defaults when not associated */
2833                 wlvif->aid = 0;
2834
2835                 /* free probe-request template */
2836                 dev_kfree_skb(wlvif->probereq);
2837                 wlvif->probereq = NULL;
2838
2839                 /* disable connection monitor features */
2840                 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
2841                 if (ret < 0)
2842                         return ret;
2843
2844                 /* Disable the keep-alive feature */
2845                 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
2846                 if (ret < 0)
2847                         return ret;
2848         }
2849
2850         if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
2851                 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2852
2853                 wl12xx_cmd_stop_channel_switch(wl, wlvif);
2854                 ieee80211_chswitch_done(vif, false);
2855                 cancel_delayed_work(&wlvif->channel_switch_work);
2856         }
2857
2858         /* invalidate keep-alive template */
2859         wl1271_acx_keep_alive_config(wl, wlvif,
2860                                      wlvif->sta.klv_template_id,
2861                                      ACX_KEEP_ALIVE_TPL_INVALID);
2862
2863         /* reset TX security counters on a clean disconnect */
2864         wlvif->tx_security_last_seq_lsb = 0;
2865         wlvif->tx_security_seq = 0;
2866
2867         return 0;
2868 }
2869
2870 static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2871 {
2872         wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
2873         wlvif->rate_set = wlvif->basic_rate_set;
2874 }
2875
2876 static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2877                              struct ieee80211_conf *conf, u32 changed)
2878 {
2879         int ret;
2880
2881         if (conf->power_level != wlvif->power_level) {
2882                 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
2883                 if (ret < 0)
2884                         return ret;
2885
2886                 wlvif->power_level = conf->power_level;
2887         }
2888
2889         return 0;
2890 }
2891
2892 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2893 {
2894         struct wl1271 *wl = hw->priv;
2895         struct wl12xx_vif *wlvif;
2896         struct ieee80211_conf *conf = &hw->conf;
2897         int ret = 0;
2898
2899         wl1271_debug(DEBUG_MAC80211, "mac80211 config psm %s power %d %s"
2900                      " changed 0x%x",
2901                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2902                      conf->power_level,
2903                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2904                          changed);
2905
2906         mutex_lock(&wl->mutex);
2907
2908         if (changed & IEEE80211_CONF_CHANGE_POWER)
2909                 wl->power_level = conf->power_level;
2910
2911         if (unlikely(wl->state != WLCORE_STATE_ON))
2912                 goto out;
2913
2914         ret = wl1271_ps_elp_wakeup(wl);
2915         if (ret < 0)
2916                 goto out;
2917
2918         /* configure each interface */
2919         wl12xx_for_each_wlvif(wl, wlvif) {
2920                 ret = wl12xx_config_vif(wl, wlvif, conf, changed);
2921                 if (ret < 0)
2922                         goto out_sleep;
2923         }
2924
2925 out_sleep:
2926         wl1271_ps_elp_sleep(wl);
2927
2928 out:
2929         mutex_unlock(&wl->mutex);
2930
2931         return ret;
2932 }
2933
2934 struct wl1271_filter_params {
2935         bool enabled;
2936         int mc_list_length;
2937         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2938 };
2939
2940 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2941                                        struct netdev_hw_addr_list *mc_list)
2942 {
2943         struct wl1271_filter_params *fp;
2944         struct netdev_hw_addr *ha;
2945
2946         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2947         if (!fp) {
2948                 wl1271_error("Out of memory setting filters.");
2949                 return 0;
2950         }
2951
2952         /* update multicast filtering parameters */
2953         fp->mc_list_length = 0;
2954         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2955                 fp->enabled = false;
2956         } else {
2957                 fp->enabled = true;
2958                 netdev_hw_addr_list_for_each(ha, mc_list) {
2959                         memcpy(fp->mc_list[fp->mc_list_length],
2960                                         ha->addr, ETH_ALEN);
2961                         fp->mc_list_length++;
2962                 }
2963         }
2964
2965         return (u64)(unsigned long)fp;
2966 }
2967
2968 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2969                                   FIF_ALLMULTI | \
2970                                   FIF_FCSFAIL | \
2971                                   FIF_BCN_PRBRESP_PROMISC | \
2972                                   FIF_CONTROL | \
2973                                   FIF_OTHER_BSS)
2974
2975 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2976                                        unsigned int changed,
2977                                        unsigned int *total, u64 multicast)
2978 {
2979         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2980         struct wl1271 *wl = hw->priv;
2981         struct wl12xx_vif *wlvif;
2982
2983         int ret;
2984
2985         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2986                      " total %x", changed, *total);
2987
2988         mutex_lock(&wl->mutex);
2989
2990         *total &= WL1271_SUPPORTED_FILTERS;
2991         changed &= WL1271_SUPPORTED_FILTERS;
2992
2993         if (unlikely(wl->state != WLCORE_STATE_ON))
2994                 goto out;
2995
2996         ret = wl1271_ps_elp_wakeup(wl);
2997         if (ret < 0)
2998                 goto out;
2999
3000         wl12xx_for_each_wlvif(wl, wlvif) {
3001                 if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
3002                         if (*total & FIF_ALLMULTI)
3003                                 ret = wl1271_acx_group_address_tbl(wl, wlvif,
3004                                                                    false,
3005                                                                    NULL, 0);
3006                         else if (fp)
3007                                 ret = wl1271_acx_group_address_tbl(wl, wlvif,
3008                                                         fp->enabled,
3009                                                         fp->mc_list,
3010                                                         fp->mc_list_length);
3011                         if (ret < 0)
3012                                 goto out_sleep;
3013                 }
3014         }
3015
3016         /*
3017          * the fw doesn't provide an api to configure the filters. instead,
3018          * the filters configuration is based on the active roles / ROC
3019          * state.
3020          */
3021
3022 out_sleep:
3023         wl1271_ps_elp_sleep(wl);
3024
3025 out:
3026         mutex_unlock(&wl->mutex);
3027         kfree(fp);
3028 }
3029
3030 static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3031                                 u8 id, u8 key_type, u8 key_size,
3032                                 const u8 *key, u8 hlid, u32 tx_seq_32,
3033                                 u16 tx_seq_16)
3034 {
3035         struct wl1271_ap_key *ap_key;
3036         int i;
3037
3038         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
3039
3040         if (key_size > MAX_KEY_SIZE)
3041                 return -EINVAL;
3042
3043         /*
3044          * Find next free entry in ap_keys. Also check we are not replacing
3045          * an existing key.
3046          */
3047         for (i = 0; i < MAX_NUM_KEYS; i++) {
3048                 if (wlvif->ap.recorded_keys[i] == NULL)
3049                         break;
3050
3051                 if (wlvif->ap.recorded_keys[i]->id == id) {
3052                         wl1271_warning("trying to record key replacement");
3053                         return -EINVAL;
3054                 }
3055         }
3056
3057         if (i == MAX_NUM_KEYS)
3058                 return -EBUSY;
3059
3060         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
3061         if (!ap_key)
3062                 return -ENOMEM;
3063
3064         ap_key->id = id;
3065         ap_key->key_type = key_type;
3066         ap_key->key_size = key_size;
3067         memcpy(ap_key->key, key, key_size);
3068         ap_key->hlid = hlid;
3069         ap_key->tx_seq_32 = tx_seq_32;
3070         ap_key->tx_seq_16 = tx_seq_16;
3071
3072         wlvif->ap.recorded_keys[i] = ap_key;
3073         return 0;
3074 }
3075
3076 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3077 {
3078         int i;
3079
3080         for (i = 0; i < MAX_NUM_KEYS; i++) {
3081                 kfree(wlvif->ap.recorded_keys[i]);
3082                 wlvif->ap.recorded_keys[i] = NULL;
3083         }
3084 }
3085
3086 static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3087 {
3088         int i, ret = 0;
3089         struct wl1271_ap_key *key;
3090         bool wep_key_added = false;
3091
3092         for (i = 0; i < MAX_NUM_KEYS; i++) {
3093                 u8 hlid;
3094                 if (wlvif->ap.recorded_keys[i] == NULL)
3095                         break;
3096
3097                 key = wlvif->ap.recorded_keys[i];
3098                 hlid = key->hlid;
3099                 if (hlid == WL12XX_INVALID_LINK_ID)
3100                         hlid = wlvif->ap.bcast_hlid;
3101
3102                 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3103                                             key->id, key->key_type,
3104                                             key->key_size, key->key,
3105                                             hlid, key->tx_seq_32,
3106                                             key->tx_seq_16);
3107                 if (ret < 0)
3108                         goto out;
3109
3110                 if (key->key_type == KEY_WEP)
3111                         wep_key_added = true;
3112         }
3113
3114         if (wep_key_added) {
3115                 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
3116                                                      wlvif->ap.bcast_hlid);
3117                 if (ret < 0)
3118                         goto out;
3119         }
3120
3121 out:
3122         wl1271_free_ap_keys(wl, wlvif);
3123         return ret;
3124 }
3125
3126 static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3127                        u16 action, u8 id, u8 key_type,
3128                        u8 key_size, const u8 *key, u32 tx_seq_32,
3129                        u16 tx_seq_16, struct ieee80211_sta *sta)
3130 {
3131         int ret;
3132         bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3133
3134         if (is_ap) {
3135                 struct wl1271_station *wl_sta;
3136                 u8 hlid;
3137
3138                 if (sta) {
3139                         wl_sta = (struct wl1271_station *)sta->drv_priv;
3140                         hlid = wl_sta->hlid;
3141                 } else {
3142                         hlid = wlvif->ap.bcast_hlid;
3143                 }
3144
3145                 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3146                         /*
3147                          * We do not support removing keys after AP shutdown.
3148                          * Pretend we do to make mac80211 happy.
3149                          */
3150                         if (action != KEY_ADD_OR_REPLACE)
3151                                 return 0;
3152
3153                         ret = wl1271_record_ap_key(wl, wlvif, id,
3154                                              key_type, key_size,
3155                                              key, hlid, tx_seq_32,
3156                                              tx_seq_16);
3157                 } else {
3158                         ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
3159                                              id, key_type, key_size,
3160                                              key, hlid, tx_seq_32,
3161                                              tx_seq_16);
3162                 }
3163
3164                 if (ret < 0)
3165                         return ret;
3166         } else {
3167                 const u8 *addr;
3168                 static const u8 bcast_addr[ETH_ALEN] = {
3169                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
3170                 };
3171
3172                 addr = sta ? sta->addr : bcast_addr;
3173
3174                 if (is_zero_ether_addr(addr)) {
3175                         /* We dont support TX only encryption */
3176                         return -EOPNOTSUPP;
3177                 }
3178
3179                 /* The wl1271 does not allow to remove unicast keys - they
3180                    will be cleared automatically on next CMD_JOIN. Ignore the
3181                    request silently, as we dont want the mac80211 to emit
3182                    an error message. */
3183                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
3184                         return 0;
3185
3186                 /* don't remove key if hlid was already deleted */
3187                 if (action == KEY_REMOVE &&
3188                     wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
3189                         return 0;
3190
3191                 ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
3192                                              id, key_type, key_size,
3193                                              key, addr, tx_seq_32,
3194                                              tx_seq_16);
3195                 if (ret < 0)
3196                         return ret;
3197
3198                 /* the default WEP key needs to be configured at least once */
3199                 if (key_type == KEY_WEP) {
3200                         ret = wl12xx_cmd_set_default_wep_key(wl,
3201                                                         wlvif->default_key,
3202                                                         wlvif->sta.hlid);
3203                         if (ret < 0)
3204                                 return ret;
3205                 }
3206         }
3207
3208         return 0;
3209 }
3210
3211 static int wlcore_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3212                              struct ieee80211_vif *vif,
3213                              struct ieee80211_sta *sta,
3214                              struct ieee80211_key_conf *key_conf)
3215 {
3216         struct wl1271 *wl = hw->priv;
3217         int ret;
3218         bool might_change_spare =
3219                 key_conf->cipher == WL1271_CIPHER_SUITE_GEM ||
3220                 key_conf->cipher == WLAN_CIPHER_SUITE_TKIP;
3221
3222         if (might_change_spare) {
3223                 /*
3224                  * stop the queues and flush to ensure the next packets are
3225                  * in sync with FW spare block accounting
3226                  */
3227                 wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
3228                 wl1271_tx_flush(wl);
3229         }
3230
3231         mutex_lock(&wl->mutex);
3232
3233         if (unlikely(wl->state != WLCORE_STATE_ON)) {
3234                 ret = -EAGAIN;
3235                 goto out_wake_queues;
3236         }
3237
3238         ret = wl1271_ps_elp_wakeup(wl);
3239         if (ret < 0)
3240                 goto out_wake_queues;
3241
3242         ret = wlcore_hw_set_key(wl, cmd, vif, sta, key_conf);
3243
3244         wl1271_ps_elp_sleep(wl);
3245
3246 out_wake_queues:
3247         if (might_change_spare)
3248                 wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
3249
3250         mutex_unlock(&wl->mutex);
3251
3252         return ret;
3253 }
3254
3255 int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
3256                    struct ieee80211_vif *vif,
3257                    struct ieee80211_sta *sta,
3258                    struct ieee80211_key_conf *key_conf)
3259 {
3260         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3261         int ret;
3262         u32 tx_seq_32 = 0;
3263         u16 tx_seq_16 = 0;
3264         u8 key_type;
3265
3266         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
3267
3268         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
3269         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
3270                      key_conf->cipher, key_conf->keyidx,
3271                      key_conf->keylen, key_conf->flags);
3272         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
3273
3274         switch (key_conf->cipher) {
3275         case WLAN_CIPHER_SUITE_WEP40:
3276         case WLAN_CIPHER_SUITE_WEP104:
3277                 key_type = KEY_WEP;
3278
3279                 key_conf->hw_key_idx = key_conf->keyidx;
3280                 break;
3281         case WLAN_CIPHER_SUITE_TKIP:
3282                 key_type = KEY_TKIP;
3283
3284                 key_conf->hw_key_idx = key_conf->keyidx;
3285                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3286                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
3287                 break;
3288         case WLAN_CIPHER_SUITE_CCMP:
3289                 key_type = KEY_AES;
3290
3291                 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
3292                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3293                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
3294                 break;
3295         case WL1271_CIPHER_SUITE_GEM:
3296                 key_type = KEY_GEM;
3297                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3298                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
3299                 break;
3300         default:
3301                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
3302
3303                 return -EOPNOTSUPP;
3304         }
3305
3306         switch (cmd) {
3307         case SET_KEY:
3308                 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3309                                  key_conf->keyidx, key_type,
3310                                  key_conf->keylen, key_conf->key,
3311                                  tx_seq_32, tx_seq_16, sta);
3312                 if (ret < 0) {
3313                         wl1271_error("Could not add or replace key");
3314                         return ret;
3315                 }
3316
3317                 /*
3318                  * reconfiguring arp response if the unicast (or common)
3319                  * encryption key type was changed
3320                  */
3321                 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
3322                     (sta || key_type == KEY_WEP) &&
3323                     wlvif->encryption_type != key_type) {
3324                         wlvif->encryption_type = key_type;
3325                         ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
3326                         if (ret < 0) {
3327                                 wl1271_warning("build arp rsp failed: %d", ret);
3328                                 return ret;
3329                         }
3330                 }
3331                 break;
3332
3333         case DISABLE_KEY:
3334                 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
3335                                      key_conf->keyidx, key_type,
3336                                      key_conf->keylen, key_conf->key,
3337                                      0, 0, sta);
3338                 if (ret < 0) {
3339                         wl1271_error("Could not remove key");
3340                         return ret;
3341                 }
3342                 break;
3343
3344         default:
3345                 wl1271_error("Unsupported key cmd 0x%x", cmd);
3346                 return -EOPNOTSUPP;
3347         }
3348
3349         return ret;
3350 }
3351 EXPORT_SYMBOL_GPL(wlcore_set_key);
3352
3353 void wlcore_regdomain_config(struct wl1271 *wl)
3354 {
3355         int ret;
3356
3357         if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF))
3358                 return;
3359
3360         mutex_lock(&wl->mutex);
3361         ret = wl1271_ps_elp_wakeup(wl);
3362         if (ret < 0)
3363                 goto out;
3364
3365         ret = wlcore_cmd_regdomain_config_locked(wl);
3366         if (ret < 0) {
3367                 wl12xx_queue_recovery_work(wl);
3368                 goto out;
3369         }
3370
3371         wl1271_ps_elp_sleep(wl);
3372 out:
3373         mutex_unlock(&wl->mutex);
3374 }
3375
3376 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3377                              struct ieee80211_vif *vif,
3378                              struct cfg80211_scan_request *req)
3379 {
3380         struct wl1271 *wl = hw->priv;
3381         int ret;
3382         u8 *ssid = NULL;
3383         size_t len = 0;
3384
3385         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3386
3387         if (req->n_ssids) {
3388                 ssid = req->ssids[0].ssid;
3389                 len = req->ssids[0].ssid_len;
3390         }
3391
3392         mutex_lock(&wl->mutex);
3393
3394         if (unlikely(wl->state != WLCORE_STATE_ON)) {
3395                 /*
3396                  * We cannot return -EBUSY here because cfg80211 will expect
3397                  * a call to ieee80211_scan_completed if we do - in this case
3398                  * there won't be any call.
3399                  */
3400                 ret = -EAGAIN;
3401                 goto out;
3402         }
3403
3404         ret = wl1271_ps_elp_wakeup(wl);
3405         if (ret < 0)
3406                 goto out;
3407
3408         /* fail if there is any role in ROC */
3409         if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
3410                 /* don't allow scanning right now */
3411                 ret = -EBUSY;
3412                 goto out_sleep;
3413         }
3414
3415         ret = wlcore_scan(hw->priv, vif, ssid, len, req);
3416 out_sleep:
3417         wl1271_ps_elp_sleep(wl);
3418 out:
3419         mutex_unlock(&wl->mutex);
3420
3421         return ret;
3422 }
3423
3424 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3425                                      struct ieee80211_vif *vif)
3426 {
3427         struct wl1271 *wl = hw->priv;
3428         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3429         int ret;
3430
3431         wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3432
3433         mutex_lock(&wl->mutex);
3434
3435         if (unlikely(wl->state != WLCORE_STATE_ON))
3436                 goto out;
3437
3438         if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3439                 goto out;
3440
3441         ret = wl1271_ps_elp_wakeup(wl);
3442         if (ret < 0)
3443                 goto out;
3444
3445         if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
3446                 ret = wl->ops->scan_stop(wl, wlvif);
3447                 if (ret < 0)
3448                         goto out_sleep;
3449         }
3450
3451         /*
3452          * Rearm the tx watchdog just before idling scan. This
3453          * prevents just-finished scans from triggering the watchdog
3454          */
3455         wl12xx_rearm_tx_watchdog_locked(wl);
3456
3457         wl->scan.state = WL1271_SCAN_STATE_IDLE;
3458         memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3459         wl->scan_wlvif = NULL;
3460         wl->scan.req = NULL;
3461         ieee80211_scan_completed(wl->hw, true);
3462
3463 out_sleep:
3464         wl1271_ps_elp_sleep(wl);
3465 out:
3466         mutex_unlock(&wl->mutex);
3467
3468         cancel_delayed_work_sync(&wl->scan_complete_work);
3469 }
3470
3471 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3472                                       struct ieee80211_vif *vif,
3473                                       struct cfg80211_sched_scan_request *req,
3474                                       struct ieee80211_sched_scan_ies *ies)
3475 {
3476         struct wl1271 *wl = hw->priv;
3477         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3478         int ret;
3479
3480         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3481
3482         mutex_lock(&wl->mutex);
3483
3484         if (unlikely(wl->state != WLCORE_STATE_ON)) {
3485                 ret = -EAGAIN;
3486                 goto out;
3487         }
3488
3489         ret = wl1271_ps_elp_wakeup(wl);
3490         if (ret < 0)
3491                 goto out;
3492
3493         ret = wl->ops->sched_scan_start(wl, wlvif, req, ies);
3494         if (ret < 0)
3495                 goto out_sleep;
3496
3497         wl->sched_vif = wlvif;
3498
3499 out_sleep:
3500         wl1271_ps_elp_sleep(wl);
3501 out:
3502         mutex_unlock(&wl->mutex);
3503         return ret;
3504 }
3505
3506 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3507                                       struct ieee80211_vif *vif)
3508 {
3509         struct wl1271 *wl = hw->priv;
3510         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3511         int ret;
3512
3513         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3514
3515         mutex_lock(&wl->mutex);
3516
3517         if (unlikely(wl->state != WLCORE_STATE_ON))
3518                 goto out;
3519
3520         ret = wl1271_ps_elp_wakeup(wl);
3521         if (ret < 0)
3522                 goto out;
3523
3524         wl->ops->sched_scan_stop(wl, wlvif);
3525
3526         wl1271_ps_elp_sleep(wl);
3527 out:
3528         mutex_unlock(&wl->mutex);
3529 }
3530
3531 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3532 {
3533         struct wl1271 *wl = hw->priv;
3534         int ret = 0;
3535
3536         mutex_lock(&wl->mutex);
3537
3538         if (unlikely(wl->state != WLCORE_STATE_ON)) {
3539                 ret = -EAGAIN;
3540                 goto out;
3541         }
3542
3543         ret = wl1271_ps_elp_wakeup(wl);
3544         if (ret < 0)
3545                 goto out;
3546
3547         ret = wl1271_acx_frag_threshold(wl, value);
3548         if (ret < 0)
3549                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3550
3551         wl1271_ps_elp_sleep(wl);
3552
3553 out:
3554         mutex_unlock(&wl->mutex);
3555
3556         return ret;
3557 }
3558
3559 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3560 {
3561         struct wl1271 *wl = hw->priv;
3562         struct wl12xx_vif *wlvif;
3563         int ret = 0;
3564
3565         mutex_lock(&wl->mutex);
3566
3567         if (unlikely(wl->state != WLCORE_STATE_ON)) {
3568                 ret = -EAGAIN;
3569                 goto out;
3570         }
3571
3572         ret = wl1271_ps_elp_wakeup(wl);
3573         if (ret < 0)
3574                 goto out;
3575
3576         wl12xx_for_each_wlvif(wl, wlvif) {
3577                 ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3578                 if (ret < 0)
3579                         wl1271_warning("set rts threshold failed: %d", ret);
3580         }
3581         wl1271_ps_elp_sleep(wl);
3582
3583 out:
3584         mutex_unlock(&wl->mutex);
3585
3586         return ret;
3587 }
3588
3589 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3590 {
3591         int len;
3592         const u8 *next, *end = skb->data + skb->len;
3593         u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3594                                         skb->len - ieoffset);
3595         if (!ie)
3596                 return;
3597         len = ie[1] + 2;
3598         next = ie + len;
3599         memmove(ie, next, end - next);
3600         skb_trim(skb, skb->len - len);
3601 }
3602
3603 static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3604                                             unsigned int oui, u8 oui_type,
3605                                             int ieoffset)
3606 {
3607         int len;
3608         const u8 *next, *end = skb->data + skb->len;
3609         u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3610                                                skb->data + ieoffset,
3611                                                skb->len - ieoffset);
3612         if (!ie)
3613                 return;
3614         len = ie[1] + 2;
3615         next = ie + len;
3616         memmove(ie, next, end - next);
3617         skb_trim(skb, skb->len - len);
3618 }
3619
3620 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
3621                                          struct ieee80211_vif *vif)
3622 {
3623         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3624         struct sk_buff *skb;
3625         int ret;
3626
3627         skb = ieee80211_proberesp_get(wl->hw, vif);
3628         if (!skb)
3629                 return -EOPNOTSUPP;
3630
3631         ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3632                                       CMD_TEMPL_AP_PROBE_RESPONSE,
3633                                       skb->data,
3634                                       skb->len, 0,
3635                                       rates);
3636         dev_kfree_skb(skb);
3637
3638         if (ret < 0)
3639                 goto out;
3640
3641         wl1271_debug(DEBUG_AP, "probe response updated");
3642         set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
3643
3644 out:
3645         return ret;
3646 }
3647
3648 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
3649                                              struct ieee80211_vif *vif,
3650                                              u8 *probe_rsp_data,
3651                                              size_t probe_rsp_len,
3652                                              u32 rates)
3653 {
3654         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3655         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
3656         u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3657         int ssid_ie_offset, ie_offset, templ_len;
3658         const u8 *ptr;
3659
3660         /* no need to change probe response if the SSID is set correctly */
3661         if (wlvif->ssid_len > 0)
3662                 return wl1271_cmd_template_set(wl, wlvif->role_id,
3663                                                CMD_TEMPL_AP_PROBE_RESPONSE,
3664                                                probe_rsp_data,
3665                                                probe_rsp_len, 0,
3666                                                rates);
3667
3668         if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3669                 wl1271_error("probe_rsp template too big");
3670                 return -EINVAL;
3671         }
3672
3673         /* start searching from IE offset */
3674         ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3675
3676         ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3677                                probe_rsp_len - ie_offset);
3678         if (!ptr) {
3679                 wl1271_error("No SSID in beacon!");
3680                 return -EINVAL;
3681         }
3682
3683         ssid_ie_offset = ptr - probe_rsp_data;
3684         ptr += (ptr[1] + 2);
3685
3686         memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3687
3688         /* insert SSID from bss_conf */
3689         probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3690         probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3691         memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3692                bss_conf->ssid, bss_conf->ssid_len);
3693         templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3694
3695         memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3696                ptr, probe_rsp_len - (ptr - probe_rsp_data));
3697         templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3698
3699         return wl1271_cmd_template_set(wl, wlvif->role_id,
3700                                        CMD_TEMPL_AP_PROBE_RESPONSE,
3701                                        probe_rsp_templ,
3702                                        templ_len, 0,
3703                                        rates);
3704 }
3705
3706 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3707                                        struct ieee80211_vif *vif,
3708                                        struct ieee80211_bss_conf *bss_conf,
3709                                        u32 changed)
3710 {
3711         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3712         int ret = 0;
3713
3714         if (changed & BSS_CHANGED_ERP_SLOT) {
3715                 if (bss_conf->use_short_slot)
3716                         ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
3717                 else
3718                         ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
3719                 if (ret < 0) {
3720                         wl1271_warning("Set slot time failed %d", ret);
3721                         goto out;
3722                 }
3723         }
3724
3725         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3726                 if (bss_conf->use_short_preamble)
3727                         wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
3728                 else
3729                         wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
3730         }
3731
3732         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3733                 if (bss_conf->use_cts_prot)
3734                         ret = wl1271_acx_cts_protect(wl, wlvif,
3735                                                      CTSPROTECT_ENABLE);
3736                 else
3737                         ret = wl1271_acx_cts_protect(wl, wlvif,
3738                                                      CTSPROTECT_DISABLE);
3739                 if (ret < 0) {
3740                         wl1271_warning("Set ctsprotect failed %d", ret);
3741                         goto out;
3742                 }
3743         }
3744
3745 out:
3746         return ret;
3747 }
3748
3749 static int wlcore_set_beacon_template(struct wl1271 *wl,
3750                                       struct ieee80211_vif *vif,
3751                                       bool is_ap)
3752 {
3753         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3754         struct ieee80211_hdr *hdr;
3755         u32 min_rate;
3756         int ret;
3757         int ieoffset = offsetof(struct ieee80211_mgmt,
3758                                 u.beacon.variable);
3759         struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3760         u16 tmpl_id;
3761
3762         if (!beacon) {
3763                 ret = -EINVAL;
3764                 goto out;
3765         }
3766
3767         wl1271_debug(DEBUG_MASTER, "beacon updated");
3768
3769         ret = wl1271_ssid_set(wlvif, beacon, ieoffset);
3770         if (ret < 0) {
3771                 dev_kfree_skb(beacon);
3772                 goto out;
3773         }
3774         min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3775         tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3776                 CMD_TEMPL_BEACON;
3777         ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
3778                                       beacon->data,
3779                                       beacon->len, 0,
3780                                       min_rate);
3781         if (ret < 0) {
3782                 dev_kfree_skb(beacon);
3783                 goto out;
3784         }
3785
3786         wlvif->wmm_enabled =
3787                 cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
3788                                         WLAN_OUI_TYPE_MICROSOFT_WMM,
3789                                         beacon->data + ieoffset,
3790                                         beacon->len - ieoffset);
3791
3792         /*
3793          * In case we already have a probe-resp beacon set explicitly
3794          * by usermode, don't use the beacon data.
3795          */
3796         if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
3797                 goto end_bcn;
3798
3799         /* remove TIM ie from probe response */
3800         wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3801
3802         /*
3803          * remove p2p ie from probe response.
3804          * the fw reponds to probe requests that don't include
3805          * the p2p ie. probe requests with p2p ie will be passed,
3806          * and will be responded by the supplicant (the spec
3807          * forbids including the p2p ie when responding to probe
3808          * requests that didn't include it).
3809          */
3810         wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3811                                 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3812
3813         hdr = (struct ieee80211_hdr *) beacon->data;
3814         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3815                                          IEEE80211_STYPE_PROBE_RESP);
3816         if (is_ap)
3817                 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
3818                                                            beacon->data,
3819                                                            beacon->len,
3820                                                            min_rate);
3821         else
3822                 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3823                                               CMD_TEMPL_PROBE_RESPONSE,
3824                                               beacon->data,
3825                                               beacon->len, 0,
3826                                               min_rate);
3827 end_bcn:
3828         dev_kfree_skb(beacon);
3829         if (ret < 0)
3830                 goto out;
3831
3832 out:
3833         return ret;
3834 }
3835
3836 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3837                                           struct ieee80211_vif *vif,
3838                                           struct ieee80211_bss_conf *bss_conf,
3839                                           u32 changed)
3840 {
3841         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3842         bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3843         int ret = 0;
3844
3845         if (changed & BSS_CHANGED_BEACON_INT) {
3846                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3847                         bss_conf->beacon_int);
3848
3849                 wlvif->beacon_int = bss_conf->beacon_int;
3850         }
3851
3852         if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
3853                 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3854
3855                 wl1271_ap_set_probe_resp_tmpl(wl, rate, vif);
3856         }
3857
3858         if (changed & BSS_CHANGED_BEACON) {
3859                 ret = wlcore_set_beacon_template(wl, vif, is_ap);
3860                 if (ret < 0)
3861                         goto out;
3862         }
3863
3864 out:
3865         if (ret != 0)
3866                 wl1271_error("beacon info change failed: %d", ret);
3867         return ret;
3868 }
3869
3870 /* AP mode changes */
3871 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3872                                        struct ieee80211_vif *vif,
3873                                        struct ieee80211_bss_conf *bss_conf,
3874                                        u32 changed)
3875 {
3876         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3877         int ret = 0;
3878
3879         if (changed & BSS_CHANGED_BASIC_RATES) {
3880                 u32 rates = bss_conf->basic_rates;
3881
3882                 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
3883                                                                  wlvif->band);
3884                 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
3885                                                         wlvif->basic_rate_set);
3886
3887                 ret = wl1271_init_ap_rates(wl, wlvif);
3888                 if (ret < 0) {
3889                         wl1271_error("AP rate policy change failed %d", ret);
3890                         goto out;
3891                 }
3892
3893                 ret = wl1271_ap_init_templates(wl, vif);
3894                 if (ret < 0)
3895                         goto out;
3896
3897                 ret = wl1271_ap_set_probe_resp_tmpl(wl, wlvif->basic_rate, vif);
3898                 if (ret < 0)
3899                         goto out;
3900
3901                 ret = wlcore_set_beacon_template(wl, vif, true);
3902                 if (ret < 0)
3903                         goto out;
3904         }
3905
3906         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3907         if (ret < 0)
3908                 goto out;
3909
3910         if (changed & BSS_CHANGED_BEACON_ENABLED) {
3911                 if (bss_conf->enable_beacon) {
3912                         if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3913                                 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
3914                                 if (ret < 0)
3915                                         goto out;
3916
3917                                 ret = wl1271_ap_init_hwenc(wl, wlvif);
3918                                 if (ret < 0)
3919                                         goto out;
3920
3921                                 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3922                                 wl1271_debug(DEBUG_AP, "started AP");
3923                         }
3924                 } else {
3925                         if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3926                                 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
3927                                 if (ret < 0)
3928                                         goto out;
3929
3930                                 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3931                                 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
3932                                           &wlvif->flags);
3933                                 wl1271_debug(DEBUG_AP, "stopped AP");
3934                         }
3935                 }
3936         }
3937
3938         ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3939         if (ret < 0)
3940                 goto out;
3941
3942         /* Handle HT information change */
3943         if ((changed & BSS_CHANGED_HT) &&
3944             (bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT)) {
3945                 ret = wl1271_acx_set_ht_information(wl, wlvif,
3946                                         bss_conf->ht_operation_mode);
3947                 if (ret < 0) {
3948                         wl1271_warning("Set ht information failed %d", ret);
3949                         goto out;
3950                 }
3951         }
3952
3953 out:
3954         return;
3955 }
3956
3957 static int wlcore_set_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3958                             struct ieee80211_bss_conf *bss_conf,
3959                             u32 sta_rate_set)
3960 {
3961         u32 rates;
3962         int ret;
3963
3964         wl1271_debug(DEBUG_MAC80211,
3965              "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x",
3966              bss_conf->bssid, bss_conf->aid,
3967              bss_conf->beacon_int,
3968              bss_conf->basic_rates, sta_rate_set);
3969
3970         wlvif->beacon_int = bss_conf->beacon_int;
3971         rates = bss_conf->basic_rates;
3972         wlvif->basic_rate_set =
3973                 wl1271_tx_enabled_rates_get(wl, rates,
3974                                             wlvif->band);
3975         wlvif->basic_rate =
3976                 wl1271_tx_min_rate_get(wl,
3977                                        wlvif->basic_rate_set);
3978
3979         if (sta_rate_set)
3980                 wlvif->rate_set =
3981                         wl1271_tx_enabled_rates_get(wl,
3982                                                 sta_rate_set,
3983                                                 wlvif->band);
3984
3985         /* we only support sched_scan while not connected */
3986         if (wl->sched_vif == wlvif)
3987                 wl->ops->sched_scan_stop(wl, wlvif);
3988
3989         ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3990         if (ret < 0)
3991                 return ret;
3992
3993         ret = wl12xx_cmd_build_null_data(wl, wlvif);
3994         if (ret < 0)
3995                 return ret;
3996
3997         ret = wl1271_build_qos_null_data(wl, wl12xx_wlvif_to_vif(wlvif));
3998         if (ret < 0)
3999                 return ret;
4000
4001         wlcore_set_ssid(wl, wlvif);
4002
4003         set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
4004
4005         return 0;
4006 }
4007
4008 static int wlcore_clear_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
4009 {
4010         int ret;
4011
4012         /* revert back to minimum rates for the current band */
4013         wl1271_set_band_rate(wl, wlvif);
4014         wlvif->basic_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4015
4016         ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4017         if (ret < 0)
4018                 return ret;
4019
4020         if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4021             test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) {
4022                 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
4023                 if (ret < 0)
4024                         return ret;
4025         }
4026
4027         clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
4028         return 0;
4029 }
4030 /* STA/IBSS mode changes */
4031 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
4032                                         struct ieee80211_vif *vif,
4033                                         struct ieee80211_bss_conf *bss_conf,
4034                                         u32 changed)
4035 {
4036         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4037         bool do_join = false;
4038         bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
4039         bool ibss_joined = false;
4040         u32 sta_rate_set = 0;
4041         int ret;
4042         struct ieee80211_sta *sta;
4043         bool sta_exists = false;
4044         struct ieee80211_sta_ht_cap sta_ht_cap;
4045
4046         if (is_ibss) {
4047                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
4048                                                      changed);
4049                 if (ret < 0)
4050                         goto out;
4051         }
4052
4053         if (changed & BSS_CHANGED_IBSS) {
4054                 if (bss_conf->ibss_joined) {
4055                         set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
4056                         ibss_joined = true;
4057                 } else {
4058                         wlcore_unset_assoc(wl, wlvif);
4059                         wl12xx_cmd_role_stop_sta(wl, wlvif);
4060                 }
4061         }
4062
4063         if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
4064                 do_join = true;
4065
4066         /* Need to update the SSID (for filtering etc) */
4067         if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
4068                 do_join = true;
4069
4070         if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
4071                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
4072                              bss_conf->enable_beacon ? "enabled" : "disabled");
4073
4074                 do_join = true;
4075         }
4076
4077         if (changed & BSS_CHANGED_CQM) {
4078                 bool enable = false;
4079                 if (bss_conf->cqm_rssi_thold)
4080                         enable = true;
4081                 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
4082                                                   bss_conf->cqm_rssi_thold,
4083                                                   bss_conf->cqm_rssi_hyst);
4084                 if (ret < 0)
4085                         goto out;
4086                 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
4087         }
4088
4089         if (changed & (BSS_CHANGED_BSSID | BSS_CHANGED_HT |
4090                        BSS_CHANGED_ASSOC)) {
4091                 rcu_read_lock();
4092                 sta = ieee80211_find_sta(vif, bss_conf->bssid);
4093                 if (sta) {
4094                         u8 *rx_mask = sta->ht_cap.mcs.rx_mask;
4095
4096                         /* save the supp_rates of the ap */
4097                         sta_rate_set = sta->supp_rates[wlvif->band];
4098                         if (sta->ht_cap.ht_supported)
4099                                 sta_rate_set |=
4100                                         (rx_mask[0] << HW_HT_RATES_OFFSET) |
4101                                         (rx_mask[1] << HW_MIMO_RATES_OFFSET);
4102                         sta_ht_cap = sta->ht_cap;
4103                         sta_exists = true;
4104                 }
4105
4106                 rcu_read_unlock();
4107         }
4108
4109         if (changed & BSS_CHANGED_BSSID) {
4110                 if (!is_zero_ether_addr(bss_conf->bssid)) {
4111                         ret = wlcore_set_bssid(wl, wlvif, bss_conf,
4112                                                sta_rate_set);
4113                         if (ret < 0)
4114                                 goto out;
4115
4116                         /* Need to update the BSSID (for filtering etc) */
4117                         do_join = true;
4118                 } else {
4119                         ret = wlcore_clear_bssid(wl, wlvif);
4120                         if (ret < 0)
4121                                 goto out;
4122                 }
4123         }
4124
4125         if (changed & BSS_CHANGED_IBSS) {
4126                 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
4127                              bss_conf->ibss_joined);
4128
4129                 if (bss_conf->ibss_joined) {
4130                         u32 rates = bss_conf->basic_rates;
4131                         wlvif->basic_rate_set =
4132                                 wl1271_tx_enabled_rates_get(wl, rates,
4133                                                             wlvif->band);
4134                         wlvif->basic_rate =
4135                                 wl1271_tx_min_rate_get(wl,
4136                                                        wlvif->basic_rate_set);
4137
4138                         /* by default, use 11b + OFDM rates */
4139                         wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
4140                         ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4141                         if (ret < 0)
4142                                 goto out;
4143                 }
4144         }
4145
4146         ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
4147         if (ret < 0)
4148                 goto out;
4149
4150         if (do_join) {
4151                 ret = wlcore_join(wl, wlvif);
4152                 if (ret < 0) {
4153                         wl1271_warning("cmd join failed %d", ret);
4154                         goto out;
4155                 }
4156         }
4157
4158         if (changed & BSS_CHANGED_ASSOC) {
4159                 if (bss_conf->assoc) {
4160                         ret = wlcore_set_assoc(wl, wlvif, bss_conf,
4161                                                sta_rate_set);
4162                         if (ret < 0)
4163                                 goto out;
4164
4165                         if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
4166                                 wl12xx_set_authorized(wl, wlvif);
4167                 } else {
4168                         wlcore_unset_assoc(wl, wlvif);
4169                 }
4170         }
4171
4172         if (changed & BSS_CHANGED_PS) {
4173                 if ((bss_conf->ps) &&
4174                     test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
4175                     !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
4176                         int ps_mode;
4177                         char *ps_mode_str;
4178
4179                         if (wl->conf.conn.forced_ps) {
4180                                 ps_mode = STATION_POWER_SAVE_MODE;
4181                                 ps_mode_str = "forced";
4182                         } else {
4183                                 ps_mode = STATION_AUTO_PS_MODE;
4184                                 ps_mode_str = "auto";
4185                         }
4186
4187                         wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);
4188
4189                         ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);
4190                         if (ret < 0)
4191                                 wl1271_warning("enter %s ps failed %d",
4192                                                ps_mode_str, ret);
4193                 } else if (!bss_conf->ps &&
4194                            test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
4195                         wl1271_debug(DEBUG_PSM, "auto ps disabled");
4196
4197                         ret = wl1271_ps_set_mode(wl, wlvif,
4198                                                  STATION_ACTIVE_MODE);
4199                         if (ret < 0)
4200                                 wl1271_warning("exit auto ps failed %d", ret);
4201                 }
4202         }
4203
4204         /* Handle new association with HT. Do this after join. */
4205         if (sta_exists &&
4206             (changed & BSS_CHANGED_HT)) {
4207                 bool enabled =
4208                         bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT;
4209
4210                 ret = wlcore_hw_set_peer_cap(wl,
4211                                              &sta_ht_cap,
4212                                              enabled,
4213                                              wlvif->rate_set,
4214                                              wlvif->sta.hlid);
4215                 if (ret < 0) {
4216                         wl1271_warning("Set ht cap failed %d", ret);
4217                         goto out;
4218
4219                 }
4220
4221                 if (enabled) {
4222                         ret = wl1271_acx_set_ht_information(wl, wlvif,
4223                                                 bss_conf->ht_operation_mode);
4224                         if (ret < 0) {
4225                                 wl1271_warning("Set ht information failed %d",
4226                                                ret);
4227                                 goto out;
4228                         }
4229                 }
4230         }
4231
4232         /* Handle arp filtering. Done after join. */
4233         if ((changed & BSS_CHANGED_ARP_FILTER) ||
4234             (!is_ibss && (changed & BSS_CHANGED_QOS))) {
4235                 __be32 addr = bss_conf->arp_addr_list[0];
4236                 wlvif->sta.qos = bss_conf->qos;
4237                 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
4238
4239                 if (bss_conf->arp_addr_cnt == 1 && bss_conf->assoc) {
4240                         wlvif->ip_addr = addr;
4241                         /*
4242                          * The template should have been configured only upon
4243                          * association. however, it seems that the correct ip
4244                          * isn't being set (when sending), so we have to
4245                          * reconfigure the template upon every ip change.
4246                          */
4247                         ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
4248                         if (ret < 0) {
4249                                 wl1271_warning("build arp rsp failed: %d", ret);
4250                                 goto out;
4251                         }
4252
4253                         ret = wl1271_acx_arp_ip_filter(wl, wlvif,
4254                                 (ACX_ARP_FILTER_ARP_FILTERING |
4255                                  ACX_ARP_FILTER_AUTO_ARP),
4256                                 addr);
4257                 } else {
4258                         wlvif->ip_addr = 0;
4259                         ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
4260                 }
4261
4262                 if (ret < 0)
4263                         goto out;
4264         }
4265
4266 out:
4267         return;
4268 }
4269
4270 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
4271                                        struct ieee80211_vif *vif,
4272                                        struct ieee80211_bss_conf *bss_conf,
4273                                        u32 changed)
4274 {
4275         struct wl1271 *wl = hw->priv;
4276         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4277         bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
4278         int ret;
4279
4280         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info role %d changed 0x%x",
4281                      wlvif->role_id, (int)changed);
4282
4283         /*
4284          * make sure to cancel pending disconnections if our association
4285          * state changed
4286          */
4287         if (!is_ap && (changed & BSS_CHANGED_ASSOC))
4288                 cancel_delayed_work_sync(&wlvif->connection_loss_work);
4289
4290         if (is_ap && (changed & BSS_CHANGED_BEACON_ENABLED) &&
4291             !bss_conf->enable_beacon)
4292                 wl1271_tx_flush(wl);
4293
4294         mutex_lock(&wl->mutex);
4295
4296         if (unlikely(wl->state != WLCORE_STATE_ON))
4297                 goto out;
4298
4299         if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
4300                 goto out;
4301
4302         ret = wl1271_ps_elp_wakeup(wl);
4303         if (ret < 0)
4304                 goto out;
4305
4306         if (is_ap)
4307                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
4308         else
4309                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
4310
4311         wl1271_ps_elp_sleep(wl);
4312
4313 out:
4314         mutex_unlock(&wl->mutex);
4315 }
4316
4317 static int wlcore_op_add_chanctx(struct ieee80211_hw *hw,
4318                                  struct ieee80211_chanctx_conf *ctx)
4319 {
4320         wl1271_debug(DEBUG_MAC80211, "mac80211 add chanctx %d (type %d)",
4321                      ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4322                      cfg80211_get_chandef_type(&ctx->def));
4323         return 0;
4324 }
4325
4326 static void wlcore_op_remove_chanctx(struct ieee80211_hw *hw,
4327                                      struct ieee80211_chanctx_conf *ctx)
4328 {
4329         wl1271_debug(DEBUG_MAC80211, "mac80211 remove chanctx %d (type %d)",
4330                      ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4331                      cfg80211_get_chandef_type(&ctx->def));
4332 }
4333
4334 static void wlcore_op_change_chanctx(struct ieee80211_hw *hw,
4335                                      struct ieee80211_chanctx_conf *ctx,
4336                                      u32 changed)
4337 {
4338         wl1271_debug(DEBUG_MAC80211,
4339                      "mac80211 change chanctx %d (type %d) changed 0x%x",
4340                      ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4341                      cfg80211_get_chandef_type(&ctx->def), changed);
4342 }
4343
4344 static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw *hw,
4345                                         struct ieee80211_vif *vif,
4346                                         struct ieee80211_chanctx_conf *ctx)
4347 {
4348         struct wl1271 *wl = hw->priv;
4349         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4350         int channel = ieee80211_frequency_to_channel(
4351                 ctx->def.chan->center_freq);
4352
4353         wl1271_debug(DEBUG_MAC80211,
4354                      "mac80211 assign chanctx (role %d) %d (type %d)",
4355                      wlvif->role_id, channel, cfg80211_get_chandef_type(&ctx->def));
4356
4357         mutex_lock(&wl->mutex);
4358
4359         wlvif->band = ctx->def.chan->band;
4360         wlvif->channel = channel;
4361         wlvif->channel_type = cfg80211_get_chandef_type(&ctx->def);
4362
4363         /* update default rates according to the band */
4364         wl1271_set_band_rate(wl, wlvif);
4365
4366         mutex_unlock(&wl->mutex);
4367
4368         return 0;
4369 }
4370
4371 static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
4372                                            struct ieee80211_vif *vif,
4373                                            struct ieee80211_chanctx_conf *ctx)
4374 {
4375         struct wl1271 *wl = hw->priv;
4376         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4377
4378         wl1271_debug(DEBUG_MAC80211,
4379                      "mac80211 unassign chanctx (role %d) %d (type %d)",
4380                      wlvif->role_id,
4381                      ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4382                      cfg80211_get_chandef_type(&ctx->def));
4383
4384         wl1271_tx_flush(wl);
4385 }
4386
4387 static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
4388                              struct ieee80211_vif *vif, u16 queue,
4389                              const struct ieee80211_tx_queue_params *params)
4390 {
4391         struct wl1271 *wl = hw->priv;
4392         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4393         u8 ps_scheme;
4394         int ret = 0;
4395
4396         mutex_lock(&wl->mutex);
4397
4398         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
4399
4400         if (params->uapsd)
4401                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
4402         else
4403                 ps_scheme = CONF_PS_SCHEME_LEGACY;
4404
4405         if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
4406                 goto out;
4407
4408         ret = wl1271_ps_elp_wakeup(wl);
4409         if (ret < 0)
4410                 goto out;
4411
4412         /*
4413          * the txop is confed in units of 32us by the mac80211,
4414          * we need us
4415          */
4416         ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4417                                 params->cw_min, params->cw_max,
4418                                 params->aifs, params->txop << 5);
4419         if (ret < 0)
4420                 goto out_sleep;
4421
4422         ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4423                                  CONF_CHANNEL_TYPE_EDCF,
4424                                  wl1271_tx_get_queue(queue),
4425                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
4426                                  0, 0);
4427
4428 out_sleep:
4429         wl1271_ps_elp_sleep(wl);
4430
4431 out:
4432         mutex_unlock(&wl->mutex);
4433
4434         return ret;
4435 }
4436
4437 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4438                              struct ieee80211_vif *vif)
4439 {
4440
4441         struct wl1271 *wl = hw->priv;
4442         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4443         u64 mactime = ULLONG_MAX;
4444         int ret;
4445
4446         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4447
4448         mutex_lock(&wl->mutex);
4449
4450         if (unlikely(wl->state != WLCORE_STATE_ON))
4451                 goto out;
4452
4453         ret = wl1271_ps_elp_wakeup(wl);
4454         if (ret < 0)
4455                 goto out;
4456
4457         ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
4458         if (ret < 0)
4459                 goto out_sleep;
4460
4461 out_sleep:
4462         wl1271_ps_elp_sleep(wl);
4463
4464 out:
4465         mutex_unlock(&wl->mutex);
4466         return mactime;
4467 }
4468
4469 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4470                                 struct survey_info *survey)
4471 {
4472         struct ieee80211_conf *conf = &hw->conf;
4473
4474         if (idx != 0)
4475                 return -ENOENT;
4476
4477         survey->channel = conf->channel;
4478         survey->filled = 0;
4479         return 0;
4480 }
4481
4482 static int wl1271_allocate_sta(struct wl1271 *wl,
4483                              struct wl12xx_vif *wlvif,
4484                              struct ieee80211_sta *sta)
4485 {
4486         struct wl1271_station *wl_sta;
4487         int ret;
4488
4489
4490         if (wl->active_sta_count >= AP_MAX_STATIONS) {
4491                 wl1271_warning("could not allocate HLID - too much stations");
4492                 return -EBUSY;
4493         }
4494
4495         wl_sta = (struct wl1271_station *)sta->drv_priv;
4496         ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4497         if (ret < 0) {
4498                 wl1271_warning("could not allocate HLID - too many links");
4499                 return -EBUSY;
4500         }
4501
4502         set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4503         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4504         wl->active_sta_count++;
4505         return 0;
4506 }
4507
4508 void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4509 {
4510         if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4511                 return;
4512
4513         clear_bit(hlid, wlvif->ap.sta_hlid_map);
4514         __clear_bit(hlid, &wl->ap_ps_map);
4515         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
4516         wl12xx_free_link(wl, wlvif, &hlid);
4517         wl->active_sta_count--;
4518
4519         /*
4520          * rearm the tx watchdog when the last STA is freed - give the FW a
4521          * chance to return STA-buffered packets before complaining.
4522          */
4523         if (wl->active_sta_count == 0)
4524                 wl12xx_rearm_tx_watchdog_locked(wl);
4525 }
4526
4527 static int wl12xx_sta_add(struct wl1271 *wl,
4528                           struct wl12xx_vif *wlvif,
4529                           struct ieee80211_sta *sta)
4530 {
4531         struct wl1271_station *wl_sta;
4532         int ret = 0;
4533         u8 hlid;
4534
4535         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4536
4537         ret = wl1271_allocate_sta(wl, wlvif, sta);
4538         if (ret < 0)
4539                 return ret;
4540
4541         wl_sta = (struct wl1271_station *)sta->drv_priv;
4542         hlid = wl_sta->hlid;
4543
4544         ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
4545         if (ret < 0)
4546                 wl1271_free_sta(wl, wlvif, hlid);
4547
4548         return ret;
4549 }
4550
4551 static int wl12xx_sta_remove(struct wl1271 *wl,
4552                              struct wl12xx_vif *wlvif,
4553                              struct ieee80211_sta *sta)
4554 {
4555         struct wl1271_station *wl_sta;
4556         int ret = 0, id;
4557
4558         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4559
4560         wl_sta = (struct wl1271_station *)sta->drv_priv;
4561         id = wl_sta->hlid;
4562         if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
4563                 return -EINVAL;
4564
4565         ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
4566         if (ret < 0)
4567                 return ret;
4568
4569         wl1271_free_sta(wl, wlvif, wl_sta->hlid);
4570         return ret;
4571 }
4572
4573 static void wlcore_roc_if_possible(struct wl1271 *wl,
4574                                    struct wl12xx_vif *wlvif)
4575 {
4576         if (find_first_bit(wl->roc_map,
4577                            WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES)
4578                 return;
4579
4580         if (WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID))
4581                 return;
4582
4583         wl12xx_roc(wl, wlvif, wlvif->role_id, wlvif->band, wlvif->channel);
4584 }
4585
4586 static void wlcore_update_inconn_sta(struct wl1271 *wl,
4587                                      struct wl12xx_vif *wlvif,
4588                                      struct wl1271_station *wl_sta,
4589                                      bool in_connection)
4590 {
4591         if (in_connection) {
4592                 if (WARN_ON(wl_sta->in_connection))
4593                         return;
4594                 wl_sta->in_connection = true;
4595                 if (!wlvif->inconn_count++)
4596                         wlcore_roc_if_possible(wl, wlvif);
4597         } else {
4598                 if (!wl_sta->in_connection)
4599                         return;
4600
4601                 wl_sta->in_connection = false;
4602                 wlvif->inconn_count--;
4603                 if (WARN_ON(wlvif->inconn_count < 0))
4604                         return;
4605
4606                 if (!wlvif->inconn_count)
4607                         if (test_bit(wlvif->role_id, wl->roc_map))
4608                                 wl12xx_croc(wl, wlvif->role_id);
4609         }
4610 }
4611
4612 static int wl12xx_update_sta_state(struct wl1271 *wl,
4613                                    struct wl12xx_vif *wlvif,
4614                                    struct ieee80211_sta *sta,
4615                                    enum ieee80211_sta_state old_state,
4616                                    enum ieee80211_sta_state new_state)
4617 {
4618         struct wl1271_station *wl_sta;
4619         u8 hlid;
4620         bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
4621         bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
4622         int ret;
4623
4624         wl_sta = (struct wl1271_station *)sta->drv_priv;
4625         hlid = wl_sta->hlid;
4626
4627         /* Add station (AP mode) */
4628         if (is_ap &&
4629             old_state == IEEE80211_STA_NOTEXIST &&
4630             new_state == IEEE80211_STA_NONE) {
4631                 ret = wl12xx_sta_add(wl, wlvif, sta);
4632                 if (ret)
4633                         return ret;
4634
4635                 wlcore_update_inconn_sta(wl, wlvif, wl_sta, true);
4636         }
4637
4638         /* Remove station (AP mode) */
4639         if (is_ap &&
4640             old_state == IEEE80211_STA_NONE &&
4641             new_state == IEEE80211_STA_NOTEXIST) {
4642                 /* must not fail */
4643                 wl12xx_sta_remove(wl, wlvif, sta);
4644
4645                 wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
4646         }
4647
4648         /* Authorize station (AP mode) */
4649         if (is_ap &&
4650             new_state == IEEE80211_STA_AUTHORIZED) {
4651                 ret = wl12xx_cmd_set_peer_state(wl, wlvif, hlid);
4652                 if (ret < 0)
4653                         return ret;
4654
4655                 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true,
4656                                                      hlid);
4657                 if (ret)
4658                         return ret;
4659
4660                 wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
4661         }
4662
4663         /* Authorize station */
4664         if (is_sta &&
4665             new_state == IEEE80211_STA_AUTHORIZED) {
4666                 set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
4667                 ret = wl12xx_set_authorized(wl, wlvif);
4668                 if (ret)
4669                         return ret;
4670         }
4671
4672         if (is_sta &&
4673             old_state == IEEE80211_STA_AUTHORIZED &&
4674             new_state == IEEE80211_STA_ASSOC) {
4675                 clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
4676                 clear_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags);
4677         }
4678
4679         /* clear ROCs on failure or authorization */
4680         if (is_sta &&
4681             (new_state == IEEE80211_STA_AUTHORIZED ||
4682              new_state == IEEE80211_STA_NOTEXIST)) {
4683                 if (test_bit(wlvif->role_id, wl->roc_map))
4684                         wl12xx_croc(wl, wlvif->role_id);
4685         }
4686
4687         if (is_sta &&
4688             old_state == IEEE80211_STA_NOTEXIST &&
4689             new_state == IEEE80211_STA_NONE) {
4690                 if (find_first_bit(wl->roc_map,
4691                                    WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES) {
4692                         WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID);
4693                         wl12xx_roc(wl, wlvif, wlvif->role_id,
4694                                    wlvif->band, wlvif->channel);
4695                 }
4696         }
4697         return 0;
4698 }
4699
4700 static int wl12xx_op_sta_state(struct ieee80211_hw *hw,
4701                                struct ieee80211_vif *vif,
4702                                struct ieee80211_sta *sta,
4703                                enum ieee80211_sta_state old_state,
4704                                enum ieee80211_sta_state new_state)
4705 {
4706         struct wl1271 *wl = hw->priv;
4707         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4708         int ret;
4709
4710         wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d",
4711                      sta->aid, old_state, new_state);
4712
4713         mutex_lock(&wl->mutex);
4714
4715         if (unlikely(wl->state != WLCORE_STATE_ON)) {
4716                 ret = -EBUSY;
4717                 goto out;
4718         }
4719
4720         ret = wl1271_ps_elp_wakeup(wl);
4721         if (ret < 0)
4722                 goto out;
4723
4724         ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
4725
4726         wl1271_ps_elp_sleep(wl);
4727 out:
4728         mutex_unlock(&wl->mutex);
4729         if (new_state < old_state)
4730                 return 0;
4731         return ret;
4732 }
4733
4734 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4735                                   struct ieee80211_vif *vif,
4736                                   enum ieee80211_ampdu_mlme_action action,
4737                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4738                                   u8 buf_size)
4739 {
4740         struct wl1271 *wl = hw->priv;
4741         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4742         int ret;
4743         u8 hlid, *ba_bitmap;
4744
4745         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4746                      tid);
4747
4748         /* sanity check - the fields in FW are only 8bits wide */
4749         if (WARN_ON(tid > 0xFF))
4750                 return -ENOTSUPP;
4751
4752         mutex_lock(&wl->mutex);
4753
4754         if (unlikely(wl->state != WLCORE_STATE_ON)) {
4755                 ret = -EAGAIN;
4756                 goto out;
4757         }
4758
4759         if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
4760                 hlid = wlvif->sta.hlid;
4761         } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
4762                 struct wl1271_station *wl_sta;
4763
4764                 wl_sta = (struct wl1271_station *)sta->drv_priv;
4765                 hlid = wl_sta->hlid;
4766         } else {
4767                 ret = -EINVAL;
4768                 goto out;
4769         }
4770
4771         ba_bitmap = &wl->links[hlid].ba_bitmap;
4772
4773         ret = wl1271_ps_elp_wakeup(wl);
4774         if (ret < 0)
4775                 goto out;
4776
4777         wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4778                      tid, action);
4779
4780         switch (action) {
4781         case IEEE80211_AMPDU_RX_START:
4782                 if (!wlvif->ba_support || !wlvif->ba_allowed) {
4783                         ret = -ENOTSUPP;
4784                         break;
4785                 }
4786
4787                 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4788                         ret = -EBUSY;
4789                         wl1271_error("exceeded max RX BA sessions");
4790                         break;
4791                 }
4792
4793                 if (*ba_bitmap & BIT(tid)) {
4794                         ret = -EINVAL;
4795                         wl1271_error("cannot enable RX BA session on active "
4796                                      "tid: %d", tid);
4797                         break;
4798                 }
4799
4800                 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4801                                                          hlid);
4802                 if (!ret) {
4803                         *ba_bitmap |= BIT(tid);
4804                         wl->ba_rx_session_count++;
4805                 }
4806                 break;
4807
4808         case IEEE80211_AMPDU_RX_STOP:
4809                 if (!(*ba_bitmap & BIT(tid))) {
4810                         /*
4811                          * this happens on reconfig - so only output a debug
4812                          * message for now, and don't fail the function.
4813                          */
4814                         wl1271_debug(DEBUG_MAC80211,
4815                                      "no active RX BA session on tid: %d",
4816                                      tid);
4817                         ret = 0;
4818                         break;
4819                 }
4820
4821                 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4822                                                          hlid);
4823                 if (!ret) {
4824                         *ba_bitmap &= ~BIT(tid);
4825                         wl->ba_rx_session_count--;
4826                 }
4827                 break;
4828
4829         /*
4830          * The BA initiator session management in FW independently.
4831          * Falling break here on purpose for all TX APDU commands.
4832          */
4833         case IEEE80211_AMPDU_TX_START:
4834         case IEEE80211_AMPDU_TX_STOP_CONT:
4835         case IEEE80211_AMPDU_TX_STOP_FLUSH:
4836         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4837         case IEEE80211_AMPDU_TX_OPERATIONAL:
4838                 ret = -EINVAL;
4839                 break;
4840
4841         default:
4842                 wl1271_error("Incorrect ampdu action id=%x\n", action);
4843                 ret = -EINVAL;
4844         }
4845
4846         wl1271_ps_elp_sleep(wl);
4847
4848 out:
4849         mutex_unlock(&wl->mutex);
4850
4851         return ret;
4852 }
4853
4854 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4855                                    struct ieee80211_vif *vif,
4856                                    const struct cfg80211_bitrate_mask *mask)
4857 {
4858         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4859         struct wl1271 *wl = hw->priv;
4860         int i, ret = 0;
4861
4862         wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4863                 mask->control[NL80211_BAND_2GHZ].legacy,
4864                 mask->control[NL80211_BAND_5GHZ].legacy);
4865
4866         mutex_lock(&wl->mutex);
4867
4868         for (i = 0; i < WLCORE_NUM_BANDS; i++)
4869                 wlvif->bitrate_masks[i] =
4870                         wl1271_tx_enabled_rates_get(wl,
4871                                                     mask->control[i].legacy,
4872                                                     i);
4873
4874         if (unlikely(wl->state != WLCORE_STATE_ON))
4875                 goto out;
4876
4877         if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4878             !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
4879
4880                 ret = wl1271_ps_elp_wakeup(wl);
4881                 if (ret < 0)
4882                         goto out;
4883
4884                 wl1271_set_band_rate(wl, wlvif);
4885                 wlvif->basic_rate =
4886                         wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4887                 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4888
4889                 wl1271_ps_elp_sleep(wl);
4890         }
4891 out:
4892         mutex_unlock(&wl->mutex);
4893
4894         return ret;
4895 }
4896
4897 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4898                                      struct ieee80211_channel_switch *ch_switch)
4899 {
4900         struct wl1271 *wl = hw->priv;
4901         struct wl12xx_vif *wlvif;
4902         int ret;
4903
4904         wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4905
4906         wl1271_tx_flush(wl);
4907
4908         mutex_lock(&wl->mutex);
4909
4910         if (unlikely(wl->state == WLCORE_STATE_OFF)) {
4911                 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4912                         struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4913                         ieee80211_chswitch_done(vif, false);
4914                 }
4915                 goto out;
4916         } else if (unlikely(wl->state != WLCORE_STATE_ON)) {
4917                 goto out;
4918         }
4919
4920         ret = wl1271_ps_elp_wakeup(wl);
4921         if (ret < 0)
4922                 goto out;
4923
4924         /* TODO: change mac80211 to pass vif as param */
4925         wl12xx_for_each_wlvif_sta(wl, wlvif) {
4926                 unsigned long delay_usec;
4927
4928                 ret = wl->ops->channel_switch(wl, wlvif, ch_switch);
4929                 if (ret)
4930                         goto out_sleep;
4931
4932                 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
4933
4934                 /* indicate failure 5 seconds after channel switch time */
4935                 delay_usec = ieee80211_tu_to_usec(wlvif->beacon_int) *
4936                              ch_switch->count;
4937                 ieee80211_queue_delayed_work(hw, &wlvif->channel_switch_work,
4938                                 usecs_to_jiffies(delay_usec) +
4939                                 msecs_to_jiffies(5000));
4940         }
4941
4942 out_sleep:
4943         wl1271_ps_elp_sleep(wl);
4944
4945 out:
4946         mutex_unlock(&wl->mutex);
4947 }
4948
4949 static void wlcore_op_flush(struct ieee80211_hw *hw, bool drop)
4950 {
4951         struct wl1271 *wl = hw->priv;
4952
4953         wl1271_tx_flush(wl);
4954 }
4955
4956 static int wlcore_op_remain_on_channel(struct ieee80211_hw *hw,
4957                                        struct ieee80211_vif *vif,
4958                                        struct ieee80211_channel *chan,
4959                                        int duration)
4960 {
4961         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4962         struct wl1271 *wl = hw->priv;
4963         int channel, ret = 0;
4964
4965         channel = ieee80211_frequency_to_channel(chan->center_freq);
4966
4967         wl1271_debug(DEBUG_MAC80211, "mac80211 roc %d (%d)",
4968                      channel, wlvif->role_id);
4969
4970         mutex_lock(&wl->mutex);
4971
4972         if (unlikely(wl->state != WLCORE_STATE_ON))
4973                 goto out;
4974
4975         /* return EBUSY if we can't ROC right now */
4976         if (WARN_ON(wl->roc_vif ||
4977                     find_first_bit(wl->roc_map,
4978                                    WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES)) {
4979                 ret = -EBUSY;
4980                 goto out;
4981         }
4982
4983         ret = wl1271_ps_elp_wakeup(wl);
4984         if (ret < 0)
4985                 goto out;
4986
4987         ret = wl12xx_start_dev(wl, wlvif, chan->band, channel);
4988         if (ret < 0)
4989                 goto out_sleep;
4990
4991         wl->roc_vif = vif;
4992         ieee80211_queue_delayed_work(hw, &wl->roc_complete_work,
4993                                      msecs_to_jiffies(duration));
4994 out_sleep:
4995         wl1271_ps_elp_sleep(wl);
4996 out:
4997         mutex_unlock(&wl->mutex);
4998         return ret;
4999 }
5000
5001 static int __wlcore_roc_completed(struct wl1271 *wl)
5002 {
5003         struct wl12xx_vif *wlvif;
5004         int ret;
5005
5006         /* already completed */
5007         if (unlikely(!wl->roc_vif))
5008                 return 0;
5009
5010         wlvif = wl12xx_vif_to_data(wl->roc_vif);
5011
5012         if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
5013                 return -EBUSY;
5014
5015         ret = wl12xx_stop_dev(wl, wlvif);
5016         if (ret < 0)
5017                 return ret;
5018
5019         wl->roc_vif = NULL;
5020
5021         return 0;
5022 }
5023
5024 static int wlcore_roc_completed(struct wl1271 *wl)
5025 {
5026         int ret;
5027
5028         wl1271_debug(DEBUG_MAC80211, "roc complete");
5029
5030         mutex_lock(&wl->mutex);
5031
5032         if (unlikely(wl->state != WLCORE_STATE_ON)) {
5033                 ret = -EBUSY;
5034                 goto out;
5035         }
5036
5037         ret = wl1271_ps_elp_wakeup(wl);
5038         if (ret < 0)
5039                 goto out;
5040
5041         ret = __wlcore_roc_completed(wl);
5042
5043         wl1271_ps_elp_sleep(wl);
5044 out:
5045         mutex_unlock(&wl->mutex);
5046
5047         return ret;
5048 }
5049
5050 static void wlcore_roc_complete_work(struct work_struct *work)
5051 {
5052         struct delayed_work *dwork;
5053         struct wl1271 *wl;
5054         int ret;
5055
5056         dwork = container_of(work, struct delayed_work, work);
5057         wl = container_of(dwork, struct wl1271, roc_complete_work);
5058
5059         ret = wlcore_roc_completed(wl);
5060         if (!ret)
5061                 ieee80211_remain_on_channel_expired(wl->hw);
5062 }
5063
5064 static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw *hw)
5065 {
5066         struct wl1271 *wl = hw->priv;
5067
5068         wl1271_debug(DEBUG_MAC80211, "mac80211 croc");
5069
5070         /* TODO: per-vif */
5071         wl1271_tx_flush(wl);
5072
5073         /*
5074          * we can't just flush_work here, because it might deadlock
5075          * (as we might get called from the same workqueue)
5076          */
5077         cancel_delayed_work_sync(&wl->roc_complete_work);
5078         wlcore_roc_completed(wl);
5079
5080         return 0;
5081 }
5082
5083 static void wlcore_op_sta_rc_update(struct ieee80211_hw *hw,
5084                                     struct ieee80211_vif *vif,
5085                                     struct ieee80211_sta *sta,
5086                                     u32 changed)
5087 {
5088         struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5089         struct wl1271 *wl = hw->priv;
5090
5091         wlcore_hw_sta_rc_update(wl, wlvif, sta, changed);
5092 }
5093
5094 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
5095 {
5096         struct wl1271 *wl = hw->priv;
5097         bool ret = false;
5098
5099         mutex_lock(&wl->mutex);
5100
5101         if (unlikely(wl->state != WLCORE_STATE_ON))
5102                 goto out;
5103
5104         /* packets are considered pending if in the TX queue or the FW */
5105         ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
5106 out:
5107         mutex_unlock(&wl->mutex);
5108
5109         return ret;
5110 }
5111
5112 /* can't be const, mac80211 writes to this */
5113 static struct ieee80211_rate wl1271_rates[] = {
5114         { .bitrate = 10,
5115           .hw_value = CONF_HW_BIT_RATE_1MBPS,
5116           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
5117         { .bitrate = 20,
5118           .hw_value = CONF_HW_BIT_RATE_2MBPS,
5119           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
5120           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5121         { .bitrate = 55,
5122           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
5123           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
5124           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5125         { .bitrate = 110,
5126           .hw_value = CONF_HW_BIT_RATE_11MBPS,
5127           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
5128           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5129         { .bitrate = 60,
5130           .hw_value = CONF_HW_BIT_RATE_6MBPS,
5131           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
5132         { .bitrate = 90,
5133           .hw_value = CONF_HW_BIT_RATE_9MBPS,
5134           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
5135         { .bitrate = 120,
5136           .hw_value = CONF_HW_BIT_RATE_12MBPS,
5137           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
5138         { .bitrate = 180,
5139           .hw_value = CONF_HW_BIT_RATE_18MBPS,
5140           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
5141         { .bitrate = 240,
5142           .hw_value = CONF_HW_BIT_RATE_24MBPS,
5143           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
5144         { .bitrate = 360,
5145          .hw_value = CONF_HW_BIT_RATE_36MBPS,
5146          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
5147         { .bitrate = 480,
5148           .hw_value = CONF_HW_BIT_RATE_48MBPS,
5149           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
5150         { .bitrate = 540,
5151           .hw_value = CONF_HW_BIT_RATE_54MBPS,
5152           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
5153 };
5154
5155 /* can't be const, mac80211 writes to this */
5156 static struct ieee80211_channel wl1271_channels[] = {
5157         { .hw_value = 1, .center_freq = 2412, .max_power = WLCORE_MAX_TXPWR },
5158         { .hw_value = 2, .center_freq = 2417, .max_power = WLCORE_MAX_TXPWR },
5159         { .hw_value = 3, .center_freq = 2422, .max_power = WLCORE_MAX_TXPWR },
5160         { .hw_value = 4, .center_freq = 2427, .max_power = WLCORE_MAX_TXPWR },
5161         { .hw_value = 5, .center_freq = 2432, .max_power = WLCORE_MAX_TXPWR },
5162         { .hw_value = 6, .center_freq = 2437, .max_power = WLCORE_MAX_TXPWR },
5163         { .hw_value = 7, .center_freq = 2442, .max_power = WLCORE_MAX_TXPWR },
5164         { .hw_value = 8, .center_freq = 2447, .max_power = WLCORE_MAX_TXPWR },
5165         { .hw_value = 9, .center_freq = 2452, .max_power = WLCORE_MAX_TXPWR },
5166         { .hw_value = 10, .center_freq = 2457, .max_power = WLCORE_MAX_TXPWR },
5167         { .hw_value = 11, .center_freq = 2462, .max_power = WLCORE_MAX_TXPWR },
5168         { .hw_value = 12, .center_freq = 2467, .max_power = WLCORE_MAX_TXPWR },
5169         { .hw_value = 13, .center_freq = 2472, .max_power = WLCORE_MAX_TXPWR },
5170         { .hw_value = 14, .center_freq = 2484, .max_power = WLCORE_MAX_TXPWR },
5171 };
5172
5173 /* can't be const, mac80211 writes to this */
5174 static struct ieee80211_supported_band wl1271_band_2ghz = {
5175         .channels = wl1271_channels,
5176         .n_channels = ARRAY_SIZE(wl1271_channels),
5177         .bitrates = wl1271_rates,
5178         .n_bitrates = ARRAY_SIZE(wl1271_rates),
5179 };
5180
5181 /* 5 GHz data rates for WL1273 */
5182 static struct ieee80211_rate wl1271_rates_5ghz[] = {
5183         { .bitrate = 60,
5184           .hw_value = CONF_HW_BIT_RATE_6MBPS,
5185           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
5186         { .bitrate = 90,
5187           .hw_value = CONF_HW_BIT_RATE_9MBPS,
5188           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
5189         { .bitrate = 120,
5190           .hw_value = CONF_HW_BIT_RATE_12MBPS,
5191           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
5192         { .bitrate = 180,
5193           .hw_value = CONF_HW_BIT_RATE_18MBPS,
5194           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
5195         { .bitrate = 240,
5196           .hw_value = CONF_HW_BIT_RATE_24MBPS,
5197           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
5198         { .bitrate = 360,
5199          .hw_value = CONF_HW_BIT_RATE_36MBPS,
5200          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
5201         { .bitrate = 480,
5202           .hw_value = CONF_HW_BIT_RATE_48MBPS,
5203           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
5204         { .bitrate = 540,
5205           .hw_value = CONF_HW_BIT_RATE_54MBPS,
5206           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
5207 };
5208
5209 /* 5 GHz band channels for WL1273 */
5210 static struct ieee80211_channel wl1271_channels_5ghz[] = {
5211         { .hw_value = 7, .center_freq = 5035, .max_power = WLCORE_MAX_TXPWR },
5212         { .hw_value = 8, .center_freq = 5040, .max_power = WLCORE_MAX_TXPWR },
5213         { .hw_value = 9, .center_freq = 5045, .max_power = WLCORE_MAX_TXPWR },
5214         { .hw_value = 11, .center_freq = 5055, .max_power = WLCORE_MAX_TXPWR },
5215         { .hw_value = 12, .center_freq = 5060, .max_power = WLCORE_MAX_TXPWR },
5216         { .hw_value = 16, .center_freq = 5080, .max_power = WLCORE_MAX_TXPWR },
5217         { .hw_value = 34, .center_freq = 5170, .max_power = WLCORE_MAX_TXPWR },
5218         { .hw_value = 36, .center_freq = 5180, .max_power = WLCORE_MAX_TXPWR },
5219         { .hw_value = 38, .center_freq = 5190, .max_power = WLCORE_MAX_TXPWR },
5220         { .hw_value = 40, .center_freq = 5200, .max_power = WLCORE_MAX_TXPWR },
5221         { .hw_value = 42, .center_freq = 5210, .max_power = WLCORE_MAX_TXPWR },
5222         { .hw_value = 44, .center_freq = 5220, .max_power = WLCORE_MAX_TXPWR },
5223         { .hw_value = 46, .center_freq = 5230, .max_power = WLCORE_MAX_TXPWR },
5224         { .hw_value = 48, .center_freq = 5240, .max_power = WLCORE_MAX_TXPWR },
5225         { .hw_value = 52, .center_freq = 5260, .max_power = WLCORE_MAX_TXPWR },
5226         { .hw_value = 56, .center_freq = 5280, .max_power = WLCORE_MAX_TXPWR },
5227         { .hw_value = 60, .center_freq = 5300, .max_power = WLCORE_MAX_TXPWR },
5228         { .hw_value = 64, .center_freq = 5320, .max_power = WLCORE_MAX_TXPWR },
5229         { .hw_value = 100, .center_freq = 5500, .max_power = WLCORE_MAX_TXPWR },
5230         { .hw_value = 104, .center_freq = 5520, .max_power = WLCORE_MAX_TXPWR },
5231         { .hw_value = 108, .center_freq = 5540, .max_power = WLCORE_MAX_TXPWR },
5232         { .hw_value = 112, .center_freq = 5560, .max_power = WLCORE_MAX_TXPWR },
5233         { .hw_value = 116, .center_freq = 5580, .max_power = WLCORE_MAX_TXPWR },
5234         { .hw_value = 120, .center_freq = 5600, .max_power = WLCORE_MAX_TXPWR },
5235         { .hw_value = 124, .center_freq = 5620, .max_power = WLCORE_MAX_TXPWR },
5236         { .hw_value = 128, .center_freq = 5640, .max_power = WLCORE_MAX_TXPWR },
5237         { .hw_value = 132, .center_freq = 5660, .max_power = WLCORE_MAX_TXPWR },
5238         { .hw_value = 136, .center_freq = 5680, .max_power = WLCORE_MAX_TXPWR },
5239         { .hw_value = 140, .center_freq = 5700, .max_power = WLCORE_MAX_TXPWR },
5240         { .hw_value = 149, .center_freq = 5745, .max_power = WLCORE_MAX_TXPWR },
5241         { .hw_value = 153, .center_freq = 5765, .max_power = WLCORE_MAX_TXPWR },
5242         { .hw_value = 157, .center_freq = 5785, .max_power = WLCORE_MAX_TXPWR },
5243         { .hw_value = 161, .center_freq = 5805, .max_power = WLCORE_MAX_TXPWR },
5244         { .hw_value = 165, .center_freq = 5825, .max_power = WLCORE_MAX_TXPWR },
5245 };
5246
5247 static struct ieee80211_supported_band wl1271_band_5ghz = {
5248         .channels = wl1271_channels_5ghz,
5249         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
5250         .bitrates = wl1271_rates_5ghz,
5251         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
5252 };
5253
5254 static const struct ieee80211_ops wl1271_ops = {
5255         .start = wl1271_op_start,
5256         .stop = wlcore_op_stop,
5257         .add_interface = wl1271_op_add_interface,
5258         .remove_interface = wl1271_op_remove_interface,
5259         .change_interface = wl12xx_op_change_interface,
5260 #ifdef CONFIG_PM
5261         .suspend = wl1271_op_suspend,
5262         .resume = wl1271_op_resume,
5263 #endif
5264         .config = wl1271_op_config,
5265         .prepare_multicast = wl1271_op_prepare_multicast,
5266         .configure_filter = wl1271_op_configure_filter,
5267         .tx = wl1271_op_tx,
5268         .set_key = wlcore_op_set_key,
5269         .hw_scan = wl1271_op_hw_scan,
5270         .cancel_hw_scan = wl1271_op_cancel_hw_scan,
5271         .sched_scan_start = wl1271_op_sched_scan_start,
5272         .sched_scan_stop = wl1271_op_sched_scan_stop,
5273         .bss_info_changed = wl1271_op_bss_info_changed,
5274         .set_frag_threshold = wl1271_op_set_frag_threshold,
5275         .set_rts_threshold = wl1271_op_set_rts_threshold,
5276         .conf_tx = wl1271_op_conf_tx,
5277         .get_tsf = wl1271_op_get_tsf,
5278         .get_survey = wl1271_op_get_survey,
5279         .sta_state = wl12xx_op_sta_state,
5280         .ampdu_action = wl1271_op_ampdu_action,
5281         .tx_frames_pending = wl1271_tx_frames_pending,
5282         .set_bitrate_mask = wl12xx_set_bitrate_mask,
5283         .channel_switch = wl12xx_op_channel_switch,
5284         .flush = wlcore_op_flush,
5285         .remain_on_channel = wlcore_op_remain_on_channel,
5286         .cancel_remain_on_channel = wlcore_op_cancel_remain_on_channel,
5287         .add_chanctx = wlcore_op_add_chanctx,
5288         .remove_chanctx = wlcore_op_remove_chanctx,
5289         .change_chanctx = wlcore_op_change_chanctx,
5290         .assign_vif_chanctx = wlcore_op_assign_vif_chanctx,
5291         .unassign_vif_chanctx = wlcore_op_unassign_vif_chanctx,
5292         .sta_rc_update = wlcore_op_sta_rc_update,
5293         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
5294 };
5295
5296
5297 u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band)
5298 {
5299         u8 idx;
5300
5301         BUG_ON(band >= 2);
5302
5303         if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
5304                 wl1271_error("Illegal RX rate from HW: %d", rate);
5305                 return 0;
5306         }
5307
5308         idx = wl->band_rate_to_idx[band][rate];
5309         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
5310                 wl1271_error("Unsupported RX rate from HW: %d", rate);
5311                 return 0;
5312         }
5313
5314         return idx;
5315 }
5316
5317 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
5318                                                struct device_attribute *attr,
5319                                                char *buf)
5320 {
5321         struct wl1271 *wl = dev_get_drvdata(dev);
5322         ssize_t len;
5323
5324         len = PAGE_SIZE;
5325
5326         mutex_lock(&wl->mutex);
5327         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
5328                        wl->sg_enabled);
5329         mutex_unlock(&wl->mutex);
5330
5331         return len;
5332
5333 }
5334
5335 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
5336                                                 struct device_attribute *attr,
5337                                                 const char *buf, size_t count)
5338 {
5339         struct wl1271 *wl = dev_get_drvdata(dev);
5340         unsigned long res;
5341         int ret;
5342
5343         ret = kstrtoul(buf, 10, &res);
5344         if (ret < 0) {
5345                 wl1271_warning("incorrect value written to bt_coex_mode");
5346                 return count;
5347         }
5348
5349         mutex_lock(&wl->mutex);
5350
5351         res = !!res;
5352
5353         if (res == wl->sg_enabled)
5354                 goto out;
5355
5356         wl->sg_enabled = res;
5357
5358         if (unlikely(wl->state != WLCORE_STATE_ON))
5359                 goto out;
5360
5361         ret = wl1271_ps_elp_wakeup(wl);
5362         if (ret < 0)
5363                 goto out;
5364
5365         wl1271_acx_sg_enable(wl, wl->sg_enabled);
5366         wl1271_ps_elp_sleep(wl);
5367
5368  out:
5369         mutex_unlock(&wl->mutex);
5370         return count;
5371 }
5372
5373 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
5374                    wl1271_sysfs_show_bt_coex_state,
5375                    wl1271_sysfs_store_bt_coex_state);
5376
5377 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
5378                                            struct device_attribute *attr,
5379                                            char *buf)
5380 {
5381         struct wl1271 *wl = dev_get_drvdata(dev);
5382         ssize_t len;
5383
5384         len = PAGE_SIZE;
5385
5386         mutex_lock(&wl->mutex);
5387         if (wl->hw_pg_ver >= 0)
5388                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
5389         else
5390                 len = snprintf(buf, len, "n/a\n");
5391         mutex_unlock(&wl->mutex);
5392
5393         return len;
5394 }
5395
5396 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
5397                    wl1271_sysfs_show_hw_pg_ver, NULL);
5398
5399 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
5400                                        struct bin_attribute *bin_attr,
5401                                        char *buffer, loff_t pos, size_t count)
5402 {
5403         struct device *dev = container_of(kobj, struct device, kobj);
5404         struct wl1271 *wl = dev_get_drvdata(dev);
5405         ssize_t len;
5406         int ret;
5407
5408         ret = mutex_lock_interruptible(&wl->mutex);
5409         if (ret < 0)
5410                 return -ERESTARTSYS;
5411
5412         /* Let only one thread read the log at a time, blocking others */
5413         while (wl->fwlog_size == 0) {
5414                 DEFINE_WAIT(wait);
5415
5416                 prepare_to_wait_exclusive(&wl->fwlog_waitq,
5417                                           &wait,
5418                                           TASK_INTERRUPTIBLE);
5419
5420                 if (wl->fwlog_size != 0) {
5421                         finish_wait(&wl->fwlog_waitq, &wait);
5422                         break;
5423                 }
5424
5425                 mutex_unlock(&wl->mutex);
5426
5427                 schedule();
5428                 finish_wait(&wl->fwlog_waitq, &wait);
5429
5430                 if (signal_pending(current))
5431                         return -ERESTARTSYS;
5432
5433                 ret = mutex_lock_interruptible(&wl->mutex);
5434                 if (ret < 0)
5435                         return -ERESTARTSYS;
5436         }
5437
5438         /* Check if the fwlog is still valid */
5439         if (wl->fwlog_size < 0) {
5440                 mutex_unlock(&wl->mutex);
5441                 return 0;
5442         }
5443
5444         /* Seeking is not supported - old logs are not kept. Disregard pos. */
5445         len = min(count, (size_t)wl->fwlog_size);
5446         wl->fwlog_size -= len;
5447         memcpy(buffer, wl->fwlog, len);
5448
5449         /* Make room for new messages */
5450         memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
5451
5452         mutex_unlock(&wl->mutex);
5453
5454         return len;
5455 }
5456
5457 static struct bin_attribute fwlog_attr = {
5458         .attr = {.name = "fwlog", .mode = S_IRUSR},
5459         .read = wl1271_sysfs_read_fwlog,
5460 };
5461
5462 static void wl12xx_derive_mac_addresses(struct wl1271 *wl, u32 oui, u32 nic)
5463 {
5464         int i;
5465
5466         wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x",
5467                      oui, nic);
5468
5469         if (nic + WLCORE_NUM_MAC_ADDRESSES - wl->num_mac_addr > 0xffffff)
5470                 wl1271_warning("NIC part of the MAC address wraps around!");
5471
5472         for (i = 0; i < wl->num_mac_addr; i++) {
5473                 wl->addresses[i].addr[0] = (u8)(oui >> 16);
5474                 wl->addresses[i].addr[1] = (u8)(oui >> 8);
5475                 wl->addresses[i].addr[2] = (u8) oui;
5476                 wl->addresses[i].addr[3] = (u8)(nic >> 16);
5477                 wl->addresses[i].addr[4] = (u8)(nic >> 8);
5478                 wl->addresses[i].addr[5] = (u8) nic;
5479                 nic++;
5480         }
5481
5482         /* we may be one address short at the most */
5483         WARN_ON(wl->num_mac_addr + 1 < WLCORE_NUM_MAC_ADDRESSES);
5484
5485         /*
5486          * turn on the LAA bit in the first address and use it as
5487          * the last address.
5488          */
5489         if (wl->num_mac_addr < WLCORE_NUM_MAC_ADDRESSES) {
5490                 int idx = WLCORE_NUM_MAC_ADDRESSES - 1;
5491                 memcpy(&wl->addresses[idx], &wl->addresses[0],
5492                        sizeof(wl->addresses[0]));
5493                 /* LAA bit */
5494                 wl->addresses[idx].addr[2] |= BIT(1);
5495         }
5496
5497         wl->hw->wiphy->n_addresses = WLCORE_NUM_MAC_ADDRESSES;
5498         wl->hw->wiphy->addresses = wl->addresses;
5499 }
5500
5501 static int wl12xx_get_hw_info(struct wl1271 *wl)
5502 {
5503         int ret;
5504
5505         ret = wl12xx_set_power_on(wl);
5506         if (ret < 0)
5507                 return ret;
5508
5509         ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &wl->chip.id);
5510         if (ret < 0)
5511                 goto out;
5512
5513         wl->fuse_oui_addr = 0;
5514         wl->fuse_nic_addr = 0;
5515
5516         ret = wl->ops->get_pg_ver(wl, &wl->hw_pg_ver);
5517         if (ret < 0)
5518                 goto out;
5519
5520         if (wl->ops->get_mac)
5521                 ret = wl->ops->get_mac(wl);
5522
5523 out:
5524         wl1271_power_off(wl);
5525         return ret;
5526 }
5527
5528 static int wl1271_register_hw(struct wl1271 *wl)
5529 {
5530         int ret;
5531         u32 oui_addr = 0, nic_addr = 0;
5532
5533         if (wl->mac80211_registered)
5534                 return 0;
5535
5536         if (wl->nvs_len >= 12) {
5537                 /* NOTE: The wl->nvs->nvs element must be first, in
5538                  * order to simplify the casting, we assume it is at
5539                  * the beginning of the wl->nvs structure.
5540                  */
5541                 u8 *nvs_ptr = (u8 *)wl->nvs;
5542
5543                 oui_addr =
5544                         (nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6];
5545                 nic_addr =
5546                         (nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3];
5547         }
5548
5549         /* if the MAC address is zeroed in the NVS derive from fuse */
5550         if (oui_addr == 0 && nic_addr == 0) {
5551                 oui_addr = wl->fuse_oui_addr;
5552                 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
5553                 nic_addr = wl->fuse_nic_addr + 1;
5554         }
5555
5556         wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr);
5557
5558         ret = ieee80211_register_hw(wl->hw);
5559         if (ret < 0) {
5560                 wl1271_error("unable to register mac80211 hw: %d", ret);
5561                 goto out;
5562         }
5563
5564         wl->mac80211_registered = true;
5565
5566         wl1271_debugfs_init(wl);
5567
5568         wl1271_notice("loaded");
5569
5570 out:
5571         return ret;
5572 }
5573
5574 static void wl1271_unregister_hw(struct wl1271 *wl)
5575 {
5576         if (wl->plt)
5577                 wl1271_plt_stop(wl);
5578
5579         ieee80211_unregister_hw(wl->hw);
5580         wl->mac80211_registered = false;
5581
5582 }
5583
5584 static const struct ieee80211_iface_limit wlcore_iface_limits[] = {
5585         {
5586                 .max = 3,
5587                 .types = BIT(NL80211_IFTYPE_STATION),
5588         },
5589         {
5590                 .max = 1,
5591                 .types = BIT(NL80211_IFTYPE_AP) |
5592                          BIT(NL80211_IFTYPE_P2P_GO) |
5593                          BIT(NL80211_IFTYPE_P2P_CLIENT),
5594         },
5595 };
5596
5597 static struct ieee80211_iface_combination
5598 wlcore_iface_combinations[] = {
5599         {
5600           .max_interfaces = 3,
5601           .limits = wlcore_iface_limits,
5602           .n_limits = ARRAY_SIZE(wlcore_iface_limits),
5603         },
5604 };
5605
5606 static int wl1271_init_ieee80211(struct wl1271 *wl)
5607 {
5608         int i;
5609         static const u32 cipher_suites[] = {
5610                 WLAN_CIPHER_SUITE_WEP40,
5611                 WLAN_CIPHER_SUITE_WEP104,
5612                 WLAN_CIPHER_SUITE_TKIP,
5613                 WLAN_CIPHER_SUITE_CCMP,
5614                 WL1271_CIPHER_SUITE_GEM,
5615         };
5616
5617         /* The tx descriptor buffer */
5618         wl->hw->extra_tx_headroom = sizeof(struct wl1271_tx_hw_descr);
5619
5620         if (wl->quirks & WLCORE_QUIRK_TKIP_HEADER_SPACE)
5621                 wl->hw->extra_tx_headroom += WL1271_EXTRA_SPACE_TKIP;
5622
5623         /* unit us */
5624         /* FIXME: find a proper value */
5625         wl->hw->channel_change_time = 10000;
5626         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
5627
5628         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
5629                 IEEE80211_HW_SUPPORTS_PS |
5630                 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
5631                 IEEE80211_HW_SUPPORTS_UAPSD |
5632                 IEEE80211_HW_HAS_RATE_CONTROL |
5633                 IEEE80211_HW_CONNECTION_MONITOR |
5634                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
5635                 IEEE80211_HW_SPECTRUM_MGMT |
5636                 IEEE80211_HW_AP_LINK_PS |
5637                 IEEE80211_HW_AMPDU_AGGREGATION |
5638                 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW |
5639                 IEEE80211_HW_QUEUE_CONTROL;
5640
5641         wl->hw->wiphy->cipher_suites = cipher_suites;
5642         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
5643
5644         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
5645                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
5646                 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
5647         wl->hw->wiphy->max_scan_ssids = 1;
5648         wl->hw->wiphy->max_sched_scan_ssids = 16;
5649         wl->hw->wiphy->max_match_sets = 16;
5650         /*
5651          * Maximum length of elements in scanning probe request templates
5652          * should be the maximum length possible for a template, without
5653          * the IEEE80211 header of the template
5654          */
5655         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5656                         sizeof(struct ieee80211_header);
5657
5658         wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5659                 sizeof(struct ieee80211_header);
5660
5661         wl->hw->wiphy->max_remain_on_channel_duration = 5000;
5662
5663         wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
5664                                 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
5665
5666         /* make sure all our channels fit in the scanned_ch bitmask */
5667         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
5668                      ARRAY_SIZE(wl1271_channels_5ghz) >
5669                      WL1271_MAX_CHANNELS);
5670         /*
5671         * clear channel flags from the previous usage
5672         * and restore max_power & max_antenna_gain values.
5673         */
5674         for (i = 0; i < ARRAY_SIZE(wl1271_channels); i++) {
5675                 wl1271_band_2ghz.channels[i].flags = 0;
5676                 wl1271_band_2ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
5677                 wl1271_band_2ghz.channels[i].max_antenna_gain = 0;
5678         }
5679
5680         for (i = 0; i < ARRAY_SIZE(wl1271_channels_5ghz); i++) {
5681                 wl1271_band_5ghz.channels[i].flags = 0;
5682                 wl1271_band_5ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
5683                 wl1271_band_5ghz.channels[i].max_antenna_gain = 0;
5684         }
5685
5686         /*
5687          * We keep local copies of the band structs because we need to
5688          * modify them on a per-device basis.
5689          */
5690         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
5691                sizeof(wl1271_band_2ghz));
5692         memcpy(&wl->bands[IEEE80211_BAND_2GHZ].ht_cap,
5693                &wl->ht_cap[IEEE80211_BAND_2GHZ],
5694                sizeof(*wl->ht_cap));
5695         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
5696                sizeof(wl1271_band_5ghz));
5697         memcpy(&wl->bands[IEEE80211_BAND_5GHZ].ht_cap,
5698                &wl->ht_cap[IEEE80211_BAND_5GHZ],
5699                sizeof(*wl->ht_cap));
5700
5701         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
5702                 &wl->bands[IEEE80211_BAND_2GHZ];
5703         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
5704                 &wl->bands[IEEE80211_BAND_5GHZ];
5705
5706         /*
5707          * allow 4 queues per mac address we support +
5708          * 1 cab queue per mac + one global offchannel Tx queue
5709          */
5710         wl->hw->queues = (NUM_TX_QUEUES + 1) * WLCORE_NUM_MAC_ADDRESSES + 1;
5711
5712         /* the last queue is the offchannel queue */
5713         wl->hw->offchannel_tx_hw_queue = wl->hw->queues - 1;
5714         wl->hw->max_rates = 1;
5715
5716         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
5717
5718         /* the FW answers probe-requests in AP-mode */
5719         wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
5720         wl->hw->wiphy->probe_resp_offload =
5721                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
5722                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
5723                 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
5724
5725         /* allowed interface combinations */
5726         wlcore_iface_combinations[0].num_different_channels = wl->num_channels;
5727         wl->hw->wiphy->iface_combinations = wlcore_iface_combinations;
5728         wl->hw->wiphy->n_iface_combinations =
5729                 ARRAY_SIZE(wlcore_iface_combinations);
5730
5731         SET_IEEE80211_DEV(wl->hw, wl->dev);
5732
5733         wl->hw->sta_data_size = sizeof(struct wl1271_station);
5734         wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
5735
5736         wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size;
5737
5738         return 0;
5739 }
5740
5741 #define WL1271_DEFAULT_CHANNEL 0
5742
5743 struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size, u32 aggr_buf_size,
5744                                      u32 mbox_size)
5745 {
5746         struct ieee80211_hw *hw;
5747         struct wl1271 *wl;
5748         int i, j, ret;
5749         unsigned int order;
5750
5751         BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
5752
5753         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
5754         if (!hw) {
5755                 wl1271_error("could not alloc ieee80211_hw");
5756                 ret = -ENOMEM;
5757                 goto err_hw_alloc;
5758         }
5759
5760         wl = hw->priv;
5761         memset(wl, 0, sizeof(*wl));
5762
5763         wl->priv = kzalloc(priv_size, GFP_KERNEL);
5764         if (!wl->priv) {
5765                 wl1271_error("could not alloc wl priv");
5766                 ret = -ENOMEM;
5767                 goto err_priv_alloc;
5768         }
5769
5770         INIT_LIST_HEAD(&wl->wlvif_list);
5771
5772         wl->hw = hw;
5773
5774         for (i = 0; i < NUM_TX_QUEUES; i++)
5775                 for (j = 0; j < WL12XX_MAX_LINKS; j++)
5776                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
5777
5778         skb_queue_head_init(&wl->deferred_rx_queue);
5779         skb_queue_head_init(&wl->deferred_tx_queue);
5780
5781         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
5782         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
5783         INIT_WORK(&wl->tx_work, wl1271_tx_work);
5784         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5785         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
5786         INIT_DELAYED_WORK(&wl->roc_complete_work, wlcore_roc_complete_work);
5787         INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
5788
5789         wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5790         if (!wl->freezable_wq) {
5791                 ret = -ENOMEM;
5792                 goto err_hw;
5793         }
5794
5795         wl->channel = WL1271_DEFAULT_CHANNEL;
5796         wl->rx_counter = 0;
5797         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
5798         wl->band = IEEE80211_BAND_2GHZ;
5799         wl->channel_type = NL80211_CHAN_NO_HT;
5800         wl->flags = 0;
5801         wl->sg_enabled = true;
5802         wl->sleep_auth = WL1271_PSM_ILLEGAL;
5803         wl->recovery_count = 0;
5804         wl->hw_pg_ver = -1;
5805         wl->ap_ps_map = 0;
5806         wl->ap_fw_ps_map = 0;
5807         wl->quirks = 0;
5808         wl->platform_quirks = 0;
5809         wl->system_hlid = WL12XX_SYSTEM_HLID;
5810         wl->active_sta_count = 0;
5811         wl->active_link_count = 0;
5812         wl->fwlog_size = 0;
5813         init_waitqueue_head(&wl->fwlog_waitq);
5814
5815         /* The system link is always allocated */
5816         __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5817
5818         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
5819         for (i = 0; i < wl->num_tx_desc; i++)
5820                 wl->tx_frames[i] = NULL;
5821
5822         spin_lock_init(&wl->wl_lock);
5823
5824         wl->state = WLCORE_STATE_OFF;
5825         wl->fw_type = WL12XX_FW_TYPE_NONE;
5826         mutex_init(&wl->mutex);
5827         mutex_init(&wl->flush_mutex);
5828         init_completion(&wl->nvs_loading_complete);
5829
5830         order = get_order(aggr_buf_size);
5831         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5832         if (!wl->aggr_buf) {
5833                 ret = -ENOMEM;
5834                 goto err_wq;
5835         }
5836         wl->aggr_buf_size = aggr_buf_size;
5837
5838         wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5839         if (!wl->dummy_packet) {
5840                 ret = -ENOMEM;
5841                 goto err_aggr;
5842         }
5843
5844         /* Allocate one page for the FW log */
5845         wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5846         if (!wl->fwlog) {
5847                 ret = -ENOMEM;
5848                 goto err_dummy_packet;
5849         }
5850
5851         wl->mbox_size = mbox_size;
5852         wl->mbox = kmalloc(wl->mbox_size, GFP_KERNEL | GFP_DMA);
5853         if (!wl->mbox) {
5854                 ret = -ENOMEM;
5855                 goto err_fwlog;
5856         }
5857
5858         wl->buffer_32 = kmalloc(sizeof(*wl->buffer_32), GFP_KERNEL);
5859         if (!wl->buffer_32) {
5860                 ret = -ENOMEM;
5861                 goto err_mbox;
5862         }
5863
5864         return hw;
5865
5866 err_mbox:
5867         kfree(wl->mbox);
5868
5869 err_fwlog:
5870         free_page((unsigned long)wl->fwlog);
5871
5872 err_dummy_packet:
5873         dev_kfree_skb(wl->dummy_packet);
5874
5875 err_aggr:
5876         free_pages((unsigned long)wl->aggr_buf, order);
5877
5878 err_wq:
5879         destroy_workqueue(wl->freezable_wq);
5880
5881 err_hw:
5882         wl1271_debugfs_exit(wl);
5883         kfree(wl->priv);
5884
5885 err_priv_alloc:
5886         ieee80211_free_hw(hw);
5887
5888 err_hw_alloc:
5889
5890         return ERR_PTR(ret);
5891 }
5892 EXPORT_SYMBOL_GPL(wlcore_alloc_hw);
5893
5894 int wlcore_free_hw(struct wl1271 *wl)
5895 {
5896         /* Unblock any fwlog readers */
5897         mutex_lock(&wl->mutex);
5898         wl->fwlog_size = -1;
5899         wake_up_interruptible_all(&wl->fwlog_waitq);
5900         mutex_unlock(&wl->mutex);
5901
5902         device_remove_bin_file(wl->dev, &fwlog_attr);
5903
5904         device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5905
5906         device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5907         kfree(wl->buffer_32);
5908         kfree(wl->mbox);
5909         free_page((unsigned long)wl->fwlog);
5910         dev_kfree_skb(wl->dummy_packet);
5911         free_pages((unsigned long)wl->aggr_buf, get_order(wl->aggr_buf_size));
5912
5913         wl1271_debugfs_exit(wl);
5914
5915         vfree(wl->fw);
5916         wl->fw = NULL;
5917         wl->fw_type = WL12XX_FW_TYPE_NONE;
5918         kfree(wl->nvs);
5919         wl->nvs = NULL;
5920
5921         kfree(wl->fw_status_1);
5922         kfree(wl->tx_res_if);
5923         destroy_workqueue(wl->freezable_wq);
5924
5925         kfree(wl->priv);
5926         ieee80211_free_hw(wl->hw);
5927
5928         return 0;
5929 }
5930 EXPORT_SYMBOL_GPL(wlcore_free_hw);
5931
5932 static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
5933 {
5934         struct wl1271 *wl = cookie;
5935         unsigned long flags;
5936
5937         wl1271_debug(DEBUG_IRQ, "IRQ");
5938
5939         /* complete the ELP completion */
5940         spin_lock_irqsave(&wl->wl_lock, flags);
5941         set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
5942         if (wl->elp_compl) {
5943                 complete(wl->elp_compl);
5944                 wl->elp_compl = NULL;
5945         }
5946
5947         if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
5948                 /* don't enqueue a work right now. mark it as pending */
5949                 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
5950                 wl1271_debug(DEBUG_IRQ, "should not enqueue work");
5951                 disable_irq_nosync(wl->irq);
5952                 pm_wakeup_event(wl->dev, 0);
5953                 spin_unlock_irqrestore(&wl->wl_lock, flags);
5954                 return IRQ_HANDLED;
5955         }
5956         spin_unlock_irqrestore(&wl->wl_lock, flags);
5957
5958         return IRQ_WAKE_THREAD;
5959 }
5960
5961 static void wlcore_nvs_cb(const struct firmware *fw, void *context)
5962 {
5963         struct wl1271 *wl = context;
5964         struct platform_device *pdev = wl->pdev;
5965         struct wlcore_platdev_data *pdev_data = pdev->dev.platform_data;
5966         struct wl12xx_platform_data *pdata = pdev_data->pdata;
5967         unsigned long irqflags;
5968         int ret;
5969
5970         if (fw) {
5971                 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
5972                 if (!wl->nvs) {
5973                         wl1271_error("Could not allocate nvs data");
5974                         goto out;
5975                 }
5976                 wl->nvs_len = fw->size;
5977         } else {
5978                 wl1271_debug(DEBUG_BOOT, "Could not get nvs file %s",
5979                              WL12XX_NVS_NAME);
5980                 wl->nvs = NULL;
5981                 wl->nvs_len = 0;
5982         }
5983
5984         ret = wl->ops->setup(wl);
5985         if (ret < 0)
5986                 goto out_free_nvs;
5987
5988         BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS);
5989
5990         /* adjust some runtime configuration parameters */
5991         wlcore_adjust_conf(wl);
5992
5993         wl->irq = platform_get_irq(pdev, 0);
5994         wl->platform_quirks = pdata->platform_quirks;
5995         wl->if_ops = pdev_data->if_ops;
5996
5997         if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
5998                 irqflags = IRQF_TRIGGER_RISING;
5999         else
6000                 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
6001
6002         ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wlcore_irq,
6003                                    irqflags,
6004                                    pdev->name, wl);
6005         if (ret < 0) {
6006                 wl1271_error("request_irq() failed: %d", ret);
6007                 goto out_free_nvs;
6008         }
6009
6010 #ifdef CONFIG_PM
6011         ret = enable_irq_wake(wl->irq);
6012         if (!ret) {
6013                 wl->irq_wake_enabled = true;
6014                 device_init_wakeup(wl->dev, 1);
6015                 if (pdata->pwr_in_suspend) {
6016                         wl->hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
6017                         wl->hw->wiphy->wowlan.n_patterns =
6018                                 WL1271_MAX_RX_FILTERS;
6019                         wl->hw->wiphy->wowlan.pattern_min_len = 1;
6020                         wl->hw->wiphy->wowlan.pattern_max_len =
6021                                 WL1271_RX_FILTER_MAX_PATTERN_SIZE;
6022                 }
6023         }
6024 #endif
6025         disable_irq(wl->irq);
6026
6027         ret = wl12xx_get_hw_info(wl);
6028         if (ret < 0) {
6029                 wl1271_error("couldn't get hw info");
6030                 goto out_irq;
6031         }
6032
6033         ret = wl->ops->identify_chip(wl);
6034         if (ret < 0)
6035                 goto out_irq;
6036
6037         ret = wl1271_init_ieee80211(wl);
6038         if (ret)
6039                 goto out_irq;
6040
6041         ret = wl1271_register_hw(wl);
6042         if (ret)
6043                 goto out_irq;
6044
6045         /* Create sysfs file to control bt coex state */
6046         ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
6047         if (ret < 0) {
6048                 wl1271_error("failed to create sysfs file bt_coex_state");
6049                 goto out_unreg;
6050         }
6051
6052         /* Create sysfs file to get HW PG version */
6053         ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
6054         if (ret < 0) {
6055                 wl1271_error("failed to create sysfs file hw_pg_ver");
6056                 goto out_bt_coex_state;
6057         }
6058
6059         /* Create sysfs file for the FW log */
6060         ret = device_create_bin_file(wl->dev, &fwlog_attr);
6061         if (ret < 0) {
6062                 wl1271_error("failed to create sysfs file fwlog");
6063                 goto out_hw_pg_ver;
6064         }
6065
6066         wl->initialized = true;
6067         goto out;
6068
6069 out_hw_pg_ver:
6070         device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
6071
6072 out_bt_coex_state:
6073         device_remove_file(wl->dev, &dev_attr_bt_coex_state);
6074
6075 out_unreg:
6076         wl1271_unregister_hw(wl);
6077
6078 out_irq:
6079         free_irq(wl->irq, wl);
6080
6081 out_free_nvs:
6082         kfree(wl->nvs);
6083
6084 out:
6085         release_firmware(fw);
6086         complete_all(&wl->nvs_loading_complete);
6087 }
6088
6089 int wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
6090 {
6091         int ret;
6092
6093         if (!wl->ops || !wl->ptable)
6094                 return -EINVAL;
6095
6096         wl->dev = &pdev->dev;
6097         wl->pdev = pdev;
6098         platform_set_drvdata(pdev, wl);
6099
6100         ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
6101                                       WL12XX_NVS_NAME, &pdev->dev, GFP_KERNEL,
6102                                       wl, wlcore_nvs_cb);
6103         if (ret < 0) {
6104                 wl1271_error("request_firmware_nowait failed: %d", ret);
6105                 complete_all(&wl->nvs_loading_complete);
6106         }
6107
6108         return ret;
6109 }
6110 EXPORT_SYMBOL_GPL(wlcore_probe);
6111
6112 int wlcore_remove(struct platform_device *pdev)
6113 {
6114         struct wl1271 *wl = platform_get_drvdata(pdev);
6115
6116         wait_for_completion(&wl->nvs_loading_complete);
6117         if (!wl->initialized)
6118                 return 0;
6119
6120         if (wl->irq_wake_enabled) {
6121                 device_init_wakeup(wl->dev, 0);
6122                 disable_irq_wake(wl->irq);
6123         }
6124         wl1271_unregister_hw(wl);
6125         free_irq(wl->irq, wl);
6126         wlcore_free_hw(wl);
6127
6128         return 0;
6129 }
6130 EXPORT_SYMBOL_GPL(wlcore_remove);
6131
6132 u32 wl12xx_debug_level = DEBUG_NONE;
6133 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
6134 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
6135 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
6136
6137 module_param_named(fwlog, fwlog_param, charp, 0);
6138 MODULE_PARM_DESC(fwlog,
6139                  "FW logger options: continuous, ondemand, dbgpins or disable");
6140
6141 module_param(bug_on_recovery, int, S_IRUSR | S_IWUSR);
6142 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
6143
6144 module_param(no_recovery, int, S_IRUSR | S_IWUSR);
6145 MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck.");
6146
6147 MODULE_LICENSE("GPL");
6148 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
6149 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
6150 MODULE_FIRMWARE(WL12XX_NVS_NAME);