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