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