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

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