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 bool bug_on_recovery; 60 static bool no_recovery; 61 62 static void __wl1271_op_remove_interface(struct wl1271 *wl, 63 struct ieee80211_vif *vif, 64 bool reset_tx_queues); 65 static void wl1271_op_stop(struct ieee80211_hw *hw); 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->sta.hlid); 83 if (ret < 0) 84 return ret; 85 86 wl12xx_croc(wl, wlvif->role_id); 87 88 wl1271_info("Association completed."); 89 return 0; 90 } 91 92 static int wl1271_reg_notify(struct wiphy *wiphy, 93 struct regulatory_request *request) 94 { 95 struct ieee80211_supported_band *band; 96 struct ieee80211_channel *ch; 97 int i; 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 return 0; 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 == WL1271_STATE_OFF)) 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 if (fwlog_param) { 307 if (!strcmp(fwlog_param, "continuous")) { 308 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS; 309 } else if (!strcmp(fwlog_param, "ondemand")) { 310 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND; 311 } else if (!strcmp(fwlog_param, "dbgpins")) { 312 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS; 313 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS; 314 } else if (!strcmp(fwlog_param, "disable")) { 315 wl->conf.fwlog.mem_blocks = 0; 316 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE; 317 } else { 318 wl1271_error("Unknown fwlog parameter %s", fwlog_param); 319 } 320 } 321 } 322 323 static int wl1271_plt_init(struct wl1271 *wl) 324 { 325 int ret; 326 327 ret = wl->ops->hw_init(wl); 328 if (ret < 0) 329 return ret; 330 331 ret = wl1271_acx_init_mem_config(wl); 332 if (ret < 0) 333 return ret; 334 335 ret = wl12xx_acx_mem_cfg(wl); 336 if (ret < 0) 337 goto out_free_memmap; 338 339 /* Enable data path */ 340 ret = wl1271_cmd_data_path(wl, 1); 341 if (ret < 0) 342 goto out_free_memmap; 343 344 /* Configure for CAM power saving (ie. always active) */ 345 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM); 346 if (ret < 0) 347 goto out_free_memmap; 348 349 /* configure PM */ 350 ret = wl1271_acx_pm_config(wl); 351 if (ret < 0) 352 goto out_free_memmap; 353 354 return 0; 355 356 out_free_memmap: 357 kfree(wl->target_mem_map); 358 wl->target_mem_map = NULL; 359 360 return ret; 361 } 362 363 static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl, 364 struct wl12xx_vif *wlvif, 365 u8 hlid, u8 tx_pkts) 366 { 367 bool fw_ps, single_sta; 368 369 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map); 370 single_sta = (wl->active_sta_count == 1); 371 372 /* 373 * Wake up from high level PS if the STA is asleep with too little 374 * packets in FW or if the STA is awake. 375 */ 376 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS) 377 wl12xx_ps_link_end(wl, wlvif, hlid); 378 379 /* 380 * Start high-level PS if the STA is asleep with enough blocks in FW. 381 * Make an exception if this is the only connected station. In this 382 * case FW-memory congestion is not a problem. 383 */ 384 else if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS) 385 wl12xx_ps_link_start(wl, wlvif, hlid, true); 386 } 387 388 static void wl12xx_irq_update_links_status(struct wl1271 *wl, 389 struct wl12xx_vif *wlvif, 390 struct wl_fw_status *status) 391 { 392 struct wl1271_link *lnk; 393 u32 cur_fw_ps_map; 394 u8 hlid, cnt; 395 396 /* TODO: also use link_fast_bitmap here */ 397 398 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap); 399 if (wl->ap_fw_ps_map != cur_fw_ps_map) { 400 wl1271_debug(DEBUG_PSM, 401 "link ps prev 0x%x cur 0x%x changed 0x%x", 402 wl->ap_fw_ps_map, cur_fw_ps_map, 403 wl->ap_fw_ps_map ^ cur_fw_ps_map); 404 405 wl->ap_fw_ps_map = cur_fw_ps_map; 406 } 407 408 for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, WL12XX_MAX_LINKS) { 409 lnk = &wl->links[hlid]; 410 cnt = status->counters.tx_lnk_free_pkts[hlid] - 411 lnk->prev_freed_pkts; 412 413 lnk->prev_freed_pkts = status->counters.tx_lnk_free_pkts[hlid]; 414 lnk->allocated_pkts -= cnt; 415 416 wl12xx_irq_ps_regulate_link(wl, wlvif, hlid, 417 lnk->allocated_pkts); 418 } 419 } 420 421 static void wl12xx_fw_status(struct wl1271 *wl, 422 struct wl_fw_status *status) 423 { 424 struct wl12xx_vif *wlvif; 425 struct timespec ts; 426 u32 old_tx_blk_count = wl->tx_blocks_available; 427 int avail, freed_blocks; 428 int i; 429 size_t status_len; 430 431 status_len = sizeof(*status) + wl->fw_status_priv_len; 432 433 wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR, status, 434 status_len, false); 435 436 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, " 437 "drv_rx_counter = %d, tx_results_counter = %d)", 438 status->intr, 439 status->fw_rx_counter, 440 status->drv_rx_counter, 441 status->tx_results_counter); 442 443 for (i = 0; i < NUM_TX_QUEUES; i++) { 444 /* prevent wrap-around in freed-packets counter */ 445 wl->tx_allocated_pkts[i] -= 446 (status->counters.tx_released_pkts[i] - 447 wl->tx_pkts_freed[i]) & 0xff; 448 449 wl->tx_pkts_freed[i] = status->counters.tx_released_pkts[i]; 450 } 451 452 /* prevent wrap-around in total blocks counter */ 453 if (likely(wl->tx_blocks_freed <= 454 le32_to_cpu(status->total_released_blks))) 455 freed_blocks = le32_to_cpu(status->total_released_blks) - 456 wl->tx_blocks_freed; 457 else 458 freed_blocks = 0x100000000LL - wl->tx_blocks_freed + 459 le32_to_cpu(status->total_released_blks); 460 461 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks); 462 463 wl->tx_allocated_blocks -= freed_blocks; 464 465 /* 466 * If the FW freed some blocks: 467 * If we still have allocated blocks - re-arm the timer, Tx is 468 * not stuck. Otherwise, cancel the timer (no Tx currently). 469 */ 470 if (freed_blocks) { 471 if (wl->tx_allocated_blocks) 472 wl12xx_rearm_tx_watchdog_locked(wl); 473 else 474 cancel_delayed_work(&wl->tx_watchdog_work); 475 } 476 477 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks; 478 479 /* 480 * The FW might change the total number of TX memblocks before 481 * we get a notification about blocks being released. Thus, the 482 * available blocks calculation might yield a temporary result 483 * which is lower than the actual available blocks. Keeping in 484 * mind that only blocks that were allocated can be moved from 485 * TX to RX, tx_blocks_available should never decrease here. 486 */ 487 wl->tx_blocks_available = max((int)wl->tx_blocks_available, 488 avail); 489 490 /* if more blocks are available now, tx work can be scheduled */ 491 if (wl->tx_blocks_available > old_tx_blk_count) 492 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags); 493 494 /* for AP update num of allocated TX blocks per link and ps status */ 495 wl12xx_for_each_wlvif_ap(wl, wlvif) { 496 wl12xx_irq_update_links_status(wl, wlvif, status); 497 } 498 499 /* update the host-chipset time offset */ 500 getnstimeofday(&ts); 501 wl->time_offset = (timespec_to_ns(&ts) >> 10) - 502 (s64)le32_to_cpu(status->fw_localtime); 503 } 504 505 static void wl1271_flush_deferred_work(struct wl1271 *wl) 506 { 507 struct sk_buff *skb; 508 509 /* Pass all received frames to the network stack */ 510 while ((skb = skb_dequeue(&wl->deferred_rx_queue))) 511 ieee80211_rx_ni(wl->hw, skb); 512 513 /* Return sent skbs to the network stack */ 514 while ((skb = skb_dequeue(&wl->deferred_tx_queue))) 515 ieee80211_tx_status_ni(wl->hw, skb); 516 } 517 518 static void wl1271_netstack_work(struct work_struct *work) 519 { 520 struct wl1271 *wl = 521 container_of(work, struct wl1271, netstack_work); 522 523 do { 524 wl1271_flush_deferred_work(wl); 525 } while (skb_queue_len(&wl->deferred_rx_queue)); 526 } 527 528 #define WL1271_IRQ_MAX_LOOPS 256 529 530 static irqreturn_t wl1271_irq(int irq, void *cookie) 531 { 532 int ret; 533 u32 intr; 534 int loopcount = WL1271_IRQ_MAX_LOOPS; 535 struct wl1271 *wl = (struct wl1271 *)cookie; 536 bool done = false; 537 unsigned int defer_count; 538 unsigned long flags; 539 540 /* TX might be handled here, avoid redundant work */ 541 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags); 542 cancel_work_sync(&wl->tx_work); 543 544 /* 545 * In case edge triggered interrupt must be used, we cannot iterate 546 * more than once without introducing race conditions with the hardirq. 547 */ 548 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ) 549 loopcount = 1; 550 551 mutex_lock(&wl->mutex); 552 553 wl1271_debug(DEBUG_IRQ, "IRQ work"); 554 555 if (unlikely(wl->state == WL1271_STATE_OFF)) 556 goto out; 557 558 ret = wl1271_ps_elp_wakeup(wl); 559 if (ret < 0) 560 goto out; 561 562 while (!done && loopcount--) { 563 /* 564 * In order to avoid a race with the hardirq, clear the flag 565 * before acknowledging the chip. Since the mutex is held, 566 * wl1271_ps_elp_wakeup cannot be called concurrently. 567 */ 568 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags); 569 smp_mb__after_clear_bit(); 570 571 wl12xx_fw_status(wl, wl->fw_status); 572 573 wlcore_hw_tx_immediate_compl(wl); 574 575 intr = le32_to_cpu(wl->fw_status->intr); 576 intr &= WL1271_INTR_MASK; 577 if (!intr) { 578 done = true; 579 continue; 580 } 581 582 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) { 583 wl1271_error("watchdog interrupt received! " 584 "starting recovery."); 585 wl12xx_queue_recovery_work(wl); 586 587 /* restarting the chip. ignore any other interrupt. */ 588 goto out; 589 } 590 591 if (likely(intr & WL1271_ACX_INTR_DATA)) { 592 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA"); 593 594 wl12xx_rx(wl, wl->fw_status); 595 596 /* Check if any tx blocks were freed */ 597 spin_lock_irqsave(&wl->wl_lock, flags); 598 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) && 599 wl1271_tx_total_queue_count(wl) > 0) { 600 spin_unlock_irqrestore(&wl->wl_lock, flags); 601 /* 602 * In order to avoid starvation of the TX path, 603 * call the work function directly. 604 */ 605 wl1271_tx_work_locked(wl); 606 } else { 607 spin_unlock_irqrestore(&wl->wl_lock, flags); 608 } 609 610 /* check for tx results */ 611 wlcore_hw_tx_delayed_compl(wl); 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 wl1271_event_handle(wl, 0); 623 } 624 625 if (intr & WL1271_ACX_INTR_EVENT_B) { 626 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B"); 627 wl1271_event_handle(wl, 1); 628 } 629 630 if (intr & WL1271_ACX_INTR_INIT_COMPLETE) 631 wl1271_debug(DEBUG_IRQ, 632 "WL1271_ACX_INTR_INIT_COMPLETE"); 633 634 if (intr & WL1271_ACX_INTR_HW_AVAILABLE) 635 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE"); 636 } 637 638 wl1271_ps_elp_sleep(wl); 639 640 out: 641 spin_lock_irqsave(&wl->wl_lock, flags); 642 /* In case TX was not handled here, queue TX work */ 643 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags); 644 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) && 645 wl1271_tx_total_queue_count(wl) > 0) 646 ieee80211_queue_work(wl->hw, &wl->tx_work); 647 spin_unlock_irqrestore(&wl->wl_lock, flags); 648 649 mutex_unlock(&wl->mutex); 650 651 return IRQ_HANDLED; 652 } 653 654 struct vif_counter_data { 655 u8 counter; 656 657 struct ieee80211_vif *cur_vif; 658 bool cur_vif_running; 659 }; 660 661 static void wl12xx_vif_count_iter(void *data, u8 *mac, 662 struct ieee80211_vif *vif) 663 { 664 struct vif_counter_data *counter = data; 665 666 counter->counter++; 667 if (counter->cur_vif == vif) 668 counter->cur_vif_running = true; 669 } 670 671 /* caller must not hold wl->mutex, as it might deadlock */ 672 static void wl12xx_get_vif_count(struct ieee80211_hw *hw, 673 struct ieee80211_vif *cur_vif, 674 struct vif_counter_data *data) 675 { 676 memset(data, 0, sizeof(*data)); 677 data->cur_vif = cur_vif; 678 679 ieee80211_iterate_active_interfaces(hw, 680 wl12xx_vif_count_iter, data); 681 } 682 683 static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt) 684 { 685 const struct firmware *fw; 686 const char *fw_name; 687 enum wl12xx_fw_type fw_type; 688 int ret; 689 690 if (plt) { 691 fw_type = WL12XX_FW_TYPE_PLT; 692 fw_name = wl->plt_fw_name; 693 } else { 694 /* 695 * we can't call wl12xx_get_vif_count() here because 696 * wl->mutex is taken, so use the cached last_vif_count value 697 */ 698 if (wl->last_vif_count > 1) { 699 fw_type = WL12XX_FW_TYPE_MULTI; 700 fw_name = wl->mr_fw_name; 701 } else { 702 fw_type = WL12XX_FW_TYPE_NORMAL; 703 fw_name = wl->sr_fw_name; 704 } 705 } 706 707 if (wl->fw_type == fw_type) 708 return 0; 709 710 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name); 711 712 ret = request_firmware(&fw, fw_name, wl->dev); 713 714 if (ret < 0) { 715 wl1271_error("could not get firmware %s: %d", fw_name, ret); 716 return ret; 717 } 718 719 if (fw->size % 4) { 720 wl1271_error("firmware size is not multiple of 32 bits: %zu", 721 fw->size); 722 ret = -EILSEQ; 723 goto out; 724 } 725 726 vfree(wl->fw); 727 wl->fw_type = WL12XX_FW_TYPE_NONE; 728 wl->fw_len = fw->size; 729 wl->fw = vmalloc(wl->fw_len); 730 731 if (!wl->fw) { 732 wl1271_error("could not allocate memory for the firmware"); 733 ret = -ENOMEM; 734 goto out; 735 } 736 737 memcpy(wl->fw, fw->data, wl->fw_len); 738 ret = 0; 739 wl->fw_type = fw_type; 740 out: 741 release_firmware(fw); 742 743 return ret; 744 } 745 746 static int wl1271_fetch_nvs(struct wl1271 *wl) 747 { 748 const struct firmware *fw; 749 int ret; 750 751 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev); 752 753 if (ret < 0) { 754 wl1271_error("could not get nvs file %s: %d", WL12XX_NVS_NAME, 755 ret); 756 return ret; 757 } 758 759 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL); 760 761 if (!wl->nvs) { 762 wl1271_error("could not allocate memory for the nvs file"); 763 ret = -ENOMEM; 764 goto out; 765 } 766 767 wl->nvs_len = fw->size; 768 769 out: 770 release_firmware(fw); 771 772 return ret; 773 } 774 775 void wl12xx_queue_recovery_work(struct wl1271 *wl) 776 { 777 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) 778 ieee80211_queue_work(wl->hw, &wl->recovery_work); 779 } 780 781 size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen) 782 { 783 size_t len = 0; 784 785 /* The FW log is a length-value list, find where the log end */ 786 while (len < maxlen) { 787 if (memblock[len] == 0) 788 break; 789 if (len + memblock[len] + 1 > maxlen) 790 break; 791 len += memblock[len] + 1; 792 } 793 794 /* Make sure we have enough room */ 795 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size)); 796 797 /* Fill the FW log file, consumed by the sysfs fwlog entry */ 798 memcpy(wl->fwlog + wl->fwlog_size, memblock, len); 799 wl->fwlog_size += len; 800 801 return len; 802 } 803 804 static void wl12xx_read_fwlog_panic(struct wl1271 *wl) 805 { 806 u32 addr; 807 u32 first_addr; 808 u8 *block; 809 810 if ((wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED) || 811 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) || 812 (wl->conf.fwlog.mem_blocks == 0)) 813 return; 814 815 wl1271_info("Reading FW panic log"); 816 817 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL); 818 if (!block) 819 return; 820 821 /* 822 * Make sure the chip is awake and the logger isn't active. 823 * This might fail if the firmware hanged. 824 */ 825 if (!wl1271_ps_elp_wakeup(wl)) 826 wl12xx_cmd_stop_fwlog(wl); 827 828 /* Read the first memory block address */ 829 wl12xx_fw_status(wl, wl->fw_status); 830 first_addr = le32_to_cpu(wl->fw_status->log_start_addr); 831 if (!first_addr) 832 goto out; 833 834 /* Traverse the memory blocks linked list */ 835 addr = first_addr; 836 do { 837 memset(block, 0, WL12XX_HW_BLOCK_SIZE); 838 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE, 839 false); 840 841 /* 842 * Memory blocks are linked to one another. The first 4 bytes 843 * of each memory block hold the hardware address of the next 844 * one. The last memory block points to the first one. 845 */ 846 addr = le32_to_cpup((__le32 *)block); 847 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr), 848 WL12XX_HW_BLOCK_SIZE - sizeof(addr))) 849 break; 850 } while (addr && (addr != first_addr)); 851 852 wake_up_interruptible(&wl->fwlog_waitq); 853 854 out: 855 kfree(block); 856 } 857 858 static void wl1271_recovery_work(struct work_struct *work) 859 { 860 struct wl1271 *wl = 861 container_of(work, struct wl1271, recovery_work); 862 struct wl12xx_vif *wlvif; 863 struct ieee80211_vif *vif; 864 865 mutex_lock(&wl->mutex); 866 867 if (wl->state != WL1271_STATE_ON || wl->plt) 868 goto out_unlock; 869 870 /* Avoid a recursive recovery */ 871 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags); 872 873 wl12xx_read_fwlog_panic(wl); 874 875 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x", 876 wl->chip.fw_ver_str, 877 wlcore_read_reg(wl, REG_PC_ON_RECOVERY)); 878 879 BUG_ON(bug_on_recovery && 880 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags)); 881 882 if (no_recovery) { 883 wl1271_info("No recovery (chosen on module load). Fw will remain stuck."); 884 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags); 885 goto out_unlock; 886 } 887 888 BUG_ON(bug_on_recovery); 889 890 /* 891 * Advance security sequence number to overcome potential progress 892 * in the firmware during recovery. This doens't hurt if the network is 893 * not encrypted. 894 */ 895 wl12xx_for_each_wlvif(wl, wlvif) { 896 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) || 897 test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) 898 wlvif->tx_security_seq += 899 WL1271_TX_SQN_POST_RECOVERY_PADDING; 900 } 901 902 /* Prevent spurious TX during FW restart */ 903 ieee80211_stop_queues(wl->hw); 904 905 if (wl->sched_scanning) { 906 ieee80211_sched_scan_stopped(wl->hw); 907 wl->sched_scanning = false; 908 } 909 910 /* reboot the chipset */ 911 while (!list_empty(&wl->wlvif_list)) { 912 wlvif = list_first_entry(&wl->wlvif_list, 913 struct wl12xx_vif, list); 914 vif = wl12xx_wlvif_to_vif(wlvif); 915 __wl1271_op_remove_interface(wl, vif, false); 916 } 917 mutex_unlock(&wl->mutex); 918 wl1271_op_stop(wl->hw); 919 920 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags); 921 922 ieee80211_restart_hw(wl->hw); 923 924 /* 925 * Its safe to enable TX now - the queues are stopped after a request 926 * to restart the HW. 927 */ 928 ieee80211_wake_queues(wl->hw); 929 return; 930 out_unlock: 931 mutex_unlock(&wl->mutex); 932 } 933 934 static void wl1271_fw_wakeup(struct wl1271 *wl) 935 { 936 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP); 937 } 938 939 static int wl1271_setup(struct wl1271 *wl) 940 { 941 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL); 942 if (!wl->fw_status) 943 return -ENOMEM; 944 945 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL); 946 if (!wl->tx_res_if) { 947 kfree(wl->fw_status); 948 return -ENOMEM; 949 } 950 951 return 0; 952 } 953 954 static int wl12xx_set_power_on(struct wl1271 *wl) 955 { 956 int ret; 957 958 msleep(WL1271_PRE_POWER_ON_SLEEP); 959 ret = wl1271_power_on(wl); 960 if (ret < 0) 961 goto out; 962 msleep(WL1271_POWER_ON_SLEEP); 963 wl1271_io_reset(wl); 964 wl1271_io_init(wl); 965 966 wlcore_set_partition(wl, &wl->ptable[PART_BOOT]); 967 968 /* ELP module wake up */ 969 wl1271_fw_wakeup(wl); 970 971 out: 972 return ret; 973 } 974 975 static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt) 976 { 977 int ret = 0; 978 979 ret = wl12xx_set_power_on(wl); 980 if (ret < 0) 981 goto out; 982 983 /* 984 * For wl127x based devices we could use the default block 985 * size (512 bytes), but due to a bug in the sdio driver, we 986 * need to set it explicitly after the chip is powered on. To 987 * simplify the code and since the performance impact is 988 * negligible, we use the same block size for all different 989 * chip types. 990 */ 991 if (wl1271_set_block_size(wl)) 992 wl->quirks |= WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN; 993 994 ret = wl->ops->identify_chip(wl); 995 if (ret < 0) 996 goto out; 997 998 /* TODO: make sure the lower driver has set things up correctly */ 999 1000 ret = wl1271_setup(wl); 1001 if (ret < 0) 1002 goto out; 1003 1004 ret = wl12xx_fetch_firmware(wl, plt); 1005 if (ret < 0) 1006 goto out; 1007 1008 /* No NVS from netlink, try to get it from the filesystem */ 1009 if (wl->nvs == NULL) { 1010 ret = wl1271_fetch_nvs(wl); 1011 if (ret < 0) 1012 goto out; 1013 } 1014 1015 out: 1016 return ret; 1017 } 1018 1019 int wl1271_plt_start(struct wl1271 *wl) 1020 { 1021 int retries = WL1271_BOOT_RETRIES; 1022 struct wiphy *wiphy = wl->hw->wiphy; 1023 int ret; 1024 1025 mutex_lock(&wl->mutex); 1026 1027 wl1271_notice("power up"); 1028 1029 if (wl->state != WL1271_STATE_OFF) { 1030 wl1271_error("cannot go into PLT state because not " 1031 "in off state: %d", wl->state); 1032 ret = -EBUSY; 1033 goto out; 1034 } 1035 1036 while (retries) { 1037 retries--; 1038 ret = wl12xx_chip_wakeup(wl, true); 1039 if (ret < 0) 1040 goto power_off; 1041 1042 ret = wl->ops->boot(wl); 1043 if (ret < 0) 1044 goto power_off; 1045 1046 ret = wl1271_plt_init(wl); 1047 if (ret < 0) 1048 goto irq_disable; 1049 1050 wl->plt = true; 1051 wl->state = WL1271_STATE_ON; 1052 wl1271_notice("firmware booted in PLT mode (%s)", 1053 wl->chip.fw_ver_str); 1054 1055 /* update hw/fw version info in wiphy struct */ 1056 wiphy->hw_version = wl->chip.id; 1057 strncpy(wiphy->fw_version, wl->chip.fw_ver_str, 1058 sizeof(wiphy->fw_version)); 1059 1060 goto out; 1061 1062 irq_disable: 1063 mutex_unlock(&wl->mutex); 1064 /* Unlocking the mutex in the middle of handling is 1065 inherently unsafe. In this case we deem it safe to do, 1066 because we need to let any possibly pending IRQ out of 1067 the system (and while we are WL1271_STATE_OFF the IRQ 1068 work function will not do anything.) Also, any other 1069 possible concurrent operations will fail due to the 1070 current state, hence the wl1271 struct should be safe. */ 1071 wlcore_disable_interrupts(wl); 1072 wl1271_flush_deferred_work(wl); 1073 cancel_work_sync(&wl->netstack_work); 1074 mutex_lock(&wl->mutex); 1075 power_off: 1076 wl1271_power_off(wl); 1077 } 1078 1079 wl1271_error("firmware boot in PLT mode failed despite %d retries", 1080 WL1271_BOOT_RETRIES); 1081 out: 1082 mutex_unlock(&wl->mutex); 1083 1084 return ret; 1085 } 1086 1087 int wl1271_plt_stop(struct wl1271 *wl) 1088 { 1089 int ret = 0; 1090 1091 wl1271_notice("power down"); 1092 1093 /* 1094 * Interrupts must be disabled before setting the state to OFF. 1095 * Otherwise, the interrupt handler might be called and exit without 1096 * reading the interrupt status. 1097 */ 1098 wlcore_disable_interrupts(wl); 1099 mutex_lock(&wl->mutex); 1100 if (!wl->plt) { 1101 mutex_unlock(&wl->mutex); 1102 1103 /* 1104 * This will not necessarily enable interrupts as interrupts 1105 * may have been disabled when op_stop was called. It will, 1106 * however, balance the above call to disable_interrupts(). 1107 */ 1108 wlcore_enable_interrupts(wl); 1109 1110 wl1271_error("cannot power down because not in PLT " 1111 "state: %d", wl->state); 1112 ret = -EBUSY; 1113 goto out; 1114 } 1115 1116 mutex_unlock(&wl->mutex); 1117 1118 wl1271_flush_deferred_work(wl); 1119 cancel_work_sync(&wl->netstack_work); 1120 cancel_work_sync(&wl->recovery_work); 1121 cancel_delayed_work_sync(&wl->elp_work); 1122 cancel_delayed_work_sync(&wl->tx_watchdog_work); 1123 1124 mutex_lock(&wl->mutex); 1125 wl1271_power_off(wl); 1126 wl->flags = 0; 1127 wl->state = WL1271_STATE_OFF; 1128 wl->plt = false; 1129 wl->rx_counter = 0; 1130 mutex_unlock(&wl->mutex); 1131 1132 out: 1133 return ret; 1134 } 1135 1136 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb) 1137 { 1138 struct wl1271 *wl = hw->priv; 1139 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1140 struct ieee80211_vif *vif = info->control.vif; 1141 struct wl12xx_vif *wlvif = NULL; 1142 unsigned long flags; 1143 int q, mapping; 1144 u8 hlid; 1145 1146 if (vif) 1147 wlvif = wl12xx_vif_to_data(vif); 1148 1149 mapping = skb_get_queue_mapping(skb); 1150 q = wl1271_tx_get_queue(mapping); 1151 1152 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb); 1153 1154 spin_lock_irqsave(&wl->wl_lock, flags); 1155 1156 /* queue the packet */ 1157 if (hlid == WL12XX_INVALID_LINK_ID || 1158 (wlvif && !test_bit(hlid, wlvif->links_map))) { 1159 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q); 1160 ieee80211_free_txskb(hw, skb); 1161 goto out; 1162 } 1163 1164 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d", 1165 hlid, q, skb->len); 1166 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb); 1167 1168 wl->tx_queue_count[q]++; 1169 1170 /* 1171 * The workqueue is slow to process the tx_queue and we need stop 1172 * the queue here, otherwise the queue will get too long. 1173 */ 1174 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) { 1175 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q); 1176 ieee80211_stop_queue(wl->hw, mapping); 1177 set_bit(q, &wl->stopped_queues_map); 1178 } 1179 1180 /* 1181 * The chip specific setup must run before the first TX packet - 1182 * before that, the tx_work will not be initialized! 1183 */ 1184 1185 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) && 1186 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags)) 1187 ieee80211_queue_work(wl->hw, &wl->tx_work); 1188 1189 out: 1190 spin_unlock_irqrestore(&wl->wl_lock, flags); 1191 } 1192 1193 int wl1271_tx_dummy_packet(struct wl1271 *wl) 1194 { 1195 unsigned long flags; 1196 int q; 1197 1198 /* no need to queue a new dummy packet if one is already pending */ 1199 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags)) 1200 return 0; 1201 1202 q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet)); 1203 1204 spin_lock_irqsave(&wl->wl_lock, flags); 1205 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags); 1206 wl->tx_queue_count[q]++; 1207 spin_unlock_irqrestore(&wl->wl_lock, flags); 1208 1209 /* The FW is low on RX memory blocks, so send the dummy packet asap */ 1210 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags)) 1211 wl1271_tx_work_locked(wl); 1212 1213 /* 1214 * If the FW TX is busy, TX work will be scheduled by the threaded 1215 * interrupt handler function 1216 */ 1217 return 0; 1218 } 1219 1220 /* 1221 * The size of the dummy packet should be at least 1400 bytes. However, in 1222 * order to minimize the number of bus transactions, aligning it to 512 bytes 1223 * boundaries could be beneficial, performance wise 1224 */ 1225 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512)) 1226 1227 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl) 1228 { 1229 struct sk_buff *skb; 1230 struct ieee80211_hdr_3addr *hdr; 1231 unsigned int dummy_packet_size; 1232 1233 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE - 1234 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr); 1235 1236 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE); 1237 if (!skb) { 1238 wl1271_warning("Failed to allocate a dummy packet skb"); 1239 return NULL; 1240 } 1241 1242 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr)); 1243 1244 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr)); 1245 memset(hdr, 0, sizeof(*hdr)); 1246 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 1247 IEEE80211_STYPE_NULLFUNC | 1248 IEEE80211_FCTL_TODS); 1249 1250 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size); 1251 1252 /* Dummy packets require the TID to be management */ 1253 skb->priority = WL1271_TID_MGMT; 1254 1255 /* Initialize all fields that might be used */ 1256 skb_set_queue_mapping(skb, 0); 1257 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info)); 1258 1259 return skb; 1260 } 1261 1262 1263 #ifdef CONFIG_PM 1264 static int wl1271_configure_suspend_sta(struct wl1271 *wl, 1265 struct wl12xx_vif *wlvif) 1266 { 1267 int ret = 0; 1268 1269 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) 1270 goto out; 1271 1272 ret = wl1271_ps_elp_wakeup(wl); 1273 if (ret < 0) 1274 goto out; 1275 1276 ret = wl1271_acx_wake_up_conditions(wl, wlvif, 1277 wl->conf.conn.suspend_wake_up_event, 1278 wl->conf.conn.suspend_listen_interval); 1279 1280 if (ret < 0) 1281 wl1271_error("suspend: set wake up conditions failed: %d", ret); 1282 1283 wl1271_ps_elp_sleep(wl); 1284 1285 out: 1286 return ret; 1287 1288 } 1289 1290 static int wl1271_configure_suspend_ap(struct wl1271 *wl, 1291 struct wl12xx_vif *wlvif) 1292 { 1293 int ret = 0; 1294 1295 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) 1296 goto out; 1297 1298 ret = wl1271_ps_elp_wakeup(wl); 1299 if (ret < 0) 1300 goto out; 1301 1302 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true); 1303 1304 wl1271_ps_elp_sleep(wl); 1305 out: 1306 return ret; 1307 1308 } 1309 1310 static int wl1271_configure_suspend(struct wl1271 *wl, 1311 struct wl12xx_vif *wlvif) 1312 { 1313 if (wlvif->bss_type == BSS_TYPE_STA_BSS) 1314 return wl1271_configure_suspend_sta(wl, wlvif); 1315 if (wlvif->bss_type == BSS_TYPE_AP_BSS) 1316 return wl1271_configure_suspend_ap(wl, wlvif); 1317 return 0; 1318 } 1319 1320 static void wl1271_configure_resume(struct wl1271 *wl, 1321 struct wl12xx_vif *wlvif) 1322 { 1323 int ret = 0; 1324 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS; 1325 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS; 1326 1327 if ((!is_ap) && (!is_sta)) 1328 return; 1329 1330 ret = wl1271_ps_elp_wakeup(wl); 1331 if (ret < 0) 1332 return; 1333 1334 if (is_sta) { 1335 ret = wl1271_acx_wake_up_conditions(wl, wlvif, 1336 wl->conf.conn.wake_up_event, 1337 wl->conf.conn.listen_interval); 1338 1339 if (ret < 0) 1340 wl1271_error("resume: wake up conditions failed: %d", 1341 ret); 1342 1343 } else if (is_ap) { 1344 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false); 1345 } 1346 1347 wl1271_ps_elp_sleep(wl); 1348 } 1349 1350 static int wl1271_op_suspend(struct ieee80211_hw *hw, 1351 struct cfg80211_wowlan *wow) 1352 { 1353 struct wl1271 *wl = hw->priv; 1354 struct wl12xx_vif *wlvif; 1355 int ret; 1356 1357 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow); 1358 WARN_ON(!wow || !wow->any); 1359 1360 wl1271_tx_flush(wl); 1361 1362 mutex_lock(&wl->mutex); 1363 wl->wow_enabled = true; 1364 wl12xx_for_each_wlvif(wl, wlvif) { 1365 ret = wl1271_configure_suspend(wl, wlvif); 1366 if (ret < 0) { 1367 wl1271_warning("couldn't prepare device to suspend"); 1368 return ret; 1369 } 1370 } 1371 mutex_unlock(&wl->mutex); 1372 /* flush any remaining work */ 1373 wl1271_debug(DEBUG_MAC80211, "flushing remaining works"); 1374 1375 /* 1376 * disable and re-enable interrupts in order to flush 1377 * the threaded_irq 1378 */ 1379 wlcore_disable_interrupts(wl); 1380 1381 /* 1382 * set suspended flag to avoid triggering a new threaded_irq 1383 * work. no need for spinlock as interrupts are disabled. 1384 */ 1385 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags); 1386 1387 wlcore_enable_interrupts(wl); 1388 flush_work(&wl->tx_work); 1389 flush_delayed_work(&wl->elp_work); 1390 1391 return 0; 1392 } 1393 1394 static int wl1271_op_resume(struct ieee80211_hw *hw) 1395 { 1396 struct wl1271 *wl = hw->priv; 1397 struct wl12xx_vif *wlvif; 1398 unsigned long flags; 1399 bool run_irq_work = false; 1400 1401 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d", 1402 wl->wow_enabled); 1403 WARN_ON(!wl->wow_enabled); 1404 1405 /* 1406 * re-enable irq_work enqueuing, and call irq_work directly if 1407 * there is a pending work. 1408 */ 1409 spin_lock_irqsave(&wl->wl_lock, flags); 1410 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags); 1411 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags)) 1412 run_irq_work = true; 1413 spin_unlock_irqrestore(&wl->wl_lock, flags); 1414 1415 if (run_irq_work) { 1416 wl1271_debug(DEBUG_MAC80211, 1417 "run postponed irq_work directly"); 1418 wl1271_irq(0, wl); 1419 wlcore_enable_interrupts(wl); 1420 } 1421 1422 mutex_lock(&wl->mutex); 1423 wl12xx_for_each_wlvif(wl, wlvif) { 1424 wl1271_configure_resume(wl, wlvif); 1425 } 1426 wl->wow_enabled = false; 1427 mutex_unlock(&wl->mutex); 1428 1429 return 0; 1430 } 1431 #endif 1432 1433 static int wl1271_op_start(struct ieee80211_hw *hw) 1434 { 1435 wl1271_debug(DEBUG_MAC80211, "mac80211 start"); 1436 1437 /* 1438 * We have to delay the booting of the hardware because 1439 * we need to know the local MAC address before downloading and 1440 * initializing the firmware. The MAC address cannot be changed 1441 * after boot, and without the proper MAC address, the firmware 1442 * will not function properly. 1443 * 1444 * The MAC address is first known when the corresponding interface 1445 * is added. That is where we will initialize the hardware. 1446 */ 1447 1448 return 0; 1449 } 1450 1451 static void wl1271_op_stop(struct ieee80211_hw *hw) 1452 { 1453 struct wl1271 *wl = hw->priv; 1454 int i; 1455 1456 wl1271_debug(DEBUG_MAC80211, "mac80211 stop"); 1457 1458 /* 1459 * Interrupts must be disabled before setting the state to OFF. 1460 * Otherwise, the interrupt handler might be called and exit without 1461 * reading the interrupt status. 1462 */ 1463 wlcore_disable_interrupts(wl); 1464 mutex_lock(&wl->mutex); 1465 if (wl->state == WL1271_STATE_OFF) { 1466 mutex_unlock(&wl->mutex); 1467 1468 /* 1469 * This will not necessarily enable interrupts as interrupts 1470 * may have been disabled when op_stop was called. It will, 1471 * however, balance the above call to disable_interrupts(). 1472 */ 1473 wlcore_enable_interrupts(wl); 1474 return; 1475 } 1476 1477 /* 1478 * this must be before the cancel_work calls below, so that the work 1479 * functions don't perform further work. 1480 */ 1481 wl->state = WL1271_STATE_OFF; 1482 mutex_unlock(&wl->mutex); 1483 1484 wl1271_flush_deferred_work(wl); 1485 cancel_delayed_work_sync(&wl->scan_complete_work); 1486 cancel_work_sync(&wl->netstack_work); 1487 cancel_work_sync(&wl->tx_work); 1488 cancel_delayed_work_sync(&wl->elp_work); 1489 cancel_delayed_work_sync(&wl->tx_watchdog_work); 1490 1491 /* let's notify MAC80211 about the remaining pending TX frames */ 1492 wl12xx_tx_reset(wl, true); 1493 mutex_lock(&wl->mutex); 1494 1495 wl1271_power_off(wl); 1496 1497 wl->band = IEEE80211_BAND_2GHZ; 1498 1499 wl->rx_counter = 0; 1500 wl->power_level = WL1271_DEFAULT_POWER_LEVEL; 1501 wl->tx_blocks_available = 0; 1502 wl->tx_allocated_blocks = 0; 1503 wl->tx_results_count = 0; 1504 wl->tx_packets_count = 0; 1505 wl->time_offset = 0; 1506 wl->ap_fw_ps_map = 0; 1507 wl->ap_ps_map = 0; 1508 wl->sched_scanning = false; 1509 memset(wl->roles_map, 0, sizeof(wl->roles_map)); 1510 memset(wl->links_map, 0, sizeof(wl->links_map)); 1511 memset(wl->roc_map, 0, sizeof(wl->roc_map)); 1512 wl->active_sta_count = 0; 1513 1514 /* The system link is always allocated */ 1515 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map); 1516 1517 /* 1518 * this is performed after the cancel_work calls and the associated 1519 * mutex_lock, so that wl1271_op_add_interface does not accidentally 1520 * get executed before all these vars have been reset. 1521 */ 1522 wl->flags = 0; 1523 1524 wl->tx_blocks_freed = 0; 1525 1526 for (i = 0; i < NUM_TX_QUEUES; i++) { 1527 wl->tx_pkts_freed[i] = 0; 1528 wl->tx_allocated_pkts[i] = 0; 1529 } 1530 1531 wl1271_debugfs_reset(wl); 1532 1533 kfree(wl->fw_status); 1534 wl->fw_status = NULL; 1535 kfree(wl->tx_res_if); 1536 wl->tx_res_if = NULL; 1537 kfree(wl->target_mem_map); 1538 wl->target_mem_map = NULL; 1539 1540 mutex_unlock(&wl->mutex); 1541 } 1542 1543 static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx) 1544 { 1545 u8 policy = find_first_zero_bit(wl->rate_policies_map, 1546 WL12XX_MAX_RATE_POLICIES); 1547 if (policy >= WL12XX_MAX_RATE_POLICIES) 1548 return -EBUSY; 1549 1550 __set_bit(policy, wl->rate_policies_map); 1551 *idx = policy; 1552 return 0; 1553 } 1554 1555 static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx) 1556 { 1557 if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES)) 1558 return; 1559 1560 __clear_bit(*idx, wl->rate_policies_map); 1561 *idx = WL12XX_MAX_RATE_POLICIES; 1562 } 1563 1564 static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif) 1565 { 1566 switch (wlvif->bss_type) { 1567 case BSS_TYPE_AP_BSS: 1568 if (wlvif->p2p) 1569 return WL1271_ROLE_P2P_GO; 1570 else 1571 return WL1271_ROLE_AP; 1572 1573 case BSS_TYPE_STA_BSS: 1574 if (wlvif->p2p) 1575 return WL1271_ROLE_P2P_CL; 1576 else 1577 return WL1271_ROLE_STA; 1578 1579 case BSS_TYPE_IBSS: 1580 return WL1271_ROLE_IBSS; 1581 1582 default: 1583 wl1271_error("invalid bss_type: %d", wlvif->bss_type); 1584 } 1585 return WL12XX_INVALID_ROLE_TYPE; 1586 } 1587 1588 static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif) 1589 { 1590 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 1591 int i; 1592 1593 /* clear everything but the persistent data */ 1594 memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent)); 1595 1596 switch (ieee80211_vif_type_p2p(vif)) { 1597 case NL80211_IFTYPE_P2P_CLIENT: 1598 wlvif->p2p = 1; 1599 /* fall-through */ 1600 case NL80211_IFTYPE_STATION: 1601 wlvif->bss_type = BSS_TYPE_STA_BSS; 1602 break; 1603 case NL80211_IFTYPE_ADHOC: 1604 wlvif->bss_type = BSS_TYPE_IBSS; 1605 break; 1606 case NL80211_IFTYPE_P2P_GO: 1607 wlvif->p2p = 1; 1608 /* fall-through */ 1609 case NL80211_IFTYPE_AP: 1610 wlvif->bss_type = BSS_TYPE_AP_BSS; 1611 break; 1612 default: 1613 wlvif->bss_type = MAX_BSS_TYPE; 1614 return -EOPNOTSUPP; 1615 } 1616 1617 wlvif->role_id = WL12XX_INVALID_ROLE_ID; 1618 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID; 1619 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID; 1620 1621 if (wlvif->bss_type == BSS_TYPE_STA_BSS || 1622 wlvif->bss_type == BSS_TYPE_IBSS) { 1623 /* init sta/ibss data */ 1624 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID; 1625 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx); 1626 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx); 1627 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx); 1628 } else { 1629 /* init ap data */ 1630 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID; 1631 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID; 1632 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx); 1633 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx); 1634 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++) 1635 wl12xx_allocate_rate_policy(wl, 1636 &wlvif->ap.ucast_rate_idx[i]); 1637 } 1638 1639 wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate; 1640 wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5; 1641 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC; 1642 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC; 1643 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC; 1644 wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT; 1645 1646 /* 1647 * mac80211 configures some values globally, while we treat them 1648 * per-interface. thus, on init, we have to copy them from wl 1649 */ 1650 wlvif->band = wl->band; 1651 wlvif->channel = wl->channel; 1652 wlvif->power_level = wl->power_level; 1653 1654 INIT_WORK(&wlvif->rx_streaming_enable_work, 1655 wl1271_rx_streaming_enable_work); 1656 INIT_WORK(&wlvif->rx_streaming_disable_work, 1657 wl1271_rx_streaming_disable_work); 1658 INIT_LIST_HEAD(&wlvif->list); 1659 1660 setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer, 1661 (unsigned long) wlvif); 1662 return 0; 1663 } 1664 1665 static bool wl12xx_init_fw(struct wl1271 *wl) 1666 { 1667 int retries = WL1271_BOOT_RETRIES; 1668 bool booted = false; 1669 struct wiphy *wiphy = wl->hw->wiphy; 1670 int ret; 1671 1672 while (retries) { 1673 retries--; 1674 ret = wl12xx_chip_wakeup(wl, false); 1675 if (ret < 0) 1676 goto power_off; 1677 1678 ret = wl->ops->boot(wl); 1679 if (ret < 0) 1680 goto power_off; 1681 1682 ret = wl1271_hw_init(wl); 1683 if (ret < 0) 1684 goto irq_disable; 1685 1686 booted = true; 1687 break; 1688 1689 irq_disable: 1690 mutex_unlock(&wl->mutex); 1691 /* Unlocking the mutex in the middle of handling is 1692 inherently unsafe. In this case we deem it safe to do, 1693 because we need to let any possibly pending IRQ out of 1694 the system (and while we are WL1271_STATE_OFF the IRQ 1695 work function will not do anything.) Also, any other 1696 possible concurrent operations will fail due to the 1697 current state, hence the wl1271 struct should be safe. */ 1698 wlcore_disable_interrupts(wl); 1699 wl1271_flush_deferred_work(wl); 1700 cancel_work_sync(&wl->netstack_work); 1701 mutex_lock(&wl->mutex); 1702 power_off: 1703 wl1271_power_off(wl); 1704 } 1705 1706 if (!booted) { 1707 wl1271_error("firmware boot failed despite %d retries", 1708 WL1271_BOOT_RETRIES); 1709 goto out; 1710 } 1711 1712 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str); 1713 1714 /* update hw/fw version info in wiphy struct */ 1715 wiphy->hw_version = wl->chip.id; 1716 strncpy(wiphy->fw_version, wl->chip.fw_ver_str, 1717 sizeof(wiphy->fw_version)); 1718 1719 /* 1720 * Now we know if 11a is supported (info from the NVS), so disable 1721 * 11a channels if not supported 1722 */ 1723 if (!wl->enable_11a) 1724 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0; 1725 1726 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported", 1727 wl->enable_11a ? "" : "not "); 1728 1729 wl->state = WL1271_STATE_ON; 1730 out: 1731 return booted; 1732 } 1733 1734 static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif) 1735 { 1736 return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID; 1737 } 1738 1739 /* 1740 * Check whether a fw switch (i.e. moving from one loaded 1741 * fw to another) is needed. This function is also responsible 1742 * for updating wl->last_vif_count, so it must be called before 1743 * loading a non-plt fw (so the correct fw (single-role/multi-role) 1744 * will be used). 1745 */ 1746 static bool wl12xx_need_fw_change(struct wl1271 *wl, 1747 struct vif_counter_data vif_counter_data, 1748 bool add) 1749 { 1750 enum wl12xx_fw_type current_fw = wl->fw_type; 1751 u8 vif_count = vif_counter_data.counter; 1752 1753 if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags)) 1754 return false; 1755 1756 /* increase the vif count if this is a new vif */ 1757 if (add && !vif_counter_data.cur_vif_running) 1758 vif_count++; 1759 1760 wl->last_vif_count = vif_count; 1761 1762 /* no need for fw change if the device is OFF */ 1763 if (wl->state == WL1271_STATE_OFF) 1764 return false; 1765 1766 if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL) 1767 return true; 1768 if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI) 1769 return true; 1770 1771 return false; 1772 } 1773 1774 /* 1775 * Enter "forced psm". Make sure the sta is in psm against the ap, 1776 * to make the fw switch a bit more disconnection-persistent. 1777 */ 1778 static void wl12xx_force_active_psm(struct wl1271 *wl) 1779 { 1780 struct wl12xx_vif *wlvif; 1781 1782 wl12xx_for_each_wlvif_sta(wl, wlvif) { 1783 wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE); 1784 } 1785 } 1786 1787 static int wl1271_op_add_interface(struct ieee80211_hw *hw, 1788 struct ieee80211_vif *vif) 1789 { 1790 struct wl1271 *wl = hw->priv; 1791 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 1792 struct vif_counter_data vif_count; 1793 int ret = 0; 1794 u8 role_type; 1795 bool booted = false; 1796 1797 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 1798 IEEE80211_VIF_SUPPORTS_CQM_RSSI; 1799 1800 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM", 1801 ieee80211_vif_type_p2p(vif), vif->addr); 1802 1803 wl12xx_get_vif_count(hw, vif, &vif_count); 1804 1805 mutex_lock(&wl->mutex); 1806 ret = wl1271_ps_elp_wakeup(wl); 1807 if (ret < 0) 1808 goto out_unlock; 1809 1810 /* 1811 * in some very corner case HW recovery scenarios its possible to 1812 * get here before __wl1271_op_remove_interface is complete, so 1813 * opt out if that is the case. 1814 */ 1815 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) || 1816 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) { 1817 ret = -EBUSY; 1818 goto out; 1819 } 1820 1821 1822 ret = wl12xx_init_vif_data(wl, vif); 1823 if (ret < 0) 1824 goto out; 1825 1826 wlvif->wl = wl; 1827 role_type = wl12xx_get_role_type(wl, wlvif); 1828 if (role_type == WL12XX_INVALID_ROLE_TYPE) { 1829 ret = -EINVAL; 1830 goto out; 1831 } 1832 1833 if (wl12xx_need_fw_change(wl, vif_count, true)) { 1834 wl12xx_force_active_psm(wl); 1835 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags); 1836 mutex_unlock(&wl->mutex); 1837 wl1271_recovery_work(&wl->recovery_work); 1838 return 0; 1839 } 1840 1841 /* 1842 * TODO: after the nvs issue will be solved, move this block 1843 * to start(), and make sure here the driver is ON. 1844 */ 1845 if (wl->state == WL1271_STATE_OFF) { 1846 /* 1847 * we still need this in order to configure the fw 1848 * while uploading the nvs 1849 */ 1850 memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN); 1851 1852 booted = wl12xx_init_fw(wl); 1853 if (!booted) { 1854 ret = -EINVAL; 1855 goto out; 1856 } 1857 } 1858 1859 if (wlvif->bss_type == BSS_TYPE_STA_BSS || 1860 wlvif->bss_type == BSS_TYPE_IBSS) { 1861 /* 1862 * The device role is a special role used for 1863 * rx and tx frames prior to association (as 1864 * the STA role can get packets only from 1865 * its associated bssid) 1866 */ 1867 ret = wl12xx_cmd_role_enable(wl, vif->addr, 1868 WL1271_ROLE_DEVICE, 1869 &wlvif->dev_role_id); 1870 if (ret < 0) 1871 goto out; 1872 } 1873 1874 ret = wl12xx_cmd_role_enable(wl, vif->addr, 1875 role_type, &wlvif->role_id); 1876 if (ret < 0) 1877 goto out; 1878 1879 ret = wl1271_init_vif_specific(wl, vif); 1880 if (ret < 0) 1881 goto out; 1882 1883 list_add(&wlvif->list, &wl->wlvif_list); 1884 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags); 1885 1886 if (wlvif->bss_type == BSS_TYPE_AP_BSS) 1887 wl->ap_count++; 1888 else 1889 wl->sta_count++; 1890 out: 1891 wl1271_ps_elp_sleep(wl); 1892 out_unlock: 1893 mutex_unlock(&wl->mutex); 1894 1895 return ret; 1896 } 1897 1898 static void __wl1271_op_remove_interface(struct wl1271 *wl, 1899 struct ieee80211_vif *vif, 1900 bool reset_tx_queues) 1901 { 1902 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 1903 int i, ret; 1904 1905 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface"); 1906 1907 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) 1908 return; 1909 1910 /* because of hardware recovery, we may get here twice */ 1911 if (wl->state != WL1271_STATE_ON) 1912 return; 1913 1914 wl1271_info("down"); 1915 1916 if (wl->scan.state != WL1271_SCAN_STATE_IDLE && 1917 wl->scan_vif == vif) { 1918 /* 1919 * Rearm the tx watchdog just before idling scan. This 1920 * prevents just-finished scans from triggering the watchdog 1921 */ 1922 wl12xx_rearm_tx_watchdog_locked(wl); 1923 1924 wl->scan.state = WL1271_SCAN_STATE_IDLE; 1925 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch)); 1926 wl->scan_vif = NULL; 1927 wl->scan.req = NULL; 1928 ieee80211_scan_completed(wl->hw, true); 1929 } 1930 1931 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) { 1932 /* disable active roles */ 1933 ret = wl1271_ps_elp_wakeup(wl); 1934 if (ret < 0) 1935 goto deinit; 1936 1937 if (wlvif->bss_type == BSS_TYPE_STA_BSS || 1938 wlvif->bss_type == BSS_TYPE_IBSS) { 1939 if (wl12xx_dev_role_started(wlvif)) 1940 wl12xx_stop_dev(wl, wlvif); 1941 1942 ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id); 1943 if (ret < 0) 1944 goto deinit; 1945 } 1946 1947 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id); 1948 if (ret < 0) 1949 goto deinit; 1950 1951 wl1271_ps_elp_sleep(wl); 1952 } 1953 deinit: 1954 /* clear all hlids (except system_hlid) */ 1955 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID; 1956 1957 if (wlvif->bss_type == BSS_TYPE_STA_BSS || 1958 wlvif->bss_type == BSS_TYPE_IBSS) { 1959 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID; 1960 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx); 1961 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx); 1962 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx); 1963 } else { 1964 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID; 1965 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID; 1966 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx); 1967 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx); 1968 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++) 1969 wl12xx_free_rate_policy(wl, 1970 &wlvif->ap.ucast_rate_idx[i]); 1971 wl1271_free_ap_keys(wl, wlvif); 1972 } 1973 1974 dev_kfree_skb(wlvif->probereq); 1975 wlvif->probereq = NULL; 1976 wl12xx_tx_reset_wlvif(wl, wlvif); 1977 if (wl->last_wlvif == wlvif) 1978 wl->last_wlvif = NULL; 1979 list_del(&wlvif->list); 1980 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map)); 1981 wlvif->role_id = WL12XX_INVALID_ROLE_ID; 1982 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID; 1983 1984 if (wlvif->bss_type == BSS_TYPE_AP_BSS) 1985 wl->ap_count--; 1986 else 1987 wl->sta_count--; 1988 1989 mutex_unlock(&wl->mutex); 1990 1991 del_timer_sync(&wlvif->rx_streaming_timer); 1992 cancel_work_sync(&wlvif->rx_streaming_enable_work); 1993 cancel_work_sync(&wlvif->rx_streaming_disable_work); 1994 1995 mutex_lock(&wl->mutex); 1996 } 1997 1998 static void wl1271_op_remove_interface(struct ieee80211_hw *hw, 1999 struct ieee80211_vif *vif) 2000 { 2001 struct wl1271 *wl = hw->priv; 2002 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 2003 struct wl12xx_vif *iter; 2004 struct vif_counter_data vif_count; 2005 bool cancel_recovery = true; 2006 2007 wl12xx_get_vif_count(hw, vif, &vif_count); 2008 mutex_lock(&wl->mutex); 2009 2010 if (wl->state == WL1271_STATE_OFF || 2011 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) 2012 goto out; 2013 2014 /* 2015 * wl->vif can be null here if someone shuts down the interface 2016 * just when hardware recovery has been started. 2017 */ 2018 wl12xx_for_each_wlvif(wl, iter) { 2019 if (iter != wlvif) 2020 continue; 2021 2022 __wl1271_op_remove_interface(wl, vif, true); 2023 break; 2024 } 2025 WARN_ON(iter != wlvif); 2026 if (wl12xx_need_fw_change(wl, vif_count, false)) { 2027 wl12xx_force_active_psm(wl); 2028 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags); 2029 wl12xx_queue_recovery_work(wl); 2030 cancel_recovery = false; 2031 } 2032 out: 2033 mutex_unlock(&wl->mutex); 2034 if (cancel_recovery) 2035 cancel_work_sync(&wl->recovery_work); 2036 } 2037 2038 static int wl12xx_op_change_interface(struct ieee80211_hw *hw, 2039 struct ieee80211_vif *vif, 2040 enum nl80211_iftype new_type, bool p2p) 2041 { 2042 struct wl1271 *wl = hw->priv; 2043 int ret; 2044 2045 set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags); 2046 wl1271_op_remove_interface(hw, vif); 2047 2048 vif->type = new_type; 2049 vif->p2p = p2p; 2050 ret = wl1271_op_add_interface(hw, vif); 2051 2052 clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags); 2053 return ret; 2054 } 2055 2056 static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif, 2057 bool set_assoc) 2058 { 2059 int ret; 2060 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS); 2061 2062 /* 2063 * One of the side effects of the JOIN command is that is clears 2064 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated 2065 * to a WPA/WPA2 access point will therefore kill the data-path. 2066 * Currently the only valid scenario for JOIN during association 2067 * is on roaming, in which case we will also be given new keys. 2068 * Keep the below message for now, unless it starts bothering 2069 * users who really like to roam a lot :) 2070 */ 2071 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) 2072 wl1271_info("JOIN while associated."); 2073 2074 /* clear encryption type */ 2075 wlvif->encryption_type = KEY_NONE; 2076 2077 if (set_assoc) 2078 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags); 2079 2080 if (is_ibss) 2081 ret = wl12xx_cmd_role_start_ibss(wl, wlvif); 2082 else 2083 ret = wl12xx_cmd_role_start_sta(wl, wlvif); 2084 if (ret < 0) 2085 goto out; 2086 2087 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) 2088 goto out; 2089 2090 /* 2091 * The join command disable the keep-alive mode, shut down its process, 2092 * and also clear the template config, so we need to reset it all after 2093 * the join. The acx_aid starts the keep-alive process, and the order 2094 * of the commands below is relevant. 2095 */ 2096 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true); 2097 if (ret < 0) 2098 goto out; 2099 2100 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid); 2101 if (ret < 0) 2102 goto out; 2103 2104 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif); 2105 if (ret < 0) 2106 goto out; 2107 2108 ret = wl1271_acx_keep_alive_config(wl, wlvif, 2109 CMD_TEMPL_KLV_IDX_NULL_DATA, 2110 ACX_KEEP_ALIVE_TPL_VALID); 2111 if (ret < 0) 2112 goto out; 2113 2114 out: 2115 return ret; 2116 } 2117 2118 static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif) 2119 { 2120 int ret; 2121 2122 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) { 2123 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 2124 2125 wl12xx_cmd_stop_channel_switch(wl); 2126 ieee80211_chswitch_done(vif, false); 2127 } 2128 2129 /* to stop listening to a channel, we disconnect */ 2130 ret = wl12xx_cmd_role_stop_sta(wl, wlvif); 2131 if (ret < 0) 2132 goto out; 2133 2134 /* reset TX security counters on a clean disconnect */ 2135 wlvif->tx_security_last_seq_lsb = 0; 2136 wlvif->tx_security_seq = 0; 2137 2138 out: 2139 return ret; 2140 } 2141 2142 static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif) 2143 { 2144 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band]; 2145 wlvif->rate_set = wlvif->basic_rate_set; 2146 } 2147 2148 static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif, 2149 bool idle) 2150 { 2151 int ret; 2152 bool cur_idle = !test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags); 2153 2154 if (idle == cur_idle) 2155 return 0; 2156 2157 if (idle) { 2158 /* no need to croc if we weren't busy (e.g. during boot) */ 2159 if (wl12xx_dev_role_started(wlvif)) { 2160 ret = wl12xx_stop_dev(wl, wlvif); 2161 if (ret < 0) 2162 goto out; 2163 } 2164 wlvif->rate_set = 2165 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 2166 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 2167 if (ret < 0) 2168 goto out; 2169 ret = wl1271_acx_keep_alive_config( 2170 wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA, 2171 ACX_KEEP_ALIVE_TPL_INVALID); 2172 if (ret < 0) 2173 goto out; 2174 clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags); 2175 } else { 2176 /* The current firmware only supports sched_scan in idle */ 2177 if (wl->sched_scanning) { 2178 wl1271_scan_sched_scan_stop(wl); 2179 ieee80211_sched_scan_stopped(wl->hw); 2180 } 2181 2182 ret = wl12xx_start_dev(wl, wlvif); 2183 if (ret < 0) 2184 goto out; 2185 set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags); 2186 } 2187 2188 out: 2189 return ret; 2190 } 2191 2192 static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif, 2193 struct ieee80211_conf *conf, u32 changed) 2194 { 2195 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 2196 int channel, ret; 2197 2198 channel = ieee80211_frequency_to_channel(conf->channel->center_freq); 2199 2200 /* if the channel changes while joined, join again */ 2201 if (changed & IEEE80211_CONF_CHANGE_CHANNEL && 2202 ((wlvif->band != conf->channel->band) || 2203 (wlvif->channel != channel))) { 2204 /* send all pending packets */ 2205 wl1271_tx_work_locked(wl); 2206 wlvif->band = conf->channel->band; 2207 wlvif->channel = channel; 2208 2209 if (!is_ap) { 2210 /* 2211 * FIXME: the mac80211 should really provide a fixed 2212 * rate to use here. for now, just use the smallest 2213 * possible rate for the band as a fixed rate for 2214 * association frames and other control messages. 2215 */ 2216 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) 2217 wl1271_set_band_rate(wl, wlvif); 2218 2219 wlvif->basic_rate = 2220 wl1271_tx_min_rate_get(wl, 2221 wlvif->basic_rate_set); 2222 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 2223 if (ret < 0) 2224 wl1271_warning("rate policy for channel " 2225 "failed %d", ret); 2226 2227 /* 2228 * change the ROC channel. do it only if we are 2229 * not idle. otherwise, CROC will be called 2230 * anyway. 2231 */ 2232 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, 2233 &wlvif->flags) && 2234 wl12xx_dev_role_started(wlvif) && 2235 !(conf->flags & IEEE80211_CONF_IDLE)) { 2236 ret = wl12xx_stop_dev(wl, wlvif); 2237 if (ret < 0) 2238 return ret; 2239 2240 ret = wl12xx_start_dev(wl, wlvif); 2241 if (ret < 0) 2242 return ret; 2243 } 2244 } 2245 } 2246 2247 if ((changed & IEEE80211_CONF_CHANGE_PS) && !is_ap) { 2248 2249 if ((conf->flags & IEEE80211_CONF_PS) && 2250 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) && 2251 !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) { 2252 2253 int ps_mode; 2254 char *ps_mode_str; 2255 2256 if (wl->conf.conn.forced_ps) { 2257 ps_mode = STATION_POWER_SAVE_MODE; 2258 ps_mode_str = "forced"; 2259 } else { 2260 ps_mode = STATION_AUTO_PS_MODE; 2261 ps_mode_str = "auto"; 2262 } 2263 2264 wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str); 2265 2266 ret = wl1271_ps_set_mode(wl, wlvif, ps_mode); 2267 2268 if (ret < 0) 2269 wl1271_warning("enter %s ps failed %d", 2270 ps_mode_str, ret); 2271 2272 } else if (!(conf->flags & IEEE80211_CONF_PS) && 2273 test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) { 2274 2275 wl1271_debug(DEBUG_PSM, "auto ps disabled"); 2276 2277 ret = wl1271_ps_set_mode(wl, wlvif, 2278 STATION_ACTIVE_MODE); 2279 if (ret < 0) 2280 wl1271_warning("exit auto ps failed %d", ret); 2281 } 2282 } 2283 2284 if (conf->power_level != wlvif->power_level) { 2285 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level); 2286 if (ret < 0) 2287 return ret; 2288 2289 wlvif->power_level = conf->power_level; 2290 } 2291 2292 return 0; 2293 } 2294 2295 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed) 2296 { 2297 struct wl1271 *wl = hw->priv; 2298 struct wl12xx_vif *wlvif; 2299 struct ieee80211_conf *conf = &hw->conf; 2300 int channel, ret = 0; 2301 2302 channel = ieee80211_frequency_to_channel(conf->channel->center_freq); 2303 2304 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s" 2305 " changed 0x%x", 2306 channel, 2307 conf->flags & IEEE80211_CONF_PS ? "on" : "off", 2308 conf->power_level, 2309 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use", 2310 changed); 2311 2312 /* 2313 * mac80211 will go to idle nearly immediately after transmitting some 2314 * frames, such as the deauth. To make sure those frames reach the air, 2315 * wait here until the TX queue is fully flushed. 2316 */ 2317 if ((changed & IEEE80211_CONF_CHANGE_IDLE) && 2318 (conf->flags & IEEE80211_CONF_IDLE)) 2319 wl1271_tx_flush(wl); 2320 2321 mutex_lock(&wl->mutex); 2322 2323 /* we support configuring the channel and band even while off */ 2324 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 2325 wl->band = conf->channel->band; 2326 wl->channel = channel; 2327 } 2328 2329 if (changed & IEEE80211_CONF_CHANGE_POWER) 2330 wl->power_level = conf->power_level; 2331 2332 if (unlikely(wl->state == WL1271_STATE_OFF)) 2333 goto out; 2334 2335 ret = wl1271_ps_elp_wakeup(wl); 2336 if (ret < 0) 2337 goto out; 2338 2339 /* configure each interface */ 2340 wl12xx_for_each_wlvif(wl, wlvif) { 2341 ret = wl12xx_config_vif(wl, wlvif, conf, changed); 2342 if (ret < 0) 2343 goto out_sleep; 2344 } 2345 2346 out_sleep: 2347 wl1271_ps_elp_sleep(wl); 2348 2349 out: 2350 mutex_unlock(&wl->mutex); 2351 2352 return ret; 2353 } 2354 2355 struct wl1271_filter_params { 2356 bool enabled; 2357 int mc_list_length; 2358 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN]; 2359 }; 2360 2361 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, 2362 struct netdev_hw_addr_list *mc_list) 2363 { 2364 struct wl1271_filter_params *fp; 2365 struct netdev_hw_addr *ha; 2366 struct wl1271 *wl = hw->priv; 2367 2368 if (unlikely(wl->state == WL1271_STATE_OFF)) 2369 return 0; 2370 2371 fp = kzalloc(sizeof(*fp), GFP_ATOMIC); 2372 if (!fp) { 2373 wl1271_error("Out of memory setting filters."); 2374 return 0; 2375 } 2376 2377 /* update multicast filtering parameters */ 2378 fp->mc_list_length = 0; 2379 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) { 2380 fp->enabled = false; 2381 } else { 2382 fp->enabled = true; 2383 netdev_hw_addr_list_for_each(ha, mc_list) { 2384 memcpy(fp->mc_list[fp->mc_list_length], 2385 ha->addr, ETH_ALEN); 2386 fp->mc_list_length++; 2387 } 2388 } 2389 2390 return (u64)(unsigned long)fp; 2391 } 2392 2393 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \ 2394 FIF_ALLMULTI | \ 2395 FIF_FCSFAIL | \ 2396 FIF_BCN_PRBRESP_PROMISC | \ 2397 FIF_CONTROL | \ 2398 FIF_OTHER_BSS) 2399 2400 static void wl1271_op_configure_filter(struct ieee80211_hw *hw, 2401 unsigned int changed, 2402 unsigned int *total, u64 multicast) 2403 { 2404 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast; 2405 struct wl1271 *wl = hw->priv; 2406 struct wl12xx_vif *wlvif; 2407 2408 int ret; 2409 2410 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x" 2411 " total %x", changed, *total); 2412 2413 mutex_lock(&wl->mutex); 2414 2415 *total &= WL1271_SUPPORTED_FILTERS; 2416 changed &= WL1271_SUPPORTED_FILTERS; 2417 2418 if (unlikely(wl->state == WL1271_STATE_OFF)) 2419 goto out; 2420 2421 ret = wl1271_ps_elp_wakeup(wl); 2422 if (ret < 0) 2423 goto out; 2424 2425 wl12xx_for_each_wlvif(wl, wlvif) { 2426 if (wlvif->bss_type != BSS_TYPE_AP_BSS) { 2427 if (*total & FIF_ALLMULTI) 2428 ret = wl1271_acx_group_address_tbl(wl, wlvif, 2429 false, 2430 NULL, 0); 2431 else if (fp) 2432 ret = wl1271_acx_group_address_tbl(wl, wlvif, 2433 fp->enabled, 2434 fp->mc_list, 2435 fp->mc_list_length); 2436 if (ret < 0) 2437 goto out_sleep; 2438 } 2439 } 2440 2441 /* 2442 * the fw doesn't provide an api to configure the filters. instead, 2443 * the filters configuration is based on the active roles / ROC 2444 * state. 2445 */ 2446 2447 out_sleep: 2448 wl1271_ps_elp_sleep(wl); 2449 2450 out: 2451 mutex_unlock(&wl->mutex); 2452 kfree(fp); 2453 } 2454 2455 static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif, 2456 u8 id, u8 key_type, u8 key_size, 2457 const u8 *key, u8 hlid, u32 tx_seq_32, 2458 u16 tx_seq_16) 2459 { 2460 struct wl1271_ap_key *ap_key; 2461 int i; 2462 2463 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id); 2464 2465 if (key_size > MAX_KEY_SIZE) 2466 return -EINVAL; 2467 2468 /* 2469 * Find next free entry in ap_keys. Also check we are not replacing 2470 * an existing key. 2471 */ 2472 for (i = 0; i < MAX_NUM_KEYS; i++) { 2473 if (wlvif->ap.recorded_keys[i] == NULL) 2474 break; 2475 2476 if (wlvif->ap.recorded_keys[i]->id == id) { 2477 wl1271_warning("trying to record key replacement"); 2478 return -EINVAL; 2479 } 2480 } 2481 2482 if (i == MAX_NUM_KEYS) 2483 return -EBUSY; 2484 2485 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL); 2486 if (!ap_key) 2487 return -ENOMEM; 2488 2489 ap_key->id = id; 2490 ap_key->key_type = key_type; 2491 ap_key->key_size = key_size; 2492 memcpy(ap_key->key, key, key_size); 2493 ap_key->hlid = hlid; 2494 ap_key->tx_seq_32 = tx_seq_32; 2495 ap_key->tx_seq_16 = tx_seq_16; 2496 2497 wlvif->ap.recorded_keys[i] = ap_key; 2498 return 0; 2499 } 2500 2501 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif) 2502 { 2503 int i; 2504 2505 for (i = 0; i < MAX_NUM_KEYS; i++) { 2506 kfree(wlvif->ap.recorded_keys[i]); 2507 wlvif->ap.recorded_keys[i] = NULL; 2508 } 2509 } 2510 2511 static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif) 2512 { 2513 int i, ret = 0; 2514 struct wl1271_ap_key *key; 2515 bool wep_key_added = false; 2516 2517 for (i = 0; i < MAX_NUM_KEYS; i++) { 2518 u8 hlid; 2519 if (wlvif->ap.recorded_keys[i] == NULL) 2520 break; 2521 2522 key = wlvif->ap.recorded_keys[i]; 2523 hlid = key->hlid; 2524 if (hlid == WL12XX_INVALID_LINK_ID) 2525 hlid = wlvif->ap.bcast_hlid; 2526 2527 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE, 2528 key->id, key->key_type, 2529 key->key_size, key->key, 2530 hlid, key->tx_seq_32, 2531 key->tx_seq_16); 2532 if (ret < 0) 2533 goto out; 2534 2535 if (key->key_type == KEY_WEP) 2536 wep_key_added = true; 2537 } 2538 2539 if (wep_key_added) { 2540 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key, 2541 wlvif->ap.bcast_hlid); 2542 if (ret < 0) 2543 goto out; 2544 } 2545 2546 out: 2547 wl1271_free_ap_keys(wl, wlvif); 2548 return ret; 2549 } 2550 2551 static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif, 2552 u16 action, u8 id, u8 key_type, 2553 u8 key_size, const u8 *key, u32 tx_seq_32, 2554 u16 tx_seq_16, struct ieee80211_sta *sta) 2555 { 2556 int ret; 2557 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 2558 2559 /* 2560 * A role set to GEM cipher requires different Tx settings (namely 2561 * spare blocks). Note when we are in this mode so the HW can adjust. 2562 */ 2563 if (key_type == KEY_GEM) { 2564 if (action == KEY_ADD_OR_REPLACE) 2565 wlvif->is_gem = true; 2566 else if (action == KEY_REMOVE) 2567 wlvif->is_gem = false; 2568 } 2569 2570 if (is_ap) { 2571 struct wl1271_station *wl_sta; 2572 u8 hlid; 2573 2574 if (sta) { 2575 wl_sta = (struct wl1271_station *)sta->drv_priv; 2576 hlid = wl_sta->hlid; 2577 } else { 2578 hlid = wlvif->ap.bcast_hlid; 2579 } 2580 2581 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) { 2582 /* 2583 * We do not support removing keys after AP shutdown. 2584 * Pretend we do to make mac80211 happy. 2585 */ 2586 if (action != KEY_ADD_OR_REPLACE) 2587 return 0; 2588 2589 ret = wl1271_record_ap_key(wl, wlvif, id, 2590 key_type, key_size, 2591 key, hlid, tx_seq_32, 2592 tx_seq_16); 2593 } else { 2594 ret = wl1271_cmd_set_ap_key(wl, wlvif, action, 2595 id, key_type, key_size, 2596 key, hlid, tx_seq_32, 2597 tx_seq_16); 2598 } 2599 2600 if (ret < 0) 2601 return ret; 2602 } else { 2603 const u8 *addr; 2604 static const u8 bcast_addr[ETH_ALEN] = { 2605 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 2606 }; 2607 2608 addr = sta ? sta->addr : bcast_addr; 2609 2610 if (is_zero_ether_addr(addr)) { 2611 /* We dont support TX only encryption */ 2612 return -EOPNOTSUPP; 2613 } 2614 2615 /* The wl1271 does not allow to remove unicast keys - they 2616 will be cleared automatically on next CMD_JOIN. Ignore the 2617 request silently, as we dont want the mac80211 to emit 2618 an error message. */ 2619 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr)) 2620 return 0; 2621 2622 /* don't remove key if hlid was already deleted */ 2623 if (action == KEY_REMOVE && 2624 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID) 2625 return 0; 2626 2627 ret = wl1271_cmd_set_sta_key(wl, wlvif, action, 2628 id, key_type, key_size, 2629 key, addr, tx_seq_32, 2630 tx_seq_16); 2631 if (ret < 0) 2632 return ret; 2633 2634 /* the default WEP key needs to be configured at least once */ 2635 if (key_type == KEY_WEP) { 2636 ret = wl12xx_cmd_set_default_wep_key(wl, 2637 wlvif->default_key, 2638 wlvif->sta.hlid); 2639 if (ret < 0) 2640 return ret; 2641 } 2642 } 2643 2644 return 0; 2645 } 2646 2647 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 2648 struct ieee80211_vif *vif, 2649 struct ieee80211_sta *sta, 2650 struct ieee80211_key_conf *key_conf) 2651 { 2652 struct wl1271 *wl = hw->priv; 2653 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 2654 int ret; 2655 u32 tx_seq_32 = 0; 2656 u16 tx_seq_16 = 0; 2657 u8 key_type; 2658 2659 wl1271_debug(DEBUG_MAC80211, "mac80211 set key"); 2660 2661 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta); 2662 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x", 2663 key_conf->cipher, key_conf->keyidx, 2664 key_conf->keylen, key_conf->flags); 2665 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen); 2666 2667 mutex_lock(&wl->mutex); 2668 2669 if (unlikely(wl->state == WL1271_STATE_OFF)) { 2670 ret = -EAGAIN; 2671 goto out_unlock; 2672 } 2673 2674 ret = wl1271_ps_elp_wakeup(wl); 2675 if (ret < 0) 2676 goto out_unlock; 2677 2678 switch (key_conf->cipher) { 2679 case WLAN_CIPHER_SUITE_WEP40: 2680 case WLAN_CIPHER_SUITE_WEP104: 2681 key_type = KEY_WEP; 2682 2683 key_conf->hw_key_idx = key_conf->keyidx; 2684 break; 2685 case WLAN_CIPHER_SUITE_TKIP: 2686 key_type = KEY_TKIP; 2687 2688 key_conf->hw_key_idx = key_conf->keyidx; 2689 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq); 2690 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq); 2691 break; 2692 case WLAN_CIPHER_SUITE_CCMP: 2693 key_type = KEY_AES; 2694 2695 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE; 2696 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq); 2697 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq); 2698 break; 2699 case WL1271_CIPHER_SUITE_GEM: 2700 key_type = KEY_GEM; 2701 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq); 2702 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq); 2703 break; 2704 default: 2705 wl1271_error("Unknown key algo 0x%x", key_conf->cipher); 2706 2707 ret = -EOPNOTSUPP; 2708 goto out_sleep; 2709 } 2710 2711 switch (cmd) { 2712 case SET_KEY: 2713 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE, 2714 key_conf->keyidx, key_type, 2715 key_conf->keylen, key_conf->key, 2716 tx_seq_32, tx_seq_16, sta); 2717 if (ret < 0) { 2718 wl1271_error("Could not add or replace key"); 2719 goto out_sleep; 2720 } 2721 2722 /* 2723 * reconfiguring arp response if the unicast (or common) 2724 * encryption key type was changed 2725 */ 2726 if (wlvif->bss_type == BSS_TYPE_STA_BSS && 2727 (sta || key_type == KEY_WEP) && 2728 wlvif->encryption_type != key_type) { 2729 wlvif->encryption_type = key_type; 2730 ret = wl1271_cmd_build_arp_rsp(wl, wlvif); 2731 if (ret < 0) { 2732 wl1271_warning("build arp rsp failed: %d", ret); 2733 goto out_sleep; 2734 } 2735 } 2736 break; 2737 2738 case DISABLE_KEY: 2739 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE, 2740 key_conf->keyidx, key_type, 2741 key_conf->keylen, key_conf->key, 2742 0, 0, sta); 2743 if (ret < 0) { 2744 wl1271_error("Could not remove key"); 2745 goto out_sleep; 2746 } 2747 break; 2748 2749 default: 2750 wl1271_error("Unsupported key cmd 0x%x", cmd); 2751 ret = -EOPNOTSUPP; 2752 break; 2753 } 2754 2755 out_sleep: 2756 wl1271_ps_elp_sleep(wl); 2757 2758 out_unlock: 2759 mutex_unlock(&wl->mutex); 2760 2761 return ret; 2762 } 2763 2764 static int wl1271_op_hw_scan(struct ieee80211_hw *hw, 2765 struct ieee80211_vif *vif, 2766 struct cfg80211_scan_request *req) 2767 { 2768 struct wl1271 *wl = hw->priv; 2769 int ret; 2770 u8 *ssid = NULL; 2771 size_t len = 0; 2772 2773 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan"); 2774 2775 if (req->n_ssids) { 2776 ssid = req->ssids[0].ssid; 2777 len = req->ssids[0].ssid_len; 2778 } 2779 2780 mutex_lock(&wl->mutex); 2781 2782 if (wl->state == WL1271_STATE_OFF) { 2783 /* 2784 * We cannot return -EBUSY here because cfg80211 will expect 2785 * a call to ieee80211_scan_completed if we do - in this case 2786 * there won't be any call. 2787 */ 2788 ret = -EAGAIN; 2789 goto out; 2790 } 2791 2792 ret = wl1271_ps_elp_wakeup(wl); 2793 if (ret < 0) 2794 goto out; 2795 2796 /* fail if there is any role in ROC */ 2797 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) { 2798 /* don't allow scanning right now */ 2799 ret = -EBUSY; 2800 goto out_sleep; 2801 } 2802 2803 ret = wl1271_scan(hw->priv, vif, ssid, len, req); 2804 out_sleep: 2805 wl1271_ps_elp_sleep(wl); 2806 out: 2807 mutex_unlock(&wl->mutex); 2808 2809 return ret; 2810 } 2811 2812 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw, 2813 struct ieee80211_vif *vif) 2814 { 2815 struct wl1271 *wl = hw->priv; 2816 int ret; 2817 2818 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan"); 2819 2820 mutex_lock(&wl->mutex); 2821 2822 if (wl->state == WL1271_STATE_OFF) 2823 goto out; 2824 2825 if (wl->scan.state == WL1271_SCAN_STATE_IDLE) 2826 goto out; 2827 2828 ret = wl1271_ps_elp_wakeup(wl); 2829 if (ret < 0) 2830 goto out; 2831 2832 if (wl->scan.state != WL1271_SCAN_STATE_DONE) { 2833 ret = wl1271_scan_stop(wl); 2834 if (ret < 0) 2835 goto out_sleep; 2836 } 2837 2838 /* 2839 * Rearm the tx watchdog just before idling scan. This 2840 * prevents just-finished scans from triggering the watchdog 2841 */ 2842 wl12xx_rearm_tx_watchdog_locked(wl); 2843 2844 wl->scan.state = WL1271_SCAN_STATE_IDLE; 2845 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch)); 2846 wl->scan_vif = NULL; 2847 wl->scan.req = NULL; 2848 ieee80211_scan_completed(wl->hw, true); 2849 2850 out_sleep: 2851 wl1271_ps_elp_sleep(wl); 2852 out: 2853 mutex_unlock(&wl->mutex); 2854 2855 cancel_delayed_work_sync(&wl->scan_complete_work); 2856 } 2857 2858 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw, 2859 struct ieee80211_vif *vif, 2860 struct cfg80211_sched_scan_request *req, 2861 struct ieee80211_sched_scan_ies *ies) 2862 { 2863 struct wl1271 *wl = hw->priv; 2864 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 2865 int ret; 2866 2867 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start"); 2868 2869 mutex_lock(&wl->mutex); 2870 2871 if (wl->state == WL1271_STATE_OFF) { 2872 ret = -EAGAIN; 2873 goto out; 2874 } 2875 2876 ret = wl1271_ps_elp_wakeup(wl); 2877 if (ret < 0) 2878 goto out; 2879 2880 ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies); 2881 if (ret < 0) 2882 goto out_sleep; 2883 2884 ret = wl1271_scan_sched_scan_start(wl, wlvif); 2885 if (ret < 0) 2886 goto out_sleep; 2887 2888 wl->sched_scanning = true; 2889 2890 out_sleep: 2891 wl1271_ps_elp_sleep(wl); 2892 out: 2893 mutex_unlock(&wl->mutex); 2894 return ret; 2895 } 2896 2897 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw, 2898 struct ieee80211_vif *vif) 2899 { 2900 struct wl1271 *wl = hw->priv; 2901 int ret; 2902 2903 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop"); 2904 2905 mutex_lock(&wl->mutex); 2906 2907 if (wl->state == WL1271_STATE_OFF) 2908 goto out; 2909 2910 ret = wl1271_ps_elp_wakeup(wl); 2911 if (ret < 0) 2912 goto out; 2913 2914 wl1271_scan_sched_scan_stop(wl); 2915 2916 wl1271_ps_elp_sleep(wl); 2917 out: 2918 mutex_unlock(&wl->mutex); 2919 } 2920 2921 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 2922 { 2923 struct wl1271 *wl = hw->priv; 2924 int ret = 0; 2925 2926 mutex_lock(&wl->mutex); 2927 2928 if (unlikely(wl->state == WL1271_STATE_OFF)) { 2929 ret = -EAGAIN; 2930 goto out; 2931 } 2932 2933 ret = wl1271_ps_elp_wakeup(wl); 2934 if (ret < 0) 2935 goto out; 2936 2937 ret = wl1271_acx_frag_threshold(wl, value); 2938 if (ret < 0) 2939 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret); 2940 2941 wl1271_ps_elp_sleep(wl); 2942 2943 out: 2944 mutex_unlock(&wl->mutex); 2945 2946 return ret; 2947 } 2948 2949 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 2950 { 2951 struct wl1271 *wl = hw->priv; 2952 struct wl12xx_vif *wlvif; 2953 int ret = 0; 2954 2955 mutex_lock(&wl->mutex); 2956 2957 if (unlikely(wl->state == WL1271_STATE_OFF)) { 2958 ret = -EAGAIN; 2959 goto out; 2960 } 2961 2962 ret = wl1271_ps_elp_wakeup(wl); 2963 if (ret < 0) 2964 goto out; 2965 2966 wl12xx_for_each_wlvif(wl, wlvif) { 2967 ret = wl1271_acx_rts_threshold(wl, wlvif, value); 2968 if (ret < 0) 2969 wl1271_warning("set rts threshold failed: %d", ret); 2970 } 2971 wl1271_ps_elp_sleep(wl); 2972 2973 out: 2974 mutex_unlock(&wl->mutex); 2975 2976 return ret; 2977 } 2978 2979 static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb, 2980 int offset) 2981 { 2982 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 2983 u8 ssid_len; 2984 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset, 2985 skb->len - offset); 2986 2987 if (!ptr) { 2988 wl1271_error("No SSID in IEs!"); 2989 return -ENOENT; 2990 } 2991 2992 ssid_len = ptr[1]; 2993 if (ssid_len > IEEE80211_MAX_SSID_LEN) { 2994 wl1271_error("SSID is too long!"); 2995 return -EINVAL; 2996 } 2997 2998 wlvif->ssid_len = ssid_len; 2999 memcpy(wlvif->ssid, ptr+2, ssid_len); 3000 return 0; 3001 } 3002 3003 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset) 3004 { 3005 int len; 3006 const u8 *next, *end = skb->data + skb->len; 3007 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset, 3008 skb->len - ieoffset); 3009 if (!ie) 3010 return; 3011 len = ie[1] + 2; 3012 next = ie + len; 3013 memmove(ie, next, end - next); 3014 skb_trim(skb, skb->len - len); 3015 } 3016 3017 static void wl12xx_remove_vendor_ie(struct sk_buff *skb, 3018 unsigned int oui, u8 oui_type, 3019 int ieoffset) 3020 { 3021 int len; 3022 const u8 *next, *end = skb->data + skb->len; 3023 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type, 3024 skb->data + ieoffset, 3025 skb->len - ieoffset); 3026 if (!ie) 3027 return; 3028 len = ie[1] + 2; 3029 next = ie + len; 3030 memmove(ie, next, end - next); 3031 skb_trim(skb, skb->len - len); 3032 } 3033 3034 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates, 3035 struct ieee80211_vif *vif) 3036 { 3037 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3038 struct sk_buff *skb; 3039 int ret; 3040 3041 skb = ieee80211_proberesp_get(wl->hw, vif); 3042 if (!skb) 3043 return -EOPNOTSUPP; 3044 3045 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 3046 CMD_TEMPL_AP_PROBE_RESPONSE, 3047 skb->data, 3048 skb->len, 0, 3049 rates); 3050 3051 dev_kfree_skb(skb); 3052 return ret; 3053 } 3054 3055 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl, 3056 struct ieee80211_vif *vif, 3057 u8 *probe_rsp_data, 3058 size_t probe_rsp_len, 3059 u32 rates) 3060 { 3061 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3062 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 3063 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE]; 3064 int ssid_ie_offset, ie_offset, templ_len; 3065 const u8 *ptr; 3066 3067 /* no need to change probe response if the SSID is set correctly */ 3068 if (wlvif->ssid_len > 0) 3069 return wl1271_cmd_template_set(wl, wlvif->role_id, 3070 CMD_TEMPL_AP_PROBE_RESPONSE, 3071 probe_rsp_data, 3072 probe_rsp_len, 0, 3073 rates); 3074 3075 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) { 3076 wl1271_error("probe_rsp template too big"); 3077 return -EINVAL; 3078 } 3079 3080 /* start searching from IE offset */ 3081 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable); 3082 3083 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset, 3084 probe_rsp_len - ie_offset); 3085 if (!ptr) { 3086 wl1271_error("No SSID in beacon!"); 3087 return -EINVAL; 3088 } 3089 3090 ssid_ie_offset = ptr - probe_rsp_data; 3091 ptr += (ptr[1] + 2); 3092 3093 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset); 3094 3095 /* insert SSID from bss_conf */ 3096 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID; 3097 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len; 3098 memcpy(probe_rsp_templ + ssid_ie_offset + 2, 3099 bss_conf->ssid, bss_conf->ssid_len); 3100 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len; 3101 3102 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len, 3103 ptr, probe_rsp_len - (ptr - probe_rsp_data)); 3104 templ_len += probe_rsp_len - (ptr - probe_rsp_data); 3105 3106 return wl1271_cmd_template_set(wl, wlvif->role_id, 3107 CMD_TEMPL_AP_PROBE_RESPONSE, 3108 probe_rsp_templ, 3109 templ_len, 0, 3110 rates); 3111 } 3112 3113 static int wl1271_bss_erp_info_changed(struct wl1271 *wl, 3114 struct ieee80211_vif *vif, 3115 struct ieee80211_bss_conf *bss_conf, 3116 u32 changed) 3117 { 3118 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3119 int ret = 0; 3120 3121 if (changed & BSS_CHANGED_ERP_SLOT) { 3122 if (bss_conf->use_short_slot) 3123 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT); 3124 else 3125 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG); 3126 if (ret < 0) { 3127 wl1271_warning("Set slot time failed %d", ret); 3128 goto out; 3129 } 3130 } 3131 3132 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 3133 if (bss_conf->use_short_preamble) 3134 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT); 3135 else 3136 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG); 3137 } 3138 3139 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 3140 if (bss_conf->use_cts_prot) 3141 ret = wl1271_acx_cts_protect(wl, wlvif, 3142 CTSPROTECT_ENABLE); 3143 else 3144 ret = wl1271_acx_cts_protect(wl, wlvif, 3145 CTSPROTECT_DISABLE); 3146 if (ret < 0) { 3147 wl1271_warning("Set ctsprotect failed %d", ret); 3148 goto out; 3149 } 3150 } 3151 3152 out: 3153 return ret; 3154 } 3155 3156 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl, 3157 struct ieee80211_vif *vif, 3158 struct ieee80211_bss_conf *bss_conf, 3159 u32 changed) 3160 { 3161 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3162 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 3163 int ret = 0; 3164 3165 if ((changed & BSS_CHANGED_BEACON_INT)) { 3166 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d", 3167 bss_conf->beacon_int); 3168 3169 wlvif->beacon_int = bss_conf->beacon_int; 3170 } 3171 3172 if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) { 3173 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 3174 if (!wl1271_ap_set_probe_resp_tmpl(wl, rate, vif)) { 3175 wl1271_debug(DEBUG_AP, "probe response updated"); 3176 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags); 3177 } 3178 } 3179 3180 if ((changed & BSS_CHANGED_BEACON)) { 3181 struct ieee80211_hdr *hdr; 3182 u32 min_rate; 3183 int ieoffset = offsetof(struct ieee80211_mgmt, 3184 u.beacon.variable); 3185 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif); 3186 u16 tmpl_id; 3187 3188 if (!beacon) { 3189 ret = -EINVAL; 3190 goto out; 3191 } 3192 3193 wl1271_debug(DEBUG_MASTER, "beacon updated"); 3194 3195 ret = wl1271_ssid_set(vif, beacon, ieoffset); 3196 if (ret < 0) { 3197 dev_kfree_skb(beacon); 3198 goto out; 3199 } 3200 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 3201 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON : 3202 CMD_TEMPL_BEACON; 3203 ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id, 3204 beacon->data, 3205 beacon->len, 0, 3206 min_rate); 3207 if (ret < 0) { 3208 dev_kfree_skb(beacon); 3209 goto out; 3210 } 3211 3212 /* 3213 * In case we already have a probe-resp beacon set explicitly 3214 * by usermode, don't use the beacon data. 3215 */ 3216 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags)) 3217 goto end_bcn; 3218 3219 /* remove TIM ie from probe response */ 3220 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset); 3221 3222 /* 3223 * remove p2p ie from probe response. 3224 * the fw reponds to probe requests that don't include 3225 * the p2p ie. probe requests with p2p ie will be passed, 3226 * and will be responded by the supplicant (the spec 3227 * forbids including the p2p ie when responding to probe 3228 * requests that didn't include it). 3229 */ 3230 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA, 3231 WLAN_OUI_TYPE_WFA_P2P, ieoffset); 3232 3233 hdr = (struct ieee80211_hdr *) beacon->data; 3234 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 3235 IEEE80211_STYPE_PROBE_RESP); 3236 if (is_ap) 3237 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif, 3238 beacon->data, 3239 beacon->len, 3240 min_rate); 3241 else 3242 ret = wl1271_cmd_template_set(wl, wlvif->role_id, 3243 CMD_TEMPL_PROBE_RESPONSE, 3244 beacon->data, 3245 beacon->len, 0, 3246 min_rate); 3247 end_bcn: 3248 dev_kfree_skb(beacon); 3249 if (ret < 0) 3250 goto out; 3251 } 3252 3253 out: 3254 if (ret != 0) 3255 wl1271_error("beacon info change failed: %d", ret); 3256 return ret; 3257 } 3258 3259 /* AP mode changes */ 3260 static void wl1271_bss_info_changed_ap(struct wl1271 *wl, 3261 struct ieee80211_vif *vif, 3262 struct ieee80211_bss_conf *bss_conf, 3263 u32 changed) 3264 { 3265 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3266 int ret = 0; 3267 3268 if ((changed & BSS_CHANGED_BASIC_RATES)) { 3269 u32 rates = bss_conf->basic_rates; 3270 3271 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates, 3272 wlvif->band); 3273 wlvif->basic_rate = wl1271_tx_min_rate_get(wl, 3274 wlvif->basic_rate_set); 3275 3276 ret = wl1271_init_ap_rates(wl, wlvif); 3277 if (ret < 0) { 3278 wl1271_error("AP rate policy change failed %d", ret); 3279 goto out; 3280 } 3281 3282 ret = wl1271_ap_init_templates(wl, vif); 3283 if (ret < 0) 3284 goto out; 3285 } 3286 3287 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed); 3288 if (ret < 0) 3289 goto out; 3290 3291 if ((changed & BSS_CHANGED_BEACON_ENABLED)) { 3292 if (bss_conf->enable_beacon) { 3293 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) { 3294 ret = wl12xx_cmd_role_start_ap(wl, wlvif); 3295 if (ret < 0) 3296 goto out; 3297 3298 ret = wl1271_ap_init_hwenc(wl, wlvif); 3299 if (ret < 0) 3300 goto out; 3301 3302 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags); 3303 wl1271_debug(DEBUG_AP, "started AP"); 3304 } 3305 } else { 3306 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) { 3307 ret = wl12xx_cmd_role_stop_ap(wl, wlvif); 3308 if (ret < 0) 3309 goto out; 3310 3311 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags); 3312 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, 3313 &wlvif->flags); 3314 wl1271_debug(DEBUG_AP, "stopped AP"); 3315 } 3316 } 3317 } 3318 3319 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed); 3320 if (ret < 0) 3321 goto out; 3322 3323 /* Handle HT information change */ 3324 if ((changed & BSS_CHANGED_HT) && 3325 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) { 3326 ret = wl1271_acx_set_ht_information(wl, wlvif, 3327 bss_conf->ht_operation_mode); 3328 if (ret < 0) { 3329 wl1271_warning("Set ht information failed %d", ret); 3330 goto out; 3331 } 3332 } 3333 3334 out: 3335 return; 3336 } 3337 3338 /* STA/IBSS mode changes */ 3339 static void wl1271_bss_info_changed_sta(struct wl1271 *wl, 3340 struct ieee80211_vif *vif, 3341 struct ieee80211_bss_conf *bss_conf, 3342 u32 changed) 3343 { 3344 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3345 bool do_join = false, set_assoc = false; 3346 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS); 3347 bool ibss_joined = false; 3348 u32 sta_rate_set = 0; 3349 int ret; 3350 struct ieee80211_sta *sta; 3351 bool sta_exists = false; 3352 struct ieee80211_sta_ht_cap sta_ht_cap; 3353 3354 if (is_ibss) { 3355 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, 3356 changed); 3357 if (ret < 0) 3358 goto out; 3359 } 3360 3361 if (changed & BSS_CHANGED_IBSS) { 3362 if (bss_conf->ibss_joined) { 3363 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags); 3364 ibss_joined = true; 3365 } else { 3366 if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED, 3367 &wlvif->flags)) 3368 wl1271_unjoin(wl, wlvif); 3369 } 3370 } 3371 3372 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined) 3373 do_join = true; 3374 3375 /* Need to update the SSID (for filtering etc) */ 3376 if ((changed & BSS_CHANGED_BEACON) && ibss_joined) 3377 do_join = true; 3378 3379 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) { 3380 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s", 3381 bss_conf->enable_beacon ? "enabled" : "disabled"); 3382 3383 do_join = true; 3384 } 3385 3386 if (changed & BSS_CHANGED_IDLE && !is_ibss) { 3387 ret = wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle); 3388 if (ret < 0) 3389 wl1271_warning("idle mode change failed %d", ret); 3390 } 3391 3392 if ((changed & BSS_CHANGED_CQM)) { 3393 bool enable = false; 3394 if (bss_conf->cqm_rssi_thold) 3395 enable = true; 3396 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable, 3397 bss_conf->cqm_rssi_thold, 3398 bss_conf->cqm_rssi_hyst); 3399 if (ret < 0) 3400 goto out; 3401 wlvif->rssi_thold = bss_conf->cqm_rssi_thold; 3402 } 3403 3404 if (changed & BSS_CHANGED_BSSID) 3405 if (!is_zero_ether_addr(bss_conf->bssid)) { 3406 ret = wl12xx_cmd_build_null_data(wl, wlvif); 3407 if (ret < 0) 3408 goto out; 3409 3410 ret = wl1271_build_qos_null_data(wl, vif); 3411 if (ret < 0) 3412 goto out; 3413 } 3414 3415 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) { 3416 rcu_read_lock(); 3417 sta = ieee80211_find_sta(vif, bss_conf->bssid); 3418 if (!sta) 3419 goto sta_not_found; 3420 3421 /* save the supp_rates of the ap */ 3422 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band]; 3423 if (sta->ht_cap.ht_supported) 3424 sta_rate_set |= 3425 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET); 3426 sta_ht_cap = sta->ht_cap; 3427 sta_exists = true; 3428 3429 sta_not_found: 3430 rcu_read_unlock(); 3431 } 3432 3433 if ((changed & BSS_CHANGED_ASSOC)) { 3434 if (bss_conf->assoc) { 3435 u32 rates; 3436 int ieoffset; 3437 wlvif->aid = bss_conf->aid; 3438 wlvif->beacon_int = bss_conf->beacon_int; 3439 do_join = true; 3440 set_assoc = true; 3441 3442 /* 3443 * use basic rates from AP, and determine lowest rate 3444 * to use with control frames. 3445 */ 3446 rates = bss_conf->basic_rates; 3447 wlvif->basic_rate_set = 3448 wl1271_tx_enabled_rates_get(wl, rates, 3449 wlvif->band); 3450 wlvif->basic_rate = 3451 wl1271_tx_min_rate_get(wl, 3452 wlvif->basic_rate_set); 3453 if (sta_rate_set) 3454 wlvif->rate_set = 3455 wl1271_tx_enabled_rates_get(wl, 3456 sta_rate_set, 3457 wlvif->band); 3458 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 3459 if (ret < 0) 3460 goto out; 3461 3462 /* 3463 * with wl1271, we don't need to update the 3464 * beacon_int and dtim_period, because the firmware 3465 * updates it by itself when the first beacon is 3466 * received after a join. 3467 */ 3468 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid); 3469 if (ret < 0) 3470 goto out; 3471 3472 /* 3473 * Get a template for hardware connection maintenance 3474 */ 3475 dev_kfree_skb(wlvif->probereq); 3476 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl, 3477 wlvif, 3478 NULL); 3479 ieoffset = offsetof(struct ieee80211_mgmt, 3480 u.probe_req.variable); 3481 wl1271_ssid_set(vif, wlvif->probereq, ieoffset); 3482 3483 /* enable the connection monitoring feature */ 3484 ret = wl1271_acx_conn_monit_params(wl, wlvif, true); 3485 if (ret < 0) 3486 goto out; 3487 } else { 3488 /* use defaults when not associated */ 3489 bool was_assoc = 3490 !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED, 3491 &wlvif->flags); 3492 bool was_ifup = 3493 !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT, 3494 &wlvif->flags); 3495 wlvif->aid = 0; 3496 3497 /* free probe-request template */ 3498 dev_kfree_skb(wlvif->probereq); 3499 wlvif->probereq = NULL; 3500 3501 /* revert back to minimum rates for the current band */ 3502 wl1271_set_band_rate(wl, wlvif); 3503 wlvif->basic_rate = 3504 wl1271_tx_min_rate_get(wl, 3505 wlvif->basic_rate_set); 3506 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 3507 if (ret < 0) 3508 goto out; 3509 3510 /* disable connection monitor features */ 3511 ret = wl1271_acx_conn_monit_params(wl, wlvif, false); 3512 3513 /* Disable the keep-alive feature */ 3514 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false); 3515 if (ret < 0) 3516 goto out; 3517 3518 /* restore the bssid filter and go to dummy bssid */ 3519 if (was_assoc) { 3520 /* 3521 * we might have to disable roc, if there was 3522 * no IF_OPER_UP notification. 3523 */ 3524 if (!was_ifup) { 3525 ret = wl12xx_croc(wl, wlvif->role_id); 3526 if (ret < 0) 3527 goto out; 3528 } 3529 /* 3530 * (we also need to disable roc in case of 3531 * roaming on the same channel. until we will 3532 * have a better flow...) 3533 */ 3534 if (test_bit(wlvif->dev_role_id, wl->roc_map)) { 3535 ret = wl12xx_croc(wl, 3536 wlvif->dev_role_id); 3537 if (ret < 0) 3538 goto out; 3539 } 3540 3541 wl1271_unjoin(wl, wlvif); 3542 if (!bss_conf->idle) 3543 wl12xx_start_dev(wl, wlvif); 3544 } 3545 } 3546 } 3547 3548 if (changed & BSS_CHANGED_IBSS) { 3549 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d", 3550 bss_conf->ibss_joined); 3551 3552 if (bss_conf->ibss_joined) { 3553 u32 rates = bss_conf->basic_rates; 3554 wlvif->basic_rate_set = 3555 wl1271_tx_enabled_rates_get(wl, rates, 3556 wlvif->band); 3557 wlvif->basic_rate = 3558 wl1271_tx_min_rate_get(wl, 3559 wlvif->basic_rate_set); 3560 3561 /* by default, use 11b + OFDM rates */ 3562 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES; 3563 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 3564 if (ret < 0) 3565 goto out; 3566 } 3567 } 3568 3569 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed); 3570 if (ret < 0) 3571 goto out; 3572 3573 if (do_join) { 3574 ret = wl1271_join(wl, wlvif, set_assoc); 3575 if (ret < 0) { 3576 wl1271_warning("cmd join failed %d", ret); 3577 goto out; 3578 } 3579 3580 /* ROC until connected (after EAPOL exchange) */ 3581 if (!is_ibss) { 3582 ret = wl12xx_roc(wl, wlvif, wlvif->role_id); 3583 if (ret < 0) 3584 goto out; 3585 3586 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags)) 3587 wl12xx_set_authorized(wl, wlvif); 3588 } 3589 /* 3590 * stop device role if started (we might already be in 3591 * STA/IBSS role). 3592 */ 3593 if (wl12xx_dev_role_started(wlvif)) { 3594 ret = wl12xx_stop_dev(wl, wlvif); 3595 if (ret < 0) 3596 goto out; 3597 } 3598 } 3599 3600 /* Handle new association with HT. Do this after join. */ 3601 if (sta_exists) { 3602 if ((changed & BSS_CHANGED_HT) && 3603 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) { 3604 ret = wl1271_acx_set_ht_capabilities(wl, 3605 &sta_ht_cap, 3606 true, 3607 wlvif->sta.hlid); 3608 if (ret < 0) { 3609 wl1271_warning("Set ht cap true failed %d", 3610 ret); 3611 goto out; 3612 } 3613 } 3614 /* handle new association without HT and disassociation */ 3615 else if (changed & BSS_CHANGED_ASSOC) { 3616 ret = wl1271_acx_set_ht_capabilities(wl, 3617 &sta_ht_cap, 3618 false, 3619 wlvif->sta.hlid); 3620 if (ret < 0) { 3621 wl1271_warning("Set ht cap false failed %d", 3622 ret); 3623 goto out; 3624 } 3625 } 3626 } 3627 3628 /* Handle HT information change. Done after join. */ 3629 if ((changed & BSS_CHANGED_HT) && 3630 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) { 3631 ret = wl1271_acx_set_ht_information(wl, wlvif, 3632 bss_conf->ht_operation_mode); 3633 if (ret < 0) { 3634 wl1271_warning("Set ht information failed %d", ret); 3635 goto out; 3636 } 3637 } 3638 3639 /* Handle arp filtering. Done after join. */ 3640 if ((changed & BSS_CHANGED_ARP_FILTER) || 3641 (!is_ibss && (changed & BSS_CHANGED_QOS))) { 3642 __be32 addr = bss_conf->arp_addr_list[0]; 3643 wlvif->sta.qos = bss_conf->qos; 3644 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS); 3645 3646 if (bss_conf->arp_addr_cnt == 1 && 3647 bss_conf->arp_filter_enabled) { 3648 wlvif->ip_addr = addr; 3649 /* 3650 * The template should have been configured only upon 3651 * association. however, it seems that the correct ip 3652 * isn't being set (when sending), so we have to 3653 * reconfigure the template upon every ip change. 3654 */ 3655 ret = wl1271_cmd_build_arp_rsp(wl, wlvif); 3656 if (ret < 0) { 3657 wl1271_warning("build arp rsp failed: %d", ret); 3658 goto out; 3659 } 3660 3661 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 3662 (ACX_ARP_FILTER_ARP_FILTERING | 3663 ACX_ARP_FILTER_AUTO_ARP), 3664 addr); 3665 } else { 3666 wlvif->ip_addr = 0; 3667 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr); 3668 } 3669 3670 if (ret < 0) 3671 goto out; 3672 } 3673 3674 out: 3675 return; 3676 } 3677 3678 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw, 3679 struct ieee80211_vif *vif, 3680 struct ieee80211_bss_conf *bss_conf, 3681 u32 changed) 3682 { 3683 struct wl1271 *wl = hw->priv; 3684 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3685 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); 3686 int ret; 3687 3688 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x", 3689 (int)changed); 3690 3691 mutex_lock(&wl->mutex); 3692 3693 if (unlikely(wl->state == WL1271_STATE_OFF)) 3694 goto out; 3695 3696 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))) 3697 goto out; 3698 3699 ret = wl1271_ps_elp_wakeup(wl); 3700 if (ret < 0) 3701 goto out; 3702 3703 if (is_ap) 3704 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed); 3705 else 3706 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed); 3707 3708 wl1271_ps_elp_sleep(wl); 3709 3710 out: 3711 mutex_unlock(&wl->mutex); 3712 } 3713 3714 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, 3715 struct ieee80211_vif *vif, u16 queue, 3716 const struct ieee80211_tx_queue_params *params) 3717 { 3718 struct wl1271 *wl = hw->priv; 3719 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3720 u8 ps_scheme; 3721 int ret = 0; 3722 3723 mutex_lock(&wl->mutex); 3724 3725 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue); 3726 3727 if (params->uapsd) 3728 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER; 3729 else 3730 ps_scheme = CONF_PS_SCHEME_LEGACY; 3731 3732 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) 3733 goto out; 3734 3735 ret = wl1271_ps_elp_wakeup(wl); 3736 if (ret < 0) 3737 goto out; 3738 3739 /* 3740 * the txop is confed in units of 32us by the mac80211, 3741 * we need us 3742 */ 3743 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue), 3744 params->cw_min, params->cw_max, 3745 params->aifs, params->txop << 5); 3746 if (ret < 0) 3747 goto out_sleep; 3748 3749 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue), 3750 CONF_CHANNEL_TYPE_EDCF, 3751 wl1271_tx_get_queue(queue), 3752 ps_scheme, CONF_ACK_POLICY_LEGACY, 3753 0, 0); 3754 3755 out_sleep: 3756 wl1271_ps_elp_sleep(wl); 3757 3758 out: 3759 mutex_unlock(&wl->mutex); 3760 3761 return ret; 3762 } 3763 3764 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw, 3765 struct ieee80211_vif *vif) 3766 { 3767 3768 struct wl1271 *wl = hw->priv; 3769 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3770 u64 mactime = ULLONG_MAX; 3771 int ret; 3772 3773 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf"); 3774 3775 mutex_lock(&wl->mutex); 3776 3777 if (unlikely(wl->state == WL1271_STATE_OFF)) 3778 goto out; 3779 3780 ret = wl1271_ps_elp_wakeup(wl); 3781 if (ret < 0) 3782 goto out; 3783 3784 ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime); 3785 if (ret < 0) 3786 goto out_sleep; 3787 3788 out_sleep: 3789 wl1271_ps_elp_sleep(wl); 3790 3791 out: 3792 mutex_unlock(&wl->mutex); 3793 return mactime; 3794 } 3795 3796 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx, 3797 struct survey_info *survey) 3798 { 3799 struct wl1271 *wl = hw->priv; 3800 struct ieee80211_conf *conf = &hw->conf; 3801 3802 if (idx != 0) 3803 return -ENOENT; 3804 3805 survey->channel = conf->channel; 3806 survey->filled = SURVEY_INFO_NOISE_DBM; 3807 survey->noise = wl->noise; 3808 3809 return 0; 3810 } 3811 3812 static int wl1271_allocate_sta(struct wl1271 *wl, 3813 struct wl12xx_vif *wlvif, 3814 struct ieee80211_sta *sta) 3815 { 3816 struct wl1271_station *wl_sta; 3817 int ret; 3818 3819 3820 if (wl->active_sta_count >= AP_MAX_STATIONS) { 3821 wl1271_warning("could not allocate HLID - too much stations"); 3822 return -EBUSY; 3823 } 3824 3825 wl_sta = (struct wl1271_station *)sta->drv_priv; 3826 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid); 3827 if (ret < 0) { 3828 wl1271_warning("could not allocate HLID - too many links"); 3829 return -EBUSY; 3830 } 3831 3832 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map); 3833 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN); 3834 wl->active_sta_count++; 3835 return 0; 3836 } 3837 3838 void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid) 3839 { 3840 if (!test_bit(hlid, wlvif->ap.sta_hlid_map)) 3841 return; 3842 3843 clear_bit(hlid, wlvif->ap.sta_hlid_map); 3844 memset(wl->links[hlid].addr, 0, ETH_ALEN); 3845 wl->links[hlid].ba_bitmap = 0; 3846 __clear_bit(hlid, &wl->ap_ps_map); 3847 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map); 3848 wl12xx_free_link(wl, wlvif, &hlid); 3849 wl->active_sta_count--; 3850 3851 /* 3852 * rearm the tx watchdog when the last STA is freed - give the FW a 3853 * chance to return STA-buffered packets before complaining. 3854 */ 3855 if (wl->active_sta_count == 0) 3856 wl12xx_rearm_tx_watchdog_locked(wl); 3857 } 3858 3859 static int wl12xx_sta_add(struct wl1271 *wl, 3860 struct wl12xx_vif *wlvif, 3861 struct ieee80211_sta *sta) 3862 { 3863 struct wl1271_station *wl_sta; 3864 int ret = 0; 3865 u8 hlid; 3866 3867 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid); 3868 3869 ret = wl1271_allocate_sta(wl, wlvif, sta); 3870 if (ret < 0) 3871 return ret; 3872 3873 wl_sta = (struct wl1271_station *)sta->drv_priv; 3874 hlid = wl_sta->hlid; 3875 3876 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid); 3877 if (ret < 0) 3878 wl1271_free_sta(wl, wlvif, hlid); 3879 3880 return ret; 3881 } 3882 3883 static int wl12xx_sta_remove(struct wl1271 *wl, 3884 struct wl12xx_vif *wlvif, 3885 struct ieee80211_sta *sta) 3886 { 3887 struct wl1271_station *wl_sta; 3888 int ret = 0, id; 3889 3890 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid); 3891 3892 wl_sta = (struct wl1271_station *)sta->drv_priv; 3893 id = wl_sta->hlid; 3894 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map))) 3895 return -EINVAL; 3896 3897 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid); 3898 if (ret < 0) 3899 return ret; 3900 3901 wl1271_free_sta(wl, wlvif, wl_sta->hlid); 3902 return ret; 3903 } 3904 3905 static int wl12xx_update_sta_state(struct wl1271 *wl, 3906 struct wl12xx_vif *wlvif, 3907 struct ieee80211_sta *sta, 3908 enum ieee80211_sta_state old_state, 3909 enum ieee80211_sta_state new_state) 3910 { 3911 struct wl1271_station *wl_sta; 3912 u8 hlid; 3913 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS; 3914 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS; 3915 int ret; 3916 3917 wl_sta = (struct wl1271_station *)sta->drv_priv; 3918 hlid = wl_sta->hlid; 3919 3920 /* Add station (AP mode) */ 3921 if (is_ap && 3922 old_state == IEEE80211_STA_NOTEXIST && 3923 new_state == IEEE80211_STA_NONE) 3924 return wl12xx_sta_add(wl, wlvif, sta); 3925 3926 /* Remove station (AP mode) */ 3927 if (is_ap && 3928 old_state == IEEE80211_STA_NONE && 3929 new_state == IEEE80211_STA_NOTEXIST) { 3930 /* must not fail */ 3931 wl12xx_sta_remove(wl, wlvif, sta); 3932 return 0; 3933 } 3934 3935 /* Authorize station (AP mode) */ 3936 if (is_ap && 3937 new_state == IEEE80211_STA_AUTHORIZED) { 3938 ret = wl12xx_cmd_set_peer_state(wl, hlid); 3939 if (ret < 0) 3940 return ret; 3941 3942 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, 3943 hlid); 3944 return ret; 3945 } 3946 3947 /* Authorize station */ 3948 if (is_sta && 3949 new_state == IEEE80211_STA_AUTHORIZED) { 3950 set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags); 3951 return wl12xx_set_authorized(wl, wlvif); 3952 } 3953 3954 if (is_sta && 3955 old_state == IEEE80211_STA_AUTHORIZED && 3956 new_state == IEEE80211_STA_ASSOC) { 3957 clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags); 3958 return 0; 3959 } 3960 3961 return 0; 3962 } 3963 3964 static int wl12xx_op_sta_state(struct ieee80211_hw *hw, 3965 struct ieee80211_vif *vif, 3966 struct ieee80211_sta *sta, 3967 enum ieee80211_sta_state old_state, 3968 enum ieee80211_sta_state new_state) 3969 { 3970 struct wl1271 *wl = hw->priv; 3971 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 3972 int ret; 3973 3974 wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d", 3975 sta->aid, old_state, new_state); 3976 3977 mutex_lock(&wl->mutex); 3978 3979 if (unlikely(wl->state == WL1271_STATE_OFF)) { 3980 ret = -EBUSY; 3981 goto out; 3982 } 3983 3984 ret = wl1271_ps_elp_wakeup(wl); 3985 if (ret < 0) 3986 goto out; 3987 3988 ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state); 3989 3990 wl1271_ps_elp_sleep(wl); 3991 out: 3992 mutex_unlock(&wl->mutex); 3993 if (new_state < old_state) 3994 return 0; 3995 return ret; 3996 } 3997 3998 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw, 3999 struct ieee80211_vif *vif, 4000 enum ieee80211_ampdu_mlme_action action, 4001 struct ieee80211_sta *sta, u16 tid, u16 *ssn, 4002 u8 buf_size) 4003 { 4004 struct wl1271 *wl = hw->priv; 4005 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4006 int ret; 4007 u8 hlid, *ba_bitmap; 4008 4009 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action, 4010 tid); 4011 4012 /* sanity check - the fields in FW are only 8bits wide */ 4013 if (WARN_ON(tid > 0xFF)) 4014 return -ENOTSUPP; 4015 4016 mutex_lock(&wl->mutex); 4017 4018 if (unlikely(wl->state == WL1271_STATE_OFF)) { 4019 ret = -EAGAIN; 4020 goto out; 4021 } 4022 4023 if (wlvif->bss_type == BSS_TYPE_STA_BSS) { 4024 hlid = wlvif->sta.hlid; 4025 ba_bitmap = &wlvif->sta.ba_rx_bitmap; 4026 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) { 4027 struct wl1271_station *wl_sta; 4028 4029 wl_sta = (struct wl1271_station *)sta->drv_priv; 4030 hlid = wl_sta->hlid; 4031 ba_bitmap = &wl->links[hlid].ba_bitmap; 4032 } else { 4033 ret = -EINVAL; 4034 goto out; 4035 } 4036 4037 ret = wl1271_ps_elp_wakeup(wl); 4038 if (ret < 0) 4039 goto out; 4040 4041 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d", 4042 tid, action); 4043 4044 switch (action) { 4045 case IEEE80211_AMPDU_RX_START: 4046 if (!wlvif->ba_support || !wlvif->ba_allowed) { 4047 ret = -ENOTSUPP; 4048 break; 4049 } 4050 4051 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) { 4052 ret = -EBUSY; 4053 wl1271_error("exceeded max RX BA sessions"); 4054 break; 4055 } 4056 4057 if (*ba_bitmap & BIT(tid)) { 4058 ret = -EINVAL; 4059 wl1271_error("cannot enable RX BA session on active " 4060 "tid: %d", tid); 4061 break; 4062 } 4063 4064 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true, 4065 hlid); 4066 if (!ret) { 4067 *ba_bitmap |= BIT(tid); 4068 wl->ba_rx_session_count++; 4069 } 4070 break; 4071 4072 case IEEE80211_AMPDU_RX_STOP: 4073 if (!(*ba_bitmap & BIT(tid))) { 4074 ret = -EINVAL; 4075 wl1271_error("no active RX BA session on tid: %d", 4076 tid); 4077 break; 4078 } 4079 4080 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false, 4081 hlid); 4082 if (!ret) { 4083 *ba_bitmap &= ~BIT(tid); 4084 wl->ba_rx_session_count--; 4085 } 4086 break; 4087 4088 /* 4089 * The BA initiator session management in FW independently. 4090 * Falling break here on purpose for all TX APDU commands. 4091 */ 4092 case IEEE80211_AMPDU_TX_START: 4093 case IEEE80211_AMPDU_TX_STOP: 4094 case IEEE80211_AMPDU_TX_OPERATIONAL: 4095 ret = -EINVAL; 4096 break; 4097 4098 default: 4099 wl1271_error("Incorrect ampdu action id=%x\n", action); 4100 ret = -EINVAL; 4101 } 4102 4103 wl1271_ps_elp_sleep(wl); 4104 4105 out: 4106 mutex_unlock(&wl->mutex); 4107 4108 return ret; 4109 } 4110 4111 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw, 4112 struct ieee80211_vif *vif, 4113 const struct cfg80211_bitrate_mask *mask) 4114 { 4115 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); 4116 struct wl1271 *wl = hw->priv; 4117 int i, ret = 0; 4118 4119 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x", 4120 mask->control[NL80211_BAND_2GHZ].legacy, 4121 mask->control[NL80211_BAND_5GHZ].legacy); 4122 4123 mutex_lock(&wl->mutex); 4124 4125 for (i = 0; i < IEEE80211_NUM_BANDS; i++) 4126 wlvif->bitrate_masks[i] = 4127 wl1271_tx_enabled_rates_get(wl, 4128 mask->control[i].legacy, 4129 i); 4130 4131 if (unlikely(wl->state == WL1271_STATE_OFF)) 4132 goto out; 4133 4134 if (wlvif->bss_type == BSS_TYPE_STA_BSS && 4135 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) { 4136 4137 ret = wl1271_ps_elp_wakeup(wl); 4138 if (ret < 0) 4139 goto out; 4140 4141 wl1271_set_band_rate(wl, wlvif); 4142 wlvif->basic_rate = 4143 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set); 4144 ret = wl1271_acx_sta_rate_policies(wl, wlvif); 4145 4146 wl1271_ps_elp_sleep(wl); 4147 } 4148 out: 4149 mutex_unlock(&wl->mutex); 4150 4151 return ret; 4152 } 4153 4154 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw, 4155 struct ieee80211_channel_switch *ch_switch) 4156 { 4157 struct wl1271 *wl = hw->priv; 4158 struct wl12xx_vif *wlvif; 4159 int ret; 4160 4161 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch"); 4162 4163 wl1271_tx_flush(wl); 4164 4165 mutex_lock(&wl->mutex); 4166 4167 if (unlikely(wl->state == WL1271_STATE_OFF)) { 4168 wl12xx_for_each_wlvif_sta(wl, wlvif) { 4169 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); 4170 ieee80211_chswitch_done(vif, false); 4171 } 4172 goto out; 4173 } 4174 4175 ret = wl1271_ps_elp_wakeup(wl); 4176 if (ret < 0) 4177 goto out; 4178 4179 /* TODO: change mac80211 to pass vif as param */ 4180 wl12xx_for_each_wlvif_sta(wl, wlvif) { 4181 ret = wl12xx_cmd_channel_switch(wl, wlvif, ch_switch); 4182 4183 if (!ret) 4184 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags); 4185 } 4186 4187 wl1271_ps_elp_sleep(wl); 4188 4189 out: 4190 mutex_unlock(&wl->mutex); 4191 } 4192 4193 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw) 4194 { 4195 struct wl1271 *wl = hw->priv; 4196 bool ret = false; 4197 4198 mutex_lock(&wl->mutex); 4199 4200 if (unlikely(wl->state == WL1271_STATE_OFF)) 4201 goto out; 4202 4203 /* packets are considered pending if in the TX queue or the FW */ 4204 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0); 4205 out: 4206 mutex_unlock(&wl->mutex); 4207 4208 return ret; 4209 } 4210 4211 /* can't be const, mac80211 writes to this */ 4212 static struct ieee80211_rate wl1271_rates[] = { 4213 { .bitrate = 10, 4214 .hw_value = CONF_HW_BIT_RATE_1MBPS, 4215 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, }, 4216 { .bitrate = 20, 4217 .hw_value = CONF_HW_BIT_RATE_2MBPS, 4218 .hw_value_short = CONF_HW_BIT_RATE_2MBPS, 4219 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 4220 { .bitrate = 55, 4221 .hw_value = CONF_HW_BIT_RATE_5_5MBPS, 4222 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS, 4223 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 4224 { .bitrate = 110, 4225 .hw_value = CONF_HW_BIT_RATE_11MBPS, 4226 .hw_value_short = CONF_HW_BIT_RATE_11MBPS, 4227 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 4228 { .bitrate = 60, 4229 .hw_value = CONF_HW_BIT_RATE_6MBPS, 4230 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, }, 4231 { .bitrate = 90, 4232 .hw_value = CONF_HW_BIT_RATE_9MBPS, 4233 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, }, 4234 { .bitrate = 120, 4235 .hw_value = CONF_HW_BIT_RATE_12MBPS, 4236 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, }, 4237 { .bitrate = 180, 4238 .hw_value = CONF_HW_BIT_RATE_18MBPS, 4239 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, }, 4240 { .bitrate = 240, 4241 .hw_value = CONF_HW_BIT_RATE_24MBPS, 4242 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, }, 4243 { .bitrate = 360, 4244 .hw_value = CONF_HW_BIT_RATE_36MBPS, 4245 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, }, 4246 { .bitrate = 480, 4247 .hw_value = CONF_HW_BIT_RATE_48MBPS, 4248 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, }, 4249 { .bitrate = 540, 4250 .hw_value = CONF_HW_BIT_RATE_54MBPS, 4251 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, }, 4252 }; 4253 4254 /* can't be const, mac80211 writes to this */ 4255 static struct ieee80211_channel wl1271_channels[] = { 4256 { .hw_value = 1, .center_freq = 2412, .max_power = 25 }, 4257 { .hw_value = 2, .center_freq = 2417, .max_power = 25 }, 4258 { .hw_value = 3, .center_freq = 2422, .max_power = 25 }, 4259 { .hw_value = 4, .center_freq = 2427, .max_power = 25 }, 4260 { .hw_value = 5, .center_freq = 2432, .max_power = 25 }, 4261 { .hw_value = 6, .center_freq = 2437, .max_power = 25 }, 4262 { .hw_value = 7, .center_freq = 2442, .max_power = 25 }, 4263 { .hw_value = 8, .center_freq = 2447, .max_power = 25 }, 4264 { .hw_value = 9, .center_freq = 2452, .max_power = 25 }, 4265 { .hw_value = 10, .center_freq = 2457, .max_power = 25 }, 4266 { .hw_value = 11, .center_freq = 2462, .max_power = 25 }, 4267 { .hw_value = 12, .center_freq = 2467, .max_power = 25 }, 4268 { .hw_value = 13, .center_freq = 2472, .max_power = 25 }, 4269 { .hw_value = 14, .center_freq = 2484, .max_power = 25 }, 4270 }; 4271 4272 /* can't be const, mac80211 writes to this */ 4273 static struct ieee80211_supported_band wl1271_band_2ghz = { 4274 .channels = wl1271_channels, 4275 .n_channels = ARRAY_SIZE(wl1271_channels), 4276 .bitrates = wl1271_rates, 4277 .n_bitrates = ARRAY_SIZE(wl1271_rates), 4278 }; 4279 4280 /* 5 GHz data rates for WL1273 */ 4281 static struct ieee80211_rate wl1271_rates_5ghz[] = { 4282 { .bitrate = 60, 4283 .hw_value = CONF_HW_BIT_RATE_6MBPS, 4284 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, }, 4285 { .bitrate = 90, 4286 .hw_value = CONF_HW_BIT_RATE_9MBPS, 4287 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, }, 4288 { .bitrate = 120, 4289 .hw_value = CONF_HW_BIT_RATE_12MBPS, 4290 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, }, 4291 { .bitrate = 180, 4292 .hw_value = CONF_HW_BIT_RATE_18MBPS, 4293 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, }, 4294 { .bitrate = 240, 4295 .hw_value = CONF_HW_BIT_RATE_24MBPS, 4296 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, }, 4297 { .bitrate = 360, 4298 .hw_value = CONF_HW_BIT_RATE_36MBPS, 4299 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, }, 4300 { .bitrate = 480, 4301 .hw_value = CONF_HW_BIT_RATE_48MBPS, 4302 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, }, 4303 { .bitrate = 540, 4304 .hw_value = CONF_HW_BIT_RATE_54MBPS, 4305 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, }, 4306 }; 4307 4308 /* 5 GHz band channels for WL1273 */ 4309 static struct ieee80211_channel wl1271_channels_5ghz[] = { 4310 { .hw_value = 7, .center_freq = 5035, .max_power = 25 }, 4311 { .hw_value = 8, .center_freq = 5040, .max_power = 25 }, 4312 { .hw_value = 9, .center_freq = 5045, .max_power = 25 }, 4313 { .hw_value = 11, .center_freq = 5055, .max_power = 25 }, 4314 { .hw_value = 12, .center_freq = 5060, .max_power = 25 }, 4315 { .hw_value = 16, .center_freq = 5080, .max_power = 25 }, 4316 { .hw_value = 34, .center_freq = 5170, .max_power = 25 }, 4317 { .hw_value = 36, .center_freq = 5180, .max_power = 25 }, 4318 { .hw_value = 38, .center_freq = 5190, .max_power = 25 }, 4319 { .hw_value = 40, .center_freq = 5200, .max_power = 25 }, 4320 { .hw_value = 42, .center_freq = 5210, .max_power = 25 }, 4321 { .hw_value = 44, .center_freq = 5220, .max_power = 25 }, 4322 { .hw_value = 46, .center_freq = 5230, .max_power = 25 }, 4323 { .hw_value = 48, .center_freq = 5240, .max_power = 25 }, 4324 { .hw_value = 52, .center_freq = 5260, .max_power = 25 }, 4325 { .hw_value = 56, .center_freq = 5280, .max_power = 25 }, 4326 { .hw_value = 60, .center_freq = 5300, .max_power = 25 }, 4327 { .hw_value = 64, .center_freq = 5320, .max_power = 25 }, 4328 { .hw_value = 100, .center_freq = 5500, .max_power = 25 }, 4329 { .hw_value = 104, .center_freq = 5520, .max_power = 25 }, 4330 { .hw_value = 108, .center_freq = 5540, .max_power = 25 }, 4331 { .hw_value = 112, .center_freq = 5560, .max_power = 25 }, 4332 { .hw_value = 116, .center_freq = 5580, .max_power = 25 }, 4333 { .hw_value = 120, .center_freq = 5600, .max_power = 25 }, 4334 { .hw_value = 124, .center_freq = 5620, .max_power = 25 }, 4335 { .hw_value = 128, .center_freq = 5640, .max_power = 25 }, 4336 { .hw_value = 132, .center_freq = 5660, .max_power = 25 }, 4337 { .hw_value = 136, .center_freq = 5680, .max_power = 25 }, 4338 { .hw_value = 140, .center_freq = 5700, .max_power = 25 }, 4339 { .hw_value = 149, .center_freq = 5745, .max_power = 25 }, 4340 { .hw_value = 153, .center_freq = 5765, .max_power = 25 }, 4341 { .hw_value = 157, .center_freq = 5785, .max_power = 25 }, 4342 { .hw_value = 161, .center_freq = 5805, .max_power = 25 }, 4343 { .hw_value = 165, .center_freq = 5825, .max_power = 25 }, 4344 }; 4345 4346 static struct ieee80211_supported_band wl1271_band_5ghz = { 4347 .channels = wl1271_channels_5ghz, 4348 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz), 4349 .bitrates = wl1271_rates_5ghz, 4350 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz), 4351 }; 4352 4353 static const struct ieee80211_ops wl1271_ops = { 4354 .start = wl1271_op_start, 4355 .stop = wl1271_op_stop, 4356 .add_interface = wl1271_op_add_interface, 4357 .remove_interface = wl1271_op_remove_interface, 4358 .change_interface = wl12xx_op_change_interface, 4359 #ifdef CONFIG_PM 4360 .suspend = wl1271_op_suspend, 4361 .resume = wl1271_op_resume, 4362 #endif 4363 .config = wl1271_op_config, 4364 .prepare_multicast = wl1271_op_prepare_multicast, 4365 .configure_filter = wl1271_op_configure_filter, 4366 .tx = wl1271_op_tx, 4367 .set_key = wl1271_op_set_key, 4368 .hw_scan = wl1271_op_hw_scan, 4369 .cancel_hw_scan = wl1271_op_cancel_hw_scan, 4370 .sched_scan_start = wl1271_op_sched_scan_start, 4371 .sched_scan_stop = wl1271_op_sched_scan_stop, 4372 .bss_info_changed = wl1271_op_bss_info_changed, 4373 .set_frag_threshold = wl1271_op_set_frag_threshold, 4374 .set_rts_threshold = wl1271_op_set_rts_threshold, 4375 .conf_tx = wl1271_op_conf_tx, 4376 .get_tsf = wl1271_op_get_tsf, 4377 .get_survey = wl1271_op_get_survey, 4378 .sta_state = wl12xx_op_sta_state, 4379 .ampdu_action = wl1271_op_ampdu_action, 4380 .tx_frames_pending = wl1271_tx_frames_pending, 4381 .set_bitrate_mask = wl12xx_set_bitrate_mask, 4382 .channel_switch = wl12xx_op_channel_switch, 4383 CFG80211_TESTMODE_CMD(wl1271_tm_cmd) 4384 }; 4385 4386 4387 u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band) 4388 { 4389 u8 idx; 4390 4391 BUG_ON(band >= 2); 4392 4393 if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) { 4394 wl1271_error("Illegal RX rate from HW: %d", rate); 4395 return 0; 4396 } 4397 4398 idx = wl->band_rate_to_idx[band][rate]; 4399 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) { 4400 wl1271_error("Unsupported RX rate from HW: %d", rate); 4401 return 0; 4402 } 4403 4404 return idx; 4405 } 4406 4407 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev, 4408 struct device_attribute *attr, 4409 char *buf) 4410 { 4411 struct wl1271 *wl = dev_get_drvdata(dev); 4412 ssize_t len; 4413 4414 len = PAGE_SIZE; 4415 4416 mutex_lock(&wl->mutex); 4417 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n", 4418 wl->sg_enabled); 4419 mutex_unlock(&wl->mutex); 4420 4421 return len; 4422 4423 } 4424 4425 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev, 4426 struct device_attribute *attr, 4427 const char *buf, size_t count) 4428 { 4429 struct wl1271 *wl = dev_get_drvdata(dev); 4430 unsigned long res; 4431 int ret; 4432 4433 ret = kstrtoul(buf, 10, &res); 4434 if (ret < 0) { 4435 wl1271_warning("incorrect value written to bt_coex_mode"); 4436 return count; 4437 } 4438 4439 mutex_lock(&wl->mutex); 4440 4441 res = !!res; 4442 4443 if (res == wl->sg_enabled) 4444 goto out; 4445 4446 wl->sg_enabled = res; 4447 4448 if (wl->state == WL1271_STATE_OFF) 4449 goto out; 4450 4451 ret = wl1271_ps_elp_wakeup(wl); 4452 if (ret < 0) 4453 goto out; 4454 4455 wl1271_acx_sg_enable(wl, wl->sg_enabled); 4456 wl1271_ps_elp_sleep(wl); 4457 4458 out: 4459 mutex_unlock(&wl->mutex); 4460 return count; 4461 } 4462 4463 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR, 4464 wl1271_sysfs_show_bt_coex_state, 4465 wl1271_sysfs_store_bt_coex_state); 4466 4467 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev, 4468 struct device_attribute *attr, 4469 char *buf) 4470 { 4471 struct wl1271 *wl = dev_get_drvdata(dev); 4472 ssize_t len; 4473 4474 len = PAGE_SIZE; 4475 4476 mutex_lock(&wl->mutex); 4477 if (wl->hw_pg_ver >= 0) 4478 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver); 4479 else 4480 len = snprintf(buf, len, "n/a\n"); 4481 mutex_unlock(&wl->mutex); 4482 4483 return len; 4484 } 4485 4486 static DEVICE_ATTR(hw_pg_ver, S_IRUGO, 4487 wl1271_sysfs_show_hw_pg_ver, NULL); 4488 4489 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj, 4490 struct bin_attribute *bin_attr, 4491 char *buffer, loff_t pos, size_t count) 4492 { 4493 struct device *dev = container_of(kobj, struct device, kobj); 4494 struct wl1271 *wl = dev_get_drvdata(dev); 4495 ssize_t len; 4496 int ret; 4497 4498 ret = mutex_lock_interruptible(&wl->mutex); 4499 if (ret < 0) 4500 return -ERESTARTSYS; 4501 4502 /* Let only one thread read the log at a time, blocking others */ 4503 while (wl->fwlog_size == 0) { 4504 DEFINE_WAIT(wait); 4505 4506 prepare_to_wait_exclusive(&wl->fwlog_waitq, 4507 &wait, 4508 TASK_INTERRUPTIBLE); 4509 4510 if (wl->fwlog_size != 0) { 4511 finish_wait(&wl->fwlog_waitq, &wait); 4512 break; 4513 } 4514 4515 mutex_unlock(&wl->mutex); 4516 4517 schedule(); 4518 finish_wait(&wl->fwlog_waitq, &wait); 4519 4520 if (signal_pending(current)) 4521 return -ERESTARTSYS; 4522 4523 ret = mutex_lock_interruptible(&wl->mutex); 4524 if (ret < 0) 4525 return -ERESTARTSYS; 4526 } 4527 4528 /* Check if the fwlog is still valid */ 4529 if (wl->fwlog_size < 0) { 4530 mutex_unlock(&wl->mutex); 4531 return 0; 4532 } 4533 4534 /* Seeking is not supported - old logs are not kept. Disregard pos. */ 4535 len = min(count, (size_t)wl->fwlog_size); 4536 wl->fwlog_size -= len; 4537 memcpy(buffer, wl->fwlog, len); 4538 4539 /* Make room for new messages */ 4540 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size); 4541 4542 mutex_unlock(&wl->mutex); 4543 4544 return len; 4545 } 4546 4547 static struct bin_attribute fwlog_attr = { 4548 .attr = {.name = "fwlog", .mode = S_IRUSR}, 4549 .read = wl1271_sysfs_read_fwlog, 4550 }; 4551 4552 static void wl12xx_derive_mac_addresses(struct wl1271 *wl, 4553 u32 oui, u32 nic, int n) 4554 { 4555 int i; 4556 4557 wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x, n %d", 4558 oui, nic, n); 4559 4560 if (nic + n - 1 > 0xffffff) 4561 wl1271_warning("NIC part of the MAC address wraps around!"); 4562 4563 for (i = 0; i < n; i++) { 4564 wl->addresses[i].addr[0] = (u8)(oui >> 16); 4565 wl->addresses[i].addr[1] = (u8)(oui >> 8); 4566 wl->addresses[i].addr[2] = (u8) oui; 4567 wl->addresses[i].addr[3] = (u8)(nic >> 16); 4568 wl->addresses[i].addr[4] = (u8)(nic >> 8); 4569 wl->addresses[i].addr[5] = (u8) nic; 4570 nic++; 4571 } 4572 4573 wl->hw->wiphy->n_addresses = n; 4574 wl->hw->wiphy->addresses = wl->addresses; 4575 } 4576 4577 static int wl12xx_get_hw_info(struct wl1271 *wl) 4578 { 4579 int ret; 4580 4581 ret = wl12xx_set_power_on(wl); 4582 if (ret < 0) 4583 goto out; 4584 4585 wl->chip.id = wlcore_read_reg(wl, REG_CHIP_ID_B); 4586 4587 wl->fuse_oui_addr = 0; 4588 wl->fuse_nic_addr = 0; 4589 4590 wl->hw_pg_ver = wl->ops->get_pg_ver(wl); 4591 4592 if (wl->ops->get_mac) 4593 wl->ops->get_mac(wl); 4594 4595 wl1271_power_off(wl); 4596 out: 4597 return ret; 4598 } 4599 4600 static int wl1271_register_hw(struct wl1271 *wl) 4601 { 4602 int ret; 4603 u32 oui_addr = 0, nic_addr = 0; 4604 4605 if (wl->mac80211_registered) 4606 return 0; 4607 4608 ret = wl12xx_get_hw_info(wl); 4609 if (ret < 0) { 4610 wl1271_error("couldn't get hw info"); 4611 goto out; 4612 } 4613 4614 ret = wl1271_fetch_nvs(wl); 4615 if (ret == 0) { 4616 /* NOTE: The wl->nvs->nvs element must be first, in 4617 * order to simplify the casting, we assume it is at 4618 * the beginning of the wl->nvs structure. 4619 */ 4620 u8 *nvs_ptr = (u8 *)wl->nvs; 4621 4622 oui_addr = 4623 (nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6]; 4624 nic_addr = 4625 (nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3]; 4626 } 4627 4628 /* if the MAC address is zeroed in the NVS derive from fuse */ 4629 if (oui_addr == 0 && nic_addr == 0) { 4630 oui_addr = wl->fuse_oui_addr; 4631 /* fuse has the BD_ADDR, the WLAN addresses are the next two */ 4632 nic_addr = wl->fuse_nic_addr + 1; 4633 } 4634 4635 wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr, 2); 4636 4637 ret = ieee80211_register_hw(wl->hw); 4638 if (ret < 0) { 4639 wl1271_error("unable to register mac80211 hw: %d", ret); 4640 goto out; 4641 } 4642 4643 wl->mac80211_registered = true; 4644 4645 wl1271_debugfs_init(wl); 4646 4647 wl1271_notice("loaded"); 4648 4649 out: 4650 return ret; 4651 } 4652 4653 static void wl1271_unregister_hw(struct wl1271 *wl) 4654 { 4655 if (wl->plt) 4656 wl1271_plt_stop(wl); 4657 4658 ieee80211_unregister_hw(wl->hw); 4659 wl->mac80211_registered = false; 4660 4661 } 4662 4663 static int wl1271_init_ieee80211(struct wl1271 *wl) 4664 { 4665 static const u32 cipher_suites[] = { 4666 WLAN_CIPHER_SUITE_WEP40, 4667 WLAN_CIPHER_SUITE_WEP104, 4668 WLAN_CIPHER_SUITE_TKIP, 4669 WLAN_CIPHER_SUITE_CCMP, 4670 WL1271_CIPHER_SUITE_GEM, 4671 }; 4672 4673 /* The tx descriptor buffer and the TKIP space. */ 4674 wl->hw->extra_tx_headroom = WL1271_EXTRA_SPACE_TKIP + 4675 sizeof(struct wl1271_tx_hw_descr); 4676 4677 /* unit us */ 4678 /* FIXME: find a proper value */ 4679 wl->hw->channel_change_time = 10000; 4680 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval; 4681 4682 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM | 4683 IEEE80211_HW_SUPPORTS_PS | 4684 IEEE80211_HW_SUPPORTS_DYNAMIC_PS | 4685 IEEE80211_HW_SUPPORTS_UAPSD | 4686 IEEE80211_HW_HAS_RATE_CONTROL | 4687 IEEE80211_HW_CONNECTION_MONITOR | 4688 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 4689 IEEE80211_HW_SPECTRUM_MGMT | 4690 IEEE80211_HW_AP_LINK_PS | 4691 IEEE80211_HW_AMPDU_AGGREGATION | 4692 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW | 4693 IEEE80211_HW_SCAN_WHILE_IDLE; 4694 4695 wl->hw->wiphy->cipher_suites = cipher_suites; 4696 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites); 4697 4698 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 4699 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) | 4700 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO); 4701 wl->hw->wiphy->max_scan_ssids = 1; 4702 wl->hw->wiphy->max_sched_scan_ssids = 16; 4703 wl->hw->wiphy->max_match_sets = 16; 4704 /* 4705 * Maximum length of elements in scanning probe request templates 4706 * should be the maximum length possible for a template, without 4707 * the IEEE80211 header of the template 4708 */ 4709 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE - 4710 sizeof(struct ieee80211_header); 4711 4712 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE - 4713 sizeof(struct ieee80211_header); 4714 4715 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD | 4716 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 4717 4718 /* make sure all our channels fit in the scanned_ch bitmask */ 4719 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) + 4720 ARRAY_SIZE(wl1271_channels_5ghz) > 4721 WL1271_MAX_CHANNELS); 4722 /* 4723 * We keep local copies of the band structs because we need to 4724 * modify them on a per-device basis. 4725 */ 4726 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz, 4727 sizeof(wl1271_band_2ghz)); 4728 memcpy(&wl->bands[IEEE80211_BAND_2GHZ].ht_cap, &wl->ht_cap, 4729 sizeof(wl->ht_cap)); 4730 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz, 4731 sizeof(wl1271_band_5ghz)); 4732 memcpy(&wl->bands[IEEE80211_BAND_5GHZ].ht_cap, &wl->ht_cap, 4733 sizeof(wl->ht_cap)); 4734 4735 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 4736 &wl->bands[IEEE80211_BAND_2GHZ]; 4737 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 4738 &wl->bands[IEEE80211_BAND_5GHZ]; 4739 4740 wl->hw->queues = 4; 4741 wl->hw->max_rates = 1; 4742 4743 wl->hw->wiphy->reg_notifier = wl1271_reg_notify; 4744 4745 /* the FW answers probe-requests in AP-mode */ 4746 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD; 4747 wl->hw->wiphy->probe_resp_offload = 4748 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS | 4749 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 | 4750 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P; 4751 4752 SET_IEEE80211_DEV(wl->hw, wl->dev); 4753 4754 wl->hw->sta_data_size = sizeof(struct wl1271_station); 4755 wl->hw->vif_data_size = sizeof(struct wl12xx_vif); 4756 4757 wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size; 4758 4759 return 0; 4760 } 4761 4762 #define WL1271_DEFAULT_CHANNEL 0 4763 4764 struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size) 4765 { 4766 struct ieee80211_hw *hw; 4767 struct wl1271 *wl; 4768 int i, j, ret; 4769 unsigned int order; 4770 4771 BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS); 4772 4773 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops); 4774 if (!hw) { 4775 wl1271_error("could not alloc ieee80211_hw"); 4776 ret = -ENOMEM; 4777 goto err_hw_alloc; 4778 } 4779 4780 wl = hw->priv; 4781 memset(wl, 0, sizeof(*wl)); 4782 4783 wl->priv = kzalloc(priv_size, GFP_KERNEL); 4784 if (!wl->priv) { 4785 wl1271_error("could not alloc wl priv"); 4786 ret = -ENOMEM; 4787 goto err_priv_alloc; 4788 } 4789 4790 INIT_LIST_HEAD(&wl->wlvif_list); 4791 4792 wl->hw = hw; 4793 4794 for (i = 0; i < NUM_TX_QUEUES; i++) 4795 for (j = 0; j < WL12XX_MAX_LINKS; j++) 4796 skb_queue_head_init(&wl->links[j].tx_queue[i]); 4797 4798 skb_queue_head_init(&wl->deferred_rx_queue); 4799 skb_queue_head_init(&wl->deferred_tx_queue); 4800 4801 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work); 4802 INIT_WORK(&wl->netstack_work, wl1271_netstack_work); 4803 INIT_WORK(&wl->tx_work, wl1271_tx_work); 4804 INIT_WORK(&wl->recovery_work, wl1271_recovery_work); 4805 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work); 4806 INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work); 4807 4808 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq"); 4809 if (!wl->freezable_wq) { 4810 ret = -ENOMEM; 4811 goto err_hw; 4812 } 4813 4814 wl->channel = WL1271_DEFAULT_CHANNEL; 4815 wl->rx_counter = 0; 4816 wl->power_level = WL1271_DEFAULT_POWER_LEVEL; 4817 wl->band = IEEE80211_BAND_2GHZ; 4818 wl->flags = 0; 4819 wl->sg_enabled = true; 4820 wl->hw_pg_ver = -1; 4821 wl->ap_ps_map = 0; 4822 wl->ap_fw_ps_map = 0; 4823 wl->quirks = 0; 4824 wl->platform_quirks = 0; 4825 wl->sched_scanning = false; 4826 wl->system_hlid = WL12XX_SYSTEM_HLID; 4827 wl->active_sta_count = 0; 4828 wl->fwlog_size = 0; 4829 init_waitqueue_head(&wl->fwlog_waitq); 4830 4831 /* The system link is always allocated */ 4832 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map); 4833 4834 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map)); 4835 for (i = 0; i < wl->num_tx_desc; i++) 4836 wl->tx_frames[i] = NULL; 4837 4838 spin_lock_init(&wl->wl_lock); 4839 4840 wl->state = WL1271_STATE_OFF; 4841 wl->fw_type = WL12XX_FW_TYPE_NONE; 4842 mutex_init(&wl->mutex); 4843 4844 order = get_order(WL1271_AGGR_BUFFER_SIZE); 4845 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order); 4846 if (!wl->aggr_buf) { 4847 ret = -ENOMEM; 4848 goto err_wq; 4849 } 4850 4851 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl); 4852 if (!wl->dummy_packet) { 4853 ret = -ENOMEM; 4854 goto err_aggr; 4855 } 4856 4857 /* Allocate one page for the FW log */ 4858 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL); 4859 if (!wl->fwlog) { 4860 ret = -ENOMEM; 4861 goto err_dummy_packet; 4862 } 4863 4864 wl->mbox = kmalloc(sizeof(*wl->mbox), GFP_DMA); 4865 if (!wl->mbox) { 4866 ret = -ENOMEM; 4867 goto err_fwlog; 4868 } 4869 4870 return hw; 4871 4872 err_fwlog: 4873 free_page((unsigned long)wl->fwlog); 4874 4875 err_dummy_packet: 4876 dev_kfree_skb(wl->dummy_packet); 4877 4878 err_aggr: 4879 free_pages((unsigned long)wl->aggr_buf, order); 4880 4881 err_wq: 4882 destroy_workqueue(wl->freezable_wq); 4883 4884 err_hw: 4885 wl1271_debugfs_exit(wl); 4886 kfree(wl->priv); 4887 4888 err_priv_alloc: 4889 ieee80211_free_hw(hw); 4890 4891 err_hw_alloc: 4892 4893 return ERR_PTR(ret); 4894 } 4895 EXPORT_SYMBOL_GPL(wlcore_alloc_hw); 4896 4897 int wlcore_free_hw(struct wl1271 *wl) 4898 { 4899 /* Unblock any fwlog readers */ 4900 mutex_lock(&wl->mutex); 4901 wl->fwlog_size = -1; 4902 wake_up_interruptible_all(&wl->fwlog_waitq); 4903 mutex_unlock(&wl->mutex); 4904 4905 device_remove_bin_file(wl->dev, &fwlog_attr); 4906 4907 device_remove_file(wl->dev, &dev_attr_hw_pg_ver); 4908 4909 device_remove_file(wl->dev, &dev_attr_bt_coex_state); 4910 free_page((unsigned long)wl->fwlog); 4911 dev_kfree_skb(wl->dummy_packet); 4912 free_pages((unsigned long)wl->aggr_buf, 4913 get_order(WL1271_AGGR_BUFFER_SIZE)); 4914 4915 wl1271_debugfs_exit(wl); 4916 4917 vfree(wl->fw); 4918 wl->fw = NULL; 4919 wl->fw_type = WL12XX_FW_TYPE_NONE; 4920 kfree(wl->nvs); 4921 wl->nvs = NULL; 4922 4923 kfree(wl->fw_status); 4924 kfree(wl->tx_res_if); 4925 destroy_workqueue(wl->freezable_wq); 4926 4927 kfree(wl->priv); 4928 ieee80211_free_hw(wl->hw); 4929 4930 return 0; 4931 } 4932 EXPORT_SYMBOL_GPL(wlcore_free_hw); 4933 4934 static irqreturn_t wl12xx_hardirq(int irq, void *cookie) 4935 { 4936 struct wl1271 *wl = cookie; 4937 unsigned long flags; 4938 4939 wl1271_debug(DEBUG_IRQ, "IRQ"); 4940 4941 /* complete the ELP completion */ 4942 spin_lock_irqsave(&wl->wl_lock, flags); 4943 set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags); 4944 if (wl->elp_compl) { 4945 complete(wl->elp_compl); 4946 wl->elp_compl = NULL; 4947 } 4948 4949 if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) { 4950 /* don't enqueue a work right now. mark it as pending */ 4951 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags); 4952 wl1271_debug(DEBUG_IRQ, "should not enqueue work"); 4953 disable_irq_nosync(wl->irq); 4954 pm_wakeup_event(wl->dev, 0); 4955 spin_unlock_irqrestore(&wl->wl_lock, flags); 4956 return IRQ_HANDLED; 4957 } 4958 spin_unlock_irqrestore(&wl->wl_lock, flags); 4959 4960 return IRQ_WAKE_THREAD; 4961 } 4962 4963 int __devinit wlcore_probe(struct wl1271 *wl, struct platform_device *pdev) 4964 { 4965 struct wl12xx_platform_data *pdata = pdev->dev.platform_data; 4966 unsigned long irqflags; 4967 int ret; 4968 4969 if (!wl->ops || !wl->ptable) { 4970 ret = -EINVAL; 4971 goto out_free_hw; 4972 } 4973 4974 BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS); 4975 4976 /* adjust some runtime configuration parameters */ 4977 wlcore_adjust_conf(wl); 4978 4979 wl->irq = platform_get_irq(pdev, 0); 4980 wl->ref_clock = pdata->board_ref_clock; 4981 wl->tcxo_clock = pdata->board_tcxo_clock; 4982 wl->platform_quirks = pdata->platform_quirks; 4983 wl->set_power = pdata->set_power; 4984 wl->dev = &pdev->dev; 4985 wl->if_ops = pdata->ops; 4986 4987 platform_set_drvdata(pdev, wl); 4988 4989 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ) 4990 irqflags = IRQF_TRIGGER_RISING; 4991 else 4992 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT; 4993 4994 ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq, 4995 irqflags, 4996 pdev->name, wl); 4997 if (ret < 0) { 4998 wl1271_error("request_irq() failed: %d", ret); 4999 goto out_free_hw; 5000 } 5001 5002 ret = enable_irq_wake(wl->irq); 5003 if (!ret) { 5004 wl->irq_wake_enabled = true; 5005 device_init_wakeup(wl->dev, 1); 5006 if (pdata->pwr_in_suspend) 5007 wl->hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY; 5008 5009 } 5010 disable_irq(wl->irq); 5011 5012 ret = wl1271_init_ieee80211(wl); 5013 if (ret) 5014 goto out_irq; 5015 5016 ret = wl1271_register_hw(wl); 5017 if (ret) 5018 goto out_irq; 5019 5020 /* Create sysfs file to control bt coex state */ 5021 ret = device_create_file(wl->dev, &dev_attr_bt_coex_state); 5022 if (ret < 0) { 5023 wl1271_error("failed to create sysfs file bt_coex_state"); 5024 goto out_irq; 5025 } 5026 5027 /* Create sysfs file to get HW PG version */ 5028 ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver); 5029 if (ret < 0) { 5030 wl1271_error("failed to create sysfs file hw_pg_ver"); 5031 goto out_bt_coex_state; 5032 } 5033 5034 /* Create sysfs file for the FW log */ 5035 ret = device_create_bin_file(wl->dev, &fwlog_attr); 5036 if (ret < 0) { 5037 wl1271_error("failed to create sysfs file fwlog"); 5038 goto out_hw_pg_ver; 5039 } 5040 5041 goto out; 5042 5043 out_hw_pg_ver: 5044 device_remove_file(wl->dev, &dev_attr_hw_pg_ver); 5045 5046 out_bt_coex_state: 5047 device_remove_file(wl->dev, &dev_attr_bt_coex_state); 5048 5049 out_irq: 5050 free_irq(wl->irq, wl); 5051 5052 out_free_hw: 5053 wlcore_free_hw(wl); 5054 5055 out: 5056 return ret; 5057 } 5058 EXPORT_SYMBOL_GPL(wlcore_probe); 5059 5060 int __devexit wlcore_remove(struct platform_device *pdev) 5061 { 5062 struct wl1271 *wl = platform_get_drvdata(pdev); 5063 5064 if (wl->irq_wake_enabled) { 5065 device_init_wakeup(wl->dev, 0); 5066 disable_irq_wake(wl->irq); 5067 } 5068 wl1271_unregister_hw(wl); 5069 free_irq(wl->irq, wl); 5070 wlcore_free_hw(wl); 5071 5072 return 0; 5073 } 5074 EXPORT_SYMBOL_GPL(wlcore_remove); 5075 5076 u32 wl12xx_debug_level = DEBUG_NONE; 5077 EXPORT_SYMBOL_GPL(wl12xx_debug_level); 5078 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR); 5079 MODULE_PARM_DESC(debug_level, "wl12xx debugging level"); 5080 5081 module_param_named(fwlog, fwlog_param, charp, 0); 5082 MODULE_PARM_DESC(fwlog, 5083 "FW logger options: continuous, ondemand, dbgpins or disable"); 5084 5085 module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR); 5086 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery"); 5087 5088 module_param(no_recovery, bool, S_IRUSR | S_IWUSR); 5089 MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck."); 5090 5091 MODULE_LICENSE("GPL"); 5092 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>"); 5093 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>"); 5094