1 /* 2 * This file is part of wl1251 3 * 4 * Copyright (C) 2008-2009 Nokia Corporation 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * version 2 as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 18 * 02110-1301 USA 19 * 20 */ 21 22 #include <linux/module.h> 23 #include <linux/interrupt.h> 24 #include <linux/firmware.h> 25 #include <linux/delay.h> 26 #include <linux/irq.h> 27 #include <linux/crc32.h> 28 #include <linux/etherdevice.h> 29 #include <linux/vmalloc.h> 30 #include <linux/slab.h> 31 32 #include "wl1251.h" 33 #include "wl12xx_80211.h" 34 #include "reg.h" 35 #include "io.h" 36 #include "cmd.h" 37 #include "event.h" 38 #include "tx.h" 39 #include "rx.h" 40 #include "ps.h" 41 #include "init.h" 42 #include "debugfs.h" 43 #include "boot.h" 44 45 void wl1251_enable_interrupts(struct wl1251 *wl) 46 { 47 wl->if_ops->enable_irq(wl); 48 } 49 50 void wl1251_disable_interrupts(struct wl1251 *wl) 51 { 52 wl->if_ops->disable_irq(wl); 53 } 54 55 static int wl1251_power_off(struct wl1251 *wl) 56 { 57 return wl->if_ops->power(wl, false); 58 } 59 60 static int wl1251_power_on(struct wl1251 *wl) 61 { 62 return wl->if_ops->power(wl, true); 63 } 64 65 static int wl1251_fetch_firmware(struct wl1251 *wl) 66 { 67 const struct firmware *fw; 68 struct device *dev = wiphy_dev(wl->hw->wiphy); 69 int ret; 70 71 ret = request_firmware(&fw, WL1251_FW_NAME, dev); 72 73 if (ret < 0) { 74 wl1251_error("could not get firmware: %d", ret); 75 return ret; 76 } 77 78 if (fw->size % 4) { 79 wl1251_error("firmware size is not multiple of 32 bits: %zu", 80 fw->size); 81 ret = -EILSEQ; 82 goto out; 83 } 84 85 wl->fw_len = fw->size; 86 wl->fw = vmalloc(wl->fw_len); 87 88 if (!wl->fw) { 89 wl1251_error("could not allocate memory for the firmware"); 90 ret = -ENOMEM; 91 goto out; 92 } 93 94 memcpy(wl->fw, fw->data, wl->fw_len); 95 96 ret = 0; 97 98 out: 99 release_firmware(fw); 100 101 return ret; 102 } 103 104 static int wl1251_fetch_nvs(struct wl1251 *wl) 105 { 106 const struct firmware *fw; 107 struct device *dev = wiphy_dev(wl->hw->wiphy); 108 int ret; 109 110 ret = request_firmware(&fw, WL1251_NVS_NAME, dev); 111 112 if (ret < 0) { 113 wl1251_error("could not get nvs file: %d", ret); 114 return ret; 115 } 116 117 if (fw->size % 4) { 118 wl1251_error("nvs size is not multiple of 32 bits: %zu", 119 fw->size); 120 ret = -EILSEQ; 121 goto out; 122 } 123 124 wl->nvs_len = fw->size; 125 wl->nvs = kmemdup(fw->data, wl->nvs_len, GFP_KERNEL); 126 127 if (!wl->nvs) { 128 wl1251_error("could not allocate memory for the nvs file"); 129 ret = -ENOMEM; 130 goto out; 131 } 132 133 ret = 0; 134 135 out: 136 release_firmware(fw); 137 138 return ret; 139 } 140 141 static void wl1251_fw_wakeup(struct wl1251 *wl) 142 { 143 u32 elp_reg; 144 145 elp_reg = ELPCTRL_WAKE_UP; 146 wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg); 147 elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR); 148 149 if (!(elp_reg & ELPCTRL_WLAN_READY)) 150 wl1251_warning("WLAN not ready"); 151 } 152 153 static int wl1251_chip_wakeup(struct wl1251 *wl) 154 { 155 int ret; 156 157 ret = wl1251_power_on(wl); 158 if (ret < 0) 159 return ret; 160 161 msleep(WL1251_POWER_ON_SLEEP); 162 wl->if_ops->reset(wl); 163 164 /* We don't need a real memory partition here, because we only want 165 * to use the registers at this point. */ 166 wl1251_set_partition(wl, 167 0x00000000, 168 0x00000000, 169 REGISTERS_BASE, 170 REGISTERS_DOWN_SIZE); 171 172 /* ELP module wake up */ 173 wl1251_fw_wakeup(wl); 174 175 /* whal_FwCtrl_BootSm() */ 176 177 /* 0. read chip id from CHIP_ID */ 178 wl->chip_id = wl1251_reg_read32(wl, CHIP_ID_B); 179 180 /* 1. check if chip id is valid */ 181 182 switch (wl->chip_id) { 183 case CHIP_ID_1251_PG12: 184 wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG12)", 185 wl->chip_id); 186 break; 187 case CHIP_ID_1251_PG11: 188 wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG11)", 189 wl->chip_id); 190 break; 191 case CHIP_ID_1251_PG10: 192 default: 193 wl1251_error("unsupported chip id: 0x%x", wl->chip_id); 194 ret = -ENODEV; 195 goto out; 196 } 197 198 if (wl->fw == NULL) { 199 ret = wl1251_fetch_firmware(wl); 200 if (ret < 0) 201 goto out; 202 } 203 204 if (wl->nvs == NULL && !wl->use_eeprom) { 205 /* No NVS from netlink, try to get it from the filesystem */ 206 ret = wl1251_fetch_nvs(wl); 207 if (ret < 0) 208 goto out; 209 } 210 211 out: 212 return ret; 213 } 214 215 #define WL1251_IRQ_LOOP_COUNT 10 216 static void wl1251_irq_work(struct work_struct *work) 217 { 218 u32 intr, ctr = WL1251_IRQ_LOOP_COUNT; 219 struct wl1251 *wl = 220 container_of(work, struct wl1251, irq_work); 221 int ret; 222 223 mutex_lock(&wl->mutex); 224 225 wl1251_debug(DEBUG_IRQ, "IRQ work"); 226 227 if (wl->state == WL1251_STATE_OFF) 228 goto out; 229 230 ret = wl1251_ps_elp_wakeup(wl); 231 if (ret < 0) 232 goto out; 233 234 wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL); 235 236 intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); 237 wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr); 238 239 do { 240 if (wl->data_path) { 241 wl->rx_counter = wl1251_mem_read32( 242 wl, wl->data_path->rx_control_addr); 243 244 /* We handle a frmware bug here */ 245 switch ((wl->rx_counter - wl->rx_handled) & 0xf) { 246 case 0: 247 wl1251_debug(DEBUG_IRQ, 248 "RX: FW and host in sync"); 249 intr &= ~WL1251_ACX_INTR_RX0_DATA; 250 intr &= ~WL1251_ACX_INTR_RX1_DATA; 251 break; 252 case 1: 253 wl1251_debug(DEBUG_IRQ, "RX: FW +1"); 254 intr |= WL1251_ACX_INTR_RX0_DATA; 255 intr &= ~WL1251_ACX_INTR_RX1_DATA; 256 break; 257 case 2: 258 wl1251_debug(DEBUG_IRQ, "RX: FW +2"); 259 intr |= WL1251_ACX_INTR_RX0_DATA; 260 intr |= WL1251_ACX_INTR_RX1_DATA; 261 break; 262 default: 263 wl1251_warning( 264 "RX: FW and host out of sync: %d", 265 wl->rx_counter - wl->rx_handled); 266 break; 267 } 268 269 wl->rx_handled = wl->rx_counter; 270 271 wl1251_debug(DEBUG_IRQ, "RX counter: %d", 272 wl->rx_counter); 273 } 274 275 intr &= wl->intr_mask; 276 277 if (intr == 0) { 278 wl1251_debug(DEBUG_IRQ, "INTR is 0"); 279 goto out_sleep; 280 } 281 282 if (intr & WL1251_ACX_INTR_RX0_DATA) { 283 wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA"); 284 wl1251_rx(wl); 285 } 286 287 if (intr & WL1251_ACX_INTR_RX1_DATA) { 288 wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA"); 289 wl1251_rx(wl); 290 } 291 292 if (intr & WL1251_ACX_INTR_TX_RESULT) { 293 wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT"); 294 wl1251_tx_complete(wl); 295 } 296 297 if (intr & WL1251_ACX_INTR_EVENT_A) { 298 wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_A"); 299 wl1251_event_handle(wl, 0); 300 } 301 302 if (intr & WL1251_ACX_INTR_EVENT_B) { 303 wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_B"); 304 wl1251_event_handle(wl, 1); 305 } 306 307 if (intr & WL1251_ACX_INTR_INIT_COMPLETE) 308 wl1251_debug(DEBUG_IRQ, 309 "WL1251_ACX_INTR_INIT_COMPLETE"); 310 311 if (--ctr == 0) 312 break; 313 314 intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); 315 } while (intr); 316 317 out_sleep: 318 wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask)); 319 wl1251_ps_elp_sleep(wl); 320 321 out: 322 mutex_unlock(&wl->mutex); 323 } 324 325 static int wl1251_join(struct wl1251 *wl, u8 bss_type, u8 channel, 326 u16 beacon_interval, u8 dtim_period) 327 { 328 int ret; 329 330 ret = wl1251_acx_frame_rates(wl, DEFAULT_HW_GEN_TX_RATE, 331 DEFAULT_HW_GEN_MODULATION_TYPE, 332 wl->tx_mgmt_frm_rate, 333 wl->tx_mgmt_frm_mod); 334 if (ret < 0) 335 goto out; 336 337 /* 338 * Join command applies filters, and if we are not associated, 339 * BSSID filter must be disabled for association to work. 340 */ 341 if (is_zero_ether_addr(wl->bssid)) 342 wl->rx_config &= ~CFG_BSSID_FILTER_EN; 343 344 ret = wl1251_cmd_join(wl, bss_type, channel, beacon_interval, 345 dtim_period); 346 if (ret < 0) 347 goto out; 348 349 ret = wl1251_event_wait(wl, JOIN_EVENT_COMPLETE_ID, 100); 350 if (ret < 0) 351 wl1251_warning("join timeout"); 352 353 out: 354 return ret; 355 } 356 357 static void wl1251_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb) 358 { 359 struct wl1251 *wl = hw->priv; 360 unsigned long flags; 361 362 skb_queue_tail(&wl->tx_queue, skb); 363 364 /* 365 * The chip specific setup must run before the first TX packet - 366 * before that, the tx_work will not be initialized! 367 */ 368 369 ieee80211_queue_work(wl->hw, &wl->tx_work); 370 371 /* 372 * The workqueue is slow to process the tx_queue and we need stop 373 * the queue here, otherwise the queue will get too long. 374 */ 375 if (skb_queue_len(&wl->tx_queue) >= WL1251_TX_QUEUE_HIGH_WATERMARK) { 376 wl1251_debug(DEBUG_TX, "op_tx: tx_queue full, stop queues"); 377 378 spin_lock_irqsave(&wl->wl_lock, flags); 379 ieee80211_stop_queues(wl->hw); 380 wl->tx_queue_stopped = true; 381 spin_unlock_irqrestore(&wl->wl_lock, flags); 382 } 383 } 384 385 static int wl1251_op_start(struct ieee80211_hw *hw) 386 { 387 struct wl1251 *wl = hw->priv; 388 struct wiphy *wiphy = hw->wiphy; 389 int ret = 0; 390 391 wl1251_debug(DEBUG_MAC80211, "mac80211 start"); 392 393 mutex_lock(&wl->mutex); 394 395 if (wl->state != WL1251_STATE_OFF) { 396 wl1251_error("cannot start because not in off state: %d", 397 wl->state); 398 ret = -EBUSY; 399 goto out; 400 } 401 402 ret = wl1251_chip_wakeup(wl); 403 if (ret < 0) 404 goto out; 405 406 ret = wl1251_boot(wl); 407 if (ret < 0) 408 goto out; 409 410 ret = wl1251_hw_init(wl); 411 if (ret < 0) 412 goto out; 413 414 ret = wl1251_acx_station_id(wl); 415 if (ret < 0) 416 goto out; 417 418 wl->state = WL1251_STATE_ON; 419 420 wl1251_info("firmware booted (%s)", wl->fw_ver); 421 422 /* update hw/fw version info in wiphy struct */ 423 wiphy->hw_version = wl->chip_id; 424 strncpy(wiphy->fw_version, wl->fw_ver, sizeof(wiphy->fw_version)); 425 426 out: 427 if (ret < 0) 428 wl1251_power_off(wl); 429 430 mutex_unlock(&wl->mutex); 431 432 return ret; 433 } 434 435 static void wl1251_op_stop(struct ieee80211_hw *hw) 436 { 437 struct wl1251 *wl = hw->priv; 438 439 wl1251_info("down"); 440 441 wl1251_debug(DEBUG_MAC80211, "mac80211 stop"); 442 443 mutex_lock(&wl->mutex); 444 445 WARN_ON(wl->state != WL1251_STATE_ON); 446 447 if (wl->scanning) { 448 ieee80211_scan_completed(wl->hw, true); 449 wl->scanning = false; 450 } 451 452 wl->state = WL1251_STATE_OFF; 453 454 wl1251_disable_interrupts(wl); 455 456 mutex_unlock(&wl->mutex); 457 458 cancel_work_sync(&wl->irq_work); 459 cancel_work_sync(&wl->tx_work); 460 cancel_delayed_work_sync(&wl->elp_work); 461 462 mutex_lock(&wl->mutex); 463 464 /* let's notify MAC80211 about the remaining pending TX frames */ 465 wl1251_tx_flush(wl); 466 wl1251_power_off(wl); 467 468 memset(wl->bssid, 0, ETH_ALEN); 469 wl->listen_int = 1; 470 wl->bss_type = MAX_BSS_TYPE; 471 472 wl->data_in_count = 0; 473 wl->rx_counter = 0; 474 wl->rx_handled = 0; 475 wl->rx_current_buffer = 0; 476 wl->rx_last_id = 0; 477 wl->next_tx_complete = 0; 478 wl->elp = false; 479 wl->station_mode = STATION_ACTIVE_MODE; 480 wl->tx_queue_stopped = false; 481 wl->power_level = WL1251_DEFAULT_POWER_LEVEL; 482 wl->rssi_thold = 0; 483 wl->channel = WL1251_DEFAULT_CHANNEL; 484 485 wl1251_debugfs_reset(wl); 486 487 mutex_unlock(&wl->mutex); 488 } 489 490 static int wl1251_op_add_interface(struct ieee80211_hw *hw, 491 struct ieee80211_vif *vif) 492 { 493 struct wl1251 *wl = hw->priv; 494 int ret = 0; 495 496 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 497 IEEE80211_VIF_SUPPORTS_CQM_RSSI; 498 499 wl1251_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM", 500 vif->type, vif->addr); 501 502 mutex_lock(&wl->mutex); 503 if (wl->vif) { 504 ret = -EBUSY; 505 goto out; 506 } 507 508 wl->vif = vif; 509 510 switch (vif->type) { 511 case NL80211_IFTYPE_STATION: 512 wl->bss_type = BSS_TYPE_STA_BSS; 513 break; 514 case NL80211_IFTYPE_ADHOC: 515 wl->bss_type = BSS_TYPE_IBSS; 516 break; 517 default: 518 ret = -EOPNOTSUPP; 519 goto out; 520 } 521 522 if (memcmp(wl->mac_addr, vif->addr, ETH_ALEN)) { 523 memcpy(wl->mac_addr, vif->addr, ETH_ALEN); 524 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); 525 ret = wl1251_acx_station_id(wl); 526 if (ret < 0) 527 goto out; 528 } 529 530 out: 531 mutex_unlock(&wl->mutex); 532 return ret; 533 } 534 535 static void wl1251_op_remove_interface(struct ieee80211_hw *hw, 536 struct ieee80211_vif *vif) 537 { 538 struct wl1251 *wl = hw->priv; 539 540 mutex_lock(&wl->mutex); 541 wl1251_debug(DEBUG_MAC80211, "mac80211 remove interface"); 542 wl->vif = NULL; 543 mutex_unlock(&wl->mutex); 544 } 545 546 static int wl1251_build_qos_null_data(struct wl1251 *wl) 547 { 548 struct ieee80211_qos_hdr template; 549 550 memset(&template, 0, sizeof(template)); 551 552 memcpy(template.addr1, wl->bssid, ETH_ALEN); 553 memcpy(template.addr2, wl->mac_addr, ETH_ALEN); 554 memcpy(template.addr3, wl->bssid, ETH_ALEN); 555 556 template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 557 IEEE80211_STYPE_QOS_NULLFUNC | 558 IEEE80211_FCTL_TODS); 559 560 /* FIXME: not sure what priority to use here */ 561 template.qos_ctrl = cpu_to_le16(0); 562 563 return wl1251_cmd_template_set(wl, CMD_QOS_NULL_DATA, &template, 564 sizeof(template)); 565 } 566 567 static int wl1251_op_config(struct ieee80211_hw *hw, u32 changed) 568 { 569 struct wl1251 *wl = hw->priv; 570 struct ieee80211_conf *conf = &hw->conf; 571 int channel, ret = 0; 572 573 channel = ieee80211_frequency_to_channel(conf->channel->center_freq); 574 575 wl1251_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d", 576 channel, 577 conf->flags & IEEE80211_CONF_PS ? "on" : "off", 578 conf->power_level); 579 580 mutex_lock(&wl->mutex); 581 582 ret = wl1251_ps_elp_wakeup(wl); 583 if (ret < 0) 584 goto out; 585 586 if (channel != wl->channel) { 587 wl->channel = channel; 588 589 ret = wl1251_join(wl, wl->bss_type, wl->channel, 590 wl->beacon_int, wl->dtim_period); 591 if (ret < 0) 592 goto out_sleep; 593 } 594 595 if (conf->flags & IEEE80211_CONF_PS && !wl->psm_requested) { 596 wl1251_debug(DEBUG_PSM, "psm enabled"); 597 598 wl->psm_requested = true; 599 600 wl->dtim_period = conf->ps_dtim_period; 601 602 ret = wl1251_acx_wr_tbtt_and_dtim(wl, wl->beacon_int, 603 wl->dtim_period); 604 605 /* 606 * mac80211 enables PSM only if we're already associated. 607 */ 608 ret = wl1251_ps_set_mode(wl, STATION_POWER_SAVE_MODE); 609 if (ret < 0) 610 goto out_sleep; 611 } else if (!(conf->flags & IEEE80211_CONF_PS) && 612 wl->psm_requested) { 613 wl1251_debug(DEBUG_PSM, "psm disabled"); 614 615 wl->psm_requested = false; 616 617 if (wl->station_mode != STATION_ACTIVE_MODE) { 618 ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); 619 if (ret < 0) 620 goto out_sleep; 621 } 622 } 623 624 if (changed & IEEE80211_CONF_CHANGE_IDLE) { 625 if (conf->flags & IEEE80211_CONF_IDLE) { 626 ret = wl1251_ps_set_mode(wl, STATION_IDLE); 627 if (ret < 0) 628 goto out_sleep; 629 } else { 630 ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); 631 if (ret < 0) 632 goto out_sleep; 633 ret = wl1251_join(wl, wl->bss_type, wl->channel, 634 wl->beacon_int, wl->dtim_period); 635 if (ret < 0) 636 goto out_sleep; 637 } 638 } 639 640 if (conf->power_level != wl->power_level) { 641 ret = wl1251_acx_tx_power(wl, conf->power_level); 642 if (ret < 0) 643 goto out_sleep; 644 645 wl->power_level = conf->power_level; 646 } 647 648 out_sleep: 649 wl1251_ps_elp_sleep(wl); 650 651 out: 652 mutex_unlock(&wl->mutex); 653 654 return ret; 655 } 656 657 #define WL1251_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \ 658 FIF_ALLMULTI | \ 659 FIF_FCSFAIL | \ 660 FIF_BCN_PRBRESP_PROMISC | \ 661 FIF_CONTROL | \ 662 FIF_OTHER_BSS | \ 663 FIF_PROBE_REQ) 664 665 static void wl1251_op_configure_filter(struct ieee80211_hw *hw, 666 unsigned int changed, 667 unsigned int *total,u64 multicast) 668 { 669 struct wl1251 *wl = hw->priv; 670 int ret; 671 672 wl1251_debug(DEBUG_MAC80211, "mac80211 configure filter"); 673 674 *total &= WL1251_SUPPORTED_FILTERS; 675 changed &= WL1251_SUPPORTED_FILTERS; 676 677 if (changed == 0) 678 /* no filters which we support changed */ 679 return; 680 681 mutex_lock(&wl->mutex); 682 683 wl->rx_config = WL1251_DEFAULT_RX_CONFIG; 684 wl->rx_filter = WL1251_DEFAULT_RX_FILTER; 685 686 if (*total & FIF_PROMISC_IN_BSS) { 687 wl->rx_config |= CFG_BSSID_FILTER_EN; 688 wl->rx_config |= CFG_RX_ALL_GOOD; 689 } 690 if (*total & FIF_ALLMULTI) 691 /* 692 * CFG_MC_FILTER_EN in rx_config needs to be 0 to receive 693 * all multicast frames 694 */ 695 wl->rx_config &= ~CFG_MC_FILTER_EN; 696 if (*total & FIF_FCSFAIL) 697 wl->rx_filter |= CFG_RX_FCS_ERROR; 698 if (*total & FIF_BCN_PRBRESP_PROMISC) { 699 wl->rx_config &= ~CFG_BSSID_FILTER_EN; 700 wl->rx_config &= ~CFG_SSID_FILTER_EN; 701 } 702 if (*total & FIF_CONTROL) 703 wl->rx_filter |= CFG_RX_CTL_EN; 704 if (*total & FIF_OTHER_BSS || is_zero_ether_addr(wl->bssid)) 705 wl->rx_config &= ~CFG_BSSID_FILTER_EN; 706 if (*total & FIF_PROBE_REQ) 707 wl->rx_filter |= CFG_RX_PREQ_EN; 708 709 if (wl->state == WL1251_STATE_OFF) 710 goto out; 711 712 ret = wl1251_ps_elp_wakeup(wl); 713 if (ret < 0) 714 goto out; 715 716 /* send filters to firmware */ 717 wl1251_acx_rx_config(wl, wl->rx_config, wl->rx_filter); 718 719 wl1251_ps_elp_sleep(wl); 720 721 out: 722 mutex_unlock(&wl->mutex); 723 } 724 725 /* HW encryption */ 726 static int wl1251_set_key_type(struct wl1251 *wl, 727 struct wl1251_cmd_set_keys *key, 728 enum set_key_cmd cmd, 729 struct ieee80211_key_conf *mac80211_key, 730 const u8 *addr) 731 { 732 switch (mac80211_key->cipher) { 733 case WLAN_CIPHER_SUITE_WEP40: 734 case WLAN_CIPHER_SUITE_WEP104: 735 if (is_broadcast_ether_addr(addr)) 736 key->key_type = KEY_WEP_DEFAULT; 737 else 738 key->key_type = KEY_WEP_ADDR; 739 740 mac80211_key->hw_key_idx = mac80211_key->keyidx; 741 break; 742 case WLAN_CIPHER_SUITE_TKIP: 743 if (is_broadcast_ether_addr(addr)) 744 key->key_type = KEY_TKIP_MIC_GROUP; 745 else 746 key->key_type = KEY_TKIP_MIC_PAIRWISE; 747 748 mac80211_key->hw_key_idx = mac80211_key->keyidx; 749 break; 750 case WLAN_CIPHER_SUITE_CCMP: 751 if (is_broadcast_ether_addr(addr)) 752 key->key_type = KEY_AES_GROUP; 753 else 754 key->key_type = KEY_AES_PAIRWISE; 755 mac80211_key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 756 break; 757 default: 758 wl1251_error("Unknown key cipher 0x%x", mac80211_key->cipher); 759 return -EOPNOTSUPP; 760 } 761 762 return 0; 763 } 764 765 static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 766 struct ieee80211_vif *vif, 767 struct ieee80211_sta *sta, 768 struct ieee80211_key_conf *key) 769 { 770 struct wl1251 *wl = hw->priv; 771 struct wl1251_cmd_set_keys *wl_cmd; 772 const u8 *addr; 773 int ret; 774 775 static const u8 bcast_addr[ETH_ALEN] = 776 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 777 778 wl1251_debug(DEBUG_MAC80211, "mac80211 set key"); 779 780 wl_cmd = kzalloc(sizeof(*wl_cmd), GFP_KERNEL); 781 if (!wl_cmd) { 782 ret = -ENOMEM; 783 goto out; 784 } 785 786 addr = sta ? sta->addr : bcast_addr; 787 788 wl1251_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd); 789 wl1251_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN); 790 wl1251_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x", 791 key->cipher, key->keyidx, key->keylen, key->flags); 792 wl1251_dump(DEBUG_CRYPT, "KEY: ", key->key, key->keylen); 793 794 if (is_zero_ether_addr(addr)) { 795 /* We dont support TX only encryption */ 796 ret = -EOPNOTSUPP; 797 goto out; 798 } 799 800 mutex_lock(&wl->mutex); 801 802 ret = wl1251_ps_elp_wakeup(wl); 803 if (ret < 0) 804 goto out_unlock; 805 806 switch (cmd) { 807 case SET_KEY: 808 wl_cmd->key_action = KEY_ADD_OR_REPLACE; 809 break; 810 case DISABLE_KEY: 811 wl_cmd->key_action = KEY_REMOVE; 812 break; 813 default: 814 wl1251_error("Unsupported key cmd 0x%x", cmd); 815 break; 816 } 817 818 ret = wl1251_set_key_type(wl, wl_cmd, cmd, key, addr); 819 if (ret < 0) { 820 wl1251_error("Set KEY type failed"); 821 goto out_sleep; 822 } 823 824 if (wl_cmd->key_type != KEY_WEP_DEFAULT) 825 memcpy(wl_cmd->addr, addr, ETH_ALEN); 826 827 if ((wl_cmd->key_type == KEY_TKIP_MIC_GROUP) || 828 (wl_cmd->key_type == KEY_TKIP_MIC_PAIRWISE)) { 829 /* 830 * We get the key in the following form: 831 * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes) 832 * but the target is expecting: 833 * TKIP - RX MIC - TX MIC 834 */ 835 memcpy(wl_cmd->key, key->key, 16); 836 memcpy(wl_cmd->key + 16, key->key + 24, 8); 837 memcpy(wl_cmd->key + 24, key->key + 16, 8); 838 839 } else { 840 memcpy(wl_cmd->key, key->key, key->keylen); 841 } 842 wl_cmd->key_size = key->keylen; 843 844 wl_cmd->id = key->keyidx; 845 wl_cmd->ssid_profile = 0; 846 847 wl1251_dump(DEBUG_CRYPT, "TARGET KEY: ", wl_cmd, sizeof(*wl_cmd)); 848 849 ret = wl1251_cmd_send(wl, CMD_SET_KEYS, wl_cmd, sizeof(*wl_cmd)); 850 if (ret < 0) { 851 wl1251_warning("could not set keys"); 852 goto out_sleep; 853 } 854 855 out_sleep: 856 wl1251_ps_elp_sleep(wl); 857 858 out_unlock: 859 mutex_unlock(&wl->mutex); 860 861 out: 862 kfree(wl_cmd); 863 864 return ret; 865 } 866 867 static int wl1251_op_hw_scan(struct ieee80211_hw *hw, 868 struct ieee80211_vif *vif, 869 struct cfg80211_scan_request *req) 870 { 871 struct wl1251 *wl = hw->priv; 872 struct sk_buff *skb; 873 size_t ssid_len = 0; 874 u8 *ssid = NULL; 875 int ret; 876 877 wl1251_debug(DEBUG_MAC80211, "mac80211 hw scan"); 878 879 if (req->n_ssids) { 880 ssid = req->ssids[0].ssid; 881 ssid_len = req->ssids[0].ssid_len; 882 } 883 884 mutex_lock(&wl->mutex); 885 886 if (wl->scanning) { 887 wl1251_debug(DEBUG_SCAN, "scan already in progress"); 888 ret = -EINVAL; 889 goto out; 890 } 891 892 ret = wl1251_ps_elp_wakeup(wl); 893 if (ret < 0) 894 goto out; 895 896 skb = ieee80211_probereq_get(wl->hw, wl->vif, ssid, ssid_len, 897 req->ie, req->ie_len); 898 if (!skb) { 899 ret = -ENOMEM; 900 goto out; 901 } 902 903 ret = wl1251_cmd_template_set(wl, CMD_PROBE_REQ, skb->data, 904 skb->len); 905 dev_kfree_skb(skb); 906 if (ret < 0) 907 goto out_sleep; 908 909 ret = wl1251_cmd_trigger_scan_to(wl, 0); 910 if (ret < 0) 911 goto out_sleep; 912 913 wl->scanning = true; 914 915 ret = wl1251_cmd_scan(wl, ssid, ssid_len, req->channels, 916 req->n_channels, WL1251_SCAN_NUM_PROBES); 917 if (ret < 0) { 918 wl->scanning = false; 919 goto out_sleep; 920 } 921 922 out_sleep: 923 wl1251_ps_elp_sleep(wl); 924 925 out: 926 mutex_unlock(&wl->mutex); 927 928 return ret; 929 } 930 931 static int wl1251_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 932 { 933 struct wl1251 *wl = hw->priv; 934 int ret; 935 936 mutex_lock(&wl->mutex); 937 938 ret = wl1251_ps_elp_wakeup(wl); 939 if (ret < 0) 940 goto out; 941 942 ret = wl1251_acx_rts_threshold(wl, (u16) value); 943 if (ret < 0) 944 wl1251_warning("wl1251_op_set_rts_threshold failed: %d", ret); 945 946 wl1251_ps_elp_sleep(wl); 947 948 out: 949 mutex_unlock(&wl->mutex); 950 951 return ret; 952 } 953 954 static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw, 955 struct ieee80211_vif *vif, 956 struct ieee80211_bss_conf *bss_conf, 957 u32 changed) 958 { 959 struct wl1251 *wl = hw->priv; 960 struct sk_buff *beacon, *skb; 961 int ret; 962 963 wl1251_debug(DEBUG_MAC80211, "mac80211 bss info changed"); 964 965 mutex_lock(&wl->mutex); 966 967 ret = wl1251_ps_elp_wakeup(wl); 968 if (ret < 0) 969 goto out; 970 971 if (changed & BSS_CHANGED_CQM) { 972 ret = wl1251_acx_low_rssi(wl, bss_conf->cqm_rssi_thold, 973 WL1251_DEFAULT_LOW_RSSI_WEIGHT, 974 WL1251_DEFAULT_LOW_RSSI_DEPTH, 975 WL1251_ACX_LOW_RSSI_TYPE_EDGE); 976 if (ret < 0) 977 goto out; 978 wl->rssi_thold = bss_conf->cqm_rssi_thold; 979 } 980 981 if (changed & BSS_CHANGED_BSSID) { 982 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN); 983 984 skb = ieee80211_nullfunc_get(wl->hw, wl->vif); 985 if (!skb) 986 goto out_sleep; 987 988 ret = wl1251_cmd_template_set(wl, CMD_NULL_DATA, 989 skb->data, skb->len); 990 dev_kfree_skb(skb); 991 if (ret < 0) 992 goto out_sleep; 993 994 ret = wl1251_build_qos_null_data(wl); 995 if (ret < 0) 996 goto out; 997 998 if (wl->bss_type != BSS_TYPE_IBSS) { 999 ret = wl1251_join(wl, wl->bss_type, wl->channel, 1000 wl->beacon_int, wl->dtim_period); 1001 if (ret < 0) 1002 goto out_sleep; 1003 } 1004 } 1005 1006 if (changed & BSS_CHANGED_ASSOC) { 1007 if (bss_conf->assoc) { 1008 wl->beacon_int = bss_conf->beacon_int; 1009 1010 skb = ieee80211_pspoll_get(wl->hw, wl->vif); 1011 if (!skb) 1012 goto out_sleep; 1013 1014 ret = wl1251_cmd_template_set(wl, CMD_PS_POLL, 1015 skb->data, 1016 skb->len); 1017 dev_kfree_skb(skb); 1018 if (ret < 0) 1019 goto out_sleep; 1020 1021 ret = wl1251_acx_aid(wl, bss_conf->aid); 1022 if (ret < 0) 1023 goto out_sleep; 1024 } else { 1025 /* use defaults when not associated */ 1026 wl->beacon_int = WL1251_DEFAULT_BEACON_INT; 1027 wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD; 1028 } 1029 } 1030 if (changed & BSS_CHANGED_ERP_SLOT) { 1031 if (bss_conf->use_short_slot) 1032 ret = wl1251_acx_slot(wl, SLOT_TIME_SHORT); 1033 else 1034 ret = wl1251_acx_slot(wl, SLOT_TIME_LONG); 1035 if (ret < 0) { 1036 wl1251_warning("Set slot time failed %d", ret); 1037 goto out_sleep; 1038 } 1039 } 1040 1041 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 1042 if (bss_conf->use_short_preamble) 1043 wl1251_acx_set_preamble(wl, ACX_PREAMBLE_SHORT); 1044 else 1045 wl1251_acx_set_preamble(wl, ACX_PREAMBLE_LONG); 1046 } 1047 1048 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 1049 if (bss_conf->use_cts_prot) 1050 ret = wl1251_acx_cts_protect(wl, CTSPROTECT_ENABLE); 1051 else 1052 ret = wl1251_acx_cts_protect(wl, CTSPROTECT_DISABLE); 1053 if (ret < 0) { 1054 wl1251_warning("Set ctsprotect failed %d", ret); 1055 goto out_sleep; 1056 } 1057 } 1058 1059 if (changed & BSS_CHANGED_BEACON) { 1060 beacon = ieee80211_beacon_get(hw, vif); 1061 if (!beacon) 1062 goto out_sleep; 1063 1064 ret = wl1251_cmd_template_set(wl, CMD_BEACON, beacon->data, 1065 beacon->len); 1066 1067 if (ret < 0) { 1068 dev_kfree_skb(beacon); 1069 goto out_sleep; 1070 } 1071 1072 ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, beacon->data, 1073 beacon->len); 1074 1075 dev_kfree_skb(beacon); 1076 1077 if (ret < 0) 1078 goto out_sleep; 1079 1080 ret = wl1251_join(wl, wl->bss_type, wl->beacon_int, 1081 wl->channel, wl->dtim_period); 1082 1083 if (ret < 0) 1084 goto out_sleep; 1085 } 1086 1087 out_sleep: 1088 wl1251_ps_elp_sleep(wl); 1089 1090 out: 1091 mutex_unlock(&wl->mutex); 1092 } 1093 1094 1095 /* can't be const, mac80211 writes to this */ 1096 static struct ieee80211_rate wl1251_rates[] = { 1097 { .bitrate = 10, 1098 .hw_value = 0x1, 1099 .hw_value_short = 0x1, }, 1100 { .bitrate = 20, 1101 .hw_value = 0x2, 1102 .hw_value_short = 0x2, 1103 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 1104 { .bitrate = 55, 1105 .hw_value = 0x4, 1106 .hw_value_short = 0x4, 1107 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 1108 { .bitrate = 110, 1109 .hw_value = 0x20, 1110 .hw_value_short = 0x20, 1111 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 1112 { .bitrate = 60, 1113 .hw_value = 0x8, 1114 .hw_value_short = 0x8, }, 1115 { .bitrate = 90, 1116 .hw_value = 0x10, 1117 .hw_value_short = 0x10, }, 1118 { .bitrate = 120, 1119 .hw_value = 0x40, 1120 .hw_value_short = 0x40, }, 1121 { .bitrate = 180, 1122 .hw_value = 0x80, 1123 .hw_value_short = 0x80, }, 1124 { .bitrate = 240, 1125 .hw_value = 0x200, 1126 .hw_value_short = 0x200, }, 1127 { .bitrate = 360, 1128 .hw_value = 0x400, 1129 .hw_value_short = 0x400, }, 1130 { .bitrate = 480, 1131 .hw_value = 0x800, 1132 .hw_value_short = 0x800, }, 1133 { .bitrate = 540, 1134 .hw_value = 0x1000, 1135 .hw_value_short = 0x1000, }, 1136 }; 1137 1138 /* can't be const, mac80211 writes to this */ 1139 static struct ieee80211_channel wl1251_channels[] = { 1140 { .hw_value = 1, .center_freq = 2412}, 1141 { .hw_value = 2, .center_freq = 2417}, 1142 { .hw_value = 3, .center_freq = 2422}, 1143 { .hw_value = 4, .center_freq = 2427}, 1144 { .hw_value = 5, .center_freq = 2432}, 1145 { .hw_value = 6, .center_freq = 2437}, 1146 { .hw_value = 7, .center_freq = 2442}, 1147 { .hw_value = 8, .center_freq = 2447}, 1148 { .hw_value = 9, .center_freq = 2452}, 1149 { .hw_value = 10, .center_freq = 2457}, 1150 { .hw_value = 11, .center_freq = 2462}, 1151 { .hw_value = 12, .center_freq = 2467}, 1152 { .hw_value = 13, .center_freq = 2472}, 1153 }; 1154 1155 static int wl1251_op_conf_tx(struct ieee80211_hw *hw, 1156 struct ieee80211_vif *vif, u16 queue, 1157 const struct ieee80211_tx_queue_params *params) 1158 { 1159 enum wl1251_acx_ps_scheme ps_scheme; 1160 struct wl1251 *wl = hw->priv; 1161 int ret; 1162 1163 mutex_lock(&wl->mutex); 1164 1165 wl1251_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue); 1166 1167 ret = wl1251_ps_elp_wakeup(wl); 1168 if (ret < 0) 1169 goto out; 1170 1171 /* mac80211 uses units of 32 usec */ 1172 ret = wl1251_acx_ac_cfg(wl, wl1251_tx_get_queue(queue), 1173 params->cw_min, params->cw_max, 1174 params->aifs, params->txop * 32); 1175 if (ret < 0) 1176 goto out_sleep; 1177 1178 if (params->uapsd) 1179 ps_scheme = WL1251_ACX_PS_SCHEME_UPSD_TRIGGER; 1180 else 1181 ps_scheme = WL1251_ACX_PS_SCHEME_LEGACY; 1182 1183 ret = wl1251_acx_tid_cfg(wl, wl1251_tx_get_queue(queue), 1184 CHANNEL_TYPE_EDCF, 1185 wl1251_tx_get_queue(queue), ps_scheme, 1186 WL1251_ACX_ACK_POLICY_LEGACY); 1187 if (ret < 0) 1188 goto out_sleep; 1189 1190 out_sleep: 1191 wl1251_ps_elp_sleep(wl); 1192 1193 out: 1194 mutex_unlock(&wl->mutex); 1195 1196 return ret; 1197 } 1198 1199 static int wl1251_op_get_survey(struct ieee80211_hw *hw, int idx, 1200 struct survey_info *survey) 1201 { 1202 struct wl1251 *wl = hw->priv; 1203 struct ieee80211_conf *conf = &hw->conf; 1204 1205 if (idx != 0) 1206 return -ENOENT; 1207 1208 survey->channel = conf->channel; 1209 survey->filled = SURVEY_INFO_NOISE_DBM; 1210 survey->noise = wl->noise; 1211 1212 return 0; 1213 } 1214 1215 /* can't be const, mac80211 writes to this */ 1216 static struct ieee80211_supported_band wl1251_band_2ghz = { 1217 .channels = wl1251_channels, 1218 .n_channels = ARRAY_SIZE(wl1251_channels), 1219 .bitrates = wl1251_rates, 1220 .n_bitrates = ARRAY_SIZE(wl1251_rates), 1221 }; 1222 1223 static const struct ieee80211_ops wl1251_ops = { 1224 .start = wl1251_op_start, 1225 .stop = wl1251_op_stop, 1226 .add_interface = wl1251_op_add_interface, 1227 .remove_interface = wl1251_op_remove_interface, 1228 .config = wl1251_op_config, 1229 .configure_filter = wl1251_op_configure_filter, 1230 .tx = wl1251_op_tx, 1231 .set_key = wl1251_op_set_key, 1232 .hw_scan = wl1251_op_hw_scan, 1233 .bss_info_changed = wl1251_op_bss_info_changed, 1234 .set_rts_threshold = wl1251_op_set_rts_threshold, 1235 .conf_tx = wl1251_op_conf_tx, 1236 .get_survey = wl1251_op_get_survey, 1237 }; 1238 1239 static int wl1251_read_eeprom_byte(struct wl1251 *wl, off_t offset, u8 *data) 1240 { 1241 unsigned long timeout; 1242 1243 wl1251_reg_write32(wl, EE_ADDR, offset); 1244 wl1251_reg_write32(wl, EE_CTL, EE_CTL_READ); 1245 1246 /* EE_CTL_READ clears when data is ready */ 1247 timeout = jiffies + msecs_to_jiffies(100); 1248 while (1) { 1249 if (!(wl1251_reg_read32(wl, EE_CTL) & EE_CTL_READ)) 1250 break; 1251 1252 if (time_after(jiffies, timeout)) 1253 return -ETIMEDOUT; 1254 1255 msleep(1); 1256 } 1257 1258 *data = wl1251_reg_read32(wl, EE_DATA); 1259 return 0; 1260 } 1261 1262 static int wl1251_read_eeprom(struct wl1251 *wl, off_t offset, 1263 u8 *data, size_t len) 1264 { 1265 size_t i; 1266 int ret; 1267 1268 wl1251_reg_write32(wl, EE_START, 0); 1269 1270 for (i = 0; i < len; i++) { 1271 ret = wl1251_read_eeprom_byte(wl, offset + i, &data[i]); 1272 if (ret < 0) 1273 return ret; 1274 } 1275 1276 return 0; 1277 } 1278 1279 static int wl1251_read_eeprom_mac(struct wl1251 *wl) 1280 { 1281 u8 mac[ETH_ALEN]; 1282 int i, ret; 1283 1284 wl1251_set_partition(wl, 0, 0, REGISTERS_BASE, REGISTERS_DOWN_SIZE); 1285 1286 ret = wl1251_read_eeprom(wl, 0x1c, mac, sizeof(mac)); 1287 if (ret < 0) { 1288 wl1251_warning("failed to read MAC address from EEPROM"); 1289 return ret; 1290 } 1291 1292 /* MAC is stored in reverse order */ 1293 for (i = 0; i < ETH_ALEN; i++) 1294 wl->mac_addr[i] = mac[ETH_ALEN - i - 1]; 1295 1296 return 0; 1297 } 1298 1299 static int wl1251_register_hw(struct wl1251 *wl) 1300 { 1301 int ret; 1302 1303 if (wl->mac80211_registered) 1304 return 0; 1305 1306 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); 1307 1308 ret = ieee80211_register_hw(wl->hw); 1309 if (ret < 0) { 1310 wl1251_error("unable to register mac80211 hw: %d", ret); 1311 return ret; 1312 } 1313 1314 wl->mac80211_registered = true; 1315 1316 wl1251_notice("loaded"); 1317 1318 return 0; 1319 } 1320 1321 int wl1251_init_ieee80211(struct wl1251 *wl) 1322 { 1323 int ret; 1324 1325 /* The tx descriptor buffer and the TKIP space */ 1326 wl->hw->extra_tx_headroom = sizeof(struct tx_double_buffer_desc) 1327 + WL1251_TKIP_IV_SPACE; 1328 1329 /* unit us */ 1330 /* FIXME: find a proper value */ 1331 wl->hw->channel_change_time = 10000; 1332 1333 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM | 1334 IEEE80211_HW_SUPPORTS_PS | 1335 IEEE80211_HW_SUPPORTS_UAPSD; 1336 1337 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 1338 BIT(NL80211_IFTYPE_ADHOC); 1339 wl->hw->wiphy->max_scan_ssids = 1; 1340 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1251_band_2ghz; 1341 1342 wl->hw->queues = 4; 1343 1344 if (wl->use_eeprom) 1345 wl1251_read_eeprom_mac(wl); 1346 1347 ret = wl1251_register_hw(wl); 1348 if (ret) 1349 goto out; 1350 1351 wl1251_debugfs_init(wl); 1352 wl1251_notice("initialized"); 1353 1354 ret = 0; 1355 1356 out: 1357 return ret; 1358 } 1359 EXPORT_SYMBOL_GPL(wl1251_init_ieee80211); 1360 1361 struct ieee80211_hw *wl1251_alloc_hw(void) 1362 { 1363 struct ieee80211_hw *hw; 1364 struct wl1251 *wl; 1365 int i; 1366 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf}; 1367 1368 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1251_ops); 1369 if (!hw) { 1370 wl1251_error("could not alloc ieee80211_hw"); 1371 return ERR_PTR(-ENOMEM); 1372 } 1373 1374 wl = hw->priv; 1375 memset(wl, 0, sizeof(*wl)); 1376 1377 wl->hw = hw; 1378 1379 wl->data_in_count = 0; 1380 1381 skb_queue_head_init(&wl->tx_queue); 1382 1383 INIT_DELAYED_WORK(&wl->elp_work, wl1251_elp_work); 1384 wl->channel = WL1251_DEFAULT_CHANNEL; 1385 wl->scanning = false; 1386 wl->default_key = 0; 1387 wl->listen_int = 1; 1388 wl->rx_counter = 0; 1389 wl->rx_handled = 0; 1390 wl->rx_current_buffer = 0; 1391 wl->rx_last_id = 0; 1392 wl->rx_config = WL1251_DEFAULT_RX_CONFIG; 1393 wl->rx_filter = WL1251_DEFAULT_RX_FILTER; 1394 wl->elp = false; 1395 wl->station_mode = STATION_ACTIVE_MODE; 1396 wl->psm_requested = false; 1397 wl->tx_queue_stopped = false; 1398 wl->power_level = WL1251_DEFAULT_POWER_LEVEL; 1399 wl->rssi_thold = 0; 1400 wl->beacon_int = WL1251_DEFAULT_BEACON_INT; 1401 wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD; 1402 wl->vif = NULL; 1403 1404 for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++) 1405 wl->tx_frames[i] = NULL; 1406 1407 wl->next_tx_complete = 0; 1408 1409 INIT_WORK(&wl->irq_work, wl1251_irq_work); 1410 INIT_WORK(&wl->tx_work, wl1251_tx_work); 1411 1412 /* 1413 * In case our MAC address is not correctly set, 1414 * we use a random but Nokia MAC. 1415 */ 1416 memcpy(wl->mac_addr, nokia_oui, 3); 1417 get_random_bytes(wl->mac_addr + 3, 3); 1418 1419 wl->state = WL1251_STATE_OFF; 1420 mutex_init(&wl->mutex); 1421 1422 wl->tx_mgmt_frm_rate = DEFAULT_HW_GEN_TX_RATE; 1423 wl->tx_mgmt_frm_mod = DEFAULT_HW_GEN_MODULATION_TYPE; 1424 1425 wl->rx_descriptor = kmalloc(sizeof(*wl->rx_descriptor), GFP_KERNEL); 1426 if (!wl->rx_descriptor) { 1427 wl1251_error("could not allocate memory for rx descriptor"); 1428 ieee80211_free_hw(hw); 1429 return ERR_PTR(-ENOMEM); 1430 } 1431 1432 return hw; 1433 } 1434 EXPORT_SYMBOL_GPL(wl1251_alloc_hw); 1435 1436 int wl1251_free_hw(struct wl1251 *wl) 1437 { 1438 ieee80211_unregister_hw(wl->hw); 1439 1440 wl1251_debugfs_exit(wl); 1441 1442 kfree(wl->target_mem_map); 1443 kfree(wl->data_path); 1444 vfree(wl->fw); 1445 wl->fw = NULL; 1446 kfree(wl->nvs); 1447 wl->nvs = NULL; 1448 1449 kfree(wl->rx_descriptor); 1450 wl->rx_descriptor = NULL; 1451 1452 ieee80211_free_hw(wl->hw); 1453 1454 return 0; 1455 } 1456 EXPORT_SYMBOL_GPL(wl1251_free_hw); 1457 1458 MODULE_DESCRIPTION("TI wl1251 Wireles LAN Driver Core"); 1459 MODULE_LICENSE("GPL"); 1460 MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>"); 1461 MODULE_FIRMWARE(WL1251_FW_NAME); 1462