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) 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 3315 wlvif->ap.recorded_keys[i] = ap_key; 3316 return 0; 3317 } 3318 3319 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif) 3320 { 3321 int i; 3322 3323 for (i = 0; i < MAX_NUM_KEYS; i++) { 3324 kfree(wlvif->ap.recorded_keys[i]); 3325 wlvif->ap.recorded_keys[i] = NULL; 3326 } 3327 } 3328 3329 static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif) 3330 { 3331 int i, ret = 0; 3332 struct wl1271_ap_key *key; 3333 bool wep_key_added = false; 3334 3335 for (i = 0; i < MAX_NUM_KEYS; i++) { 3336 u8 hlid; 3337 if (wlvif->ap.recorded_keys[i] == NULL) 3338 break; 3339 3340 key = wlvif->ap.recorded_keys[i]; 3341 hlid = key->hlid; 3342 if (hlid == WL12XX_INVALID_LINK_ID) 3343 hlid = wlvif->ap.bcast_hlid; 3344 3345 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE, 3346 key->id, key->key_type, 3347 key->key_size, key->key, 3348 hlid, key->tx_seq_32, 3349 key->tx_seq_16); 3350 if (ret < 0) 3351 goto out; 3352 3353 if (key->key_type == KEY_WEP) 3354 wep_key_added = true; 3355 } 3356 3357 if (wep_key_added) { 3358 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key, 3359 wlvif->ap.bcast_hlid); 3360 if (ret < 0) 3361 goto out; 3362 } 3363 3364 out: 3365 wl1271_free_ap_keys(wl, wlvif); 3366 return ret; 3367 } 3368 3369 static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif, 3370 u16 action, u8 id, u8 key_type, 3371 u8 key_size, const u8 *key, u32 tx_seq_32, 3372 u16 tx_seq_16, struct ieee80211_sta *sta) 3373 { 3374 int ret; 3375 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 3376 3377 if (is_ap) { 3378 struct wl1271_station *wl_sta; 3379 u8 hlid; 3380 3381 if (sta) { 3382 wl_sta = (struct wl1271_station *)sta->drv_priv; 3383 hlid = wl_sta->hlid; 3384 } else { 3385 hlid = wlvif->ap.bcast_hlid; 3386 } 3387 3388 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) { 3389 /* 3390 * We do not support removing keys after AP shutdown. 3391 * Pretend we do to make mac80211 happy. 3392 */ 3393 if (action != KEY_ADD_OR_REPLACE) 3394 return 0; 3395 3396 ret = wl1271_record_ap_key(wl, wlvif, id, 3397 key_type, key_size, 3398 key, hlid, tx_seq_32, 3399 tx_seq_16); 3400 } else { 3401 ret = wl1271_cmd_set_ap_key(wl, wlvif, action, 3402 id, key_type, key_size, 3403 key, hlid, tx_seq_32, 3404 tx_seq_16); 3405 } 3406 3407 if (ret < 0) 3408 return ret; 3409 } else { 3410 const u8 *addr; 3411 static const u8 bcast_addr[ETH_ALEN] = { 3412 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 3413 }; 3414 3415 addr = sta ? sta->addr : bcast_addr; 3416 3417 if (is_zero_ether_addr(addr)) { 3418 /* We dont support TX only encryption */ 3419 return -EOPNOTSUPP; 3420 } 3421 3422 /* The wl1271 does not allow to remove unicast keys - they 3423 will be cleared automatically on next CMD_JOIN. Ignore the 3424 request silently, as we dont want the mac80211 to emit 3425 an error message. */ 3426 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr)) 3427 return 0; 3428 3429 /* don't remove key if hlid was already deleted */ 3430 if (action == KEY_REMOVE && 3431 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) 3432 return 0; 3433 3434 ret = wl1271_cmd_set_sta_key(wl, wlvif, action, 3435 id, key_type, key_size, 3436 key, addr, tx_seq_32, 3437 tx_seq_16); 3438 if (ret < 0) 3439 return ret; 3440 3441 } 3442 3443 return 0; 3444 } 3445 3446 static int wlcore_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 3447 struct ieee80211_vif *vif, 3448 struct ieee80211_sta *sta, 3449 struct ieee80211_key_conf *key_conf) 3450 { 3451 struct wl1271 *wl = hw->priv; 3452 int ret; 3453 bool might_change_spare = 3454 key_conf->cipher == WL1271_CIPHER_SUITE_GEM || 3455 key_conf->cipher == WLAN_CIPHER_SUITE_TKIP; 3456 3457 if (might_change_spare) { 3458 /* 3459 * stop the queues and flush to ensure the next packets are 3460 * in sync with FW spare block accounting 3461 */ 3462 wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK); 3463 wl1271_tx_flush(wl); 3464 } 3465 3466 mutex_lock(&wl->mutex); 3467 3468 if (unlikely(wl->state != WLCORE_STATE_ON)) { 3469 ret = -EAGAIN; 3470 goto out_wake_queues; 3471 } 3472 3473 ret = pm_runtime_get_sync(wl->dev); 3474 if (ret < 0) { 3475 pm_runtime_put_noidle(wl->dev); 3476 goto out_wake_queues; 3477 } 3478 3479 ret = wlcore_hw_set_key(wl, cmd, vif, sta, key_conf); 3480 3481 pm_runtime_mark_last_busy(wl->dev); 3482 pm_runtime_put_autosuspend(wl->dev); 3483 3484 out_wake_queues: 3485 if (might_change_spare) 3486 wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK); 3487 3488 mutex_unlock(&wl->mutex); 3489 3490 return ret; 3491 } 3492 3493 int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd, 3494 struct ieee80211_vif *vif, 3495 struct ieee80211_sta *sta, 3496 struct ieee80211_key_conf *key_conf) 3497 { 3498 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3499 int ret; 3500 u32 tx_seq_32 = 0; 3501 u16 tx_seq_16 = 0; 3502 u8 key_type; 3503 u8 hlid; 3504 3505 wl1271_debug(DEBUG_MAC80211, "mac80211 set key"); 3506 3507 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta); 3508 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x", 3509 key_conf->cipher, key_conf->keyidx, 3510 key_conf->keylen, key_conf->flags); 3511 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen); 3512 3513 if (wlvif->bss_type == BSS_TYPE_AP_BSS) 3514 if (sta) { 3515 struct wl1271_station *wl_sta = (void *)sta->drv_priv; 3516 hlid = wl_sta->hlid; 3517 } else { 3518 hlid = wlvif->ap.bcast_hlid; 3519 } 3520 else 3521 hlid = wlvif->sta.hlid; 3522 3523 if (hlid != WL12XX_INVALID_LINK_ID) { 3524 u64 tx_seq = wl->links[hlid].total_freed_pkts; 3525 tx_seq_32 = WL1271_TX_SECURITY_HI32(tx_seq); 3526 tx_seq_16 = WL1271_TX_SECURITY_LO16(tx_seq); 3527 } 3528 3529 switch (key_conf->cipher) { 3530 case WLAN_CIPHER_SUITE_WEP40: 3531 case WLAN_CIPHER_SUITE_WEP104: 3532 key_type = KEY_WEP; 3533 3534 key_conf->hw_key_idx = key_conf->keyidx; 3535 break; 3536 case WLAN_CIPHER_SUITE_TKIP: 3537 key_type = KEY_TKIP; 3538 key_conf->hw_key_idx = key_conf->keyidx; 3539 break; 3540 case WLAN_CIPHER_SUITE_CCMP: 3541 key_type = KEY_AES; 3542 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE; 3543 break; 3544 case WL1271_CIPHER_SUITE_GEM: 3545 key_type = KEY_GEM; 3546 break; 3547 default: 3548 wl1271_error("Unknown key algo 0x%x", key_conf->cipher); 3549 3550 return -EOPNOTSUPP; 3551 } 3552 3553 switch (cmd) { 3554 case SET_KEY: 3555 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE, 3556 key_conf->keyidx, key_type, 3557 key_conf->keylen, key_conf->key, 3558 tx_seq_32, tx_seq_16, sta); 3559 if (ret < 0) { 3560 wl1271_error("Could not add or replace key"); 3561 return ret; 3562 } 3563 3564 /* 3565 * reconfiguring arp response if the unicast (or common) 3566 * encryption key type was changed 3567 */ 3568 if (wlvif->bss_type == BSS_TYPE_STA_BSS && 3569 (sta || key_type == KEY_WEP) && 3570 wlvif->encryption_type != key_type) { 3571 wlvif->encryption_type = key_type; 3572 ret = wl1271_cmd_build_arp_rsp(wl, wlvif); 3573 if (ret < 0) { 3574 wl1271_warning("build arp rsp failed: %d", ret); 3575 return ret; 3576 } 3577 } 3578 break; 3579 3580 case DISABLE_KEY: 3581 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE, 3582 key_conf->keyidx, key_type, 3583 key_conf->keylen, key_conf->key, 3584 0, 0, sta); 3585 if (ret < 0) { 3586 wl1271_error("Could not remove key"); 3587 return ret; 3588 } 3589 break; 3590 3591 default: 3592 wl1271_error("Unsupported key cmd 0x%x", cmd); 3593 return -EOPNOTSUPP; 3594 } 3595 3596 return ret; 3597 } 3598 EXPORT_SYMBOL_GPL(wlcore_set_key); 3599 3600 static void wl1271_op_set_default_key_idx(struct ieee80211_hw *hw, 3601 struct ieee80211_vif *vif, 3602 int key_idx) 3603 { 3604 struct wl1271 *wl = hw->priv; 3605 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3606 int ret; 3607 3608 wl1271_debug(DEBUG_MAC80211, "mac80211 set default key idx %d", 3609 key_idx); 3610 3611 /* we don't handle unsetting of default key */ 3612 if (key_idx == -1) 3613 return; 3614 3615 mutex_lock(&wl->mutex); 3616 3617 if (unlikely(wl->state != WLCORE_STATE_ON)) { 3618 ret = -EAGAIN; 3619 goto out_unlock; 3620 } 3621 3622 ret = pm_runtime_get_sync(wl->dev); 3623 if (ret < 0) { 3624 pm_runtime_put_noidle(wl->dev); 3625 goto out_unlock; 3626 } 3627 3628 wlvif->default_key = key_idx; 3629 3630 /* the default WEP key needs to be configured at least once */ 3631 if (wlvif->encryption_type == KEY_WEP) { 3632 ret = wl12xx_cmd_set_default_wep_key(wl, 3633 key_idx, 3634 wlvif->sta.hlid); 3635 if (ret < 0) 3636 goto out_sleep; 3637 } 3638 3639 out_sleep: 3640 pm_runtime_mark_last_busy(wl->dev); 3641 pm_runtime_put_autosuspend(wl->dev); 3642 3643 out_unlock: 3644 mutex_unlock(&wl->mutex); 3645 } 3646 3647 void wlcore_regdomain_config(struct wl1271 *wl) 3648 { 3649 int ret; 3650 3651 if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF)) 3652 return; 3653 3654 mutex_lock(&wl->mutex); 3655 3656 if (unlikely(wl->state != WLCORE_STATE_ON)) 3657 goto out; 3658 3659 ret = pm_runtime_get_sync(wl->dev); 3660 if (ret < 0) 3661 goto out; 3662 3663 ret = wlcore_cmd_regdomain_config_locked(wl); 3664 if (ret < 0) { 3665 wl12xx_queue_recovery_work(wl); 3666 goto out; 3667 } 3668 3669 pm_runtime_mark_last_busy(wl->dev); 3670 pm_runtime_put_autosuspend(wl->dev); 3671 out: 3672 mutex_unlock(&wl->mutex); 3673 } 3674 3675 static int wl1271_op_hw_scan(struct ieee80211_hw *hw, 3676 struct ieee80211_vif *vif, 3677 struct ieee80211_scan_request *hw_req) 3678 { 3679 struct cfg80211_scan_request *req = &hw_req->req; 3680 struct wl1271 *wl = hw->priv; 3681 int ret; 3682 u8 *ssid = NULL; 3683 size_t len = 0; 3684 3685 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan"); 3686 3687 if (req->n_ssids) { 3688 ssid = req->ssids[0].ssid; 3689 len = req->ssids[0].ssid_len; 3690 } 3691 3692 mutex_lock(&wl->mutex); 3693 3694 if (unlikely(wl->state != WLCORE_STATE_ON)) { 3695 /* 3696 * We cannot return -EBUSY here because cfg80211 will expect 3697 * a call to ieee80211_scan_completed if we do - in this case 3698 * there won't be any call. 3699 */ 3700 ret = -EAGAIN; 3701 goto out; 3702 } 3703 3704 ret = pm_runtime_get_sync(wl->dev); 3705 if (ret < 0) { 3706 pm_runtime_put_noidle(wl->dev); 3707 goto out; 3708 } 3709 3710 /* fail if there is any role in ROC */ 3711 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) { 3712 /* don't allow scanning right now */ 3713 ret = -EBUSY; 3714 goto out_sleep; 3715 } 3716 3717 ret = wlcore_scan(hw->priv, vif, ssid, len, req); 3718 out_sleep: 3719 pm_runtime_mark_last_busy(wl->dev); 3720 pm_runtime_put_autosuspend(wl->dev); 3721 out: 3722 mutex_unlock(&wl->mutex); 3723 3724 return ret; 3725 } 3726 3727 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw, 3728 struct ieee80211_vif *vif) 3729 { 3730 struct wl1271 *wl = hw->priv; 3731 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3732 struct cfg80211_scan_info info = { 3733 .aborted = true, 3734 }; 3735 int ret; 3736 3737 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan"); 3738 3739 mutex_lock(&wl->mutex); 3740 3741 if (unlikely(wl->state != WLCORE_STATE_ON)) 3742 goto out; 3743 3744 if (wl->scan.state == WL1271_SCAN_STATE_IDLE) 3745 goto out; 3746 3747 ret = pm_runtime_get_sync(wl->dev); 3748 if (ret < 0) { 3749 pm_runtime_put_noidle(wl->dev); 3750 goto out; 3751 } 3752 3753 if (wl->scan.state != WL1271_SCAN_STATE_DONE) { 3754 ret = wl->ops->scan_stop(wl, wlvif); 3755 if (ret < 0) 3756 goto out_sleep; 3757 } 3758 3759 /* 3760 * Rearm the tx watchdog just before idling scan. This 3761 * prevents just-finished scans from triggering the watchdog 3762 */ 3763 wl12xx_rearm_tx_watchdog_locked(wl); 3764 3765 wl->scan.state = WL1271_SCAN_STATE_IDLE; 3766 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch)); 3767 wl->scan_wlvif = NULL; 3768 wl->scan.req = NULL; 3769 ieee80211_scan_completed(wl->hw, &info); 3770 3771 out_sleep: 3772 pm_runtime_mark_last_busy(wl->dev); 3773 pm_runtime_put_autosuspend(wl->dev); 3774 out: 3775 mutex_unlock(&wl->mutex); 3776 3777 cancel_delayed_work_sync(&wl->scan_complete_work); 3778 } 3779 3780 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw, 3781 struct ieee80211_vif *vif, 3782 struct cfg80211_sched_scan_request *req, 3783 struct ieee80211_scan_ies *ies) 3784 { 3785 struct wl1271 *wl = hw->priv; 3786 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3787 int ret; 3788 3789 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start"); 3790 3791 mutex_lock(&wl->mutex); 3792 3793 if (unlikely(wl->state != WLCORE_STATE_ON)) { 3794 ret = -EAGAIN; 3795 goto out; 3796 } 3797 3798 ret = pm_runtime_get_sync(wl->dev); 3799 if (ret < 0) { 3800 pm_runtime_put_noidle(wl->dev); 3801 goto out; 3802 } 3803 3804 ret = wl->ops->sched_scan_start(wl, wlvif, req, ies); 3805 if (ret < 0) 3806 goto out_sleep; 3807 3808 wl->sched_vif = wlvif; 3809 3810 out_sleep: 3811 pm_runtime_mark_last_busy(wl->dev); 3812 pm_runtime_put_autosuspend(wl->dev); 3813 out: 3814 mutex_unlock(&wl->mutex); 3815 return ret; 3816 } 3817 3818 static int wl1271_op_sched_scan_stop(struct ieee80211_hw *hw, 3819 struct ieee80211_vif *vif) 3820 { 3821 struct wl1271 *wl = hw->priv; 3822 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3823 int ret; 3824 3825 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop"); 3826 3827 mutex_lock(&wl->mutex); 3828 3829 if (unlikely(wl->state != WLCORE_STATE_ON)) 3830 goto out; 3831 3832 ret = pm_runtime_get_sync(wl->dev); 3833 if (ret < 0) { 3834 pm_runtime_put_noidle(wl->dev); 3835 goto out; 3836 } 3837 3838 wl->ops->sched_scan_stop(wl, wlvif); 3839 3840 pm_runtime_mark_last_busy(wl->dev); 3841 pm_runtime_put_autosuspend(wl->dev); 3842 out: 3843 mutex_unlock(&wl->mutex); 3844 3845 return 0; 3846 } 3847 3848 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 3849 { 3850 struct wl1271 *wl = hw->priv; 3851 int ret = 0; 3852 3853 mutex_lock(&wl->mutex); 3854 3855 if (unlikely(wl->state != WLCORE_STATE_ON)) { 3856 ret = -EAGAIN; 3857 goto out; 3858 } 3859 3860 ret = pm_runtime_get_sync(wl->dev); 3861 if (ret < 0) { 3862 pm_runtime_put_noidle(wl->dev); 3863 goto out; 3864 } 3865 3866 ret = wl1271_acx_frag_threshold(wl, value); 3867 if (ret < 0) 3868 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret); 3869 3870 pm_runtime_mark_last_busy(wl->dev); 3871 pm_runtime_put_autosuspend(wl->dev); 3872 3873 out: 3874 mutex_unlock(&wl->mutex); 3875 3876 return ret; 3877 } 3878 3879 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 3880 { 3881 struct wl1271 *wl = hw->priv; 3882 struct wl12xx_vif *wlvif; 3883 int ret = 0; 3884 3885 mutex_lock(&wl->mutex); 3886 3887 if (unlikely(wl->state != WLCORE_STATE_ON)) { 3888 ret = -EAGAIN; 3889 goto out; 3890 } 3891 3892 ret = pm_runtime_get_sync(wl->dev); 3893 if (ret < 0) { 3894 pm_runtime_put_noidle(wl->dev); 3895 goto out; 3896 } 3897 3898 wl12xx_for_each_wlvif(wl, wlvif) { 3899 ret = wl1271_acx_rts_threshold(wl, wlvif, value); 3900 if (ret < 0) 3901 wl1271_warning("set rts threshold failed: %d", ret); 3902 } 3903 pm_runtime_mark_last_busy(wl->dev); 3904 pm_runtime_put_autosuspend(wl->dev); 3905 3906 out: 3907 mutex_unlock(&wl->mutex); 3908 3909 return ret; 3910 } 3911 3912 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset) 3913 { 3914 int len; 3915 const u8 *next, *end = skb->data + skb->len; 3916 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset, 3917 skb->len - ieoffset); 3918 if (!ie) 3919 return; 3920 len = ie[1] + 2; 3921 next = ie + len; 3922 memmove(ie, next, end - next); 3923 skb_trim(skb, skb->len - len); 3924 } 3925 3926 static void wl12xx_remove_vendor_ie(struct sk_buff *skb, 3927 unsigned int oui, u8 oui_type, 3928 int ieoffset) 3929 { 3930 int len; 3931 const u8 *next, *end = skb->data + skb->len; 3932 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type, 3933 skb->data + ieoffset, 3934 skb->len - ieoffset); 3935 if (!ie) 3936 return; 3937 len = ie[1] + 2; 3938 next = ie + len; 3939 memmove(ie, next, end - next); 3940 skb_trim(skb, skb->len - len); 3941 } 3942 3943 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates, 3944 struct ieee80211_vif *vif) 3945 { 3946 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3947 struct sk_buff *skb; 3948 int ret; 3949 3950 skb = ieee80211_proberesp_get(wl->hw, vif); 3951 if (!skb) 3952 return -EOPNOTSUPP; 3953 3954 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 3955 CMD_TEMPL_AP_PROBE_RESPONSE, 3956 skb->data, 3957 skb->len, 0, 3958 rates); 3959 dev_kfree_skb(skb); 3960 3961 if (ret < 0) 3962 goto out; 3963 3964 wl1271_debug(DEBUG_AP, "probe response updated"); 3965 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags); 3966 3967 out: 3968 return ret; 3969 } 3970 3971 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl, 3972 struct ieee80211_vif *vif, 3973 u8 *probe_rsp_data, 3974 size_t probe_rsp_len, 3975 u32 rates) 3976 { 3977 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3978 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 3979 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE]; 3980 int ssid_ie_offset, ie_offset, templ_len; 3981 const u8 *ptr; 3982 3983 /* no need to change probe response if the SSID is set correctly */ 3984 if (wlvif->ssid_len > 0) 3985 return wl1271_cmd_template_set(wl, wlvif->role_id, 3986 CMD_TEMPL_AP_PROBE_RESPONSE, 3987 probe_rsp_data, 3988 probe_rsp_len, 0, 3989 rates); 3990 3991 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) { 3992 wl1271_error("probe_rsp template too big"); 3993 return -EINVAL; 3994 } 3995 3996 /* start searching from IE offset */ 3997 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable); 3998 3999 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset, 4000 probe_rsp_len - ie_offset); 4001 if (!ptr) { 4002 wl1271_error("No SSID in beacon!"); 4003 return -EINVAL; 4004 } 4005 4006 ssid_ie_offset = ptr - probe_rsp_data; 4007 ptr += (ptr[1] + 2); 4008 4009 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset); 4010 4011 /* insert SSID from bss_conf */ 4012 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID; 4013 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len; 4014 memcpy(probe_rsp_templ + ssid_ie_offset + 2, 4015 bss_conf->ssid, bss_conf->ssid_len); 4016 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len; 4017 4018 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len, 4019 ptr, probe_rsp_len - (ptr - probe_rsp_data)); 4020 templ_len += probe_rsp_len - (ptr - probe_rsp_data); 4021 4022 return wl1271_cmd_template_set(wl, wlvif->role_id, 4023 CMD_TEMPL_AP_PROBE_RESPONSE, 4024 probe_rsp_templ, 4025 templ_len, 0, 4026 rates); 4027 } 4028 4029 static int wl1271_bss_erp_info_changed(struct wl1271 *wl, 4030 struct ieee80211_vif *vif, 4031 struct ieee80211_bss_conf *bss_conf, 4032 u32 changed) 4033 { 4034 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4035 int ret = 0; 4036 4037 if (changed & BSS_CHANGED_ERP_SLOT) { 4038 if (bss_conf->use_short_slot) 4039 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT); 4040 else 4041 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG); 4042 if (ret < 0) { 4043 wl1271_warning("Set slot time failed %d", ret); 4044 goto out; 4045 } 4046 } 4047 4048 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 4049 if (bss_conf->use_short_preamble) 4050 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT); 4051 else 4052 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG); 4053 } 4054 4055 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 4056 if (bss_conf->use_cts_prot) 4057 ret = wl1271_acx_cts_protect(wl, wlvif, 4058 CTSPROTECT_ENABLE); 4059 else 4060 ret = wl1271_acx_cts_protect(wl, wlvif, 4061 CTSPROTECT_DISABLE); 4062 if (ret < 0) { 4063 wl1271_warning("Set ctsprotect failed %d", ret); 4064 goto out; 4065 } 4066 } 4067 4068 out: 4069 return ret; 4070 } 4071 4072 static int wlcore_set_beacon_template(struct wl1271 *wl, 4073 struct ieee80211_vif *vif, 4074 bool is_ap) 4075 { 4076 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4077 struct ieee80211_hdr *hdr; 4078 u32 min_rate; 4079 int ret; 4080 int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable); 4081 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif); 4082 u16 tmpl_id; 4083 4084 if (!beacon) { 4085 ret = -EINVAL; 4086 goto out; 4087 } 4088 4089 wl1271_debug(DEBUG_MASTER, "beacon updated"); 4090 4091 ret = wl1271_ssid_set(wlvif, beacon, ieoffset); 4092 if (ret < 0) { 4093 dev_kfree_skb(beacon); 4094 goto out; 4095 } 4096 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 4097 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON : 4098 CMD_TEMPL_BEACON; 4099 ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id, 4100 beacon->data, 4101 beacon->len, 0, 4102 min_rate); 4103 if (ret < 0) { 4104 dev_kfree_skb(beacon); 4105 goto out; 4106 } 4107 4108 wlvif->wmm_enabled = 4109 cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 4110 WLAN_OUI_TYPE_MICROSOFT_WMM, 4111 beacon->data + ieoffset, 4112 beacon->len - ieoffset); 4113 4114 /* 4115 * In case we already have a probe-resp beacon set explicitly 4116 * by usermode, don't use the beacon data. 4117 */ 4118 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags)) 4119 goto end_bcn; 4120 4121 /* remove TIM ie from probe response */ 4122 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset); 4123 4124 /* 4125 * remove p2p ie from probe response. 4126 * the fw reponds to probe requests that don't include 4127 * the p2p ie. probe requests with p2p ie will be passed, 4128 * and will be responded by the supplicant (the spec 4129 * forbids including the p2p ie when responding to probe 4130 * requests that didn't include it). 4131 */ 4132 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA, 4133 WLAN_OUI_TYPE_WFA_P2P, ieoffset); 4134 4135 hdr = (struct ieee80211_hdr *) beacon->data; 4136 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 4137 IEEE80211_STYPE_PROBE_RESP); 4138 if (is_ap) 4139 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif, 4140 beacon->data, 4141 beacon->len, 4142 min_rate); 4143 else 4144 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 4145 CMD_TEMPL_PROBE_RESPONSE, 4146 beacon->data, 4147 beacon->len, 0, 4148 min_rate); 4149 end_bcn: 4150 dev_kfree_skb(beacon); 4151 if (ret < 0) 4152 goto out; 4153 4154 out: 4155 return ret; 4156 } 4157 4158 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl, 4159 struct ieee80211_vif *vif, 4160 struct ieee80211_bss_conf *bss_conf, 4161 u32 changed) 4162 { 4163 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4164 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 4165 int ret = 0; 4166 4167 if (changed & BSS_CHANGED_BEACON_INT) { 4168 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d", 4169 bss_conf->beacon_int); 4170 4171 wlvif->beacon_int = bss_conf->beacon_int; 4172 } 4173 4174 if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) { 4175 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 4176 4177 wl1271_ap_set_probe_resp_tmpl(wl, rate, vif); 4178 } 4179 4180 if (changed & BSS_CHANGED_BEACON) { 4181 ret = wlcore_set_beacon_template(wl, vif, is_ap); 4182 if (ret < 0) 4183 goto out; 4184 4185 if (test_and_clear_bit(WLVIF_FLAG_BEACON_DISABLED, 4186 &wlvif->flags)) { 4187 ret = wlcore_hw_dfs_master_restart(wl, wlvif); 4188 if (ret < 0) 4189 goto out; 4190 } 4191 } 4192 out: 4193 if (ret != 0) 4194 wl1271_error("beacon info change failed: %d", ret); 4195 return ret; 4196 } 4197 4198 /* AP mode changes */ 4199 static void wl1271_bss_info_changed_ap(struct wl1271 *wl, 4200 struct ieee80211_vif *vif, 4201 struct ieee80211_bss_conf *bss_conf, 4202 u32 changed) 4203 { 4204 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4205 int ret = 0; 4206 4207 if (changed & BSS_CHANGED_BASIC_RATES) { 4208 u32 rates = bss_conf->basic_rates; 4209 4210 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates, 4211 wlvif->band); 4212 wlvif->basic_rate = wl1271_tx_min_rate_get(wl, 4213 wlvif->basic_rate_set); 4214 4215 ret = wl1271_init_ap_rates(wl, wlvif); 4216 if (ret < 0) { 4217 wl1271_error("AP rate policy change failed %d", ret); 4218 goto out; 4219 } 4220 4221 ret = wl1271_ap_init_templates(wl, vif); 4222 if (ret < 0) 4223 goto out; 4224 4225 /* No need to set probe resp template for mesh */ 4226 if (!ieee80211_vif_is_mesh(vif)) { 4227 ret = wl1271_ap_set_probe_resp_tmpl(wl, 4228 wlvif->basic_rate, 4229 vif); 4230 if (ret < 0) 4231 goto out; 4232 } 4233 4234 ret = wlcore_set_beacon_template(wl, vif, true); 4235 if (ret < 0) 4236 goto out; 4237 } 4238 4239 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed); 4240 if (ret < 0) 4241 goto out; 4242 4243 if (changed & BSS_CHANGED_BEACON_ENABLED) { 4244 if (bss_conf->enable_beacon) { 4245 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) { 4246 ret = wl12xx_cmd_role_start_ap(wl, wlvif); 4247 if (ret < 0) 4248 goto out; 4249 4250 ret = wl1271_ap_init_hwenc(wl, wlvif); 4251 if (ret < 0) 4252 goto out; 4253 4254 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags); 4255 wl1271_debug(DEBUG_AP, "started AP"); 4256 } 4257 } else { 4258 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) { 4259 /* 4260 * AP might be in ROC in case we have just 4261 * sent auth reply. handle it. 4262 */ 4263 if (test_bit(wlvif->role_id, wl->roc_map)) 4264 wl12xx_croc(wl, wlvif->role_id); 4265 4266 ret = wl12xx_cmd_role_stop_ap(wl, wlvif); 4267 if (ret < 0) 4268 goto out; 4269 4270 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags); 4271 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, 4272 &wlvif->flags); 4273 wl1271_debug(DEBUG_AP, "stopped AP"); 4274 } 4275 } 4276 } 4277 4278 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed); 4279 if (ret < 0) 4280 goto out; 4281 4282 /* Handle HT information change */ 4283 if ((changed & BSS_CHANGED_HT) && 4284 (bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT)) { 4285 ret = wl1271_acx_set_ht_information(wl, wlvif, 4286 bss_conf->ht_operation_mode); 4287 if (ret < 0) { 4288 wl1271_warning("Set ht information failed %d", ret); 4289 goto out; 4290 } 4291 } 4292 4293 out: 4294 return; 4295 } 4296 4297 static int wlcore_set_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif, 4298 struct ieee80211_bss_conf *bss_conf, 4299 u32 sta_rate_set) 4300 { 4301 u32 rates; 4302 int ret; 4303 4304 wl1271_debug(DEBUG_MAC80211, 4305 "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x", 4306 bss_conf->bssid, bss_conf->aid, 4307 bss_conf->beacon_int, 4308 bss_conf->basic_rates, sta_rate_set); 4309 4310 wlvif->beacon_int = bss_conf->beacon_int; 4311 rates = bss_conf->basic_rates; 4312 wlvif->basic_rate_set = 4313 wl1271_tx_enabled_rates_get(wl, rates, 4314 wlvif->band); 4315 wlvif->basic_rate = 4316 wl1271_tx_min_rate_get(wl, 4317 wlvif->basic_rate_set); 4318 4319 if (sta_rate_set) 4320 wlvif->rate_set = 4321 wl1271_tx_enabled_rates_get(wl, 4322 sta_rate_set, 4323 wlvif->band); 4324 4325 /* we only support sched_scan while not connected */ 4326 if (wl->sched_vif == wlvif) 4327 wl->ops->sched_scan_stop(wl, wlvif); 4328 4329 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 4330 if (ret < 0) 4331 return ret; 4332 4333 ret = wl12xx_cmd_build_null_data(wl, wlvif); 4334 if (ret < 0) 4335 return ret; 4336 4337 ret = wl1271_build_qos_null_data(wl, wl12xx_wlvif_to_vif(wlvif)); 4338 if (ret < 0) 4339 return ret; 4340 4341 wlcore_set_ssid(wl, wlvif); 4342 4343 set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags); 4344 4345 return 0; 4346 } 4347 4348 static int wlcore_clear_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif) 4349 { 4350 int ret; 4351 4352 /* revert back to minimum rates for the current band */ 4353 wl1271_set_band_rate(wl, wlvif); 4354 wlvif->basic_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 4355 4356 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 4357 if (ret < 0) 4358 return ret; 4359 4360 if (wlvif->bss_type == BSS_TYPE_STA_BSS && 4361 test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) { 4362 ret = wl12xx_cmd_role_stop_sta(wl, wlvif); 4363 if (ret < 0) 4364 return ret; 4365 } 4366 4367 clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags); 4368 return 0; 4369 } 4370 /* STA/IBSS mode changes */ 4371 static void wl1271_bss_info_changed_sta(struct wl1271 *wl, 4372 struct ieee80211_vif *vif, 4373 struct ieee80211_bss_conf *bss_conf, 4374 u32 changed) 4375 { 4376 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4377 bool do_join = false; 4378 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS); 4379 bool ibss_joined = false; 4380 u32 sta_rate_set = 0; 4381 int ret; 4382 struct ieee80211_sta *sta; 4383 bool sta_exists = false; 4384 struct ieee80211_sta_ht_cap sta_ht_cap; 4385 4386 if (is_ibss) { 4387 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, 4388 changed); 4389 if (ret < 0) 4390 goto out; 4391 } 4392 4393 if (changed & BSS_CHANGED_IBSS) { 4394 if (bss_conf->ibss_joined) { 4395 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags); 4396 ibss_joined = true; 4397 } else { 4398 wlcore_unset_assoc(wl, wlvif); 4399 wl12xx_cmd_role_stop_sta(wl, wlvif); 4400 } 4401 } 4402 4403 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined) 4404 do_join = true; 4405 4406 /* Need to update the SSID (for filtering etc) */ 4407 if ((changed & BSS_CHANGED_BEACON) && ibss_joined) 4408 do_join = true; 4409 4410 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) { 4411 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s", 4412 bss_conf->enable_beacon ? "enabled" : "disabled"); 4413 4414 do_join = true; 4415 } 4416 4417 if (changed & BSS_CHANGED_IDLE && !is_ibss) 4418 wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle); 4419 4420 if (changed & BSS_CHANGED_CQM) { 4421 bool enable = false; 4422 if (bss_conf->cqm_rssi_thold) 4423 enable = true; 4424 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable, 4425 bss_conf->cqm_rssi_thold, 4426 bss_conf->cqm_rssi_hyst); 4427 if (ret < 0) 4428 goto out; 4429 wlvif->rssi_thold = bss_conf->cqm_rssi_thold; 4430 } 4431 4432 if (changed & (BSS_CHANGED_BSSID | BSS_CHANGED_HT | 4433 BSS_CHANGED_ASSOC)) { 4434 rcu_read_lock(); 4435 sta = ieee80211_find_sta(vif, bss_conf->bssid); 4436 if (sta) { 4437 u8 *rx_mask = sta->ht_cap.mcs.rx_mask; 4438 4439 /* save the supp_rates of the ap */ 4440 sta_rate_set = sta->supp_rates[wlvif->band]; 4441 if (sta->ht_cap.ht_supported) 4442 sta_rate_set |= 4443 (rx_mask[0] << HW_HT_RATES_OFFSET) | 4444 (rx_mask[1] << HW_MIMO_RATES_OFFSET); 4445 sta_ht_cap = sta->ht_cap; 4446 sta_exists = true; 4447 } 4448 4449 rcu_read_unlock(); 4450 } 4451 4452 if (changed & BSS_CHANGED_BSSID) { 4453 if (!is_zero_ether_addr(bss_conf->bssid)) { 4454 ret = wlcore_set_bssid(wl, wlvif, bss_conf, 4455 sta_rate_set); 4456 if (ret < 0) 4457 goto out; 4458 4459 /* Need to update the BSSID (for filtering etc) */ 4460 do_join = true; 4461 } else { 4462 ret = wlcore_clear_bssid(wl, wlvif); 4463 if (ret < 0) 4464 goto out; 4465 } 4466 } 4467 4468 if (changed & BSS_CHANGED_IBSS) { 4469 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d", 4470 bss_conf->ibss_joined); 4471 4472 if (bss_conf->ibss_joined) { 4473 u32 rates = bss_conf->basic_rates; 4474 wlvif->basic_rate_set = 4475 wl1271_tx_enabled_rates_get(wl, rates, 4476 wlvif->band); 4477 wlvif->basic_rate = 4478 wl1271_tx_min_rate_get(wl, 4479 wlvif->basic_rate_set); 4480 4481 /* by default, use 11b + OFDM rates */ 4482 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES; 4483 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 4484 if (ret < 0) 4485 goto out; 4486 } 4487 } 4488 4489 if ((changed & BSS_CHANGED_BEACON_INFO) && bss_conf->dtim_period) { 4490 /* enable beacon filtering */ 4491 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true); 4492 if (ret < 0) 4493 goto out; 4494 } 4495 4496 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed); 4497 if (ret < 0) 4498 goto out; 4499 4500 if (do_join) { 4501 ret = wlcore_join(wl, wlvif); 4502 if (ret < 0) { 4503 wl1271_warning("cmd join failed %d", ret); 4504 goto out; 4505 } 4506 } 4507 4508 if (changed & BSS_CHANGED_ASSOC) { 4509 if (bss_conf->assoc) { 4510 ret = wlcore_set_assoc(wl, wlvif, bss_conf, 4511 sta_rate_set); 4512 if (ret < 0) 4513 goto out; 4514 4515 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags)) 4516 wl12xx_set_authorized(wl, wlvif); 4517 } else { 4518 wlcore_unset_assoc(wl, wlvif); 4519 } 4520 } 4521 4522 if (changed & BSS_CHANGED_PS) { 4523 if ((bss_conf->ps) && 4524 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) && 4525 !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) { 4526 int ps_mode; 4527 char *ps_mode_str; 4528 4529 if (wl->conf.conn.forced_ps) { 4530 ps_mode = STATION_POWER_SAVE_MODE; 4531 ps_mode_str = "forced"; 4532 } else { 4533 ps_mode = STATION_AUTO_PS_MODE; 4534 ps_mode_str = "auto"; 4535 } 4536 4537 wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str); 4538 4539 ret = wl1271_ps_set_mode(wl, wlvif, ps_mode); 4540 if (ret < 0) 4541 wl1271_warning("enter %s ps failed %d", 4542 ps_mode_str, ret); 4543 } else if (!bss_conf->ps && 4544 test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) { 4545 wl1271_debug(DEBUG_PSM, "auto ps disabled"); 4546 4547 ret = wl1271_ps_set_mode(wl, wlvif, 4548 STATION_ACTIVE_MODE); 4549 if (ret < 0) 4550 wl1271_warning("exit auto ps failed %d", ret); 4551 } 4552 } 4553 4554 /* Handle new association with HT. Do this after join. */ 4555 if (sta_exists) { 4556 bool enabled = 4557 bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT; 4558 4559 ret = wlcore_hw_set_peer_cap(wl, 4560 &sta_ht_cap, 4561 enabled, 4562 wlvif->rate_set, 4563 wlvif->sta.hlid); 4564 if (ret < 0) { 4565 wl1271_warning("Set ht cap failed %d", ret); 4566 goto out; 4567 4568 } 4569 4570 if (enabled) { 4571 ret = wl1271_acx_set_ht_information(wl, wlvif, 4572 bss_conf->ht_operation_mode); 4573 if (ret < 0) { 4574 wl1271_warning("Set ht information failed %d", 4575 ret); 4576 goto out; 4577 } 4578 } 4579 } 4580 4581 /* Handle arp filtering. Done after join. */ 4582 if ((changed & BSS_CHANGED_ARP_FILTER) || 4583 (!is_ibss && (changed & BSS_CHANGED_QOS))) { 4584 __be32 addr = bss_conf->arp_addr_list[0]; 4585 wlvif->sta.qos = bss_conf->qos; 4586 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS); 4587 4588 if (bss_conf->arp_addr_cnt == 1 && bss_conf->assoc) { 4589 wlvif->ip_addr = addr; 4590 /* 4591 * The template should have been configured only upon 4592 * association. however, it seems that the correct ip 4593 * isn't being set (when sending), so we have to 4594 * reconfigure the template upon every ip change. 4595 */ 4596 ret = wl1271_cmd_build_arp_rsp(wl, wlvif); 4597 if (ret < 0) { 4598 wl1271_warning("build arp rsp failed: %d", ret); 4599 goto out; 4600 } 4601 4602 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 4603 (ACX_ARP_FILTER_ARP_FILTERING | 4604 ACX_ARP_FILTER_AUTO_ARP), 4605 addr); 4606 } else { 4607 wlvif->ip_addr = 0; 4608 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr); 4609 } 4610 4611 if (ret < 0) 4612 goto out; 4613 } 4614 4615 out: 4616 return; 4617 } 4618 4619 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw, 4620 struct ieee80211_vif *vif, 4621 struct ieee80211_bss_conf *bss_conf, 4622 u32 changed) 4623 { 4624 struct wl1271 *wl = hw->priv; 4625 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4626 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 4627 int ret; 4628 4629 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info role %d changed 0x%x", 4630 wlvif->role_id, (int)changed); 4631 4632 /* 4633 * make sure to cancel pending disconnections if our association 4634 * state changed 4635 */ 4636 if (!is_ap && (changed & BSS_CHANGED_ASSOC)) 4637 cancel_delayed_work_sync(&wlvif->connection_loss_work); 4638 4639 if (is_ap && (changed & BSS_CHANGED_BEACON_ENABLED) && 4640 !bss_conf->enable_beacon) 4641 wl1271_tx_flush(wl); 4642 4643 mutex_lock(&wl->mutex); 4644 4645 if (unlikely(wl->state != WLCORE_STATE_ON)) 4646 goto out; 4647 4648 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))) 4649 goto out; 4650 4651 ret = pm_runtime_get_sync(wl->dev); 4652 if (ret < 0) { 4653 pm_runtime_put_noidle(wl->dev); 4654 goto out; 4655 } 4656 4657 if ((changed & BSS_CHANGED_TXPOWER) && 4658 bss_conf->txpower != wlvif->power_level) { 4659 4660 ret = wl1271_acx_tx_power(wl, wlvif, bss_conf->txpower); 4661 if (ret < 0) 4662 goto out; 4663 4664 wlvif->power_level = bss_conf->txpower; 4665 } 4666 4667 if (is_ap) 4668 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed); 4669 else 4670 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed); 4671 4672 pm_runtime_mark_last_busy(wl->dev); 4673 pm_runtime_put_autosuspend(wl->dev); 4674 4675 out: 4676 mutex_unlock(&wl->mutex); 4677 } 4678 4679 static int wlcore_op_add_chanctx(struct ieee80211_hw *hw, 4680 struct ieee80211_chanctx_conf *ctx) 4681 { 4682 wl1271_debug(DEBUG_MAC80211, "mac80211 add chanctx %d (type %d)", 4683 ieee80211_frequency_to_channel(ctx->def.chan->center_freq), 4684 cfg80211_get_chandef_type(&ctx->def)); 4685 return 0; 4686 } 4687 4688 static void wlcore_op_remove_chanctx(struct ieee80211_hw *hw, 4689 struct ieee80211_chanctx_conf *ctx) 4690 { 4691 wl1271_debug(DEBUG_MAC80211, "mac80211 remove chanctx %d (type %d)", 4692 ieee80211_frequency_to_channel(ctx->def.chan->center_freq), 4693 cfg80211_get_chandef_type(&ctx->def)); 4694 } 4695 4696 static void wlcore_op_change_chanctx(struct ieee80211_hw *hw, 4697 struct ieee80211_chanctx_conf *ctx, 4698 u32 changed) 4699 { 4700 struct wl1271 *wl = hw->priv; 4701 struct wl12xx_vif *wlvif; 4702 int ret; 4703 int channel = ieee80211_frequency_to_channel( 4704 ctx->def.chan->center_freq); 4705 4706 wl1271_debug(DEBUG_MAC80211, 4707 "mac80211 change chanctx %d (type %d) changed 0x%x", 4708 channel, cfg80211_get_chandef_type(&ctx->def), changed); 4709 4710 mutex_lock(&wl->mutex); 4711 4712 ret = pm_runtime_get_sync(wl->dev); 4713 if (ret < 0) { 4714 pm_runtime_put_noidle(wl->dev); 4715 goto out; 4716 } 4717 4718 wl12xx_for_each_wlvif(wl, wlvif) { 4719 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 4720 4721 rcu_read_lock(); 4722 if (rcu_access_pointer(vif->chanctx_conf) != ctx) { 4723 rcu_read_unlock(); 4724 continue; 4725 } 4726 rcu_read_unlock(); 4727 4728 /* start radar if needed */ 4729 if (changed & IEEE80211_CHANCTX_CHANGE_RADAR && 4730 wlvif->bss_type == BSS_TYPE_AP_BSS && 4731 ctx->radar_enabled && !wlvif->radar_enabled && 4732 ctx->def.chan->dfs_state == NL80211_DFS_USABLE) { 4733 wl1271_debug(DEBUG_MAC80211, "Start radar detection"); 4734 wlcore_hw_set_cac(wl, wlvif, true); 4735 wlvif->radar_enabled = true; 4736 } 4737 } 4738 4739 pm_runtime_mark_last_busy(wl->dev); 4740 pm_runtime_put_autosuspend(wl->dev); 4741 out: 4742 mutex_unlock(&wl->mutex); 4743 } 4744 4745 static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw *hw, 4746 struct ieee80211_vif *vif, 4747 struct ieee80211_chanctx_conf *ctx) 4748 { 4749 struct wl1271 *wl = hw->priv; 4750 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4751 int channel = ieee80211_frequency_to_channel( 4752 ctx->def.chan->center_freq); 4753 int ret = -EINVAL; 4754 4755 wl1271_debug(DEBUG_MAC80211, 4756 "mac80211 assign chanctx (role %d) %d (type %d) (radar %d dfs_state %d)", 4757 wlvif->role_id, channel, 4758 cfg80211_get_chandef_type(&ctx->def), 4759 ctx->radar_enabled, ctx->def.chan->dfs_state); 4760 4761 mutex_lock(&wl->mutex); 4762 4763 if (unlikely(wl->state != WLCORE_STATE_ON)) 4764 goto out; 4765 4766 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))) 4767 goto out; 4768 4769 ret = pm_runtime_get_sync(wl->dev); 4770 if (ret < 0) { 4771 pm_runtime_put_noidle(wl->dev); 4772 goto out; 4773 } 4774 4775 wlvif->band = ctx->def.chan->band; 4776 wlvif->channel = channel; 4777 wlvif->channel_type = cfg80211_get_chandef_type(&ctx->def); 4778 4779 /* update default rates according to the band */ 4780 wl1271_set_band_rate(wl, wlvif); 4781 4782 if (ctx->radar_enabled && 4783 ctx->def.chan->dfs_state == NL80211_DFS_USABLE) { 4784 wl1271_debug(DEBUG_MAC80211, "Start radar detection"); 4785 wlcore_hw_set_cac(wl, wlvif, true); 4786 wlvif->radar_enabled = true; 4787 } 4788 4789 pm_runtime_mark_last_busy(wl->dev); 4790 pm_runtime_put_autosuspend(wl->dev); 4791 out: 4792 mutex_unlock(&wl->mutex); 4793 4794 return 0; 4795 } 4796 4797 static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw *hw, 4798 struct ieee80211_vif *vif, 4799 struct ieee80211_chanctx_conf *ctx) 4800 { 4801 struct wl1271 *wl = hw->priv; 4802 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4803 int ret; 4804 4805 wl1271_debug(DEBUG_MAC80211, 4806 "mac80211 unassign chanctx (role %d) %d (type %d)", 4807 wlvif->role_id, 4808 ieee80211_frequency_to_channel(ctx->def.chan->center_freq), 4809 cfg80211_get_chandef_type(&ctx->def)); 4810 4811 wl1271_tx_flush(wl); 4812 4813 mutex_lock(&wl->mutex); 4814 4815 if (unlikely(wl->state != WLCORE_STATE_ON)) 4816 goto out; 4817 4818 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))) 4819 goto out; 4820 4821 ret = pm_runtime_get_sync(wl->dev); 4822 if (ret < 0) { 4823 pm_runtime_put_noidle(wl->dev); 4824 goto out; 4825 } 4826 4827 if (wlvif->radar_enabled) { 4828 wl1271_debug(DEBUG_MAC80211, "Stop radar detection"); 4829 wlcore_hw_set_cac(wl, wlvif, false); 4830 wlvif->radar_enabled = false; 4831 } 4832 4833 pm_runtime_mark_last_busy(wl->dev); 4834 pm_runtime_put_autosuspend(wl->dev); 4835 out: 4836 mutex_unlock(&wl->mutex); 4837 } 4838 4839 static int __wlcore_switch_vif_chan(struct wl1271 *wl, 4840 struct wl12xx_vif *wlvif, 4841 struct ieee80211_chanctx_conf *new_ctx) 4842 { 4843 int channel = ieee80211_frequency_to_channel( 4844 new_ctx->def.chan->center_freq); 4845 4846 wl1271_debug(DEBUG_MAC80211, 4847 "switch vif (role %d) %d -> %d chan_type: %d", 4848 wlvif->role_id, wlvif->channel, channel, 4849 cfg80211_get_chandef_type(&new_ctx->def)); 4850 4851 if (WARN_ON_ONCE(wlvif->bss_type != BSS_TYPE_AP_BSS)) 4852 return 0; 4853 4854 WARN_ON(!test_bit(WLVIF_FLAG_BEACON_DISABLED, &wlvif->flags)); 4855 4856 if (wlvif->radar_enabled) { 4857 wl1271_debug(DEBUG_MAC80211, "Stop radar detection"); 4858 wlcore_hw_set_cac(wl, wlvif, false); 4859 wlvif->radar_enabled = false; 4860 } 4861 4862 wlvif->band = new_ctx->def.chan->band; 4863 wlvif->channel = channel; 4864 wlvif->channel_type = cfg80211_get_chandef_type(&new_ctx->def); 4865 4866 /* start radar if needed */ 4867 if (new_ctx->radar_enabled) { 4868 wl1271_debug(DEBUG_MAC80211, "Start radar detection"); 4869 wlcore_hw_set_cac(wl, wlvif, true); 4870 wlvif->radar_enabled = true; 4871 } 4872 4873 return 0; 4874 } 4875 4876 static int 4877 wlcore_op_switch_vif_chanctx(struct ieee80211_hw *hw, 4878 struct ieee80211_vif_chanctx_switch *vifs, 4879 int n_vifs, 4880 enum ieee80211_chanctx_switch_mode mode) 4881 { 4882 struct wl1271 *wl = hw->priv; 4883 int i, ret; 4884 4885 wl1271_debug(DEBUG_MAC80211, 4886 "mac80211 switch chanctx n_vifs %d mode %d", 4887 n_vifs, mode); 4888 4889 mutex_lock(&wl->mutex); 4890 4891 ret = pm_runtime_get_sync(wl->dev); 4892 if (ret < 0) { 4893 pm_runtime_put_noidle(wl->dev); 4894 goto out; 4895 } 4896 4897 for (i = 0; i < n_vifs; i++) { 4898 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vifs[i].vif); 4899 4900 ret = __wlcore_switch_vif_chan(wl, wlvif, vifs[i].new_ctx); 4901 if (ret) 4902 goto out_sleep; 4903 } 4904 out_sleep: 4905 pm_runtime_mark_last_busy(wl->dev); 4906 pm_runtime_put_autosuspend(wl->dev); 4907 out: 4908 mutex_unlock(&wl->mutex); 4909 4910 return 0; 4911 } 4912 4913 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, 4914 struct ieee80211_vif *vif, u16 queue, 4915 const struct ieee80211_tx_queue_params *params) 4916 { 4917 struct wl1271 *wl = hw->priv; 4918 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4919 u8 ps_scheme; 4920 int ret = 0; 4921 4922 if (wlcore_is_p2p_mgmt(wlvif)) 4923 return 0; 4924 4925 mutex_lock(&wl->mutex); 4926 4927 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue); 4928 4929 if (params->uapsd) 4930 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER; 4931 else 4932 ps_scheme = CONF_PS_SCHEME_LEGACY; 4933 4934 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) 4935 goto out; 4936 4937 ret = pm_runtime_get_sync(wl->dev); 4938 if (ret < 0) { 4939 pm_runtime_put_noidle(wl->dev); 4940 goto out; 4941 } 4942 4943 /* 4944 * the txop is confed in units of 32us by the mac80211, 4945 * we need us 4946 */ 4947 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue), 4948 params->cw_min, params->cw_max, 4949 params->aifs, params->txop << 5); 4950 if (ret < 0) 4951 goto out_sleep; 4952 4953 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue), 4954 CONF_CHANNEL_TYPE_EDCF, 4955 wl1271_tx_get_queue(queue), 4956 ps_scheme, CONF_ACK_POLICY_LEGACY, 4957 0, 0); 4958 4959 out_sleep: 4960 pm_runtime_mark_last_busy(wl->dev); 4961 pm_runtime_put_autosuspend(wl->dev); 4962 4963 out: 4964 mutex_unlock(&wl->mutex); 4965 4966 return ret; 4967 } 4968 4969 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw, 4970 struct ieee80211_vif *vif) 4971 { 4972 4973 struct wl1271 *wl = hw->priv; 4974 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4975 u64 mactime = ULLONG_MAX; 4976 int ret; 4977 4978 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf"); 4979 4980 mutex_lock(&wl->mutex); 4981 4982 if (unlikely(wl->state != WLCORE_STATE_ON)) 4983 goto out; 4984 4985 ret = pm_runtime_get_sync(wl->dev); 4986 if (ret < 0) { 4987 pm_runtime_put_noidle(wl->dev); 4988 goto out; 4989 } 4990 4991 ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime); 4992 if (ret < 0) 4993 goto out_sleep; 4994 4995 out_sleep: 4996 pm_runtime_mark_last_busy(wl->dev); 4997 pm_runtime_put_autosuspend(wl->dev); 4998 4999 out: 5000 mutex_unlock(&wl->mutex); 5001 return mactime; 5002 } 5003 5004 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx, 5005 struct survey_info *survey) 5006 { 5007 struct ieee80211_conf *conf = &hw->conf; 5008 5009 if (idx != 0) 5010 return -ENOENT; 5011 5012 survey->channel = conf->chandef.chan; 5013 survey->filled = 0; 5014 return 0; 5015 } 5016 5017 static int wl1271_allocate_sta(struct wl1271 *wl, 5018 struct wl12xx_vif *wlvif, 5019 struct ieee80211_sta *sta) 5020 { 5021 struct wl1271_station *wl_sta; 5022 int ret; 5023 5024 5025 if (wl->active_sta_count >= wl->max_ap_stations) { 5026 wl1271_warning("could not allocate HLID - too much stations"); 5027 return -EBUSY; 5028 } 5029 5030 wl_sta = (struct wl1271_station *)sta->drv_priv; 5031 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid); 5032 if (ret < 0) { 5033 wl1271_warning("could not allocate HLID - too many links"); 5034 return -EBUSY; 5035 } 5036 5037 /* use the previous security seq, if this is a recovery/resume */ 5038 wl->links[wl_sta->hlid].total_freed_pkts = wl_sta->total_freed_pkts; 5039 5040 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map); 5041 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN); 5042 wl->active_sta_count++; 5043 return 0; 5044 } 5045 5046 void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid) 5047 { 5048 if (!test_bit(hlid, wlvif->ap.sta_hlid_map)) 5049 return; 5050 5051 clear_bit(hlid, wlvif->ap.sta_hlid_map); 5052 __clear_bit(hlid, &wl->ap_ps_map); 5053 __clear_bit(hlid, &wl->ap_fw_ps_map); 5054 5055 /* 5056 * save the last used PN in the private part of iee80211_sta, 5057 * in case of recovery/suspend 5058 */ 5059 wlcore_save_freed_pkts_addr(wl, wlvif, hlid, wl->links[hlid].addr); 5060 5061 wl12xx_free_link(wl, wlvif, &hlid); 5062 wl->active_sta_count--; 5063 5064 /* 5065 * rearm the tx watchdog when the last STA is freed - give the FW a 5066 * chance to return STA-buffered packets before complaining. 5067 */ 5068 if (wl->active_sta_count == 0) 5069 wl12xx_rearm_tx_watchdog_locked(wl); 5070 } 5071 5072 static int wl12xx_sta_add(struct wl1271 *wl, 5073 struct wl12xx_vif *wlvif, 5074 struct ieee80211_sta *sta) 5075 { 5076 struct wl1271_station *wl_sta; 5077 int ret = 0; 5078 u8 hlid; 5079 5080 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid); 5081 5082 ret = wl1271_allocate_sta(wl, wlvif, sta); 5083 if (ret < 0) 5084 return ret; 5085 5086 wl_sta = (struct wl1271_station *)sta->drv_priv; 5087 hlid = wl_sta->hlid; 5088 5089 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid); 5090 if (ret < 0) 5091 wl1271_free_sta(wl, wlvif, hlid); 5092 5093 return ret; 5094 } 5095 5096 static int wl12xx_sta_remove(struct wl1271 *wl, 5097 struct wl12xx_vif *wlvif, 5098 struct ieee80211_sta *sta) 5099 { 5100 struct wl1271_station *wl_sta; 5101 int ret = 0, id; 5102 5103 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid); 5104 5105 wl_sta = (struct wl1271_station *)sta->drv_priv; 5106 id = wl_sta->hlid; 5107 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map))) 5108 return -EINVAL; 5109 5110 ret = wl12xx_cmd_remove_peer(wl, wlvif, wl_sta->hlid); 5111 if (ret < 0) 5112 return ret; 5113 5114 wl1271_free_sta(wl, wlvif, wl_sta->hlid); 5115 return ret; 5116 } 5117 5118 static void wlcore_roc_if_possible(struct wl1271 *wl, 5119 struct wl12xx_vif *wlvif) 5120 { 5121 if (find_first_bit(wl->roc_map, 5122 WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) 5123 return; 5124 5125 if (WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID)) 5126 return; 5127 5128 wl12xx_roc(wl, wlvif, wlvif->role_id, wlvif->band, wlvif->channel); 5129 } 5130 5131 /* 5132 * when wl_sta is NULL, we treat this call as if coming from a 5133 * pending auth reply. 5134 * wl->mutex must be taken and the FW must be awake when the call 5135 * takes place. 5136 */ 5137 void wlcore_update_inconn_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, 5138 struct wl1271_station *wl_sta, bool in_conn) 5139 { 5140 if (in_conn) { 5141 if (WARN_ON(wl_sta && wl_sta->in_connection)) 5142 return; 5143 5144 if (!wlvif->ap_pending_auth_reply && 5145 !wlvif->inconn_count) 5146 wlcore_roc_if_possible(wl, wlvif); 5147 5148 if (wl_sta) { 5149 wl_sta->in_connection = true; 5150 wlvif->inconn_count++; 5151 } else { 5152 wlvif->ap_pending_auth_reply = true; 5153 } 5154 } else { 5155 if (wl_sta && !wl_sta->in_connection) 5156 return; 5157 5158 if (WARN_ON(!wl_sta && !wlvif->ap_pending_auth_reply)) 5159 return; 5160 5161 if (WARN_ON(wl_sta && !wlvif->inconn_count)) 5162 return; 5163 5164 if (wl_sta) { 5165 wl_sta->in_connection = false; 5166 wlvif->inconn_count--; 5167 } else { 5168 wlvif->ap_pending_auth_reply = false; 5169 } 5170 5171 if (!wlvif->inconn_count && !wlvif->ap_pending_auth_reply && 5172 test_bit(wlvif->role_id, wl->roc_map)) 5173 wl12xx_croc(wl, wlvif->role_id); 5174 } 5175 } 5176 5177 static int wl12xx_update_sta_state(struct wl1271 *wl, 5178 struct wl12xx_vif *wlvif, 5179 struct ieee80211_sta *sta, 5180 enum ieee80211_sta_state old_state, 5181 enum ieee80211_sta_state new_state) 5182 { 5183 struct wl1271_station *wl_sta; 5184 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS; 5185 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS; 5186 int ret; 5187 5188 wl_sta = (struct wl1271_station *)sta->drv_priv; 5189 5190 /* Add station (AP mode) */ 5191 if (is_ap && 5192 old_state == IEEE80211_STA_NOTEXIST && 5193 new_state == IEEE80211_STA_NONE) { 5194 ret = wl12xx_sta_add(wl, wlvif, sta); 5195 if (ret) 5196 return ret; 5197 5198 wlcore_update_inconn_sta(wl, wlvif, wl_sta, true); 5199 } 5200 5201 /* Remove station (AP mode) */ 5202 if (is_ap && 5203 old_state == IEEE80211_STA_NONE && 5204 new_state == IEEE80211_STA_NOTEXIST) { 5205 /* must not fail */ 5206 wl12xx_sta_remove(wl, wlvif, sta); 5207 5208 wlcore_update_inconn_sta(wl, wlvif, wl_sta, false); 5209 } 5210 5211 /* Authorize station (AP mode) */ 5212 if (is_ap && 5213 new_state == IEEE80211_STA_AUTHORIZED) { 5214 ret = wl12xx_cmd_set_peer_state(wl, wlvif, wl_sta->hlid); 5215 if (ret < 0) 5216 return ret; 5217 5218 /* reconfigure rates */ 5219 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, wl_sta->hlid); 5220 if (ret < 0) 5221 return ret; 5222 5223 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, 5224 wl_sta->hlid); 5225 if (ret) 5226 return ret; 5227 5228 wlcore_update_inconn_sta(wl, wlvif, wl_sta, false); 5229 } 5230 5231 /* Authorize station */ 5232 if (is_sta && 5233 new_state == IEEE80211_STA_AUTHORIZED) { 5234 set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags); 5235 ret = wl12xx_set_authorized(wl, wlvif); 5236 if (ret) 5237 return ret; 5238 } 5239 5240 if (is_sta && 5241 old_state == IEEE80211_STA_AUTHORIZED && 5242 new_state == IEEE80211_STA_ASSOC) { 5243 clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags); 5244 clear_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags); 5245 } 5246 5247 /* save seq number on disassoc (suspend) */ 5248 if (is_sta && 5249 old_state == IEEE80211_STA_ASSOC && 5250 new_state == IEEE80211_STA_AUTH) { 5251 wlcore_save_freed_pkts(wl, wlvif, wlvif->sta.hlid, sta); 5252 wlvif->total_freed_pkts = 0; 5253 } 5254 5255 /* restore seq number on assoc (resume) */ 5256 if (is_sta && 5257 old_state == IEEE80211_STA_AUTH && 5258 new_state == IEEE80211_STA_ASSOC) { 5259 wlvif->total_freed_pkts = wl_sta->total_freed_pkts; 5260 } 5261 5262 /* clear ROCs on failure or authorization */ 5263 if (is_sta && 5264 (new_state == IEEE80211_STA_AUTHORIZED || 5265 new_state == IEEE80211_STA_NOTEXIST)) { 5266 if (test_bit(wlvif->role_id, wl->roc_map)) 5267 wl12xx_croc(wl, wlvif->role_id); 5268 } 5269 5270 if (is_sta && 5271 old_state == IEEE80211_STA_NOTEXIST && 5272 new_state == IEEE80211_STA_NONE) { 5273 if (find_first_bit(wl->roc_map, 5274 WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES) { 5275 WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID); 5276 wl12xx_roc(wl, wlvif, wlvif->role_id, 5277 wlvif->band, wlvif->channel); 5278 } 5279 } 5280 return 0; 5281 } 5282 5283 static int wl12xx_op_sta_state(struct ieee80211_hw *hw, 5284 struct ieee80211_vif *vif, 5285 struct ieee80211_sta *sta, 5286 enum ieee80211_sta_state old_state, 5287 enum ieee80211_sta_state new_state) 5288 { 5289 struct wl1271 *wl = hw->priv; 5290 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5291 int ret; 5292 5293 wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d", 5294 sta->aid, old_state, new_state); 5295 5296 mutex_lock(&wl->mutex); 5297 5298 if (unlikely(wl->state != WLCORE_STATE_ON)) { 5299 ret = -EBUSY; 5300 goto out; 5301 } 5302 5303 ret = pm_runtime_get_sync(wl->dev); 5304 if (ret < 0) { 5305 pm_runtime_put_noidle(wl->dev); 5306 goto out; 5307 } 5308 5309 ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state); 5310 5311 pm_runtime_mark_last_busy(wl->dev); 5312 pm_runtime_put_autosuspend(wl->dev); 5313 out: 5314 mutex_unlock(&wl->mutex); 5315 if (new_state < old_state) 5316 return 0; 5317 return ret; 5318 } 5319 5320 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw, 5321 struct ieee80211_vif *vif, 5322 struct ieee80211_ampdu_params *params) 5323 { 5324 struct wl1271 *wl = hw->priv; 5325 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5326 int ret; 5327 u8 hlid, *ba_bitmap; 5328 struct ieee80211_sta *sta = params->sta; 5329 enum ieee80211_ampdu_mlme_action action = params->action; 5330 u16 tid = params->tid; 5331 u16 *ssn = ¶ms->ssn; 5332 5333 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action, 5334 tid); 5335 5336 /* sanity check - the fields in FW are only 8bits wide */ 5337 if (WARN_ON(tid > 0xFF)) 5338 return -ENOTSUPP; 5339 5340 mutex_lock(&wl->mutex); 5341 5342 if (unlikely(wl->state != WLCORE_STATE_ON)) { 5343 ret = -EAGAIN; 5344 goto out; 5345 } 5346 5347 if (wlvif->bss_type == BSS_TYPE_STA_BSS) { 5348 hlid = wlvif->sta.hlid; 5349 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) { 5350 struct wl1271_station *wl_sta; 5351 5352 wl_sta = (struct wl1271_station *)sta->drv_priv; 5353 hlid = wl_sta->hlid; 5354 } else { 5355 ret = -EINVAL; 5356 goto out; 5357 } 5358 5359 ba_bitmap = &wl->links[hlid].ba_bitmap; 5360 5361 ret = pm_runtime_get_sync(wl->dev); 5362 if (ret < 0) { 5363 pm_runtime_put_noidle(wl->dev); 5364 goto out; 5365 } 5366 5367 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d", 5368 tid, action); 5369 5370 switch (action) { 5371 case IEEE80211_AMPDU_RX_START: 5372 if (!wlvif->ba_support || !wlvif->ba_allowed) { 5373 ret = -ENOTSUPP; 5374 break; 5375 } 5376 5377 if (wl->ba_rx_session_count >= wl->ba_rx_session_count_max) { 5378 ret = -EBUSY; 5379 wl1271_error("exceeded max RX BA sessions"); 5380 break; 5381 } 5382 5383 if (*ba_bitmap & BIT(tid)) { 5384 ret = -EINVAL; 5385 wl1271_error("cannot enable RX BA session on active " 5386 "tid: %d", tid); 5387 break; 5388 } 5389 5390 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true, 5391 hlid, 5392 params->buf_size); 5393 5394 if (!ret) { 5395 *ba_bitmap |= BIT(tid); 5396 wl->ba_rx_session_count++; 5397 } 5398 break; 5399 5400 case IEEE80211_AMPDU_RX_STOP: 5401 if (!(*ba_bitmap & BIT(tid))) { 5402 /* 5403 * this happens on reconfig - so only output a debug 5404 * message for now, and don't fail the function. 5405 */ 5406 wl1271_debug(DEBUG_MAC80211, 5407 "no active RX BA session on tid: %d", 5408 tid); 5409 ret = 0; 5410 break; 5411 } 5412 5413 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false, 5414 hlid, 0); 5415 if (!ret) { 5416 *ba_bitmap &= ~BIT(tid); 5417 wl->ba_rx_session_count--; 5418 } 5419 break; 5420 5421 /* 5422 * The BA initiator session management in FW independently. 5423 * Falling break here on purpose for all TX APDU commands. 5424 */ 5425 case IEEE80211_AMPDU_TX_START: 5426 case IEEE80211_AMPDU_TX_STOP_CONT: 5427 case IEEE80211_AMPDU_TX_STOP_FLUSH: 5428 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 5429 case IEEE80211_AMPDU_TX_OPERATIONAL: 5430 ret = -EINVAL; 5431 break; 5432 5433 default: 5434 wl1271_error("Incorrect ampdu action id=%x\n", action); 5435 ret = -EINVAL; 5436 } 5437 5438 pm_runtime_mark_last_busy(wl->dev); 5439 pm_runtime_put_autosuspend(wl->dev); 5440 5441 out: 5442 mutex_unlock(&wl->mutex); 5443 5444 return ret; 5445 } 5446 5447 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw, 5448 struct ieee80211_vif *vif, 5449 const struct cfg80211_bitrate_mask *mask) 5450 { 5451 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5452 struct wl1271 *wl = hw->priv; 5453 int i, ret = 0; 5454 5455 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x", 5456 mask->control[NL80211_BAND_2GHZ].legacy, 5457 mask->control[NL80211_BAND_5GHZ].legacy); 5458 5459 mutex_lock(&wl->mutex); 5460 5461 for (i = 0; i < WLCORE_NUM_BANDS; i++) 5462 wlvif->bitrate_masks[i] = 5463 wl1271_tx_enabled_rates_get(wl, 5464 mask->control[i].legacy, 5465 i); 5466 5467 if (unlikely(wl->state != WLCORE_STATE_ON)) 5468 goto out; 5469 5470 if (wlvif->bss_type == BSS_TYPE_STA_BSS && 5471 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) { 5472 5473 ret = pm_runtime_get_sync(wl->dev); 5474 if (ret < 0) { 5475 pm_runtime_put_noidle(wl->dev); 5476 goto out; 5477 } 5478 5479 wl1271_set_band_rate(wl, wlvif); 5480 wlvif->basic_rate = 5481 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 5482 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 5483 5484 pm_runtime_mark_last_busy(wl->dev); 5485 pm_runtime_put_autosuspend(wl->dev); 5486 } 5487 out: 5488 mutex_unlock(&wl->mutex); 5489 5490 return ret; 5491 } 5492 5493 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw, 5494 struct ieee80211_vif *vif, 5495 struct ieee80211_channel_switch *ch_switch) 5496 { 5497 struct wl1271 *wl = hw->priv; 5498 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5499 int ret; 5500 5501 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch"); 5502 5503 wl1271_tx_flush(wl); 5504 5505 mutex_lock(&wl->mutex); 5506 5507 if (unlikely(wl->state == WLCORE_STATE_OFF)) { 5508 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) 5509 ieee80211_chswitch_done(vif, false); 5510 goto out; 5511 } else if (unlikely(wl->state != WLCORE_STATE_ON)) { 5512 goto out; 5513 } 5514 5515 ret = pm_runtime_get_sync(wl->dev); 5516 if (ret < 0) { 5517 pm_runtime_put_noidle(wl->dev); 5518 goto out; 5519 } 5520 5521 /* TODO: change mac80211 to pass vif as param */ 5522 5523 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) { 5524 unsigned long delay_usec; 5525 5526 ret = wl->ops->channel_switch(wl, wlvif, ch_switch); 5527 if (ret) 5528 goto out_sleep; 5529 5530 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags); 5531 5532 /* indicate failure 5 seconds after channel switch time */ 5533 delay_usec = ieee80211_tu_to_usec(wlvif->beacon_int) * 5534 ch_switch->count; 5535 ieee80211_queue_delayed_work(hw, &wlvif->channel_switch_work, 5536 usecs_to_jiffies(delay_usec) + 5537 msecs_to_jiffies(5000)); 5538 } 5539 5540 out_sleep: 5541 pm_runtime_mark_last_busy(wl->dev); 5542 pm_runtime_put_autosuspend(wl->dev); 5543 5544 out: 5545 mutex_unlock(&wl->mutex); 5546 } 5547 5548 static const void *wlcore_get_beacon_ie(struct wl1271 *wl, 5549 struct wl12xx_vif *wlvif, 5550 u8 eid) 5551 { 5552 int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable); 5553 struct sk_buff *beacon = 5554 ieee80211_beacon_get(wl->hw, wl12xx_wlvif_to_vif(wlvif)); 5555 5556 if (!beacon) 5557 return NULL; 5558 5559 return cfg80211_find_ie(eid, 5560 beacon->data + ieoffset, 5561 beacon->len - ieoffset); 5562 } 5563 5564 static int wlcore_get_csa_count(struct wl1271 *wl, struct wl12xx_vif *wlvif, 5565 u8 *csa_count) 5566 { 5567 const u8 *ie; 5568 const struct ieee80211_channel_sw_ie *ie_csa; 5569 5570 ie = wlcore_get_beacon_ie(wl, wlvif, WLAN_EID_CHANNEL_SWITCH); 5571 if (!ie) 5572 return -EINVAL; 5573 5574 ie_csa = (struct ieee80211_channel_sw_ie *)&ie[2]; 5575 *csa_count = ie_csa->count; 5576 5577 return 0; 5578 } 5579 5580 static void wlcore_op_channel_switch_beacon(struct ieee80211_hw *hw, 5581 struct ieee80211_vif *vif, 5582 struct cfg80211_chan_def *chandef) 5583 { 5584 struct wl1271 *wl = hw->priv; 5585 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5586 struct ieee80211_channel_switch ch_switch = { 5587 .block_tx = true, 5588 .chandef = *chandef, 5589 }; 5590 int ret; 5591 5592 wl1271_debug(DEBUG_MAC80211, 5593 "mac80211 channel switch beacon (role %d)", 5594 wlvif->role_id); 5595 5596 ret = wlcore_get_csa_count(wl, wlvif, &ch_switch.count); 5597 if (ret < 0) { 5598 wl1271_error("error getting beacon (for CSA counter)"); 5599 return; 5600 } 5601 5602 mutex_lock(&wl->mutex); 5603 5604 if (unlikely(wl->state != WLCORE_STATE_ON)) { 5605 ret = -EBUSY; 5606 goto out; 5607 } 5608 5609 ret = pm_runtime_get_sync(wl->dev); 5610 if (ret < 0) { 5611 pm_runtime_put_noidle(wl->dev); 5612 goto out; 5613 } 5614 5615 ret = wl->ops->channel_switch(wl, wlvif, &ch_switch); 5616 if (ret) 5617 goto out_sleep; 5618 5619 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags); 5620 5621 out_sleep: 5622 pm_runtime_mark_last_busy(wl->dev); 5623 pm_runtime_put_autosuspend(wl->dev); 5624 out: 5625 mutex_unlock(&wl->mutex); 5626 } 5627 5628 static void wlcore_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 5629 u32 queues, bool drop) 5630 { 5631 struct wl1271 *wl = hw->priv; 5632 5633 wl1271_tx_flush(wl); 5634 } 5635 5636 static int wlcore_op_remain_on_channel(struct ieee80211_hw *hw, 5637 struct ieee80211_vif *vif, 5638 struct ieee80211_channel *chan, 5639 int duration, 5640 enum ieee80211_roc_type type) 5641 { 5642 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5643 struct wl1271 *wl = hw->priv; 5644 int channel, active_roc, ret = 0; 5645 5646 channel = ieee80211_frequency_to_channel(chan->center_freq); 5647 5648 wl1271_debug(DEBUG_MAC80211, "mac80211 roc %d (%d)", 5649 channel, wlvif->role_id); 5650 5651 mutex_lock(&wl->mutex); 5652 5653 if (unlikely(wl->state != WLCORE_STATE_ON)) 5654 goto out; 5655 5656 /* return EBUSY if we can't ROC right now */ 5657 active_roc = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES); 5658 if (wl->roc_vif || active_roc < WL12XX_MAX_ROLES) { 5659 wl1271_warning("active roc on role %d", active_roc); 5660 ret = -EBUSY; 5661 goto out; 5662 } 5663 5664 ret = pm_runtime_get_sync(wl->dev); 5665 if (ret < 0) { 5666 pm_runtime_put_noidle(wl->dev); 5667 goto out; 5668 } 5669 5670 ret = wl12xx_start_dev(wl, wlvif, chan->band, channel); 5671 if (ret < 0) 5672 goto out_sleep; 5673 5674 wl->roc_vif = vif; 5675 ieee80211_queue_delayed_work(hw, &wl->roc_complete_work, 5676 msecs_to_jiffies(duration)); 5677 out_sleep: 5678 pm_runtime_mark_last_busy(wl->dev); 5679 pm_runtime_put_autosuspend(wl->dev); 5680 out: 5681 mutex_unlock(&wl->mutex); 5682 return ret; 5683 } 5684 5685 static int __wlcore_roc_completed(struct wl1271 *wl) 5686 { 5687 struct wl12xx_vif *wlvif; 5688 int ret; 5689 5690 /* already completed */ 5691 if (unlikely(!wl->roc_vif)) 5692 return 0; 5693 5694 wlvif = wl12xx_vif_to_data(wl->roc_vif); 5695 5696 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) 5697 return -EBUSY; 5698 5699 ret = wl12xx_stop_dev(wl, wlvif); 5700 if (ret < 0) 5701 return ret; 5702 5703 wl->roc_vif = NULL; 5704 5705 return 0; 5706 } 5707 5708 static int wlcore_roc_completed(struct wl1271 *wl) 5709 { 5710 int ret; 5711 5712 wl1271_debug(DEBUG_MAC80211, "roc complete"); 5713 5714 mutex_lock(&wl->mutex); 5715 5716 if (unlikely(wl->state != WLCORE_STATE_ON)) { 5717 ret = -EBUSY; 5718 goto out; 5719 } 5720 5721 ret = pm_runtime_get_sync(wl->dev); 5722 if (ret < 0) { 5723 pm_runtime_put_noidle(wl->dev); 5724 goto out; 5725 } 5726 5727 ret = __wlcore_roc_completed(wl); 5728 5729 pm_runtime_mark_last_busy(wl->dev); 5730 pm_runtime_put_autosuspend(wl->dev); 5731 out: 5732 mutex_unlock(&wl->mutex); 5733 5734 return ret; 5735 } 5736 5737 static void wlcore_roc_complete_work(struct work_struct *work) 5738 { 5739 struct delayed_work *dwork; 5740 struct wl1271 *wl; 5741 int ret; 5742 5743 dwork = to_delayed_work(work); 5744 wl = container_of(dwork, struct wl1271, roc_complete_work); 5745 5746 ret = wlcore_roc_completed(wl); 5747 if (!ret) 5748 ieee80211_remain_on_channel_expired(wl->hw); 5749 } 5750 5751 static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw *hw, 5752 struct ieee80211_vif *vif) 5753 { 5754 struct wl1271 *wl = hw->priv; 5755 5756 wl1271_debug(DEBUG_MAC80211, "mac80211 croc"); 5757 5758 /* TODO: per-vif */ 5759 wl1271_tx_flush(wl); 5760 5761 /* 5762 * we can't just flush_work here, because it might deadlock 5763 * (as we might get called from the same workqueue) 5764 */ 5765 cancel_delayed_work_sync(&wl->roc_complete_work); 5766 wlcore_roc_completed(wl); 5767 5768 return 0; 5769 } 5770 5771 static void wlcore_op_sta_rc_update(struct ieee80211_hw *hw, 5772 struct ieee80211_vif *vif, 5773 struct ieee80211_sta *sta, 5774 u32 changed) 5775 { 5776 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5777 5778 wl1271_debug(DEBUG_MAC80211, "mac80211 sta_rc_update"); 5779 5780 if (!(changed & IEEE80211_RC_BW_CHANGED)) 5781 return; 5782 5783 /* this callback is atomic, so schedule a new work */ 5784 wlvif->rc_update_bw = sta->bandwidth; 5785 memcpy(&wlvif->rc_ht_cap, &sta->ht_cap, sizeof(sta->ht_cap)); 5786 ieee80211_queue_work(hw, &wlvif->rc_update_work); 5787 } 5788 5789 static void wlcore_op_sta_statistics(struct ieee80211_hw *hw, 5790 struct ieee80211_vif *vif, 5791 struct ieee80211_sta *sta, 5792 struct station_info *sinfo) 5793 { 5794 struct wl1271 *wl = hw->priv; 5795 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 5796 s8 rssi_dbm; 5797 int ret; 5798 5799 wl1271_debug(DEBUG_MAC80211, "mac80211 get_rssi"); 5800 5801 mutex_lock(&wl->mutex); 5802 5803 if (unlikely(wl->state != WLCORE_STATE_ON)) 5804 goto out; 5805 5806 ret = pm_runtime_get_sync(wl->dev); 5807 if (ret < 0) { 5808 pm_runtime_put_noidle(wl->dev); 5809 goto out_sleep; 5810 } 5811 5812 ret = wlcore_acx_average_rssi(wl, wlvif, &rssi_dbm); 5813 if (ret < 0) 5814 goto out_sleep; 5815 5816 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 5817 sinfo->signal = rssi_dbm; 5818 5819 out_sleep: 5820 pm_runtime_mark_last_busy(wl->dev); 5821 pm_runtime_put_autosuspend(wl->dev); 5822 5823 out: 5824 mutex_unlock(&wl->mutex); 5825 } 5826 5827 static u32 wlcore_op_get_expected_throughput(struct ieee80211_hw *hw, 5828 struct ieee80211_sta *sta) 5829 { 5830 struct wl1271_station *wl_sta = (struct wl1271_station *)sta->drv_priv; 5831 struct wl1271 *wl = hw->priv; 5832 u8 hlid = wl_sta->hlid; 5833 5834 /* return in units of Kbps */ 5835 return (wl->links[hlid].fw_rate_mbps * 1000); 5836 } 5837 5838 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw) 5839 { 5840 struct wl1271 *wl = hw->priv; 5841 bool ret = false; 5842 5843 mutex_lock(&wl->mutex); 5844 5845 if (unlikely(wl->state != WLCORE_STATE_ON)) 5846 goto out; 5847 5848 /* packets are considered pending if in the TX queue or the FW */ 5849 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0); 5850 out: 5851 mutex_unlock(&wl->mutex); 5852 5853 return ret; 5854 } 5855 5856 /* can't be const, mac80211 writes to this */ 5857 static struct ieee80211_rate wl1271_rates[] = { 5858 { .bitrate = 10, 5859 .hw_value = CONF_HW_BIT_RATE_1MBPS, 5860 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, }, 5861 { .bitrate = 20, 5862 .hw_value = CONF_HW_BIT_RATE_2MBPS, 5863 .hw_value_short = CONF_HW_BIT_RATE_2MBPS, 5864 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 5865 { .bitrate = 55, 5866 .hw_value = CONF_HW_BIT_RATE_5_5MBPS, 5867 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS, 5868 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 5869 { .bitrate = 110, 5870 .hw_value = CONF_HW_BIT_RATE_11MBPS, 5871 .hw_value_short = CONF_HW_BIT_RATE_11MBPS, 5872 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 5873 { .bitrate = 60, 5874 .hw_value = CONF_HW_BIT_RATE_6MBPS, 5875 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, }, 5876 { .bitrate = 90, 5877 .hw_value = CONF_HW_BIT_RATE_9MBPS, 5878 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, }, 5879 { .bitrate = 120, 5880 .hw_value = CONF_HW_BIT_RATE_12MBPS, 5881 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, }, 5882 { .bitrate = 180, 5883 .hw_value = CONF_HW_BIT_RATE_18MBPS, 5884 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, }, 5885 { .bitrate = 240, 5886 .hw_value = CONF_HW_BIT_RATE_24MBPS, 5887 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, }, 5888 { .bitrate = 360, 5889 .hw_value = CONF_HW_BIT_RATE_36MBPS, 5890 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, }, 5891 { .bitrate = 480, 5892 .hw_value = CONF_HW_BIT_RATE_48MBPS, 5893 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, }, 5894 { .bitrate = 540, 5895 .hw_value = CONF_HW_BIT_RATE_54MBPS, 5896 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, }, 5897 }; 5898 5899 /* can't be const, mac80211 writes to this */ 5900 static struct ieee80211_channel wl1271_channels[] = { 5901 { .hw_value = 1, .center_freq = 2412, .max_power = WLCORE_MAX_TXPWR }, 5902 { .hw_value = 2, .center_freq = 2417, .max_power = WLCORE_MAX_TXPWR }, 5903 { .hw_value = 3, .center_freq = 2422, .max_power = WLCORE_MAX_TXPWR }, 5904 { .hw_value = 4, .center_freq = 2427, .max_power = WLCORE_MAX_TXPWR }, 5905 { .hw_value = 5, .center_freq = 2432, .max_power = WLCORE_MAX_TXPWR }, 5906 { .hw_value = 6, .center_freq = 2437, .max_power = WLCORE_MAX_TXPWR }, 5907 { .hw_value = 7, .center_freq = 2442, .max_power = WLCORE_MAX_TXPWR }, 5908 { .hw_value = 8, .center_freq = 2447, .max_power = WLCORE_MAX_TXPWR }, 5909 { .hw_value = 9, .center_freq = 2452, .max_power = WLCORE_MAX_TXPWR }, 5910 { .hw_value = 10, .center_freq = 2457, .max_power = WLCORE_MAX_TXPWR }, 5911 { .hw_value = 11, .center_freq = 2462, .max_power = WLCORE_MAX_TXPWR }, 5912 { .hw_value = 12, .center_freq = 2467, .max_power = WLCORE_MAX_TXPWR }, 5913 { .hw_value = 13, .center_freq = 2472, .max_power = WLCORE_MAX_TXPWR }, 5914 { .hw_value = 14, .center_freq = 2484, .max_power = WLCORE_MAX_TXPWR }, 5915 }; 5916 5917 /* can't be const, mac80211 writes to this */ 5918 static struct ieee80211_supported_band wl1271_band_2ghz = { 5919 .channels = wl1271_channels, 5920 .n_channels = ARRAY_SIZE(wl1271_channels), 5921 .bitrates = wl1271_rates, 5922 .n_bitrates = ARRAY_SIZE(wl1271_rates), 5923 }; 5924 5925 /* 5 GHz data rates for WL1273 */ 5926 static struct ieee80211_rate wl1271_rates_5ghz[] = { 5927 { .bitrate = 60, 5928 .hw_value = CONF_HW_BIT_RATE_6MBPS, 5929 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, }, 5930 { .bitrate = 90, 5931 .hw_value = CONF_HW_BIT_RATE_9MBPS, 5932 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, }, 5933 { .bitrate = 120, 5934 .hw_value = CONF_HW_BIT_RATE_12MBPS, 5935 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, }, 5936 { .bitrate = 180, 5937 .hw_value = CONF_HW_BIT_RATE_18MBPS, 5938 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, }, 5939 { .bitrate = 240, 5940 .hw_value = CONF_HW_BIT_RATE_24MBPS, 5941 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, }, 5942 { .bitrate = 360, 5943 .hw_value = CONF_HW_BIT_RATE_36MBPS, 5944 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, }, 5945 { .bitrate = 480, 5946 .hw_value = CONF_HW_BIT_RATE_48MBPS, 5947 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, }, 5948 { .bitrate = 540, 5949 .hw_value = CONF_HW_BIT_RATE_54MBPS, 5950 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, }, 5951 }; 5952 5953 /* 5 GHz band channels for WL1273 */ 5954 static struct ieee80211_channel wl1271_channels_5ghz[] = { 5955 { .hw_value = 8, .center_freq = 5040, .max_power = WLCORE_MAX_TXPWR }, 5956 { .hw_value = 12, .center_freq = 5060, .max_power = WLCORE_MAX_TXPWR }, 5957 { .hw_value = 16, .center_freq = 5080, .max_power = WLCORE_MAX_TXPWR }, 5958 { .hw_value = 34, .center_freq = 5170, .max_power = WLCORE_MAX_TXPWR }, 5959 { .hw_value = 36, .center_freq = 5180, .max_power = WLCORE_MAX_TXPWR }, 5960 { .hw_value = 38, .center_freq = 5190, .max_power = WLCORE_MAX_TXPWR }, 5961 { .hw_value = 40, .center_freq = 5200, .max_power = WLCORE_MAX_TXPWR }, 5962 { .hw_value = 42, .center_freq = 5210, .max_power = WLCORE_MAX_TXPWR }, 5963 { .hw_value = 44, .center_freq = 5220, .max_power = WLCORE_MAX_TXPWR }, 5964 { .hw_value = 46, .center_freq = 5230, .max_power = WLCORE_MAX_TXPWR }, 5965 { .hw_value = 48, .center_freq = 5240, .max_power = WLCORE_MAX_TXPWR }, 5966 { .hw_value = 52, .center_freq = 5260, .max_power = WLCORE_MAX_TXPWR }, 5967 { .hw_value = 56, .center_freq = 5280, .max_power = WLCORE_MAX_TXPWR }, 5968 { .hw_value = 60, .center_freq = 5300, .max_power = WLCORE_MAX_TXPWR }, 5969 { .hw_value = 64, .center_freq = 5320, .max_power = WLCORE_MAX_TXPWR }, 5970 { .hw_value = 100, .center_freq = 5500, .max_power = WLCORE_MAX_TXPWR }, 5971 { .hw_value = 104, .center_freq = 5520, .max_power = WLCORE_MAX_TXPWR }, 5972 { .hw_value = 108, .center_freq = 5540, .max_power = WLCORE_MAX_TXPWR }, 5973 { .hw_value = 112, .center_freq = 5560, .max_power = WLCORE_MAX_TXPWR }, 5974 { .hw_value = 116, .center_freq = 5580, .max_power = WLCORE_MAX_TXPWR }, 5975 { .hw_value = 120, .center_freq = 5600, .max_power = WLCORE_MAX_TXPWR }, 5976 { .hw_value = 124, .center_freq = 5620, .max_power = WLCORE_MAX_TXPWR }, 5977 { .hw_value = 128, .center_freq = 5640, .max_power = WLCORE_MAX_TXPWR }, 5978 { .hw_value = 132, .center_freq = 5660, .max_power = WLCORE_MAX_TXPWR }, 5979 { .hw_value = 136, .center_freq = 5680, .max_power = WLCORE_MAX_TXPWR }, 5980 { .hw_value = 140, .center_freq = 5700, .max_power = WLCORE_MAX_TXPWR }, 5981 { .hw_value = 149, .center_freq = 5745, .max_power = WLCORE_MAX_TXPWR }, 5982 { .hw_value = 153, .center_freq = 5765, .max_power = WLCORE_MAX_TXPWR }, 5983 { .hw_value = 157, .center_freq = 5785, .max_power = WLCORE_MAX_TXPWR }, 5984 { .hw_value = 161, .center_freq = 5805, .max_power = WLCORE_MAX_TXPWR }, 5985 { .hw_value = 165, .center_freq = 5825, .max_power = WLCORE_MAX_TXPWR }, 5986 }; 5987 5988 static struct ieee80211_supported_band wl1271_band_5ghz = { 5989 .channels = wl1271_channels_5ghz, 5990 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz), 5991 .bitrates = wl1271_rates_5ghz, 5992 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz), 5993 }; 5994 5995 static const struct ieee80211_ops wl1271_ops = { 5996 .start = wl1271_op_start, 5997 .stop = wlcore_op_stop, 5998 .add_interface = wl1271_op_add_interface, 5999 .remove_interface = wl1271_op_remove_interface, 6000 .change_interface = wl12xx_op_change_interface, 6001 #ifdef CONFIG_PM 6002 .suspend = wl1271_op_suspend, 6003 .resume = wl1271_op_resume, 6004 #endif 6005 .config = wl1271_op_config, 6006 .prepare_multicast = wl1271_op_prepare_multicast, 6007 .configure_filter = wl1271_op_configure_filter, 6008 .tx = wl1271_op_tx, 6009 .set_key = wlcore_op_set_key, 6010 .hw_scan = wl1271_op_hw_scan, 6011 .cancel_hw_scan = wl1271_op_cancel_hw_scan, 6012 .sched_scan_start = wl1271_op_sched_scan_start, 6013 .sched_scan_stop = wl1271_op_sched_scan_stop, 6014 .bss_info_changed = wl1271_op_bss_info_changed, 6015 .set_frag_threshold = wl1271_op_set_frag_threshold, 6016 .set_rts_threshold = wl1271_op_set_rts_threshold, 6017 .conf_tx = wl1271_op_conf_tx, 6018 .get_tsf = wl1271_op_get_tsf, 6019 .get_survey = wl1271_op_get_survey, 6020 .sta_state = wl12xx_op_sta_state, 6021 .ampdu_action = wl1271_op_ampdu_action, 6022 .tx_frames_pending = wl1271_tx_frames_pending, 6023 .set_bitrate_mask = wl12xx_set_bitrate_mask, 6024 .set_default_unicast_key = wl1271_op_set_default_key_idx, 6025 .channel_switch = wl12xx_op_channel_switch, 6026 .channel_switch_beacon = wlcore_op_channel_switch_beacon, 6027 .flush = wlcore_op_flush, 6028 .remain_on_channel = wlcore_op_remain_on_channel, 6029 .cancel_remain_on_channel = wlcore_op_cancel_remain_on_channel, 6030 .add_chanctx = wlcore_op_add_chanctx, 6031 .remove_chanctx = wlcore_op_remove_chanctx, 6032 .change_chanctx = wlcore_op_change_chanctx, 6033 .assign_vif_chanctx = wlcore_op_assign_vif_chanctx, 6034 .unassign_vif_chanctx = wlcore_op_unassign_vif_chanctx, 6035 .switch_vif_chanctx = wlcore_op_switch_vif_chanctx, 6036 .sta_rc_update = wlcore_op_sta_rc_update, 6037 .sta_statistics = wlcore_op_sta_statistics, 6038 .get_expected_throughput = wlcore_op_get_expected_throughput, 6039 CFG80211_TESTMODE_CMD(wl1271_tm_cmd) 6040 }; 6041 6042 6043 u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum nl80211_band band) 6044 { 6045 u8 idx; 6046 6047 BUG_ON(band >= 2); 6048 6049 if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) { 6050 wl1271_error("Illegal RX rate from HW: %d", rate); 6051 return 0; 6052 } 6053 6054 idx = wl->band_rate_to_idx[band][rate]; 6055 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) { 6056 wl1271_error("Unsupported RX rate from HW: %d", rate); 6057 return 0; 6058 } 6059 6060 return idx; 6061 } 6062 6063 static void wl12xx_derive_mac_addresses(struct wl1271 *wl, u32 oui, u32 nic) 6064 { 6065 int i; 6066 6067 wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x", 6068 oui, nic); 6069 6070 if (nic + WLCORE_NUM_MAC_ADDRESSES - wl->num_mac_addr > 0xffffff) 6071 wl1271_warning("NIC part of the MAC address wraps around!"); 6072 6073 for (i = 0; i < wl->num_mac_addr; i++) { 6074 wl->addresses[i].addr[0] = (u8)(oui >> 16); 6075 wl->addresses[i].addr[1] = (u8)(oui >> 8); 6076 wl->addresses[i].addr[2] = (u8) oui; 6077 wl->addresses[i].addr[3] = (u8)(nic >> 16); 6078 wl->addresses[i].addr[4] = (u8)(nic >> 8); 6079 wl->addresses[i].addr[5] = (u8) nic; 6080 nic++; 6081 } 6082 6083 /* we may be one address short at the most */ 6084 WARN_ON(wl->num_mac_addr + 1 < WLCORE_NUM_MAC_ADDRESSES); 6085 6086 /* 6087 * turn on the LAA bit in the first address and use it as 6088 * the last address. 6089 */ 6090 if (wl->num_mac_addr < WLCORE_NUM_MAC_ADDRESSES) { 6091 int idx = WLCORE_NUM_MAC_ADDRESSES - 1; 6092 memcpy(&wl->addresses[idx], &wl->addresses[0], 6093 sizeof(wl->addresses[0])); 6094 /* LAA bit */ 6095 wl->addresses[idx].addr[0] |= BIT(1); 6096 } 6097 6098 wl->hw->wiphy->n_addresses = WLCORE_NUM_MAC_ADDRESSES; 6099 wl->hw->wiphy->addresses = wl->addresses; 6100 } 6101 6102 static int wl12xx_get_hw_info(struct wl1271 *wl) 6103 { 6104 int ret; 6105 6106 ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &wl->chip.id); 6107 if (ret < 0) 6108 goto out; 6109 6110 wl->fuse_oui_addr = 0; 6111 wl->fuse_nic_addr = 0; 6112 6113 ret = wl->ops->get_pg_ver(wl, &wl->hw_pg_ver); 6114 if (ret < 0) 6115 goto out; 6116 6117 if (wl->ops->get_mac) 6118 ret = wl->ops->get_mac(wl); 6119 6120 out: 6121 return ret; 6122 } 6123 6124 static int wl1271_register_hw(struct wl1271 *wl) 6125 { 6126 int ret; 6127 u32 oui_addr = 0, nic_addr = 0; 6128 struct platform_device *pdev = wl->pdev; 6129 struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev); 6130 6131 if (wl->mac80211_registered) 6132 return 0; 6133 6134 if (wl->nvs_len >= 12) { 6135 /* NOTE: The wl->nvs->nvs element must be first, in 6136 * order to simplify the casting, we assume it is at 6137 * the beginning of the wl->nvs structure. 6138 */ 6139 u8 *nvs_ptr = (u8 *)wl->nvs; 6140 6141 oui_addr = 6142 (nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6]; 6143 nic_addr = 6144 (nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3]; 6145 } 6146 6147 /* if the MAC address is zeroed in the NVS derive from fuse */ 6148 if (oui_addr == 0 && nic_addr == 0) { 6149 oui_addr = wl->fuse_oui_addr; 6150 /* fuse has the BD_ADDR, the WLAN addresses are the next two */ 6151 nic_addr = wl->fuse_nic_addr + 1; 6152 } 6153 6154 if (oui_addr == 0xdeadbe && nic_addr == 0xef0000) { 6155 wl1271_warning("Detected unconfigured mac address in nvs, derive from fuse instead."); 6156 if (!strcmp(pdev_data->family->name, "wl18xx")) { 6157 wl1271_warning("This default nvs file can be removed from the file system"); 6158 } else { 6159 wl1271_warning("Your device performance is not optimized."); 6160 wl1271_warning("Please use the calibrator tool to configure your device."); 6161 } 6162 6163 if (wl->fuse_oui_addr == 0 && wl->fuse_nic_addr == 0) { 6164 wl1271_warning("Fuse mac address is zero. using random mac"); 6165 /* Use TI oui and a random nic */ 6166 oui_addr = WLCORE_TI_OUI_ADDRESS; 6167 nic_addr = get_random_int(); 6168 } else { 6169 oui_addr = wl->fuse_oui_addr; 6170 /* fuse has the BD_ADDR, the WLAN addresses are the next two */ 6171 nic_addr = wl->fuse_nic_addr + 1; 6172 } 6173 } 6174 6175 wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr); 6176 6177 ret = ieee80211_register_hw(wl->hw); 6178 if (ret < 0) { 6179 wl1271_error("unable to register mac80211 hw: %d", ret); 6180 goto out; 6181 } 6182 6183 wl->mac80211_registered = true; 6184 6185 wl1271_debugfs_init(wl); 6186 6187 wl1271_notice("loaded"); 6188 6189 out: 6190 return ret; 6191 } 6192 6193 static void wl1271_unregister_hw(struct wl1271 *wl) 6194 { 6195 if (wl->plt) 6196 wl1271_plt_stop(wl); 6197 6198 ieee80211_unregister_hw(wl->hw); 6199 wl->mac80211_registered = false; 6200 6201 } 6202 6203 static int wl1271_init_ieee80211(struct wl1271 *wl) 6204 { 6205 int i; 6206 static const u32 cipher_suites[] = { 6207 WLAN_CIPHER_SUITE_WEP40, 6208 WLAN_CIPHER_SUITE_WEP104, 6209 WLAN_CIPHER_SUITE_TKIP, 6210 WLAN_CIPHER_SUITE_CCMP, 6211 WL1271_CIPHER_SUITE_GEM, 6212 }; 6213 6214 /* The tx descriptor buffer */ 6215 wl->hw->extra_tx_headroom = sizeof(struct wl1271_tx_hw_descr); 6216 6217 if (wl->quirks & WLCORE_QUIRK_TKIP_HEADER_SPACE) 6218 wl->hw->extra_tx_headroom += WL1271_EXTRA_SPACE_TKIP; 6219 6220 /* unit us */ 6221 /* FIXME: find a proper value */ 6222 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval; 6223 6224 ieee80211_hw_set(wl->hw, SUPPORT_FAST_XMIT); 6225 ieee80211_hw_set(wl->hw, CHANCTX_STA_CSA); 6226 ieee80211_hw_set(wl->hw, QUEUE_CONTROL); 6227 ieee80211_hw_set(wl->hw, TX_AMPDU_SETUP_IN_HW); 6228 ieee80211_hw_set(wl->hw, AMPDU_AGGREGATION); 6229 ieee80211_hw_set(wl->hw, AP_LINK_PS); 6230 ieee80211_hw_set(wl->hw, SPECTRUM_MGMT); 6231 ieee80211_hw_set(wl->hw, REPORTS_TX_ACK_STATUS); 6232 ieee80211_hw_set(wl->hw, CONNECTION_MONITOR); 6233 ieee80211_hw_set(wl->hw, HAS_RATE_CONTROL); 6234 ieee80211_hw_set(wl->hw, SUPPORTS_DYNAMIC_PS); 6235 ieee80211_hw_set(wl->hw, SIGNAL_DBM); 6236 ieee80211_hw_set(wl->hw, SUPPORTS_PS); 6237 ieee80211_hw_set(wl->hw, SUPPORTS_TX_FRAG); 6238 6239 wl->hw->wiphy->cipher_suites = cipher_suites; 6240 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 6241 6242 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 6243 BIT(NL80211_IFTYPE_AP) | 6244 BIT(NL80211_IFTYPE_P2P_DEVICE) | 6245 BIT(NL80211_IFTYPE_P2P_CLIENT) | 6246 #ifdef CONFIG_MAC80211_MESH 6247 BIT(NL80211_IFTYPE_MESH_POINT) | 6248 #endif 6249 BIT(NL80211_IFTYPE_P2P_GO); 6250 6251 wl->hw->wiphy->max_scan_ssids = 1; 6252 wl->hw->wiphy->max_sched_scan_ssids = 16; 6253 wl->hw->wiphy->max_match_sets = 16; 6254 /* 6255 * Maximum length of elements in scanning probe request templates 6256 * should be the maximum length possible for a template, without 6257 * the IEEE80211 header of the template 6258 */ 6259 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE - 6260 sizeof(struct ieee80211_header); 6261 6262 wl->hw->wiphy->max_sched_scan_reqs = 1; 6263 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE - 6264 sizeof(struct ieee80211_header); 6265 6266 wl->hw->wiphy->max_remain_on_channel_duration = 30000; 6267 6268 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD | 6269 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL | 6270 WIPHY_FLAG_HAS_CHANNEL_SWITCH; 6271 6272 wl->hw->wiphy->features |= NL80211_FEATURE_AP_SCAN; 6273 6274 /* make sure all our channels fit in the scanned_ch bitmask */ 6275 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) + 6276 ARRAY_SIZE(wl1271_channels_5ghz) > 6277 WL1271_MAX_CHANNELS); 6278 /* 6279 * clear channel flags from the previous usage 6280 * and restore max_power & max_antenna_gain values. 6281 */ 6282 for (i = 0; i < ARRAY_SIZE(wl1271_channels); i++) { 6283 wl1271_band_2ghz.channels[i].flags = 0; 6284 wl1271_band_2ghz.channels[i].max_power = WLCORE_MAX_TXPWR; 6285 wl1271_band_2ghz.channels[i].max_antenna_gain = 0; 6286 } 6287 6288 for (i = 0; i < ARRAY_SIZE(wl1271_channels_5ghz); i++) { 6289 wl1271_band_5ghz.channels[i].flags = 0; 6290 wl1271_band_5ghz.channels[i].max_power = WLCORE_MAX_TXPWR; 6291 wl1271_band_5ghz.channels[i].max_antenna_gain = 0; 6292 } 6293 6294 /* 6295 * We keep local copies of the band structs because we need to 6296 * modify them on a per-device basis. 6297 */ 6298 memcpy(&wl->bands[NL80211_BAND_2GHZ], &wl1271_band_2ghz, 6299 sizeof(wl1271_band_2ghz)); 6300 memcpy(&wl->bands[NL80211_BAND_2GHZ].ht_cap, 6301 &wl->ht_cap[NL80211_BAND_2GHZ], 6302 sizeof(*wl->ht_cap)); 6303 memcpy(&wl->bands[NL80211_BAND_5GHZ], &wl1271_band_5ghz, 6304 sizeof(wl1271_band_5ghz)); 6305 memcpy(&wl->bands[NL80211_BAND_5GHZ].ht_cap, 6306 &wl->ht_cap[NL80211_BAND_5GHZ], 6307 sizeof(*wl->ht_cap)); 6308 6309 wl->hw->wiphy->bands[NL80211_BAND_2GHZ] = 6310 &wl->bands[NL80211_BAND_2GHZ]; 6311 wl->hw->wiphy->bands[NL80211_BAND_5GHZ] = 6312 &wl->bands[NL80211_BAND_5GHZ]; 6313 6314 /* 6315 * allow 4 queues per mac address we support + 6316 * 1 cab queue per mac + one global offchannel Tx queue 6317 */ 6318 wl->hw->queues = (NUM_TX_QUEUES + 1) * WLCORE_NUM_MAC_ADDRESSES + 1; 6319 6320 /* the last queue is the offchannel queue */ 6321 wl->hw->offchannel_tx_hw_queue = wl->hw->queues - 1; 6322 wl->hw->max_rates = 1; 6323 6324 wl->hw->wiphy->reg_notifier = wl1271_reg_notify; 6325 6326 /* the FW answers probe-requests in AP-mode */ 6327 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 6328 wl->hw->wiphy->probe_resp_offload = 6329 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 6330 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 6331 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 6332 6333 /* allowed interface combinations */ 6334 wl->hw->wiphy->iface_combinations = wl->iface_combinations; 6335 wl->hw->wiphy->n_iface_combinations = wl->n_iface_combinations; 6336 6337 /* register vendor commands */ 6338 wlcore_set_vendor_commands(wl->hw->wiphy); 6339 6340 SET_IEEE80211_DEV(wl->hw, wl->dev); 6341 6342 wl->hw->sta_data_size = sizeof(struct wl1271_station); 6343 wl->hw->vif_data_size = sizeof(struct wl12xx_vif); 6344 6345 wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size; 6346 6347 return 0; 6348 } 6349 6350 struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size, u32 aggr_buf_size, 6351 u32 mbox_size) 6352 { 6353 struct ieee80211_hw *hw; 6354 struct wl1271 *wl; 6355 int i, j, ret; 6356 unsigned int order; 6357 6358 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops); 6359 if (!hw) { 6360 wl1271_error("could not alloc ieee80211_hw"); 6361 ret = -ENOMEM; 6362 goto err_hw_alloc; 6363 } 6364 6365 wl = hw->priv; 6366 memset(wl, 0, sizeof(*wl)); 6367 6368 wl->priv = kzalloc(priv_size, GFP_KERNEL); 6369 if (!wl->priv) { 6370 wl1271_error("could not alloc wl priv"); 6371 ret = -ENOMEM; 6372 goto err_priv_alloc; 6373 } 6374 6375 INIT_LIST_HEAD(&wl->wlvif_list); 6376 6377 wl->hw = hw; 6378 6379 /* 6380 * wl->num_links is not configured yet, so just use WLCORE_MAX_LINKS. 6381 * we don't allocate any additional resource here, so that's fine. 6382 */ 6383 for (i = 0; i < NUM_TX_QUEUES; i++) 6384 for (j = 0; j < WLCORE_MAX_LINKS; j++) 6385 skb_queue_head_init(&wl->links[j].tx_queue[i]); 6386 6387 skb_queue_head_init(&wl->deferred_rx_queue); 6388 skb_queue_head_init(&wl->deferred_tx_queue); 6389 6390 INIT_WORK(&wl->netstack_work, wl1271_netstack_work); 6391 INIT_WORK(&wl->tx_work, wl1271_tx_work); 6392 INIT_WORK(&wl->recovery_work, wl1271_recovery_work); 6393 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work); 6394 INIT_DELAYED_WORK(&wl->roc_complete_work, wlcore_roc_complete_work); 6395 INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work); 6396 6397 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq"); 6398 if (!wl->freezable_wq) { 6399 ret = -ENOMEM; 6400 goto err_hw; 6401 } 6402 6403 wl->channel = 0; 6404 wl->rx_counter = 0; 6405 wl->power_level = WL1271_DEFAULT_POWER_LEVEL; 6406 wl->band = NL80211_BAND_2GHZ; 6407 wl->channel_type = NL80211_CHAN_NO_HT; 6408 wl->flags = 0; 6409 wl->sg_enabled = true; 6410 wl->sleep_auth = WL1271_PSM_ILLEGAL; 6411 wl->recovery_count = 0; 6412 wl->hw_pg_ver = -1; 6413 wl->ap_ps_map = 0; 6414 wl->ap_fw_ps_map = 0; 6415 wl->quirks = 0; 6416 wl->system_hlid = WL12XX_SYSTEM_HLID; 6417 wl->active_sta_count = 0; 6418 wl->active_link_count = 0; 6419 wl->fwlog_size = 0; 6420 6421 /* The system link is always allocated */ 6422 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map); 6423 6424 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map)); 6425 for (i = 0; i < wl->num_tx_desc; i++) 6426 wl->tx_frames[i] = NULL; 6427 6428 spin_lock_init(&wl->wl_lock); 6429 6430 wl->state = WLCORE_STATE_OFF; 6431 wl->fw_type = WL12XX_FW_TYPE_NONE; 6432 mutex_init(&wl->mutex); 6433 mutex_init(&wl->flush_mutex); 6434 init_completion(&wl->nvs_loading_complete); 6435 6436 order = get_order(aggr_buf_size); 6437 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order); 6438 if (!wl->aggr_buf) { 6439 ret = -ENOMEM; 6440 goto err_wq; 6441 } 6442 wl->aggr_buf_size = aggr_buf_size; 6443 6444 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl); 6445 if (!wl->dummy_packet) { 6446 ret = -ENOMEM; 6447 goto err_aggr; 6448 } 6449 6450 /* Allocate one page for the FW log */ 6451 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL); 6452 if (!wl->fwlog) { 6453 ret = -ENOMEM; 6454 goto err_dummy_packet; 6455 } 6456 6457 wl->mbox_size = mbox_size; 6458 wl->mbox = kmalloc(wl->mbox_size, GFP_KERNEL | GFP_DMA); 6459 if (!wl->mbox) { 6460 ret = -ENOMEM; 6461 goto err_fwlog; 6462 } 6463 6464 wl->buffer_32 = kmalloc(sizeof(*wl->buffer_32), GFP_KERNEL); 6465 if (!wl->buffer_32) { 6466 ret = -ENOMEM; 6467 goto err_mbox; 6468 } 6469 6470 return hw; 6471 6472 err_mbox: 6473 kfree(wl->mbox); 6474 6475 err_fwlog: 6476 free_page((unsigned long)wl->fwlog); 6477 6478 err_dummy_packet: 6479 dev_kfree_skb(wl->dummy_packet); 6480 6481 err_aggr: 6482 free_pages((unsigned long)wl->aggr_buf, order); 6483 6484 err_wq: 6485 destroy_workqueue(wl->freezable_wq); 6486 6487 err_hw: 6488 wl1271_debugfs_exit(wl); 6489 kfree(wl->priv); 6490 6491 err_priv_alloc: 6492 ieee80211_free_hw(hw); 6493 6494 err_hw_alloc: 6495 6496 return ERR_PTR(ret); 6497 } 6498 EXPORT_SYMBOL_GPL(wlcore_alloc_hw); 6499 6500 int wlcore_free_hw(struct wl1271 *wl) 6501 { 6502 /* Unblock any fwlog readers */ 6503 mutex_lock(&wl->mutex); 6504 wl->fwlog_size = -1; 6505 mutex_unlock(&wl->mutex); 6506 6507 wlcore_sysfs_free(wl); 6508 6509 kfree(wl->buffer_32); 6510 kfree(wl->mbox); 6511 free_page((unsigned long)wl->fwlog); 6512 dev_kfree_skb(wl->dummy_packet); 6513 free_pages((unsigned long)wl->aggr_buf, get_order(wl->aggr_buf_size)); 6514 6515 wl1271_debugfs_exit(wl); 6516 6517 vfree(wl->fw); 6518 wl->fw = NULL; 6519 wl->fw_type = WL12XX_FW_TYPE_NONE; 6520 kfree(wl->nvs); 6521 wl->nvs = NULL; 6522 6523 kfree(wl->raw_fw_status); 6524 kfree(wl->fw_status); 6525 kfree(wl->tx_res_if); 6526 destroy_workqueue(wl->freezable_wq); 6527 6528 kfree(wl->priv); 6529 ieee80211_free_hw(wl->hw); 6530 6531 return 0; 6532 } 6533 EXPORT_SYMBOL_GPL(wlcore_free_hw); 6534 6535 #ifdef CONFIG_PM 6536 static const struct wiphy_wowlan_support wlcore_wowlan_support = { 6537 .flags = WIPHY_WOWLAN_ANY, 6538 .n_patterns = WL1271_MAX_RX_FILTERS, 6539 .pattern_min_len = 1, 6540 .pattern_max_len = WL1271_RX_FILTER_MAX_PATTERN_SIZE, 6541 }; 6542 #endif 6543 6544 static irqreturn_t wlcore_hardirq(int irq, void *cookie) 6545 { 6546 return IRQ_WAKE_THREAD; 6547 } 6548 6549 static void wlcore_nvs_cb(const struct firmware *fw, void *context) 6550 { 6551 struct wl1271 *wl = context; 6552 struct platform_device *pdev = wl->pdev; 6553 struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev); 6554 struct resource *res; 6555 6556 int ret; 6557 irq_handler_t hardirq_fn = NULL; 6558 6559 if (fw) { 6560 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL); 6561 if (!wl->nvs) { 6562 wl1271_error("Could not allocate nvs data"); 6563 goto out; 6564 } 6565 wl->nvs_len = fw->size; 6566 } else if (pdev_data->family->nvs_name) { 6567 wl1271_debug(DEBUG_BOOT, "Could not get nvs file %s", 6568 pdev_data->family->nvs_name); 6569 wl->nvs = NULL; 6570 wl->nvs_len = 0; 6571 } else { 6572 wl->nvs = NULL; 6573 wl->nvs_len = 0; 6574 } 6575 6576 ret = wl->ops->setup(wl); 6577 if (ret < 0) 6578 goto out_free_nvs; 6579 6580 BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS); 6581 6582 /* adjust some runtime configuration parameters */ 6583 wlcore_adjust_conf(wl); 6584 6585 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 6586 if (!res) { 6587 wl1271_error("Could not get IRQ resource"); 6588 goto out_free_nvs; 6589 } 6590 6591 wl->irq = res->start; 6592 wl->irq_flags = res->flags & IRQF_TRIGGER_MASK; 6593 wl->if_ops = pdev_data->if_ops; 6594 6595 if (wl->irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)) 6596 hardirq_fn = wlcore_hardirq; 6597 else 6598 wl->irq_flags |= IRQF_ONESHOT; 6599 6600 ret = wl12xx_set_power_on(wl); 6601 if (ret < 0) 6602 goto out_free_nvs; 6603 6604 ret = wl12xx_get_hw_info(wl); 6605 if (ret < 0) { 6606 wl1271_error("couldn't get hw info"); 6607 wl1271_power_off(wl); 6608 goto out_free_nvs; 6609 } 6610 6611 ret = request_threaded_irq(wl->irq, hardirq_fn, wlcore_irq, 6612 wl->irq_flags, pdev->name, wl); 6613 if (ret < 0) { 6614 wl1271_error("interrupt configuration failed"); 6615 wl1271_power_off(wl); 6616 goto out_free_nvs; 6617 } 6618 6619 #ifdef CONFIG_PM 6620 device_init_wakeup(wl->dev, true); 6621 6622 ret = enable_irq_wake(wl->irq); 6623 if (!ret) { 6624 wl->irq_wake_enabled = true; 6625 if (pdev_data->pwr_in_suspend) 6626 wl->hw->wiphy->wowlan = &wlcore_wowlan_support; 6627 } 6628 6629 res = platform_get_resource(pdev, IORESOURCE_IRQ, 1); 6630 if (res) { 6631 wl->wakeirq = res->start; 6632 wl->wakeirq_flags = res->flags & IRQF_TRIGGER_MASK; 6633 ret = dev_pm_set_dedicated_wake_irq(wl->dev, wl->wakeirq); 6634 if (ret) 6635 wl->wakeirq = -ENODEV; 6636 } else { 6637 wl->wakeirq = -ENODEV; 6638 } 6639 #endif 6640 disable_irq(wl->irq); 6641 wl1271_power_off(wl); 6642 6643 ret = wl->ops->identify_chip(wl); 6644 if (ret < 0) 6645 goto out_irq; 6646 6647 ret = wl1271_init_ieee80211(wl); 6648 if (ret) 6649 goto out_irq; 6650 6651 ret = wl1271_register_hw(wl); 6652 if (ret) 6653 goto out_irq; 6654 6655 ret = wlcore_sysfs_init(wl); 6656 if (ret) 6657 goto out_unreg; 6658 6659 wl->initialized = true; 6660 goto out; 6661 6662 out_unreg: 6663 wl1271_unregister_hw(wl); 6664 6665 out_irq: 6666 if (wl->wakeirq >= 0) 6667 dev_pm_clear_wake_irq(wl->dev); 6668 device_init_wakeup(wl->dev, false); 6669 free_irq(wl->irq, wl); 6670 6671 out_free_nvs: 6672 kfree(wl->nvs); 6673 6674 out: 6675 release_firmware(fw); 6676 complete_all(&wl->nvs_loading_complete); 6677 } 6678 6679 static int __maybe_unused wlcore_runtime_suspend(struct device *dev) 6680 { 6681 struct wl1271 *wl = dev_get_drvdata(dev); 6682 struct wl12xx_vif *wlvif; 6683 int error; 6684 6685 /* We do not enter elp sleep in PLT mode */ 6686 if (wl->plt) 6687 return 0; 6688 6689 /* Nothing to do if no ELP mode requested */ 6690 if (wl->sleep_auth != WL1271_PSM_ELP) 6691 return 0; 6692 6693 wl12xx_for_each_wlvif(wl, wlvif) { 6694 if (!test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags) && 6695 test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) 6696 return -EBUSY; 6697 } 6698 6699 wl1271_debug(DEBUG_PSM, "chip to elp"); 6700 error = wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_SLEEP); 6701 if (error < 0) { 6702 wl12xx_queue_recovery_work(wl); 6703 6704 return error; 6705 } 6706 6707 set_bit(WL1271_FLAG_IN_ELP, &wl->flags); 6708 6709 return 0; 6710 } 6711 6712 static int __maybe_unused wlcore_runtime_resume(struct device *dev) 6713 { 6714 struct wl1271 *wl = dev_get_drvdata(dev); 6715 DECLARE_COMPLETION_ONSTACK(compl); 6716 unsigned long flags; 6717 int ret; 6718 unsigned long start_time = jiffies; 6719 bool pending = false; 6720 bool recovery = false; 6721 6722 /* Nothing to do if no ELP mode requested */ 6723 if (!test_bit(WL1271_FLAG_IN_ELP, &wl->flags)) 6724 return 0; 6725 6726 wl1271_debug(DEBUG_PSM, "waking up chip from elp"); 6727 6728 spin_lock_irqsave(&wl->wl_lock, flags); 6729 if (test_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags)) 6730 pending = true; 6731 else 6732 wl->elp_compl = &compl; 6733 spin_unlock_irqrestore(&wl->wl_lock, flags); 6734 6735 ret = wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP); 6736 if (ret < 0) { 6737 recovery = true; 6738 goto err; 6739 } 6740 6741 if (!pending) { 6742 ret = wait_for_completion_timeout(&compl, 6743 msecs_to_jiffies(WL1271_WAKEUP_TIMEOUT)); 6744 if (ret == 0) { 6745 wl1271_warning("ELP wakeup timeout!"); 6746 6747 /* Return no error for runtime PM for recovery */ 6748 ret = 0; 6749 recovery = true; 6750 goto err; 6751 } 6752 } 6753 6754 clear_bit(WL1271_FLAG_IN_ELP, &wl->flags); 6755 6756 wl1271_debug(DEBUG_PSM, "wakeup time: %u ms", 6757 jiffies_to_msecs(jiffies - start_time)); 6758 6759 return 0; 6760 6761 err: 6762 spin_lock_irqsave(&wl->wl_lock, flags); 6763 wl->elp_compl = NULL; 6764 spin_unlock_irqrestore(&wl->wl_lock, flags); 6765 6766 if (recovery) { 6767 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags); 6768 wl12xx_queue_recovery_work(wl); 6769 } 6770 6771 return ret; 6772 } 6773 6774 static const struct dev_pm_ops wlcore_pm_ops = { 6775 SET_RUNTIME_PM_OPS(wlcore_runtime_suspend, 6776 wlcore_runtime_resume, 6777 NULL) 6778 }; 6779 6780 int wlcore_probe(struct wl1271 *wl, struct platform_device *pdev) 6781 { 6782 struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev); 6783 const char *nvs_name; 6784 int ret = 0; 6785 6786 if (!wl->ops || !wl->ptable || !pdev_data) 6787 return -EINVAL; 6788 6789 wl->dev = &pdev->dev; 6790 wl->pdev = pdev; 6791 platform_set_drvdata(pdev, wl); 6792 6793 if (pdev_data->family && pdev_data->family->nvs_name) { 6794 nvs_name = pdev_data->family->nvs_name; 6795 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG, 6796 nvs_name, &pdev->dev, GFP_KERNEL, 6797 wl, wlcore_nvs_cb); 6798 if (ret < 0) { 6799 wl1271_error("request_firmware_nowait failed for %s: %d", 6800 nvs_name, ret); 6801 complete_all(&wl->nvs_loading_complete); 6802 } 6803 } else { 6804 wlcore_nvs_cb(NULL, wl); 6805 } 6806 6807 wl->dev->driver->pm = &wlcore_pm_ops; 6808 pm_runtime_set_autosuspend_delay(wl->dev, 50); 6809 pm_runtime_use_autosuspend(wl->dev); 6810 pm_runtime_enable(wl->dev); 6811 6812 return ret; 6813 } 6814 EXPORT_SYMBOL_GPL(wlcore_probe); 6815 6816 int wlcore_remove(struct platform_device *pdev) 6817 { 6818 struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev); 6819 struct wl1271 *wl = platform_get_drvdata(pdev); 6820 int error; 6821 6822 error = pm_runtime_get_sync(wl->dev); 6823 if (error < 0) 6824 dev_warn(wl->dev, "PM runtime failed: %i\n", error); 6825 6826 wl->dev->driver->pm = NULL; 6827 6828 if (pdev_data->family && pdev_data->family->nvs_name) 6829 wait_for_completion(&wl->nvs_loading_complete); 6830 if (!wl->initialized) 6831 return 0; 6832 6833 if (wl->wakeirq >= 0) { 6834 dev_pm_clear_wake_irq(wl->dev); 6835 wl->wakeirq = -ENODEV; 6836 } 6837 6838 device_init_wakeup(wl->dev, false); 6839 6840 if (wl->irq_wake_enabled) 6841 disable_irq_wake(wl->irq); 6842 6843 wl1271_unregister_hw(wl); 6844 6845 pm_runtime_put_sync(wl->dev); 6846 pm_runtime_dont_use_autosuspend(wl->dev); 6847 pm_runtime_disable(wl->dev); 6848 6849 free_irq(wl->irq, wl); 6850 wlcore_free_hw(wl); 6851 6852 return 0; 6853 } 6854 EXPORT_SYMBOL_GPL(wlcore_remove); 6855 6856 u32 wl12xx_debug_level = DEBUG_NONE; 6857 EXPORT_SYMBOL_GPL(wl12xx_debug_level); 6858 module_param_named(debug_level, wl12xx_debug_level, uint, 0600); 6859 MODULE_PARM_DESC(debug_level, "wl12xx debugging level"); 6860 6861 module_param_named(fwlog, fwlog_param, charp, 0); 6862 MODULE_PARM_DESC(fwlog, 6863 "FW logger options: continuous, dbgpins or disable"); 6864 6865 module_param(fwlog_mem_blocks, int, 0600); 6866 MODULE_PARM_DESC(fwlog_mem_blocks, "fwlog mem_blocks"); 6867 6868 module_param(bug_on_recovery, int, 0600); 6869 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery"); 6870 6871 module_param(no_recovery, int, 0600); 6872 MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck."); 6873 6874 MODULE_LICENSE("GPL"); 6875 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); 6876 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); 6877