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

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