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);
625 msleep(WL1271_POWER_ON_SLEEP);
629 /* We don't need a real memory partition here, because we only want
630 * to use the registers at this point. */
631 memset(&partition, 0, sizeof(partition));
632 partition.reg.start = REGISTERS_BASE;
633 partition.reg.size = REGISTERS_DOWN_SIZE;
634 wl1271_set_partition(wl, &partition);
636 /* ELP module wake up */
637 wl1271_fw_wakeup(wl);
639 /* whal_FwCtrl_BootSm() */
641 /* 0. read chip id from CHIP_ID */
642 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
644 /* 1. check if chip id is valid */
646 switch (wl->chip.id) {
647 case CHIP_ID_1271_PG10:
648 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
651 ret = wl1271_setup(wl);
655 case CHIP_ID_1271_PG20:
656 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
659 ret = wl1271_setup(wl);
664 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
669 if (wl->fw == NULL) {
670 ret = wl1271_fetch_firmware(wl);
675 /* No NVS from netlink, try to get it from the filesystem */
676 if (wl->nvs == NULL) {
677 ret = wl1271_fetch_nvs(wl);
686 int wl1271_plt_start(struct wl1271 *wl)
688 int retries = WL1271_BOOT_RETRIES;
691 mutex_lock(&wl->mutex);
693 wl1271_notice("power up");
695 if (wl->state != WL1271_STATE_OFF) {
696 wl1271_error("cannot go into PLT state because not "
697 "in off state: %d", wl->state);
704 ret = wl1271_chip_wakeup(wl);
708 ret = wl1271_boot(wl);
712 ret = wl1271_plt_init(wl);
716 wl->state = WL1271_STATE_PLT;
717 wl1271_notice("firmware booted in PLT mode (%s)",
722 wl1271_disable_interrupts(wl);
723 mutex_unlock(&wl->mutex);
724 /* Unlocking the mutex in the middle of handling is
725 inherently unsafe. In this case we deem it safe to do,
726 because we need to let any possibly pending IRQ out of
727 the system (and while we are WL1271_STATE_OFF the IRQ
728 work function will not do anything.) Also, any other
729 possible concurrent operations will fail due to the
730 current state, hence the wl1271 struct should be safe. */
731 cancel_work_sync(&wl->irq_work);
732 mutex_lock(&wl->mutex);
734 wl1271_power_off(wl);
737 wl1271_error("firmware boot in PLT mode failed despite %d retries",
738 WL1271_BOOT_RETRIES);
740 mutex_unlock(&wl->mutex);
745 int wl1271_plt_stop(struct wl1271 *wl)
749 mutex_lock(&wl->mutex);
751 wl1271_notice("power down");
753 if (wl->state != WL1271_STATE_PLT) {
754 wl1271_error("cannot power down because not in PLT "
755 "state: %d", wl->state);
760 wl1271_disable_interrupts(wl);
761 wl1271_power_off(wl);
763 wl->state = WL1271_STATE_OFF;
767 mutex_unlock(&wl->mutex);
773 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
775 struct wl1271 *wl = hw->priv;
776 struct ieee80211_conf *conf = &hw->conf;
777 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
778 struct ieee80211_sta *sta = txinfo->control.sta;
781 /* peek into the rates configured in the STA entry */
782 spin_lock_irqsave(&wl->wl_lock, flags);
783 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
784 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
785 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
787 spin_unlock_irqrestore(&wl->wl_lock, flags);
789 /* queue the packet */
790 skb_queue_tail(&wl->tx_queue, skb);
793 * The chip specific setup must run before the first TX packet -
794 * before that, the tx_work will not be initialized!
797 ieee80211_queue_work(wl->hw, &wl->tx_work);
800 * The workqueue is slow to process the tx_queue and we need stop
801 * the queue here, otherwise the queue will get too long.
803 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
804 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
806 spin_lock_irqsave(&wl->wl_lock, flags);
807 ieee80211_stop_queues(wl->hw);
808 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
809 spin_unlock_irqrestore(&wl->wl_lock, flags);
815 static int wl1271_op_start(struct ieee80211_hw *hw)
817 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
820 * We have to delay the booting of the hardware because
821 * we need to know the local MAC address before downloading and
822 * initializing the firmware. The MAC address cannot be changed
823 * after boot, and without the proper MAC address, the firmware
824 * will not function properly.
826 * The MAC address is first known when the corresponding interface
827 * is added. That is where we will initialize the hardware.
833 static void wl1271_op_stop(struct ieee80211_hw *hw)
835 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
838 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
839 struct ieee80211_vif *vif)
841 struct wl1271 *wl = hw->priv;
842 int retries = WL1271_BOOT_RETRIES;
845 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
846 vif->type, vif->addr);
848 mutex_lock(&wl->mutex);
857 case NL80211_IFTYPE_STATION:
858 wl->bss_type = BSS_TYPE_STA_BSS;
859 wl->set_bss_type = BSS_TYPE_STA_BSS;
861 case NL80211_IFTYPE_ADHOC:
862 wl->bss_type = BSS_TYPE_IBSS;
863 wl->set_bss_type = BSS_TYPE_STA_BSS;
870 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
872 if (wl->state != WL1271_STATE_OFF) {
873 wl1271_error("cannot start because not in off state: %d",
881 ret = wl1271_chip_wakeup(wl);
885 ret = wl1271_boot(wl);
889 ret = wl1271_hw_init(wl);
893 wl->state = WL1271_STATE_ON;
894 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
898 wl1271_disable_interrupts(wl);
899 mutex_unlock(&wl->mutex);
900 /* Unlocking the mutex in the middle of handling is
901 inherently unsafe. In this case we deem it safe to do,
902 because we need to let any possibly pending IRQ out of
903 the system (and while we are WL1271_STATE_OFF the IRQ
904 work function will not do anything.) Also, any other
905 possible concurrent operations will fail due to the
906 current state, hence the wl1271 struct should be safe. */
907 cancel_work_sync(&wl->irq_work);
908 mutex_lock(&wl->mutex);
910 wl1271_power_off(wl);
913 wl1271_error("firmware boot failed despite %d retries",
914 WL1271_BOOT_RETRIES);
916 mutex_unlock(&wl->mutex);
919 list_add(&wl->list, &wl_list);
924 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
925 struct ieee80211_vif *vif)
927 struct wl1271 *wl = hw->priv;
930 mutex_lock(&wl->mutex);
931 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
937 WARN_ON(wl->state != WL1271_STATE_ON);
939 /* enable dyn ps just in case (if left on due to fw crash etc) */
940 if (wl->bss_type == BSS_TYPE_STA_BSS)
941 ieee80211_enable_dyn_ps(wl->vif);
943 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
944 mutex_unlock(&wl->mutex);
945 ieee80211_scan_completed(wl->hw, true);
946 mutex_lock(&wl->mutex);
947 wl->scan.state = WL1271_SCAN_STATE_IDLE;
948 kfree(wl->scan.scanned_ch);
949 wl->scan.scanned_ch = NULL;
952 wl->state = WL1271_STATE_OFF;
954 wl1271_disable_interrupts(wl);
956 mutex_unlock(&wl->mutex);
958 cancel_work_sync(&wl->irq_work);
959 cancel_work_sync(&wl->tx_work);
960 cancel_delayed_work_sync(&wl->pspoll_work);
962 mutex_lock(&wl->mutex);
964 /* let's notify MAC80211 about the remaining pending TX frames */
966 wl1271_power_off(wl);
968 memset(wl->bssid, 0, ETH_ALEN);
969 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
971 wl->bss_type = MAX_BSS_TYPE;
972 wl->set_bss_type = MAX_BSS_TYPE;
973 wl->band = IEEE80211_BAND_2GHZ;
976 wl->psm_entry_retry = 0;
977 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
978 wl->tx_blocks_available = 0;
979 wl->tx_results_count = 0;
980 wl->tx_packets_count = 0;
981 wl->tx_security_last_seq = 0;
982 wl->tx_security_seq = 0;
984 wl->session_counter = 0;
985 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
986 wl->sta_rate_set = 0;
991 for (i = 0; i < NUM_TX_QUEUES; i++)
992 wl->tx_blocks_freed[i] = 0;
994 wl1271_debugfs_reset(wl);
996 kfree(wl->fw_status);
997 wl->fw_status = NULL;
998 kfree(wl->tx_res_if);
999 wl->tx_res_if = NULL;
1000 kfree(wl->target_mem_map);
1001 wl->target_mem_map = NULL;
1003 mutex_unlock(&wl->mutex);
1006 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1008 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1009 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1011 /* combine requested filters with current filter config */
1012 filters = wl->filters | filters;
1014 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1016 if (filters & FIF_PROMISC_IN_BSS) {
1017 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1018 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1019 wl->rx_config |= CFG_BSSID_FILTER_EN;
1021 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1022 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1023 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1024 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1026 if (filters & FIF_OTHER_BSS) {
1027 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1028 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1030 if (filters & FIF_CONTROL) {
1031 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1032 wl->rx_filter |= CFG_RX_CTL_EN;
1034 if (filters & FIF_FCSFAIL) {
1035 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1036 wl->rx_filter |= CFG_RX_FCS_ERROR;
1040 static int wl1271_dummy_join(struct wl1271 *wl)
1043 /* we need to use a dummy BSSID for now */
1044 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1047 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1049 /* pass through frames from all BSS */
1050 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1052 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1056 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1062 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1067 * One of the side effects of the JOIN command is that is clears
1068 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1069 * to a WPA/WPA2 access point will therefore kill the data-path.
1070 * Currently there is no supported scenario for JOIN during
1071 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1072 * must be handled somehow.
1075 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1076 wl1271_info("JOIN while associated.");
1079 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1081 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1085 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1087 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1091 * The join command disable the keep-alive mode, shut down its process,
1092 * and also clear the template config, so we need to reset it all after
1093 * the join. The acx_aid starts the keep-alive process, and the order
1094 * of the commands below is relevant.
1096 ret = wl1271_acx_keep_alive_mode(wl, true);
1100 ret = wl1271_acx_aid(wl, wl->aid);
1104 ret = wl1271_cmd_build_klv_null_data(wl);
1108 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1109 ACX_KEEP_ALIVE_TPL_VALID);
1117 static int wl1271_unjoin(struct wl1271 *wl)
1121 /* to stop listening to a channel, we disconnect */
1122 ret = wl1271_cmd_disconnect(wl);
1126 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1127 memset(wl->bssid, 0, ETH_ALEN);
1129 /* stop filterting packets based on bssid */
1130 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1136 static void wl1271_set_band_rate(struct wl1271 *wl)
1138 if (wl->band == IEEE80211_BAND_2GHZ)
1139 wl->basic_rate_set = wl->conf.tx.basic_rate;
1141 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1144 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1149 if (!wl->basic_rate_set) {
1151 wl->basic_rate_set = wl->conf.tx.basic_rate;
1154 for (i = 0; !rate; i++) {
1155 if ((wl->basic_rate_set >> i) & 0x1)
1162 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1167 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1168 ret = wl1271_unjoin(wl);
1172 wl->rate_set = wl1271_min_rate_get(wl);
1173 wl->sta_rate_set = 0;
1174 ret = wl1271_acx_rate_policies(wl);
1177 ret = wl1271_acx_keep_alive_config(
1178 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1179 ACX_KEEP_ALIVE_TPL_INVALID);
1182 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1184 /* increment the session counter */
1185 wl->session_counter++;
1186 if (wl->session_counter >= SESSION_COUNTER_MAX)
1187 wl->session_counter = 0;
1188 ret = wl1271_dummy_join(wl);
1191 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1198 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1200 struct wl1271 *wl = hw->priv;
1201 struct ieee80211_conf *conf = &hw->conf;
1202 int channel, ret = 0;
1204 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1206 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1208 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1210 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1213 * mac80211 will go to idle nearly immediately after transmitting some
1214 * frames, such as the deauth. To make sure those frames reach the air,
1215 * wait here until the TX queue is fully flushed.
1217 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1218 (conf->flags & IEEE80211_CONF_IDLE))
1219 wl1271_tx_flush(wl);
1221 mutex_lock(&wl->mutex);
1223 if (unlikely(wl->state == WL1271_STATE_OFF))
1226 ret = wl1271_ps_elp_wakeup(wl, false);
1230 /* if the channel changes while joined, join again */
1231 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1232 ((wl->band != conf->channel->band) ||
1233 (wl->channel != channel))) {
1234 wl->band = conf->channel->band;
1235 wl->channel = channel;
1238 * FIXME: the mac80211 should really provide a fixed rate
1239 * to use here. for now, just use the smallest possible rate
1240 * for the band as a fixed rate for association frames and
1241 * other control messages.
1243 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1244 wl1271_set_band_rate(wl);
1246 wl->basic_rate = wl1271_min_rate_get(wl);
1247 ret = wl1271_acx_rate_policies(wl);
1249 wl1271_warning("rate policy for update channel "
1252 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1253 ret = wl1271_join(wl, false);
1255 wl1271_warning("cmd join to update channel "
1260 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1261 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1263 wl1271_warning("idle mode change failed %d", ret);
1267 * if mac80211 changes the PSM mode, make sure the mode is not
1268 * incorrectly changed after the pspoll failure active window.
1270 if (changed & IEEE80211_CONF_CHANGE_PS)
1271 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1273 if (conf->flags & IEEE80211_CONF_PS &&
1274 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1275 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1278 * We enter PSM only if we're already associated.
1279 * If we're not, we'll enter it when joining an SSID,
1280 * through the bss_info_changed() hook.
1282 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1283 wl1271_debug(DEBUG_PSM, "psm enabled");
1284 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1287 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1288 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1289 wl1271_debug(DEBUG_PSM, "psm disabled");
1291 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1293 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1294 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1298 if (conf->power_level != wl->power_level) {
1299 ret = wl1271_acx_tx_power(wl, conf->power_level);
1303 wl->power_level = conf->power_level;
1307 wl1271_ps_elp_sleep(wl);
1310 mutex_unlock(&wl->mutex);
1315 struct wl1271_filter_params {
1318 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1321 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1322 struct netdev_hw_addr_list *mc_list)
1324 struct wl1271_filter_params *fp;
1325 struct netdev_hw_addr *ha;
1326 struct wl1271 *wl = hw->priv;
1328 if (unlikely(wl->state == WL1271_STATE_OFF))
1331 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1333 wl1271_error("Out of memory setting filters.");
1337 /* update multicast filtering parameters */
1338 fp->mc_list_length = 0;
1339 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1340 fp->enabled = false;
1343 netdev_hw_addr_list_for_each(ha, mc_list) {
1344 memcpy(fp->mc_list[fp->mc_list_length],
1345 ha->addr, ETH_ALEN);
1346 fp->mc_list_length++;
1350 return (u64)(unsigned long)fp;
1353 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1356 FIF_BCN_PRBRESP_PROMISC | \
1360 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1361 unsigned int changed,
1362 unsigned int *total, u64 multicast)
1364 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1365 struct wl1271 *wl = hw->priv;
1368 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1370 mutex_lock(&wl->mutex);
1372 *total &= WL1271_SUPPORTED_FILTERS;
1373 changed &= WL1271_SUPPORTED_FILTERS;
1375 if (unlikely(wl->state == WL1271_STATE_OFF))
1378 ret = wl1271_ps_elp_wakeup(wl, false);
1383 if (*total & FIF_ALLMULTI)
1384 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1386 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1388 fp->mc_list_length);
1392 /* determine, whether supported filter values have changed */
1396 /* configure filters */
1397 wl->filters = *total;
1398 wl1271_configure_filters(wl, 0);
1400 /* apply configured filters */
1401 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1406 wl1271_ps_elp_sleep(wl);
1409 mutex_unlock(&wl->mutex);
1413 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1414 struct ieee80211_vif *vif,
1415 struct ieee80211_sta *sta,
1416 struct ieee80211_key_conf *key_conf)
1418 struct wl1271 *wl = hw->priv;
1425 static const u8 bcast_addr[ETH_ALEN] =
1426 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1428 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1430 addr = sta ? sta->addr : bcast_addr;
1432 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1433 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1434 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1435 key_conf->alg, key_conf->keyidx,
1436 key_conf->keylen, key_conf->flags);
1437 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1439 if (is_zero_ether_addr(addr)) {
1440 /* We dont support TX only encryption */
1445 mutex_lock(&wl->mutex);
1447 ret = wl1271_ps_elp_wakeup(wl, false);
1451 switch (key_conf->alg) {
1455 key_conf->hw_key_idx = key_conf->keyidx;
1458 key_type = KEY_TKIP;
1460 key_conf->hw_key_idx = key_conf->keyidx;
1461 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1462 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1467 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1468 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1469 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1472 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1480 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1481 key_conf->keyidx, key_type,
1482 key_conf->keylen, key_conf->key,
1483 addr, tx_seq_32, tx_seq_16);
1485 wl1271_error("Could not add or replace key");
1489 /* the default WEP key needs to be configured at least once */
1490 if (key_type == KEY_WEP) {
1491 ret = wl1271_cmd_set_default_wep_key(wl,
1499 /* The wl1271 does not allow to remove unicast keys - they
1500 will be cleared automatically on next CMD_JOIN. Ignore the
1501 request silently, as we dont want the mac80211 to emit
1502 an error message. */
1503 if (!is_broadcast_ether_addr(addr))
1506 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1507 key_conf->keyidx, key_type,
1508 key_conf->keylen, key_conf->key,
1511 wl1271_error("Could not remove key");
1517 wl1271_error("Unsupported key cmd 0x%x", cmd);
1523 wl1271_ps_elp_sleep(wl);
1526 mutex_unlock(&wl->mutex);
1532 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1533 struct ieee80211_vif *vif,
1534 struct cfg80211_scan_request *req)
1536 struct wl1271 *wl = hw->priv;
1541 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1544 ssid = req->ssids[0].ssid;
1545 len = req->ssids[0].ssid_len;
1548 mutex_lock(&wl->mutex);
1550 ret = wl1271_ps_elp_wakeup(wl, false);
1554 if (wl1271_11a_enabled())
1555 ret = wl1271_scan(hw->priv, ssid, len, req);
1557 ret = wl1271_scan(hw->priv, ssid, len, req);
1559 wl1271_ps_elp_sleep(wl);
1562 mutex_unlock(&wl->mutex);
1567 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1569 struct wl1271 *wl = hw->priv;
1572 mutex_lock(&wl->mutex);
1574 if (unlikely(wl->state == WL1271_STATE_OFF))
1577 ret = wl1271_ps_elp_wakeup(wl, false);
1581 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1583 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1585 wl1271_ps_elp_sleep(wl);
1588 mutex_unlock(&wl->mutex);
1593 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1595 u8 *ptr = beacon->data +
1596 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1598 /* find the location of the ssid in the beacon */
1599 while (ptr < beacon->data + beacon->len) {
1600 if (ptr[0] == WLAN_EID_SSID) {
1601 wl->ssid_len = ptr[1];
1602 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1607 wl1271_error("ad-hoc beacon template has no SSID!\n");
1610 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1611 struct ieee80211_vif *vif,
1612 struct ieee80211_bss_conf *bss_conf,
1615 enum wl1271_cmd_ps_mode mode;
1616 struct wl1271 *wl = hw->priv;
1617 bool do_join = false;
1618 bool set_assoc = false;
1621 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1623 mutex_lock(&wl->mutex);
1625 ret = wl1271_ps_elp_wakeup(wl, false);
1629 if ((changed && BSS_CHANGED_BEACON_INT) &&
1630 (wl->bss_type == BSS_TYPE_IBSS)) {
1631 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1632 bss_conf->beacon_int);
1634 wl->beacon_int = bss_conf->beacon_int;
1638 if ((changed && BSS_CHANGED_BEACON) &&
1639 (wl->bss_type == BSS_TYPE_IBSS)) {
1640 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1642 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1645 struct ieee80211_hdr *hdr;
1647 wl1271_ssid_set(wl, beacon);
1648 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1651 wl1271_min_rate_get(wl));
1654 dev_kfree_skb(beacon);
1658 hdr = (struct ieee80211_hdr *) beacon->data;
1659 hdr->frame_control = cpu_to_le16(
1660 IEEE80211_FTYPE_MGMT |
1661 IEEE80211_STYPE_PROBE_RESP);
1663 ret = wl1271_cmd_template_set(wl,
1664 CMD_TEMPL_PROBE_RESPONSE,
1667 wl1271_min_rate_get(wl));
1668 dev_kfree_skb(beacon);
1672 /* Need to update the SSID (for filtering etc) */
1677 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1678 (wl->bss_type == BSS_TYPE_IBSS)) {
1679 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1680 bss_conf->enable_beacon ? "enabled" : "disabled");
1682 if (bss_conf->enable_beacon)
1683 wl->set_bss_type = BSS_TYPE_IBSS;
1685 wl->set_bss_type = BSS_TYPE_STA_BSS;
1689 if (changed & BSS_CHANGED_CQM) {
1690 bool enable = false;
1691 if (bss_conf->cqm_rssi_thold)
1693 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1694 bss_conf->cqm_rssi_thold,
1695 bss_conf->cqm_rssi_hyst);
1698 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1701 if ((changed & BSS_CHANGED_BSSID) &&
1703 * Now we know the correct bssid, so we send a new join command
1704 * and enable the BSSID filter
1706 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1707 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1709 ret = wl1271_cmd_build_null_data(wl);
1713 ret = wl1271_build_qos_null_data(wl);
1717 /* filter out all packets not from this BSSID */
1718 wl1271_configure_filters(wl, 0);
1720 /* Need to update the BSSID (for filtering etc) */
1724 if (changed & BSS_CHANGED_ASSOC) {
1725 if (bss_conf->assoc) {
1727 wl->aid = bss_conf->aid;
1730 wl->ps_poll_failures = 0;
1733 * use basic rates from AP, and determine lowest rate
1734 * to use with control frames.
1736 rates = bss_conf->basic_rates;
1737 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1739 wl->basic_rate = wl1271_min_rate_get(wl);
1740 ret = wl1271_acx_rate_policies(wl);
1745 * with wl1271, we don't need to update the
1746 * beacon_int and dtim_period, because the firmware
1747 * updates it by itself when the first beacon is
1748 * received after a join.
1750 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1755 * The SSID is intentionally set to NULL here - the
1756 * firmware will set the probe request with a
1757 * broadcast SSID regardless of what we set in the
1760 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1763 /* enable the connection monitoring feature */
1764 ret = wl1271_acx_conn_monit_params(wl, true);
1768 /* If we want to go in PSM but we're not there yet */
1769 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1770 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1771 mode = STATION_POWER_SAVE_MODE;
1772 ret = wl1271_ps_set_mode(wl, mode, true);
1777 /* use defaults when not associated */
1778 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1781 /* re-enable dynamic ps - just in case */
1782 ieee80211_enable_dyn_ps(wl->vif);
1784 /* revert back to minimum rates for the current band */
1785 wl1271_set_band_rate(wl);
1786 wl->basic_rate = wl1271_min_rate_get(wl);
1787 ret = wl1271_acx_rate_policies(wl);
1791 /* disable connection monitor features */
1792 ret = wl1271_acx_conn_monit_params(wl, false);
1794 /* Disable the keep-alive feature */
1795 ret = wl1271_acx_keep_alive_mode(wl, false);
1803 if (changed & BSS_CHANGED_ERP_SLOT) {
1804 if (bss_conf->use_short_slot)
1805 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1807 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1809 wl1271_warning("Set slot time failed %d", ret);
1814 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1815 if (bss_conf->use_short_preamble)
1816 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1818 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1821 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1822 if (bss_conf->use_cts_prot)
1823 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1825 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1827 wl1271_warning("Set ctsprotect failed %d", ret);
1832 if (changed & BSS_CHANGED_ARP_FILTER) {
1833 __be32 addr = bss_conf->arp_addr_list[0];
1834 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1836 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1837 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1839 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1846 ret = wl1271_join(wl, set_assoc);
1848 wl1271_warning("cmd join failed %d", ret);
1854 wl1271_ps_elp_sleep(wl);
1857 mutex_unlock(&wl->mutex);
1860 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1861 const struct ieee80211_tx_queue_params *params)
1863 struct wl1271 *wl = hw->priv;
1867 mutex_lock(&wl->mutex);
1869 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1871 ret = wl1271_ps_elp_wakeup(wl, false);
1875 /* the txop is confed in units of 32us by the mac80211, we need us */
1876 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1877 params->cw_min, params->cw_max,
1878 params->aifs, params->txop << 5);
1883 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1885 ps_scheme = CONF_PS_SCHEME_LEGACY;
1887 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1888 CONF_CHANNEL_TYPE_EDCF,
1889 wl1271_tx_get_queue(queue),
1890 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1895 wl1271_ps_elp_sleep(wl);
1898 mutex_unlock(&wl->mutex);
1903 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1906 struct wl1271 *wl = hw->priv;
1907 u64 mactime = ULLONG_MAX;
1910 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1912 mutex_lock(&wl->mutex);
1914 ret = wl1271_ps_elp_wakeup(wl, false);
1918 ret = wl1271_acx_tsf_info(wl, &mactime);
1923 wl1271_ps_elp_sleep(wl);
1926 mutex_unlock(&wl->mutex);
1930 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1931 struct survey_info *survey)
1933 struct wl1271 *wl = hw->priv;
1934 struct ieee80211_conf *conf = &hw->conf;
1939 survey->channel = conf->channel;
1940 survey->filled = SURVEY_INFO_NOISE_DBM;
1941 survey->noise = wl->noise;
1946 /* can't be const, mac80211 writes to this */
1947 static struct ieee80211_rate wl1271_rates[] = {
1949 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1950 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1952 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1953 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1954 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1956 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1957 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1958 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1960 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1961 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1962 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1964 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1965 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1967 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1968 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1970 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1971 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1973 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1974 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1976 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1977 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1979 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1980 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1982 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1983 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1985 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1986 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1989 /* can't be const, mac80211 writes to this */
1990 static struct ieee80211_channel wl1271_channels[] = {
1991 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1992 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1993 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1994 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1995 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1996 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1997 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1998 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1999 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2000 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2001 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2002 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2003 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2006 /* mapping to indexes for wl1271_rates */
2007 static const u8 wl1271_rate_to_idx_2ghz[] = {
2008 /* MCS rates are used only with 11n */
2009 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2010 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2011 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2012 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2013 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2014 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2015 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2016 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2018 11, /* CONF_HW_RXTX_RATE_54 */
2019 10, /* CONF_HW_RXTX_RATE_48 */
2020 9, /* CONF_HW_RXTX_RATE_36 */
2021 8, /* CONF_HW_RXTX_RATE_24 */
2023 /* TI-specific rate */
2024 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2026 7, /* CONF_HW_RXTX_RATE_18 */
2027 6, /* CONF_HW_RXTX_RATE_12 */
2028 3, /* CONF_HW_RXTX_RATE_11 */
2029 5, /* CONF_HW_RXTX_RATE_9 */
2030 4, /* CONF_HW_RXTX_RATE_6 */
2031 2, /* CONF_HW_RXTX_RATE_5_5 */
2032 1, /* CONF_HW_RXTX_RATE_2 */
2033 0 /* CONF_HW_RXTX_RATE_1 */
2036 /* can't be const, mac80211 writes to this */
2037 static struct ieee80211_supported_band wl1271_band_2ghz = {
2038 .channels = wl1271_channels,
2039 .n_channels = ARRAY_SIZE(wl1271_channels),
2040 .bitrates = wl1271_rates,
2041 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2044 /* 5 GHz data rates for WL1273 */
2045 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2047 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2048 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2050 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2051 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2053 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2054 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2056 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2057 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2059 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2060 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2062 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2063 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2065 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2066 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2068 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2069 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2072 /* 5 GHz band channels for WL1273 */
2073 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2074 { .hw_value = 183, .center_freq = 4915},
2075 { .hw_value = 184, .center_freq = 4920},
2076 { .hw_value = 185, .center_freq = 4925},
2077 { .hw_value = 187, .center_freq = 4935},
2078 { .hw_value = 188, .center_freq = 4940},
2079 { .hw_value = 189, .center_freq = 4945},
2080 { .hw_value = 192, .center_freq = 4960},
2081 { .hw_value = 196, .center_freq = 4980},
2082 { .hw_value = 7, .center_freq = 5035},
2083 { .hw_value = 8, .center_freq = 5040},
2084 { .hw_value = 9, .center_freq = 5045},
2085 { .hw_value = 11, .center_freq = 5055},
2086 { .hw_value = 12, .center_freq = 5060},
2087 { .hw_value = 16, .center_freq = 5080},
2088 { .hw_value = 34, .center_freq = 5170},
2089 { .hw_value = 36, .center_freq = 5180},
2090 { .hw_value = 38, .center_freq = 5190},
2091 { .hw_value = 40, .center_freq = 5200},
2092 { .hw_value = 42, .center_freq = 5210},
2093 { .hw_value = 44, .center_freq = 5220},
2094 { .hw_value = 46, .center_freq = 5230},
2095 { .hw_value = 48, .center_freq = 5240},
2096 { .hw_value = 52, .center_freq = 5260},
2097 { .hw_value = 56, .center_freq = 5280},
2098 { .hw_value = 60, .center_freq = 5300},
2099 { .hw_value = 64, .center_freq = 5320},
2100 { .hw_value = 100, .center_freq = 5500},
2101 { .hw_value = 104, .center_freq = 5520},
2102 { .hw_value = 108, .center_freq = 5540},
2103 { .hw_value = 112, .center_freq = 5560},
2104 { .hw_value = 116, .center_freq = 5580},
2105 { .hw_value = 120, .center_freq = 5600},
2106 { .hw_value = 124, .center_freq = 5620},
2107 { .hw_value = 128, .center_freq = 5640},
2108 { .hw_value = 132, .center_freq = 5660},
2109 { .hw_value = 136, .center_freq = 5680},
2110 { .hw_value = 140, .center_freq = 5700},
2111 { .hw_value = 149, .center_freq = 5745},
2112 { .hw_value = 153, .center_freq = 5765},
2113 { .hw_value = 157, .center_freq = 5785},
2114 { .hw_value = 161, .center_freq = 5805},
2115 { .hw_value = 165, .center_freq = 5825},
2118 /* mapping to indexes for wl1271_rates_5ghz */
2119 static const u8 wl1271_rate_to_idx_5ghz[] = {
2120 /* MCS rates are used only with 11n */
2121 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2122 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2123 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2124 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2125 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2126 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2127 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2128 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2130 7, /* CONF_HW_RXTX_RATE_54 */
2131 6, /* CONF_HW_RXTX_RATE_48 */
2132 5, /* CONF_HW_RXTX_RATE_36 */
2133 4, /* CONF_HW_RXTX_RATE_24 */
2135 /* TI-specific rate */
2136 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2138 3, /* CONF_HW_RXTX_RATE_18 */
2139 2, /* CONF_HW_RXTX_RATE_12 */
2140 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2141 1, /* CONF_HW_RXTX_RATE_9 */
2142 0, /* CONF_HW_RXTX_RATE_6 */
2143 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2144 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2145 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2148 static struct ieee80211_supported_band wl1271_band_5ghz = {
2149 .channels = wl1271_channels_5ghz,
2150 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2151 .bitrates = wl1271_rates_5ghz,
2152 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2155 static const u8 *wl1271_band_rate_to_idx[] = {
2156 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2157 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2160 static const struct ieee80211_ops wl1271_ops = {
2161 .start = wl1271_op_start,
2162 .stop = wl1271_op_stop,
2163 .add_interface = wl1271_op_add_interface,
2164 .remove_interface = wl1271_op_remove_interface,
2165 .config = wl1271_op_config,
2166 .prepare_multicast = wl1271_op_prepare_multicast,
2167 .configure_filter = wl1271_op_configure_filter,
2169 .set_key = wl1271_op_set_key,
2170 .hw_scan = wl1271_op_hw_scan,
2171 .bss_info_changed = wl1271_op_bss_info_changed,
2172 .set_rts_threshold = wl1271_op_set_rts_threshold,
2173 .conf_tx = wl1271_op_conf_tx,
2174 .get_tsf = wl1271_op_get_tsf,
2175 .get_survey = wl1271_op_get_survey,
2176 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2180 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2184 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2186 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2187 wl1271_error("Illegal RX rate from HW: %d", rate);
2191 idx = wl1271_band_rate_to_idx[wl->band][rate];
2192 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2193 wl1271_error("Unsupported RX rate from HW: %d", rate);
2200 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2201 struct device_attribute *attr,
2204 struct wl1271 *wl = dev_get_drvdata(dev);
2207 /* FIXME: what's the maximum length of buf? page size?*/
2210 mutex_lock(&wl->mutex);
2211 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2213 mutex_unlock(&wl->mutex);
2219 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2220 struct device_attribute *attr,
2221 const char *buf, size_t count)
2223 struct wl1271 *wl = dev_get_drvdata(dev);
2227 ret = strict_strtoul(buf, 10, &res);
2230 wl1271_warning("incorrect value written to bt_coex_mode");
2234 mutex_lock(&wl->mutex);
2238 if (res == wl->sg_enabled)
2241 wl->sg_enabled = res;
2243 if (wl->state == WL1271_STATE_OFF)
2246 ret = wl1271_ps_elp_wakeup(wl, false);
2250 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2251 wl1271_ps_elp_sleep(wl);
2254 mutex_unlock(&wl->mutex);
2258 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2259 wl1271_sysfs_show_bt_coex_state,
2260 wl1271_sysfs_store_bt_coex_state);
2262 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2263 struct device_attribute *attr,
2266 struct wl1271 *wl = dev_get_drvdata(dev);
2269 /* FIXME: what's the maximum length of buf? page size?*/
2272 mutex_lock(&wl->mutex);
2273 if (wl->hw_pg_ver >= 0)
2274 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2276 len = snprintf(buf, len, "n/a\n");
2277 mutex_unlock(&wl->mutex);
2282 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2283 wl1271_sysfs_show_hw_pg_ver, NULL);
2285 int wl1271_register_hw(struct wl1271 *wl)
2289 if (wl->mac80211_registered)
2292 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2294 ret = ieee80211_register_hw(wl->hw);
2296 wl1271_error("unable to register mac80211 hw: %d", ret);
2300 wl->mac80211_registered = true;
2302 wl1271_notice("loaded");
2306 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2308 void wl1271_unregister_hw(struct wl1271 *wl)
2310 ieee80211_unregister_hw(wl->hw);
2311 wl->mac80211_registered = false;
2314 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2316 int wl1271_init_ieee80211(struct wl1271 *wl)
2318 /* The tx descriptor buffer and the TKIP space. */
2319 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2320 sizeof(struct wl1271_tx_hw_descr);
2323 /* FIXME: find a proper value */
2324 wl->hw->channel_change_time = 10000;
2325 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2327 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2328 IEEE80211_HW_BEACON_FILTER |
2329 IEEE80211_HW_SUPPORTS_PS |
2330 IEEE80211_HW_SUPPORTS_UAPSD |
2331 IEEE80211_HW_HAS_RATE_CONTROL |
2332 IEEE80211_HW_CONNECTION_MONITOR |
2333 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2335 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2336 BIT(NL80211_IFTYPE_ADHOC);
2337 wl->hw->wiphy->max_scan_ssids = 1;
2338 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2340 if (wl1271_11a_enabled())
2341 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2344 wl->hw->max_rates = 1;
2346 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2350 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2352 #define WL1271_DEFAULT_CHANNEL 0
2354 struct ieee80211_hw *wl1271_alloc_hw(void)
2356 struct ieee80211_hw *hw;
2357 struct platform_device *plat_dev = NULL;
2361 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2363 wl1271_error("could not alloc ieee80211_hw");
2368 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2370 wl1271_error("could not allocate platform_device");
2372 goto err_plat_alloc;
2376 memset(wl, 0, sizeof(*wl));
2378 INIT_LIST_HEAD(&wl->list);
2381 wl->plat_dev = plat_dev;
2383 skb_queue_head_init(&wl->tx_queue);
2385 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2386 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2387 wl->channel = WL1271_DEFAULT_CHANNEL;
2388 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2389 wl->default_key = 0;
2391 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2392 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2393 wl->psm_entry_retry = 0;
2394 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2395 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2396 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2397 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2398 wl->sta_rate_set = 0;
2399 wl->band = IEEE80211_BAND_2GHZ;
2402 wl->sg_enabled = true;
2405 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2406 wl->tx_frames[i] = NULL;
2408 spin_lock_init(&wl->wl_lock);
2410 wl->state = WL1271_STATE_OFF;
2411 mutex_init(&wl->mutex);
2413 /* Apply default driver configuration. */
2414 wl1271_conf_init(wl);
2416 wl1271_debugfs_init(wl);
2418 /* Register platform device */
2419 ret = platform_device_register(wl->plat_dev);
2421 wl1271_error("couldn't register platform device");
2424 dev_set_drvdata(&wl->plat_dev->dev, wl);
2426 /* Create sysfs file to control bt coex state */
2427 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2429 wl1271_error("failed to create sysfs file bt_coex_state");
2433 /* Create sysfs file to get HW PG version */
2434 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2436 wl1271_error("failed to create sysfs file hw_pg_ver");
2437 goto err_bt_coex_state;
2443 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2446 platform_device_unregister(wl->plat_dev);
2449 wl1271_debugfs_exit(wl);
2453 ieee80211_free_hw(hw);
2457 return ERR_PTR(ret);
2459 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2461 int wl1271_free_hw(struct wl1271 *wl)
2463 platform_device_unregister(wl->plat_dev);
2464 kfree(wl->plat_dev);
2466 wl1271_debugfs_exit(wl);
2473 kfree(wl->fw_status);
2474 kfree(wl->tx_res_if);
2476 ieee80211_free_hw(wl->hw);
2480 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2482 MODULE_LICENSE("GPL");
2483 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2484 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");