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

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