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

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