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

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