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