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