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