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