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

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