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