2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
35 #include "wl12xx_80211.h"
36 #include "wl1271_reg.h"
37 #include "wl1271_io.h"
38 #include "wl1271_event.h"
39 #include "wl1271_tx.h"
40 #include "wl1271_rx.h"
41 #include "wl1271_ps.h"
42 #include "wl1271_init.h"
43 #include "wl1271_debugfs.h"
44 #include "wl1271_cmd.h"
45 #include "wl1271_boot.h"
46 #include "wl1271_testmode.h"
47 #include "wl1271_scan.h"
49 #define WL1271_BOOT_RETRIES 3
51 static struct conf_drv_settings default_conf = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
58 [CONF_SG_AUTO_PS_MODE] = 1,
59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
103 .state = CONF_SG_PROTECTIVE,
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
110 .rts_threshold = 2347,
111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
118 .tx_energy_detection = 0,
121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
145 .aifsn = CONF_TX_AIFS_PIFS,
152 .aifsn = CONF_TX_AIFS_PIFS,
160 .channel_type = CONF_CHANNEL_TYPE_DCF,
161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
168 .channel_type = CONF_CHANNEL_TYPE_DCF,
169 .tsid = CONF_TX_AC_BE,
170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
176 .channel_type = CONF_CHANNEL_TYPE_DCF,
177 .tsid = CONF_TX_AC_BE,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
184 .channel_type = CONF_CHANNEL_TYPE_DCF,
185 .tsid = CONF_TX_AC_BE,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
192 .channel_type = CONF_CHANNEL_TYPE_DCF,
193 .tsid = CONF_TX_AC_BE,
194 .ps_scheme = CONF_PS_SCHEME_LEGACY,
195 .ack_policy = CONF_ACK_POLICY_LEGACY,
200 .channel_type = CONF_CHANNEL_TYPE_DCF,
201 .tsid = CONF_TX_AC_BE,
202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
208 .channel_type = CONF_CHANNEL_TYPE_DCF,
209 .tsid = CONF_TX_AC_BE,
210 .ps_scheme = CONF_PS_SCHEME_LEGACY,
211 .ack_policy = CONF_ACK_POLICY_LEGACY,
215 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
216 .tx_compl_timeout = 700,
217 .tx_compl_threshold = 4,
218 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
219 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
222 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
223 .listen_interval = 1,
224 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
225 .bcn_filt_ie_count = 1,
228 .ie = WLAN_EID_CHANNEL_SWITCH,
229 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
232 .synch_fail_thold = 10,
233 .bss_lose_timeout = 100,
234 .beacon_rx_timeout = 10000,
235 .broadcast_timeout = 20000,
236 .rx_broadcast_in_ps = 1,
237 .ps_poll_threshold = 10,
238 .ps_poll_recovery_period = 700,
239 .bet_enable = CONF_BET_MODE_ENABLE,
240 .bet_max_consecutive = 10,
241 .psm_entry_retries = 3,
242 .keep_alive_interval = 55000,
243 .max_listen_interval = 20,
250 .host_clk_settling_time = 5000,
251 .host_fast_wakeup_support = false
254 /* FIXME: due to firmware bug, must use value 1 for now */
256 .avg_weight_rssi_beacon = 20,
257 .avg_weight_rssi_data = 10,
258 .avg_weight_snr_beacon = 20,
259 .avg_weight_snr_data = 10
263 static void wl1271_device_release(struct device *dev)
268 static struct platform_device wl1271_device = {
272 /* device model insists to have a release function */
274 .release = wl1271_device_release,
278 static LIST_HEAD(wl_list);
280 static void wl1271_conf_init(struct wl1271 *wl)
284 * This function applies the default configuration to the driver. This
285 * function is invoked upon driver load (spi probe.)
287 * The configuration is stored in a run-time structure in order to
288 * facilitate for run-time adjustment of any of the parameters. Making
289 * changes to the configuration structure will apply the new values on
290 * the next interface up (wl1271_op_start.)
293 /* apply driver default configuration */
294 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
298 static int wl1271_plt_init(struct wl1271 *wl)
300 struct conf_tx_ac_category *conf_ac;
301 struct conf_tx_tid *conf_tid;
304 ret = wl1271_cmd_general_parms(wl);
308 ret = wl1271_cmd_radio_parms(wl);
312 ret = wl1271_init_templates_config(wl);
316 ret = wl1271_acx_init_mem_config(wl);
320 /* PHY layer config */
321 ret = wl1271_init_phy_config(wl);
323 goto out_free_memmap;
325 ret = wl1271_acx_dco_itrim_params(wl);
327 goto out_free_memmap;
329 /* Initialize connection monitoring thresholds */
330 ret = wl1271_acx_conn_monit_params(wl, false);
332 goto out_free_memmap;
334 /* Bluetooth WLAN coexistence */
335 ret = wl1271_init_pta(wl);
337 goto out_free_memmap;
339 /* Energy detection */
340 ret = wl1271_init_energy_detection(wl);
342 goto out_free_memmap;
344 /* Default fragmentation threshold */
345 ret = wl1271_acx_frag_threshold(wl);
347 goto out_free_memmap;
349 /* Default TID configuration */
350 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
351 conf_tid = &wl->conf.tx.tid_conf[i];
352 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
353 conf_tid->channel_type,
356 conf_tid->ack_policy,
357 conf_tid->apsd_conf[0],
358 conf_tid->apsd_conf[1]);
360 goto out_free_memmap;
363 /* Default AC configuration */
364 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
365 conf_ac = &wl->conf.tx.ac_conf[i];
366 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
367 conf_ac->cw_max, conf_ac->aifsn,
368 conf_ac->tx_op_limit);
370 goto out_free_memmap;
373 /* Enable data path */
374 ret = wl1271_cmd_data_path(wl, 1);
376 goto out_free_memmap;
378 /* Configure for CAM power saving (ie. always active) */
379 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
381 goto out_free_memmap;
384 ret = wl1271_acx_pm_config(wl);
386 goto out_free_memmap;
391 kfree(wl->target_mem_map);
392 wl->target_mem_map = NULL;
397 static void wl1271_fw_status(struct wl1271 *wl,
398 struct wl1271_fw_status *status)
404 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
406 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
407 "drv_rx_counter = %d, tx_results_counter = %d)",
409 status->fw_rx_counter,
410 status->drv_rx_counter,
411 status->tx_results_counter);
413 /* update number of available TX blocks */
414 for (i = 0; i < NUM_TX_QUEUES; i++) {
415 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
416 wl->tx_blocks_freed[i];
418 wl->tx_blocks_freed[i] =
419 le32_to_cpu(status->tx_released_blks[i]);
420 wl->tx_blocks_available += cnt;
424 /* if more blocks are available now, schedule some tx work */
425 if (total && !skb_queue_empty(&wl->tx_queue))
426 ieee80211_queue_work(wl->hw, &wl->tx_work);
428 /* update the host-chipset time offset */
430 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
431 (s64)le32_to_cpu(status->fw_localtime);
434 #define WL1271_IRQ_MAX_LOOPS 10
436 static void wl1271_irq_work(struct work_struct *work)
440 int loopcount = WL1271_IRQ_MAX_LOOPS;
443 container_of(work, struct wl1271, irq_work);
445 mutex_lock(&wl->mutex);
447 wl1271_debug(DEBUG_IRQ, "IRQ work");
449 if (unlikely(wl->state == WL1271_STATE_OFF))
452 ret = wl1271_ps_elp_wakeup(wl, true);
456 spin_lock_irqsave(&wl->wl_lock, flags);
457 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
458 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
459 spin_unlock_irqrestore(&wl->wl_lock, flags);
462 wl1271_fw_status(wl, wl->fw_status);
463 intr = le32_to_cpu(wl->fw_status->intr);
465 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
466 spin_lock_irqsave(&wl->wl_lock, flags);
470 intr &= WL1271_INTR_MASK;
472 if (intr & WL1271_ACX_INTR_DATA) {
473 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
475 /* check for tx results */
476 if (wl->fw_status->tx_results_counter !=
477 (wl->tx_results_count & 0xff))
478 wl1271_tx_complete(wl);
480 wl1271_rx(wl, wl->fw_status);
483 if (intr & WL1271_ACX_INTR_EVENT_A) {
484 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
485 wl1271_event_handle(wl, 0);
488 if (intr & WL1271_ACX_INTR_EVENT_B) {
489 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
490 wl1271_event_handle(wl, 1);
493 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
494 wl1271_debug(DEBUG_IRQ,
495 "WL1271_ACX_INTR_INIT_COMPLETE");
497 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
498 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
500 spin_lock_irqsave(&wl->wl_lock, flags);
503 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
504 ieee80211_queue_work(wl->hw, &wl->irq_work);
506 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
507 spin_unlock_irqrestore(&wl->wl_lock, flags);
509 wl1271_ps_elp_sleep(wl);
512 mutex_unlock(&wl->mutex);
515 static int wl1271_fetch_firmware(struct wl1271 *wl)
517 const struct firmware *fw;
520 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
523 wl1271_error("could not get firmware: %d", ret);
528 wl1271_error("firmware size is not multiple of 32 bits: %zu",
534 wl->fw_len = fw->size;
535 wl->fw = vmalloc(wl->fw_len);
538 wl1271_error("could not allocate memory for the firmware");
543 memcpy(wl->fw, fw->data, wl->fw_len);
548 release_firmware(fw);
553 static int wl1271_fetch_nvs(struct wl1271 *wl)
555 const struct firmware *fw;
558 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
561 wl1271_error("could not get nvs file: %d", ret);
566 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
567 * configurations) can be removed when those NVS files stop floating
570 if (fw->size != sizeof(struct wl1271_nvs_file) &&
571 (fw->size != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
572 wl1271_11a_enabled())) {
573 wl1271_error("nvs size is not as expected: %zu != %zu",
574 fw->size, sizeof(struct wl1271_nvs_file));
579 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
582 wl1271_error("could not allocate memory for the nvs file");
588 release_firmware(fw);
593 static void wl1271_fw_wakeup(struct wl1271 *wl)
597 elp_reg = ELPCTRL_WAKE_UP;
598 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
601 static int wl1271_setup(struct wl1271 *wl)
603 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
607 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
608 if (!wl->tx_res_if) {
609 kfree(wl->fw_status);
613 INIT_WORK(&wl->irq_work, wl1271_irq_work);
614 INIT_WORK(&wl->tx_work, wl1271_tx_work);
618 static int wl1271_chip_wakeup(struct wl1271 *wl)
620 struct wl1271_partition_set partition;
623 msleep(WL1271_PRE_POWER_ON_SLEEP);
624 ret = wl1271_power_on(wl);
627 msleep(WL1271_POWER_ON_SLEEP);
631 /* We don't need a real memory partition here, because we only want
632 * to use the registers at this point. */
633 memset(&partition, 0, sizeof(partition));
634 partition.reg.start = REGISTERS_BASE;
635 partition.reg.size = REGISTERS_DOWN_SIZE;
636 wl1271_set_partition(wl, &partition);
638 /* ELP module wake up */
639 wl1271_fw_wakeup(wl);
641 /* whal_FwCtrl_BootSm() */
643 /* 0. read chip id from CHIP_ID */
644 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
646 /* 1. check if chip id is valid */
648 switch (wl->chip.id) {
649 case CHIP_ID_1271_PG10:
650 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
653 ret = wl1271_setup(wl);
657 case CHIP_ID_1271_PG20:
658 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
661 ret = wl1271_setup(wl);
666 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
671 if (wl->fw == NULL) {
672 ret = wl1271_fetch_firmware(wl);
677 /* No NVS from netlink, try to get it from the filesystem */
678 if (wl->nvs == NULL) {
679 ret = wl1271_fetch_nvs(wl);
688 int wl1271_plt_start(struct wl1271 *wl)
690 int retries = WL1271_BOOT_RETRIES;
693 mutex_lock(&wl->mutex);
695 wl1271_notice("power up");
697 if (wl->state != WL1271_STATE_OFF) {
698 wl1271_error("cannot go into PLT state because not "
699 "in off state: %d", wl->state);
706 ret = wl1271_chip_wakeup(wl);
710 ret = wl1271_boot(wl);
714 ret = wl1271_plt_init(wl);
718 wl->state = WL1271_STATE_PLT;
719 wl1271_notice("firmware booted in PLT mode (%s)",
724 wl1271_disable_interrupts(wl);
725 mutex_unlock(&wl->mutex);
726 /* Unlocking the mutex in the middle of handling is
727 inherently unsafe. In this case we deem it safe to do,
728 because we need to let any possibly pending IRQ out of
729 the system (and while we are WL1271_STATE_OFF the IRQ
730 work function will not do anything.) Also, any other
731 possible concurrent operations will fail due to the
732 current state, hence the wl1271 struct should be safe. */
733 cancel_work_sync(&wl->irq_work);
734 mutex_lock(&wl->mutex);
736 wl1271_power_off(wl);
739 wl1271_error("firmware boot in PLT mode failed despite %d retries",
740 WL1271_BOOT_RETRIES);
742 mutex_unlock(&wl->mutex);
747 int wl1271_plt_stop(struct wl1271 *wl)
751 mutex_lock(&wl->mutex);
753 wl1271_notice("power down");
755 if (wl->state != WL1271_STATE_PLT) {
756 wl1271_error("cannot power down because not in PLT "
757 "state: %d", wl->state);
762 wl1271_disable_interrupts(wl);
763 wl1271_power_off(wl);
765 wl->state = WL1271_STATE_OFF;
769 mutex_unlock(&wl->mutex);
775 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
777 struct wl1271 *wl = hw->priv;
778 struct ieee80211_conf *conf = &hw->conf;
779 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
780 struct ieee80211_sta *sta = txinfo->control.sta;
783 /* peek into the rates configured in the STA entry */
784 spin_lock_irqsave(&wl->wl_lock, flags);
785 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
786 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
787 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
789 spin_unlock_irqrestore(&wl->wl_lock, flags);
791 /* queue the packet */
792 skb_queue_tail(&wl->tx_queue, skb);
795 * The chip specific setup must run before the first TX packet -
796 * before that, the tx_work will not be initialized!
799 ieee80211_queue_work(wl->hw, &wl->tx_work);
802 * The workqueue is slow to process the tx_queue and we need stop
803 * the queue here, otherwise the queue will get too long.
805 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
806 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
808 spin_lock_irqsave(&wl->wl_lock, flags);
809 ieee80211_stop_queues(wl->hw);
810 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
811 spin_unlock_irqrestore(&wl->wl_lock, flags);
817 static int wl1271_op_start(struct ieee80211_hw *hw)
819 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
822 * We have to delay the booting of the hardware because
823 * we need to know the local MAC address before downloading and
824 * initializing the firmware. The MAC address cannot be changed
825 * after boot, and without the proper MAC address, the firmware
826 * will not function properly.
828 * The MAC address is first known when the corresponding interface
829 * is added. That is where we will initialize the hardware.
835 static void wl1271_op_stop(struct ieee80211_hw *hw)
837 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
840 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
841 struct ieee80211_vif *vif)
843 struct wl1271 *wl = hw->priv;
844 struct wiphy *wiphy = hw->wiphy;
845 int retries = WL1271_BOOT_RETRIES;
848 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
849 vif->type, vif->addr);
851 mutex_lock(&wl->mutex);
860 case NL80211_IFTYPE_STATION:
861 wl->bss_type = BSS_TYPE_STA_BSS;
862 wl->set_bss_type = BSS_TYPE_STA_BSS;
864 case NL80211_IFTYPE_ADHOC:
865 wl->bss_type = BSS_TYPE_IBSS;
866 wl->set_bss_type = BSS_TYPE_STA_BSS;
873 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
875 if (wl->state != WL1271_STATE_OFF) {
876 wl1271_error("cannot start because not in off state: %d",
884 ret = wl1271_chip_wakeup(wl);
888 ret = wl1271_boot(wl);
892 ret = wl1271_hw_init(wl);
896 wl->state = WL1271_STATE_ON;
897 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
899 /* update hw/fw version info in wiphy struct */
900 wiphy->hw_version = wl->chip.id;
901 strncpy(wiphy->fw_version, wl->chip.fw_ver,
902 sizeof(wiphy->fw_version));
907 wl1271_disable_interrupts(wl);
908 mutex_unlock(&wl->mutex);
909 /* Unlocking the mutex in the middle of handling is
910 inherently unsafe. In this case we deem it safe to do,
911 because we need to let any possibly pending IRQ out of
912 the system (and while we are WL1271_STATE_OFF the IRQ
913 work function will not do anything.) Also, any other
914 possible concurrent operations will fail due to the
915 current state, hence the wl1271 struct should be safe. */
916 cancel_work_sync(&wl->irq_work);
917 mutex_lock(&wl->mutex);
919 wl1271_power_off(wl);
922 wl1271_error("firmware boot failed despite %d retries",
923 WL1271_BOOT_RETRIES);
925 mutex_unlock(&wl->mutex);
928 list_add(&wl->list, &wl_list);
933 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
934 struct ieee80211_vif *vif)
936 struct wl1271 *wl = hw->priv;
939 mutex_lock(&wl->mutex);
940 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
946 WARN_ON(wl->state != WL1271_STATE_ON);
948 /* enable dyn ps just in case (if left on due to fw crash etc) */
949 if (wl->bss_type == BSS_TYPE_STA_BSS)
950 ieee80211_enable_dyn_ps(wl->vif);
952 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
953 ieee80211_scan_completed(wl->hw, true);
954 wl->scan.state = WL1271_SCAN_STATE_IDLE;
955 kfree(wl->scan.scanned_ch);
956 wl->scan.scanned_ch = NULL;
959 wl->state = WL1271_STATE_OFF;
961 wl1271_disable_interrupts(wl);
963 mutex_unlock(&wl->mutex);
965 cancel_work_sync(&wl->irq_work);
966 cancel_work_sync(&wl->tx_work);
967 cancel_delayed_work_sync(&wl->pspoll_work);
969 mutex_lock(&wl->mutex);
971 /* let's notify MAC80211 about the remaining pending TX frames */
973 wl1271_power_off(wl);
975 memset(wl->bssid, 0, ETH_ALEN);
976 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
978 wl->bss_type = MAX_BSS_TYPE;
979 wl->set_bss_type = MAX_BSS_TYPE;
980 wl->band = IEEE80211_BAND_2GHZ;
983 wl->psm_entry_retry = 0;
984 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
985 wl->tx_blocks_available = 0;
986 wl->tx_results_count = 0;
987 wl->tx_packets_count = 0;
988 wl->tx_security_last_seq = 0;
989 wl->tx_security_seq = 0;
991 wl->session_counter = 0;
992 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
993 wl->sta_rate_set = 0;
998 for (i = 0; i < NUM_TX_QUEUES; i++)
999 wl->tx_blocks_freed[i] = 0;
1001 wl1271_debugfs_reset(wl);
1003 kfree(wl->fw_status);
1004 wl->fw_status = NULL;
1005 kfree(wl->tx_res_if);
1006 wl->tx_res_if = NULL;
1007 kfree(wl->target_mem_map);
1008 wl->target_mem_map = NULL;
1010 mutex_unlock(&wl->mutex);
1013 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1015 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1016 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1018 /* combine requested filters with current filter config */
1019 filters = wl->filters | filters;
1021 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1023 if (filters & FIF_PROMISC_IN_BSS) {
1024 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1025 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1026 wl->rx_config |= CFG_BSSID_FILTER_EN;
1028 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1029 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1030 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1031 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1033 if (filters & FIF_OTHER_BSS) {
1034 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1035 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1037 if (filters & FIF_CONTROL) {
1038 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1039 wl->rx_filter |= CFG_RX_CTL_EN;
1041 if (filters & FIF_FCSFAIL) {
1042 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1043 wl->rx_filter |= CFG_RX_FCS_ERROR;
1047 static int wl1271_dummy_join(struct wl1271 *wl)
1050 /* we need to use a dummy BSSID for now */
1051 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1054 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1056 /* pass through frames from all BSS */
1057 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1059 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1063 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1069 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1074 * One of the side effects of the JOIN command is that is clears
1075 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1076 * to a WPA/WPA2 access point will therefore kill the data-path.
1077 * Currently there is no supported scenario for JOIN during
1078 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1079 * must be handled somehow.
1082 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1083 wl1271_info("JOIN while associated.");
1086 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1088 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1092 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1094 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1098 * The join command disable the keep-alive mode, shut down its process,
1099 * and also clear the template config, so we need to reset it all after
1100 * the join. The acx_aid starts the keep-alive process, and the order
1101 * of the commands below is relevant.
1103 ret = wl1271_acx_keep_alive_mode(wl, true);
1107 ret = wl1271_acx_aid(wl, wl->aid);
1111 ret = wl1271_cmd_build_klv_null_data(wl);
1115 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1116 ACX_KEEP_ALIVE_TPL_VALID);
1124 static int wl1271_unjoin(struct wl1271 *wl)
1128 /* to stop listening to a channel, we disconnect */
1129 ret = wl1271_cmd_disconnect(wl);
1133 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1134 memset(wl->bssid, 0, ETH_ALEN);
1136 /* stop filterting packets based on bssid */
1137 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1143 static void wl1271_set_band_rate(struct wl1271 *wl)
1145 if (wl->band == IEEE80211_BAND_2GHZ)
1146 wl->basic_rate_set = wl->conf.tx.basic_rate;
1148 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1151 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1156 if (!wl->basic_rate_set) {
1158 wl->basic_rate_set = wl->conf.tx.basic_rate;
1161 for (i = 0; !rate; i++) {
1162 if ((wl->basic_rate_set >> i) & 0x1)
1169 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1174 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1175 ret = wl1271_unjoin(wl);
1179 wl->rate_set = wl1271_min_rate_get(wl);
1180 wl->sta_rate_set = 0;
1181 ret = wl1271_acx_rate_policies(wl);
1184 ret = wl1271_acx_keep_alive_config(
1185 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1186 ACX_KEEP_ALIVE_TPL_INVALID);
1189 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1191 /* increment the session counter */
1192 wl->session_counter++;
1193 if (wl->session_counter >= SESSION_COUNTER_MAX)
1194 wl->session_counter = 0;
1195 ret = wl1271_dummy_join(wl);
1198 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1205 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1207 struct wl1271 *wl = hw->priv;
1208 struct ieee80211_conf *conf = &hw->conf;
1209 int channel, ret = 0;
1211 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1213 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1215 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1217 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1220 * mac80211 will go to idle nearly immediately after transmitting some
1221 * frames, such as the deauth. To make sure those frames reach the air,
1222 * wait here until the TX queue is fully flushed.
1224 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1225 (conf->flags & IEEE80211_CONF_IDLE))
1226 wl1271_tx_flush(wl);
1228 mutex_lock(&wl->mutex);
1230 if (unlikely(wl->state == WL1271_STATE_OFF))
1233 ret = wl1271_ps_elp_wakeup(wl, false);
1237 /* if the channel changes while joined, join again */
1238 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1239 ((wl->band != conf->channel->band) ||
1240 (wl->channel != channel))) {
1241 wl->band = conf->channel->band;
1242 wl->channel = channel;
1245 * FIXME: the mac80211 should really provide a fixed rate
1246 * to use here. for now, just use the smallest possible rate
1247 * for the band as a fixed rate for association frames and
1248 * other control messages.
1250 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1251 wl1271_set_band_rate(wl);
1253 wl->basic_rate = wl1271_min_rate_get(wl);
1254 ret = wl1271_acx_rate_policies(wl);
1256 wl1271_warning("rate policy for update channel "
1259 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1260 ret = wl1271_join(wl, false);
1262 wl1271_warning("cmd join to update channel "
1267 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1268 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1270 wl1271_warning("idle mode change failed %d", ret);
1274 * if mac80211 changes the PSM mode, make sure the mode is not
1275 * incorrectly changed after the pspoll failure active window.
1277 if (changed & IEEE80211_CONF_CHANGE_PS)
1278 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1280 if (conf->flags & IEEE80211_CONF_PS &&
1281 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1282 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1285 * We enter PSM only if we're already associated.
1286 * If we're not, we'll enter it when joining an SSID,
1287 * through the bss_info_changed() hook.
1289 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1290 wl1271_debug(DEBUG_PSM, "psm enabled");
1291 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1294 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1295 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1296 wl1271_debug(DEBUG_PSM, "psm disabled");
1298 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1300 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1301 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1305 if (conf->power_level != wl->power_level) {
1306 ret = wl1271_acx_tx_power(wl, conf->power_level);
1310 wl->power_level = conf->power_level;
1314 wl1271_ps_elp_sleep(wl);
1317 mutex_unlock(&wl->mutex);
1322 struct wl1271_filter_params {
1325 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1328 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1329 struct netdev_hw_addr_list *mc_list)
1331 struct wl1271_filter_params *fp;
1332 struct netdev_hw_addr *ha;
1333 struct wl1271 *wl = hw->priv;
1335 if (unlikely(wl->state == WL1271_STATE_OFF))
1338 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1340 wl1271_error("Out of memory setting filters.");
1344 /* update multicast filtering parameters */
1345 fp->mc_list_length = 0;
1346 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1347 fp->enabled = false;
1350 netdev_hw_addr_list_for_each(ha, mc_list) {
1351 memcpy(fp->mc_list[fp->mc_list_length],
1352 ha->addr, ETH_ALEN);
1353 fp->mc_list_length++;
1357 return (u64)(unsigned long)fp;
1360 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1363 FIF_BCN_PRBRESP_PROMISC | \
1367 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1368 unsigned int changed,
1369 unsigned int *total, u64 multicast)
1371 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1372 struct wl1271 *wl = hw->priv;
1375 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1377 mutex_lock(&wl->mutex);
1379 *total &= WL1271_SUPPORTED_FILTERS;
1380 changed &= WL1271_SUPPORTED_FILTERS;
1382 if (unlikely(wl->state == WL1271_STATE_OFF))
1385 ret = wl1271_ps_elp_wakeup(wl, false);
1390 if (*total & FIF_ALLMULTI)
1391 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1393 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1395 fp->mc_list_length);
1399 /* determine, whether supported filter values have changed */
1403 /* configure filters */
1404 wl->filters = *total;
1405 wl1271_configure_filters(wl, 0);
1407 /* apply configured filters */
1408 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1413 wl1271_ps_elp_sleep(wl);
1416 mutex_unlock(&wl->mutex);
1420 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1421 struct ieee80211_vif *vif,
1422 struct ieee80211_sta *sta,
1423 struct ieee80211_key_conf *key_conf)
1425 struct wl1271 *wl = hw->priv;
1432 static const u8 bcast_addr[ETH_ALEN] =
1433 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1435 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1437 addr = sta ? sta->addr : bcast_addr;
1439 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1440 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1441 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1442 key_conf->cipher, key_conf->keyidx,
1443 key_conf->keylen, key_conf->flags);
1444 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1446 if (is_zero_ether_addr(addr)) {
1447 /* We dont support TX only encryption */
1452 mutex_lock(&wl->mutex);
1454 ret = wl1271_ps_elp_wakeup(wl, false);
1458 switch (key_conf->cipher) {
1459 case WLAN_CIPHER_SUITE_WEP40:
1460 case WLAN_CIPHER_SUITE_WEP104:
1463 key_conf->hw_key_idx = key_conf->keyidx;
1465 case WLAN_CIPHER_SUITE_TKIP:
1466 key_type = KEY_TKIP;
1468 key_conf->hw_key_idx = key_conf->keyidx;
1469 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1470 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1472 case WLAN_CIPHER_SUITE_CCMP:
1475 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1476 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1477 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1480 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1488 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1489 key_conf->keyidx, key_type,
1490 key_conf->keylen, key_conf->key,
1491 addr, tx_seq_32, tx_seq_16);
1493 wl1271_error("Could not add or replace key");
1497 /* the default WEP key needs to be configured at least once */
1498 if (key_type == KEY_WEP) {
1499 ret = wl1271_cmd_set_default_wep_key(wl,
1507 /* The wl1271 does not allow to remove unicast keys - they
1508 will be cleared automatically on next CMD_JOIN. Ignore the
1509 request silently, as we dont want the mac80211 to emit
1510 an error message. */
1511 if (!is_broadcast_ether_addr(addr))
1514 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1515 key_conf->keyidx, key_type,
1516 key_conf->keylen, key_conf->key,
1519 wl1271_error("Could not remove key");
1525 wl1271_error("Unsupported key cmd 0x%x", cmd);
1531 wl1271_ps_elp_sleep(wl);
1534 mutex_unlock(&wl->mutex);
1540 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1541 struct ieee80211_vif *vif,
1542 struct cfg80211_scan_request *req)
1544 struct wl1271 *wl = hw->priv;
1549 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1552 ssid = req->ssids[0].ssid;
1553 len = req->ssids[0].ssid_len;
1556 mutex_lock(&wl->mutex);
1558 ret = wl1271_ps_elp_wakeup(wl, false);
1562 if (wl1271_11a_enabled())
1563 ret = wl1271_scan(hw->priv, ssid, len, req);
1565 ret = wl1271_scan(hw->priv, ssid, len, req);
1567 wl1271_ps_elp_sleep(wl);
1570 mutex_unlock(&wl->mutex);
1575 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1577 struct wl1271 *wl = hw->priv;
1580 mutex_lock(&wl->mutex);
1582 if (unlikely(wl->state == WL1271_STATE_OFF))
1585 ret = wl1271_ps_elp_wakeup(wl, false);
1589 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1591 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1593 wl1271_ps_elp_sleep(wl);
1596 mutex_unlock(&wl->mutex);
1601 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1603 u8 *ptr = beacon->data +
1604 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1606 /* find the location of the ssid in the beacon */
1607 while (ptr < beacon->data + beacon->len) {
1608 if (ptr[0] == WLAN_EID_SSID) {
1609 wl->ssid_len = ptr[1];
1610 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1615 wl1271_error("ad-hoc beacon template has no SSID!\n");
1618 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1619 struct ieee80211_vif *vif,
1620 struct ieee80211_bss_conf *bss_conf,
1623 enum wl1271_cmd_ps_mode mode;
1624 struct wl1271 *wl = hw->priv;
1625 bool do_join = false;
1626 bool set_assoc = false;
1629 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1631 mutex_lock(&wl->mutex);
1633 ret = wl1271_ps_elp_wakeup(wl, false);
1637 if ((changed & BSS_CHANGED_BEACON_INT) &&
1638 (wl->bss_type == BSS_TYPE_IBSS)) {
1639 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1640 bss_conf->beacon_int);
1642 wl->beacon_int = bss_conf->beacon_int;
1646 if ((changed & BSS_CHANGED_BEACON) &&
1647 (wl->bss_type == BSS_TYPE_IBSS)) {
1648 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1650 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1653 struct ieee80211_hdr *hdr;
1655 wl1271_ssid_set(wl, beacon);
1656 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1659 wl1271_min_rate_get(wl));
1662 dev_kfree_skb(beacon);
1666 hdr = (struct ieee80211_hdr *) beacon->data;
1667 hdr->frame_control = cpu_to_le16(
1668 IEEE80211_FTYPE_MGMT |
1669 IEEE80211_STYPE_PROBE_RESP);
1671 ret = wl1271_cmd_template_set(wl,
1672 CMD_TEMPL_PROBE_RESPONSE,
1675 wl1271_min_rate_get(wl));
1676 dev_kfree_skb(beacon);
1680 /* Need to update the SSID (for filtering etc) */
1685 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1686 (wl->bss_type == BSS_TYPE_IBSS)) {
1687 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1688 bss_conf->enable_beacon ? "enabled" : "disabled");
1690 if (bss_conf->enable_beacon)
1691 wl->set_bss_type = BSS_TYPE_IBSS;
1693 wl->set_bss_type = BSS_TYPE_STA_BSS;
1697 if (changed & BSS_CHANGED_CQM) {
1698 bool enable = false;
1699 if (bss_conf->cqm_rssi_thold)
1701 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1702 bss_conf->cqm_rssi_thold,
1703 bss_conf->cqm_rssi_hyst);
1706 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1709 if ((changed & BSS_CHANGED_BSSID) &&
1711 * Now we know the correct bssid, so we send a new join command
1712 * and enable the BSSID filter
1714 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1715 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1717 ret = wl1271_cmd_build_null_data(wl);
1721 ret = wl1271_build_qos_null_data(wl);
1725 /* filter out all packets not from this BSSID */
1726 wl1271_configure_filters(wl, 0);
1728 /* Need to update the BSSID (for filtering etc) */
1732 if (changed & BSS_CHANGED_ASSOC) {
1733 if (bss_conf->assoc) {
1735 wl->aid = bss_conf->aid;
1738 wl->ps_poll_failures = 0;
1741 * use basic rates from AP, and determine lowest rate
1742 * to use with control frames.
1744 rates = bss_conf->basic_rates;
1745 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1747 wl->basic_rate = wl1271_min_rate_get(wl);
1748 ret = wl1271_acx_rate_policies(wl);
1753 * with wl1271, we don't need to update the
1754 * beacon_int and dtim_period, because the firmware
1755 * updates it by itself when the first beacon is
1756 * received after a join.
1758 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1763 * The SSID is intentionally set to NULL here - the
1764 * firmware will set the probe request with a
1765 * broadcast SSID regardless of what we set in the
1768 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1771 /* enable the connection monitoring feature */
1772 ret = wl1271_acx_conn_monit_params(wl, true);
1776 /* If we want to go in PSM but we're not there yet */
1777 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1778 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1779 mode = STATION_POWER_SAVE_MODE;
1780 ret = wl1271_ps_set_mode(wl, mode, true);
1785 /* use defaults when not associated */
1786 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1789 /* re-enable dynamic ps - just in case */
1790 ieee80211_enable_dyn_ps(wl->vif);
1792 /* revert back to minimum rates for the current band */
1793 wl1271_set_band_rate(wl);
1794 wl->basic_rate = wl1271_min_rate_get(wl);
1795 ret = wl1271_acx_rate_policies(wl);
1799 /* disable connection monitor features */
1800 ret = wl1271_acx_conn_monit_params(wl, false);
1802 /* Disable the keep-alive feature */
1803 ret = wl1271_acx_keep_alive_mode(wl, false);
1811 if (changed & BSS_CHANGED_ERP_SLOT) {
1812 if (bss_conf->use_short_slot)
1813 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1815 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1817 wl1271_warning("Set slot time failed %d", ret);
1822 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1823 if (bss_conf->use_short_preamble)
1824 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1826 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1829 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1830 if (bss_conf->use_cts_prot)
1831 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1833 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1835 wl1271_warning("Set ctsprotect failed %d", ret);
1840 if (changed & BSS_CHANGED_ARP_FILTER) {
1841 __be32 addr = bss_conf->arp_addr_list[0];
1842 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1844 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1845 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1847 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1854 ret = wl1271_join(wl, set_assoc);
1856 wl1271_warning("cmd join failed %d", ret);
1862 wl1271_ps_elp_sleep(wl);
1865 mutex_unlock(&wl->mutex);
1868 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1869 const struct ieee80211_tx_queue_params *params)
1871 struct wl1271 *wl = hw->priv;
1875 mutex_lock(&wl->mutex);
1877 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1879 ret = wl1271_ps_elp_wakeup(wl, false);
1883 /* the txop is confed in units of 32us by the mac80211, we need us */
1884 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1885 params->cw_min, params->cw_max,
1886 params->aifs, params->txop << 5);
1891 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1893 ps_scheme = CONF_PS_SCHEME_LEGACY;
1895 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1896 CONF_CHANNEL_TYPE_EDCF,
1897 wl1271_tx_get_queue(queue),
1898 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1903 wl1271_ps_elp_sleep(wl);
1906 mutex_unlock(&wl->mutex);
1911 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1914 struct wl1271 *wl = hw->priv;
1915 u64 mactime = ULLONG_MAX;
1918 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1920 mutex_lock(&wl->mutex);
1922 ret = wl1271_ps_elp_wakeup(wl, false);
1926 ret = wl1271_acx_tsf_info(wl, &mactime);
1931 wl1271_ps_elp_sleep(wl);
1934 mutex_unlock(&wl->mutex);
1938 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1939 struct survey_info *survey)
1941 struct wl1271 *wl = hw->priv;
1942 struct ieee80211_conf *conf = &hw->conf;
1947 survey->channel = conf->channel;
1948 survey->filled = SURVEY_INFO_NOISE_DBM;
1949 survey->noise = wl->noise;
1954 /* can't be const, mac80211 writes to this */
1955 static struct ieee80211_rate wl1271_rates[] = {
1957 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1958 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1960 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1961 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1962 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1964 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1965 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1966 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1968 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1969 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1970 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1972 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1973 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1975 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1976 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1978 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1979 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1981 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1982 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1984 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1985 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1987 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1988 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1990 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1991 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1993 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1994 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1997 /* can't be const, mac80211 writes to this */
1998 static struct ieee80211_channel wl1271_channels[] = {
1999 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2000 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2001 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2002 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2003 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2004 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2005 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2006 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2007 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2008 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2009 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2010 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2011 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2014 /* mapping to indexes for wl1271_rates */
2015 static const u8 wl1271_rate_to_idx_2ghz[] = {
2016 /* MCS rates are used only with 11n */
2017 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2018 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2019 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2020 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2021 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2022 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2023 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2024 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2026 11, /* CONF_HW_RXTX_RATE_54 */
2027 10, /* CONF_HW_RXTX_RATE_48 */
2028 9, /* CONF_HW_RXTX_RATE_36 */
2029 8, /* CONF_HW_RXTX_RATE_24 */
2031 /* TI-specific rate */
2032 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2034 7, /* CONF_HW_RXTX_RATE_18 */
2035 6, /* CONF_HW_RXTX_RATE_12 */
2036 3, /* CONF_HW_RXTX_RATE_11 */
2037 5, /* CONF_HW_RXTX_RATE_9 */
2038 4, /* CONF_HW_RXTX_RATE_6 */
2039 2, /* CONF_HW_RXTX_RATE_5_5 */
2040 1, /* CONF_HW_RXTX_RATE_2 */
2041 0 /* CONF_HW_RXTX_RATE_1 */
2044 /* can't be const, mac80211 writes to this */
2045 static struct ieee80211_supported_band wl1271_band_2ghz = {
2046 .channels = wl1271_channels,
2047 .n_channels = ARRAY_SIZE(wl1271_channels),
2048 .bitrates = wl1271_rates,
2049 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2052 /* 5 GHz data rates for WL1273 */
2053 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2055 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2056 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2058 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2059 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2061 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2062 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2064 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2065 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2067 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2068 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2070 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2071 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2073 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2074 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2076 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2077 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2080 /* 5 GHz band channels for WL1273 */
2081 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2082 { .hw_value = 183, .center_freq = 4915},
2083 { .hw_value = 184, .center_freq = 4920},
2084 { .hw_value = 185, .center_freq = 4925},
2085 { .hw_value = 187, .center_freq = 4935},
2086 { .hw_value = 188, .center_freq = 4940},
2087 { .hw_value = 189, .center_freq = 4945},
2088 { .hw_value = 192, .center_freq = 4960},
2089 { .hw_value = 196, .center_freq = 4980},
2090 { .hw_value = 7, .center_freq = 5035},
2091 { .hw_value = 8, .center_freq = 5040},
2092 { .hw_value = 9, .center_freq = 5045},
2093 { .hw_value = 11, .center_freq = 5055},
2094 { .hw_value = 12, .center_freq = 5060},
2095 { .hw_value = 16, .center_freq = 5080},
2096 { .hw_value = 34, .center_freq = 5170},
2097 { .hw_value = 36, .center_freq = 5180},
2098 { .hw_value = 38, .center_freq = 5190},
2099 { .hw_value = 40, .center_freq = 5200},
2100 { .hw_value = 42, .center_freq = 5210},
2101 { .hw_value = 44, .center_freq = 5220},
2102 { .hw_value = 46, .center_freq = 5230},
2103 { .hw_value = 48, .center_freq = 5240},
2104 { .hw_value = 52, .center_freq = 5260},
2105 { .hw_value = 56, .center_freq = 5280},
2106 { .hw_value = 60, .center_freq = 5300},
2107 { .hw_value = 64, .center_freq = 5320},
2108 { .hw_value = 100, .center_freq = 5500},
2109 { .hw_value = 104, .center_freq = 5520},
2110 { .hw_value = 108, .center_freq = 5540},
2111 { .hw_value = 112, .center_freq = 5560},
2112 { .hw_value = 116, .center_freq = 5580},
2113 { .hw_value = 120, .center_freq = 5600},
2114 { .hw_value = 124, .center_freq = 5620},
2115 { .hw_value = 128, .center_freq = 5640},
2116 { .hw_value = 132, .center_freq = 5660},
2117 { .hw_value = 136, .center_freq = 5680},
2118 { .hw_value = 140, .center_freq = 5700},
2119 { .hw_value = 149, .center_freq = 5745},
2120 { .hw_value = 153, .center_freq = 5765},
2121 { .hw_value = 157, .center_freq = 5785},
2122 { .hw_value = 161, .center_freq = 5805},
2123 { .hw_value = 165, .center_freq = 5825},
2126 /* mapping to indexes for wl1271_rates_5ghz */
2127 static const u8 wl1271_rate_to_idx_5ghz[] = {
2128 /* MCS rates are used only with 11n */
2129 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2130 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2131 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2132 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2133 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2134 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2135 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2136 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2138 7, /* CONF_HW_RXTX_RATE_54 */
2139 6, /* CONF_HW_RXTX_RATE_48 */
2140 5, /* CONF_HW_RXTX_RATE_36 */
2141 4, /* CONF_HW_RXTX_RATE_24 */
2143 /* TI-specific rate */
2144 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2146 3, /* CONF_HW_RXTX_RATE_18 */
2147 2, /* CONF_HW_RXTX_RATE_12 */
2148 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2149 1, /* CONF_HW_RXTX_RATE_9 */
2150 0, /* CONF_HW_RXTX_RATE_6 */
2151 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2152 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2153 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2156 static struct ieee80211_supported_band wl1271_band_5ghz = {
2157 .channels = wl1271_channels_5ghz,
2158 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2159 .bitrates = wl1271_rates_5ghz,
2160 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2163 static const u8 *wl1271_band_rate_to_idx[] = {
2164 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2165 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2168 static const struct ieee80211_ops wl1271_ops = {
2169 .start = wl1271_op_start,
2170 .stop = wl1271_op_stop,
2171 .add_interface = wl1271_op_add_interface,
2172 .remove_interface = wl1271_op_remove_interface,
2173 .config = wl1271_op_config,
2174 .prepare_multicast = wl1271_op_prepare_multicast,
2175 .configure_filter = wl1271_op_configure_filter,
2177 .set_key = wl1271_op_set_key,
2178 .hw_scan = wl1271_op_hw_scan,
2179 .bss_info_changed = wl1271_op_bss_info_changed,
2180 .set_rts_threshold = wl1271_op_set_rts_threshold,
2181 .conf_tx = wl1271_op_conf_tx,
2182 .get_tsf = wl1271_op_get_tsf,
2183 .get_survey = wl1271_op_get_survey,
2184 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2188 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2192 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2194 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2195 wl1271_error("Illegal RX rate from HW: %d", rate);
2199 idx = wl1271_band_rate_to_idx[wl->band][rate];
2200 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2201 wl1271_error("Unsupported RX rate from HW: %d", rate);
2208 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2209 struct device_attribute *attr,
2212 struct wl1271 *wl = dev_get_drvdata(dev);
2215 /* FIXME: what's the maximum length of buf? page size?*/
2218 mutex_lock(&wl->mutex);
2219 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2221 mutex_unlock(&wl->mutex);
2227 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2228 struct device_attribute *attr,
2229 const char *buf, size_t count)
2231 struct wl1271 *wl = dev_get_drvdata(dev);
2235 ret = strict_strtoul(buf, 10, &res);
2238 wl1271_warning("incorrect value written to bt_coex_mode");
2242 mutex_lock(&wl->mutex);
2246 if (res == wl->sg_enabled)
2249 wl->sg_enabled = res;
2251 if (wl->state == WL1271_STATE_OFF)
2254 ret = wl1271_ps_elp_wakeup(wl, false);
2258 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2259 wl1271_ps_elp_sleep(wl);
2262 mutex_unlock(&wl->mutex);
2266 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2267 wl1271_sysfs_show_bt_coex_state,
2268 wl1271_sysfs_store_bt_coex_state);
2270 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2271 struct device_attribute *attr,
2274 struct wl1271 *wl = dev_get_drvdata(dev);
2277 /* FIXME: what's the maximum length of buf? page size?*/
2280 mutex_lock(&wl->mutex);
2281 if (wl->hw_pg_ver >= 0)
2282 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2284 len = snprintf(buf, len, "n/a\n");
2285 mutex_unlock(&wl->mutex);
2290 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2291 wl1271_sysfs_show_hw_pg_ver, NULL);
2293 int wl1271_register_hw(struct wl1271 *wl)
2297 if (wl->mac80211_registered)
2300 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2302 ret = ieee80211_register_hw(wl->hw);
2304 wl1271_error("unable to register mac80211 hw: %d", ret);
2308 wl->mac80211_registered = true;
2310 wl1271_notice("loaded");
2314 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2316 void wl1271_unregister_hw(struct wl1271 *wl)
2318 ieee80211_unregister_hw(wl->hw);
2319 wl->mac80211_registered = false;
2322 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2324 int wl1271_init_ieee80211(struct wl1271 *wl)
2326 /* The tx descriptor buffer and the TKIP space. */
2327 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2328 sizeof(struct wl1271_tx_hw_descr);
2331 /* FIXME: find a proper value */
2332 wl->hw->channel_change_time = 10000;
2333 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2335 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2336 IEEE80211_HW_BEACON_FILTER |
2337 IEEE80211_HW_SUPPORTS_PS |
2338 IEEE80211_HW_SUPPORTS_UAPSD |
2339 IEEE80211_HW_HAS_RATE_CONTROL |
2340 IEEE80211_HW_CONNECTION_MONITOR |
2341 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2343 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2344 BIT(NL80211_IFTYPE_ADHOC);
2345 wl->hw->wiphy->max_scan_ssids = 1;
2346 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2348 if (wl1271_11a_enabled())
2349 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2352 wl->hw->max_rates = 1;
2354 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2358 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2360 #define WL1271_DEFAULT_CHANNEL 0
2362 struct ieee80211_hw *wl1271_alloc_hw(void)
2364 struct ieee80211_hw *hw;
2365 struct platform_device *plat_dev = NULL;
2369 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2371 wl1271_error("could not alloc ieee80211_hw");
2376 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2378 wl1271_error("could not allocate platform_device");
2380 goto err_plat_alloc;
2384 memset(wl, 0, sizeof(*wl));
2386 INIT_LIST_HEAD(&wl->list);
2389 wl->plat_dev = plat_dev;
2391 skb_queue_head_init(&wl->tx_queue);
2393 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2394 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2395 wl->channel = WL1271_DEFAULT_CHANNEL;
2396 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2397 wl->default_key = 0;
2399 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2400 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2401 wl->psm_entry_retry = 0;
2402 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2403 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2404 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2405 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2406 wl->sta_rate_set = 0;
2407 wl->band = IEEE80211_BAND_2GHZ;
2410 wl->sg_enabled = true;
2413 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2414 wl->tx_frames[i] = NULL;
2416 spin_lock_init(&wl->wl_lock);
2418 wl->state = WL1271_STATE_OFF;
2419 mutex_init(&wl->mutex);
2421 /* Apply default driver configuration. */
2422 wl1271_conf_init(wl);
2424 wl1271_debugfs_init(wl);
2426 /* Register platform device */
2427 ret = platform_device_register(wl->plat_dev);
2429 wl1271_error("couldn't register platform device");
2432 dev_set_drvdata(&wl->plat_dev->dev, wl);
2434 /* Create sysfs file to control bt coex state */
2435 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2437 wl1271_error("failed to create sysfs file bt_coex_state");
2441 /* Create sysfs file to get HW PG version */
2442 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2444 wl1271_error("failed to create sysfs file hw_pg_ver");
2445 goto err_bt_coex_state;
2451 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2454 platform_device_unregister(wl->plat_dev);
2457 wl1271_debugfs_exit(wl);
2461 ieee80211_free_hw(hw);
2465 return ERR_PTR(ret);
2467 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2469 int wl1271_free_hw(struct wl1271 *wl)
2471 platform_device_unregister(wl->plat_dev);
2472 kfree(wl->plat_dev);
2474 wl1271_debugfs_exit(wl);
2481 kfree(wl->fw_status);
2482 kfree(wl->tx_res_if);
2484 ieee80211_free_hw(wl->hw);
2488 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2490 MODULE_LICENSE("GPL");
2491 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2492 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");