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"
48 #define WL1271_BOOT_RETRIES 3
50 static struct conf_drv_settings default_conf = {
53 [CONF_SG_BT_PER_THRESHOLD] = 7500,
54 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
55 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
56 [CONF_SG_BT_LOAD_RATIO] = 50,
57 [CONF_SG_AUTO_PS_MODE] = 0,
58 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
59 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
60 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
61 [CONF_SG_BEACON_MISS_PERCENT] = 60,
62 [CONF_SG_RATE_ADAPT_THRESH] = 12,
63 [CONF_SG_RATE_ADAPT_SNR] = 0,
64 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
66 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
67 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
69 /* Note: with UPSD, this should be 4 */
70 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
71 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
73 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
74 /* Note: with UPDS, this should be 15 */
75 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
76 /* Note: with UPDS, this should be 50 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
78 /* Note: with UPDS, this should be 10 */
79 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
82 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
83 [CONF_SG_PS_POLL_TIMEOUT] = 10,
84 [CONF_SG_UPSD_TIMEOUT] = 10,
85 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
87 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
90 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
93 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
94 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
96 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
97 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
98 [CONF_SG_HV3_MAX_SERVED] = 6,
99 [CONF_SG_DHCP_TIME] = 5000,
100 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 .state = CONF_SG_PROTECTIVE,
105 .rx_msdu_life_time = 512000,
106 .packet_detection_threshold = 0,
107 .ps_poll_timeout = 15,
109 .rts_threshold = 2347,
110 .rx_cca_threshold = 0,
111 .irq_blk_threshold = 0xFFFF,
112 .irq_pkt_threshold = 0,
114 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
117 .tx_energy_detection = 0,
120 .short_retry_limit = 10,
121 .long_retry_limit = 10,
144 .aifsn = CONF_TX_AIFS_PIFS,
151 .aifsn = CONF_TX_AIFS_PIFS,
159 .channel_type = CONF_CHANNEL_TYPE_DCF,
160 .tsid = CONF_TX_AC_BE,
161 .ps_scheme = CONF_PS_SCHEME_LEGACY,
162 .ack_policy = CONF_ACK_POLICY_LEGACY,
167 .channel_type = CONF_CHANNEL_TYPE_DCF,
168 .tsid = CONF_TX_AC_BE,
169 .ps_scheme = CONF_PS_SCHEME_LEGACY,
170 .ack_policy = CONF_ACK_POLICY_LEGACY,
175 .channel_type = CONF_CHANNEL_TYPE_DCF,
176 .tsid = CONF_TX_AC_BE,
177 .ps_scheme = CONF_PS_SCHEME_LEGACY,
178 .ack_policy = CONF_ACK_POLICY_LEGACY,
183 .channel_type = CONF_CHANNEL_TYPE_DCF,
184 .tsid = CONF_TX_AC_BE,
185 .ps_scheme = CONF_PS_SCHEME_LEGACY,
186 .ack_policy = CONF_ACK_POLICY_LEGACY,
191 .channel_type = CONF_CHANNEL_TYPE_DCF,
192 .tsid = CONF_TX_AC_BE,
193 .ps_scheme = CONF_PS_SCHEME_LEGACY,
194 .ack_policy = CONF_ACK_POLICY_LEGACY,
199 .channel_type = CONF_CHANNEL_TYPE_DCF,
200 .tsid = CONF_TX_AC_BE,
201 .ps_scheme = CONF_PS_SCHEME_LEGACY,
202 .ack_policy = CONF_ACK_POLICY_LEGACY,
207 .channel_type = CONF_CHANNEL_TYPE_DCF,
208 .tsid = CONF_TX_AC_BE,
209 .ps_scheme = CONF_PS_SCHEME_LEGACY,
210 .ack_policy = CONF_ACK_POLICY_LEGACY,
214 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
215 .tx_compl_timeout = 700,
216 .tx_compl_threshold = 4,
217 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
218 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
221 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
222 .listen_interval = 1,
223 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
224 .bcn_filt_ie_count = 1,
227 .ie = WLAN_EID_CHANNEL_SWITCH,
228 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
231 .synch_fail_thold = 10,
232 .bss_lose_timeout = 100,
233 .beacon_rx_timeout = 10000,
234 .broadcast_timeout = 20000,
235 .rx_broadcast_in_ps = 1,
236 .ps_poll_threshold = 10,
237 .ps_poll_recovery_period = 700,
238 .bet_enable = CONF_BET_MODE_ENABLE,
239 .bet_max_consecutive = 10,
240 .psm_entry_retries = 3,
241 .keep_alive_interval = 55000,
242 .max_listen_interval = 20,
249 .host_clk_settling_time = 5000,
250 .host_fast_wakeup_support = false
253 /* FIXME: due to firmware bug, must use value 1 for now */
255 .avg_weight_rssi_beacon = 20,
256 .avg_weight_rssi_data = 10,
257 .avg_weight_snr_beacon = 20,
258 .avg_weight_snr_data = 10
262 static void wl1271_device_release(struct device *dev)
267 static struct platform_device wl1271_device = {
271 /* device model insists to have a release function */
273 .release = wl1271_device_release,
277 static LIST_HEAD(wl_list);
279 static void wl1271_conf_init(struct wl1271 *wl)
283 * This function applies the default configuration to the driver. This
284 * function is invoked upon driver load (spi probe.)
286 * The configuration is stored in a run-time structure in order to
287 * facilitate for run-time adjustment of any of the parameters. Making
288 * changes to the configuration structure will apply the new values on
289 * the next interface up (wl1271_op_start.)
292 /* apply driver default configuration */
293 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
297 static int wl1271_plt_init(struct wl1271 *wl)
299 struct conf_tx_ac_category *conf_ac;
300 struct conf_tx_tid *conf_tid;
303 ret = wl1271_cmd_general_parms(wl);
307 ret = wl1271_cmd_radio_parms(wl);
311 ret = wl1271_init_templates_config(wl);
315 ret = wl1271_acx_init_mem_config(wl);
319 /* PHY layer config */
320 ret = wl1271_init_phy_config(wl);
322 goto out_free_memmap;
324 ret = wl1271_acx_dco_itrim_params(wl);
326 goto out_free_memmap;
328 /* Initialize connection monitoring thresholds */
329 ret = wl1271_acx_conn_monit_params(wl, false);
331 goto out_free_memmap;
333 /* Bluetooth WLAN coexistence */
334 ret = wl1271_init_pta(wl);
336 goto out_free_memmap;
338 /* Energy detection */
339 ret = wl1271_init_energy_detection(wl);
341 goto out_free_memmap;
343 /* Default fragmentation threshold */
344 ret = wl1271_acx_frag_threshold(wl);
346 goto out_free_memmap;
348 /* Default TID configuration */
349 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
350 conf_tid = &wl->conf.tx.tid_conf[i];
351 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
352 conf_tid->channel_type,
355 conf_tid->ack_policy,
356 conf_tid->apsd_conf[0],
357 conf_tid->apsd_conf[1]);
359 goto out_free_memmap;
362 /* Default AC configuration */
363 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
364 conf_ac = &wl->conf.tx.ac_conf[i];
365 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
366 conf_ac->cw_max, conf_ac->aifsn,
367 conf_ac->tx_op_limit);
369 goto out_free_memmap;
372 /* Enable data path */
373 ret = wl1271_cmd_data_path(wl, 1);
375 goto out_free_memmap;
377 /* Configure for CAM power saving (ie. always active) */
378 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
380 goto out_free_memmap;
383 ret = wl1271_acx_pm_config(wl);
385 goto out_free_memmap;
390 kfree(wl->target_mem_map);
391 wl->target_mem_map = NULL;
396 static void wl1271_fw_status(struct wl1271 *wl,
397 struct wl1271_fw_status *status)
403 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
405 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
406 "drv_rx_counter = %d, tx_results_counter = %d)",
408 status->fw_rx_counter,
409 status->drv_rx_counter,
410 status->tx_results_counter);
412 /* update number of available TX blocks */
413 for (i = 0; i < NUM_TX_QUEUES; i++) {
414 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
415 wl->tx_blocks_freed[i];
417 wl->tx_blocks_freed[i] =
418 le32_to_cpu(status->tx_released_blks[i]);
419 wl->tx_blocks_available += cnt;
423 /* if more blocks are available now, schedule some tx work */
424 if (total && !skb_queue_empty(&wl->tx_queue))
425 ieee80211_queue_work(wl->hw, &wl->tx_work);
427 /* update the host-chipset time offset */
429 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
430 (s64)le32_to_cpu(status->fw_localtime);
433 #define WL1271_IRQ_MAX_LOOPS 10
435 static void wl1271_irq_work(struct work_struct *work)
439 int loopcount = WL1271_IRQ_MAX_LOOPS;
442 container_of(work, struct wl1271, irq_work);
444 mutex_lock(&wl->mutex);
446 wl1271_debug(DEBUG_IRQ, "IRQ work");
448 if (unlikely(wl->state == WL1271_STATE_OFF))
451 ret = wl1271_ps_elp_wakeup(wl, true);
455 spin_lock_irqsave(&wl->wl_lock, flags);
456 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
457 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
458 spin_unlock_irqrestore(&wl->wl_lock, flags);
461 wl1271_fw_status(wl, wl->fw_status);
462 intr = le32_to_cpu(wl->fw_status->intr);
464 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
465 spin_lock_irqsave(&wl->wl_lock, flags);
469 intr &= WL1271_INTR_MASK;
471 if (intr & WL1271_ACX_INTR_DATA) {
472 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
474 /* check for tx results */
475 if (wl->fw_status->tx_results_counter !=
476 (wl->tx_results_count & 0xff))
477 wl1271_tx_complete(wl);
479 wl1271_rx(wl, wl->fw_status);
482 if (intr & WL1271_ACX_INTR_EVENT_A) {
483 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
484 wl1271_event_handle(wl, 0);
487 if (intr & WL1271_ACX_INTR_EVENT_B) {
488 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
489 wl1271_event_handle(wl, 1);
492 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
493 wl1271_debug(DEBUG_IRQ,
494 "WL1271_ACX_INTR_INIT_COMPLETE");
496 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
497 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
499 spin_lock_irqsave(&wl->wl_lock, flags);
502 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
503 ieee80211_queue_work(wl->hw, &wl->irq_work);
505 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
506 spin_unlock_irqrestore(&wl->wl_lock, flags);
508 wl1271_ps_elp_sleep(wl);
511 mutex_unlock(&wl->mutex);
514 static int wl1271_fetch_firmware(struct wl1271 *wl)
516 const struct firmware *fw;
519 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
522 wl1271_error("could not get firmware: %d", ret);
527 wl1271_error("firmware size is not multiple of 32 bits: %zu",
533 wl->fw_len = fw->size;
534 wl->fw = vmalloc(wl->fw_len);
537 wl1271_error("could not allocate memory for the firmware");
542 memcpy(wl->fw, fw->data, wl->fw_len);
547 release_firmware(fw);
552 static int wl1271_fetch_nvs(struct wl1271 *wl)
554 const struct firmware *fw;
557 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
560 wl1271_error("could not get nvs file: %d", ret);
565 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
566 * configurations) can be removed when those NVS files stop floating
569 if (fw->size != sizeof(struct wl1271_nvs_file) &&
570 (fw->size != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
571 wl1271_11a_enabled())) {
572 wl1271_error("nvs size is not as expected: %zu != %zu",
573 fw->size, sizeof(struct wl1271_nvs_file));
578 wl->nvs = kzalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
581 wl1271_error("could not allocate memory for the nvs file");
586 memcpy(wl->nvs, fw->data, fw->size);
589 release_firmware(fw);
594 static void wl1271_fw_wakeup(struct wl1271 *wl)
598 elp_reg = ELPCTRL_WAKE_UP;
599 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
602 static int wl1271_setup(struct wl1271 *wl)
604 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
608 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
609 if (!wl->tx_res_if) {
610 kfree(wl->fw_status);
614 INIT_WORK(&wl->irq_work, wl1271_irq_work);
615 INIT_WORK(&wl->tx_work, wl1271_tx_work);
619 static int wl1271_chip_wakeup(struct wl1271 *wl)
621 struct wl1271_partition_set partition;
624 msleep(WL1271_PRE_POWER_ON_SLEEP);
626 msleep(WL1271_POWER_ON_SLEEP);
630 /* We don't need a real memory partition here, because we only want
631 * to use the registers at this point. */
632 memset(&partition, 0, sizeof(partition));
633 partition.reg.start = REGISTERS_BASE;
634 partition.reg.size = REGISTERS_DOWN_SIZE;
635 wl1271_set_partition(wl, &partition);
637 /* ELP module wake up */
638 wl1271_fw_wakeup(wl);
640 /* whal_FwCtrl_BootSm() */
642 /* 0. read chip id from CHIP_ID */
643 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
645 /* 1. check if chip id is valid */
647 switch (wl->chip.id) {
648 case CHIP_ID_1271_PG10:
649 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
652 ret = wl1271_setup(wl);
656 case CHIP_ID_1271_PG20:
657 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
660 ret = wl1271_setup(wl);
665 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
670 if (wl->fw == NULL) {
671 ret = wl1271_fetch_firmware(wl);
676 /* No NVS from netlink, try to get it from the filesystem */
677 if (wl->nvs == NULL) {
678 ret = wl1271_fetch_nvs(wl);
687 int wl1271_plt_start(struct wl1271 *wl)
689 int retries = WL1271_BOOT_RETRIES;
692 mutex_lock(&wl->mutex);
694 wl1271_notice("power up");
696 if (wl->state != WL1271_STATE_OFF) {
697 wl1271_error("cannot go into PLT state because not "
698 "in off state: %d", wl->state);
705 ret = wl1271_chip_wakeup(wl);
709 ret = wl1271_boot(wl);
713 ret = wl1271_plt_init(wl);
717 wl->state = WL1271_STATE_PLT;
718 wl1271_notice("firmware booted in PLT mode (%s)",
723 wl1271_disable_interrupts(wl);
724 mutex_unlock(&wl->mutex);
725 /* Unlocking the mutex in the middle of handling is
726 inherently unsafe. In this case we deem it safe to do,
727 because we need to let any possibly pending IRQ out of
728 the system (and while we are WL1271_STATE_OFF the IRQ
729 work function will not do anything.) Also, any other
730 possible concurrent operations will fail due to the
731 current state, hence the wl1271 struct should be safe. */
732 cancel_work_sync(&wl->irq_work);
733 mutex_lock(&wl->mutex);
735 wl1271_power_off(wl);
738 wl1271_error("firmware boot in PLT mode failed despite %d retries",
739 WL1271_BOOT_RETRIES);
741 mutex_unlock(&wl->mutex);
746 int wl1271_plt_stop(struct wl1271 *wl)
750 mutex_lock(&wl->mutex);
752 wl1271_notice("power down");
754 if (wl->state != WL1271_STATE_PLT) {
755 wl1271_error("cannot power down because not in PLT "
756 "state: %d", wl->state);
761 wl1271_disable_interrupts(wl);
762 wl1271_power_off(wl);
764 wl->state = WL1271_STATE_OFF;
768 mutex_unlock(&wl->mutex);
774 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
776 struct wl1271 *wl = hw->priv;
777 struct ieee80211_conf *conf = &hw->conf;
778 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
779 struct ieee80211_sta *sta = txinfo->control.sta;
782 /* peek into the rates configured in the STA entry */
783 spin_lock_irqsave(&wl->wl_lock, flags);
784 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
785 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
786 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
788 spin_unlock_irqrestore(&wl->wl_lock, flags);
790 /* queue the packet */
791 skb_queue_tail(&wl->tx_queue, skb);
794 * The chip specific setup must run before the first TX packet -
795 * before that, the tx_work will not be initialized!
798 ieee80211_queue_work(wl->hw, &wl->tx_work);
801 * The workqueue is slow to process the tx_queue and we need stop
802 * the queue here, otherwise the queue will get too long.
804 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
805 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
807 spin_lock_irqsave(&wl->wl_lock, flags);
808 ieee80211_stop_queues(wl->hw);
809 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
810 spin_unlock_irqrestore(&wl->wl_lock, flags);
816 static int wl1271_op_start(struct ieee80211_hw *hw)
818 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
821 * We have to delay the booting of the hardware because
822 * we need to know the local MAC address before downloading and
823 * initializing the firmware. The MAC address cannot be changed
824 * after boot, and without the proper MAC address, the firmware
825 * will not function properly.
827 * The MAC address is first known when the corresponding interface
828 * is added. That is where we will initialize the hardware.
834 static void wl1271_op_stop(struct ieee80211_hw *hw)
836 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
839 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
840 struct ieee80211_vif *vif)
842 struct wl1271 *wl = hw->priv;
843 int retries = WL1271_BOOT_RETRIES;
846 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
847 vif->type, vif->addr);
849 mutex_lock(&wl->mutex);
858 case NL80211_IFTYPE_STATION:
859 wl->bss_type = BSS_TYPE_STA_BSS;
860 wl->set_bss_type = BSS_TYPE_STA_BSS;
862 case NL80211_IFTYPE_ADHOC:
863 wl->bss_type = BSS_TYPE_IBSS;
864 wl->set_bss_type = BSS_TYPE_STA_BSS;
871 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
873 if (wl->state != WL1271_STATE_OFF) {
874 wl1271_error("cannot start because not in off state: %d",
882 ret = wl1271_chip_wakeup(wl);
886 ret = wl1271_boot(wl);
890 ret = wl1271_hw_init(wl);
894 wl->state = WL1271_STATE_ON;
895 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
899 wl1271_disable_interrupts(wl);
900 mutex_unlock(&wl->mutex);
901 /* Unlocking the mutex in the middle of handling is
902 inherently unsafe. In this case we deem it safe to do,
903 because we need to let any possibly pending IRQ out of
904 the system (and while we are WL1271_STATE_OFF the IRQ
905 work function will not do anything.) Also, any other
906 possible concurrent operations will fail due to the
907 current state, hence the wl1271 struct should be safe. */
908 cancel_work_sync(&wl->irq_work);
909 mutex_lock(&wl->mutex);
911 wl1271_power_off(wl);
914 wl1271_error("firmware boot failed despite %d retries",
915 WL1271_BOOT_RETRIES);
917 mutex_unlock(&wl->mutex);
920 list_add(&wl->list, &wl_list);
925 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
926 struct ieee80211_vif *vif)
928 struct wl1271 *wl = hw->priv;
931 mutex_lock(&wl->mutex);
932 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
938 WARN_ON(wl->state != WL1271_STATE_ON);
940 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
941 mutex_unlock(&wl->mutex);
942 ieee80211_scan_completed(wl->hw, true);
943 mutex_lock(&wl->mutex);
946 wl->state = WL1271_STATE_OFF;
948 wl1271_disable_interrupts(wl);
950 mutex_unlock(&wl->mutex);
952 cancel_work_sync(&wl->irq_work);
953 cancel_work_sync(&wl->tx_work);
954 cancel_delayed_work_sync(&wl->pspoll_work);
956 mutex_lock(&wl->mutex);
958 /* let's notify MAC80211 about the remaining pending TX frames */
960 wl1271_power_off(wl);
962 memset(wl->bssid, 0, ETH_ALEN);
963 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
965 wl->bss_type = MAX_BSS_TYPE;
966 wl->set_bss_type = MAX_BSS_TYPE;
967 wl->band = IEEE80211_BAND_2GHZ;
970 wl->psm_entry_retry = 0;
971 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
972 wl->tx_blocks_available = 0;
973 wl->tx_results_count = 0;
974 wl->tx_packets_count = 0;
975 wl->tx_security_last_seq = 0;
976 wl->tx_security_seq = 0;
978 wl->session_counter = 0;
979 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
980 wl->sta_rate_set = 0;
985 for (i = 0; i < NUM_TX_QUEUES; i++)
986 wl->tx_blocks_freed[i] = 0;
988 wl1271_debugfs_reset(wl);
990 kfree(wl->fw_status);
991 wl->fw_status = NULL;
992 kfree(wl->tx_res_if);
993 wl->tx_res_if = NULL;
994 kfree(wl->target_mem_map);
995 wl->target_mem_map = NULL;
997 mutex_unlock(&wl->mutex);
1000 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1002 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1003 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1005 /* combine requested filters with current filter config */
1006 filters = wl->filters | filters;
1008 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1010 if (filters & FIF_PROMISC_IN_BSS) {
1011 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1012 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1013 wl->rx_config |= CFG_BSSID_FILTER_EN;
1015 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1016 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1017 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1018 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1020 if (filters & FIF_OTHER_BSS) {
1021 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1022 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1024 if (filters & FIF_CONTROL) {
1025 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1026 wl->rx_filter |= CFG_RX_CTL_EN;
1028 if (filters & FIF_FCSFAIL) {
1029 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1030 wl->rx_filter |= CFG_RX_FCS_ERROR;
1034 static int wl1271_dummy_join(struct wl1271 *wl)
1037 /* we need to use a dummy BSSID for now */
1038 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1041 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1043 /* pass through frames from all BSS */
1044 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1046 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1050 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1056 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1061 * One of the side effects of the JOIN command is that is clears
1062 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1063 * to a WPA/WPA2 access point will therefore kill the data-path.
1064 * Currently there is no supported scenario for JOIN during
1065 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1066 * must be handled somehow.
1069 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1070 wl1271_info("JOIN while associated.");
1073 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1075 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1079 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1081 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1085 * The join command disable the keep-alive mode, shut down its process,
1086 * and also clear the template config, so we need to reset it all after
1087 * the join. The acx_aid starts the keep-alive process, and the order
1088 * of the commands below is relevant.
1090 ret = wl1271_acx_keep_alive_mode(wl, true);
1094 ret = wl1271_acx_aid(wl, wl->aid);
1098 ret = wl1271_cmd_build_klv_null_data(wl);
1102 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1103 ACX_KEEP_ALIVE_TPL_VALID);
1111 static int wl1271_unjoin(struct wl1271 *wl)
1115 /* to stop listening to a channel, we disconnect */
1116 ret = wl1271_cmd_disconnect(wl);
1120 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1121 memset(wl->bssid, 0, ETH_ALEN);
1123 /* stop filterting packets based on bssid */
1124 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1130 static void wl1271_set_band_rate(struct wl1271 *wl)
1132 if (wl->band == IEEE80211_BAND_2GHZ)
1133 wl->basic_rate_set = wl->conf.tx.basic_rate;
1135 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1138 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1143 if (!wl->basic_rate_set) {
1145 wl->basic_rate_set = wl->conf.tx.basic_rate;
1148 for (i = 0; !rate; i++) {
1149 if ((wl->basic_rate_set >> i) & 0x1)
1156 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1161 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1162 ret = wl1271_unjoin(wl);
1166 wl->rate_set = wl1271_min_rate_get(wl);
1167 wl->sta_rate_set = 0;
1168 ret = wl1271_acx_rate_policies(wl);
1171 ret = wl1271_acx_keep_alive_config(
1172 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1173 ACX_KEEP_ALIVE_TPL_INVALID);
1176 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1178 /* increment the session counter */
1179 wl->session_counter++;
1180 if (wl->session_counter >= SESSION_COUNTER_MAX)
1181 wl->session_counter = 0;
1182 ret = wl1271_dummy_join(wl);
1185 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1192 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1194 struct wl1271 *wl = hw->priv;
1195 struct ieee80211_conf *conf = &hw->conf;
1196 int channel, ret = 0;
1198 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1200 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1202 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1204 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1207 * mac80211 will go to idle nearly immediately after transmitting some
1208 * frames, such as the deauth. To make sure those frames reach the air,
1209 * wait here until the TX queue is fully flushed.
1211 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1212 (conf->flags & IEEE80211_CONF_IDLE))
1213 wl1271_tx_flush(wl);
1215 mutex_lock(&wl->mutex);
1217 if (unlikely(wl->state == WL1271_STATE_OFF))
1220 ret = wl1271_ps_elp_wakeup(wl, false);
1224 /* if the channel changes while joined, join again */
1225 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1226 ((wl->band != conf->channel->band) ||
1227 (wl->channel != channel))) {
1228 wl->band = conf->channel->band;
1229 wl->channel = channel;
1232 * FIXME: the mac80211 should really provide a fixed rate
1233 * to use here. for now, just use the smallest possible rate
1234 * for the band as a fixed rate for association frames and
1235 * other control messages.
1237 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1238 wl1271_set_band_rate(wl);
1240 wl->basic_rate = wl1271_min_rate_get(wl);
1241 ret = wl1271_acx_rate_policies(wl);
1243 wl1271_warning("rate policy for update channel "
1246 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1247 ret = wl1271_join(wl, false);
1249 wl1271_warning("cmd join to update channel "
1254 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1255 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1257 wl1271_warning("idle mode change failed %d", ret);
1261 * if mac80211 changes the PSM mode, make sure the mode is not
1262 * incorrectly changed after the pspoll failure active window.
1264 if (changed & IEEE80211_CONF_CHANGE_PS)
1265 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1267 if (conf->flags & IEEE80211_CONF_PS &&
1268 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1269 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1272 * We enter PSM only if we're already associated.
1273 * If we're not, we'll enter it when joining an SSID,
1274 * through the bss_info_changed() hook.
1276 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1277 wl1271_debug(DEBUG_PSM, "psm enabled");
1278 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1281 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1282 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1283 wl1271_debug(DEBUG_PSM, "psm disabled");
1285 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1287 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1288 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1292 if (conf->power_level != wl->power_level) {
1293 ret = wl1271_acx_tx_power(wl, conf->power_level);
1297 wl->power_level = conf->power_level;
1301 wl1271_ps_elp_sleep(wl);
1304 mutex_unlock(&wl->mutex);
1309 struct wl1271_filter_params {
1312 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1315 static int wl1271_op_configure_arp_filter(struct ieee80211_hw *hw,
1316 struct ieee80211_vif *vif,
1317 struct in_ifaddr *ifa_list)
1319 struct wl1271 *wl = hw->priv;
1322 WARN_ON(vif != wl->vif);
1324 /* disable filtering if there are multiple addresses */
1325 if (ifa_list && ifa_list->ifa_next)
1328 mutex_lock(&wl->mutex);
1330 if (wl->state == WL1271_STATE_OFF)
1333 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1335 ret = wl1271_ps_elp_wakeup(wl, false);
1340 ret = wl1271_cmd_build_arp_reply(wl, &ifa_list->ifa_address);
1343 ret = wl1271_acx_arp_ip_filter(wl, ACX_ARP_FILTER_AND_REPLY,
1344 (u8 *)&ifa_list->ifa_address);
1348 ret = wl1271_acx_arp_ip_filter(wl, ACX_ARP_DISABLE, NULL);
1354 wl1271_ps_elp_sleep(wl);
1357 mutex_unlock(&wl->mutex);
1362 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1363 struct netdev_hw_addr_list *mc_list)
1365 struct wl1271_filter_params *fp;
1366 struct netdev_hw_addr *ha;
1367 struct wl1271 *wl = hw->priv;
1369 if (unlikely(wl->state == WL1271_STATE_OFF))
1372 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1374 wl1271_error("Out of memory setting filters.");
1378 /* update multicast filtering parameters */
1379 fp->mc_list_length = 0;
1380 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1381 fp->enabled = false;
1384 netdev_hw_addr_list_for_each(ha, mc_list) {
1385 memcpy(fp->mc_list[fp->mc_list_length],
1386 ha->addr, ETH_ALEN);
1387 fp->mc_list_length++;
1391 return (u64)(unsigned long)fp;
1394 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1397 FIF_BCN_PRBRESP_PROMISC | \
1401 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1402 unsigned int changed,
1403 unsigned int *total, u64 multicast)
1405 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1406 struct wl1271 *wl = hw->priv;
1409 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1411 mutex_lock(&wl->mutex);
1413 *total &= WL1271_SUPPORTED_FILTERS;
1414 changed &= WL1271_SUPPORTED_FILTERS;
1416 if (unlikely(wl->state == WL1271_STATE_OFF))
1419 ret = wl1271_ps_elp_wakeup(wl, false);
1424 if (*total & FIF_ALLMULTI)
1425 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1427 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1429 fp->mc_list_length);
1433 /* determine, whether supported filter values have changed */
1437 /* configure filters */
1438 wl->filters = *total;
1439 wl1271_configure_filters(wl, 0);
1441 /* apply configured filters */
1442 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1447 wl1271_ps_elp_sleep(wl);
1450 mutex_unlock(&wl->mutex);
1454 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1455 struct ieee80211_vif *vif,
1456 struct ieee80211_sta *sta,
1457 struct ieee80211_key_conf *key_conf)
1459 struct wl1271 *wl = hw->priv;
1466 static const u8 bcast_addr[ETH_ALEN] =
1467 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1469 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1471 addr = sta ? sta->addr : bcast_addr;
1473 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1474 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1475 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1476 key_conf->alg, key_conf->keyidx,
1477 key_conf->keylen, key_conf->flags);
1478 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1480 if (is_zero_ether_addr(addr)) {
1481 /* We dont support TX only encryption */
1486 mutex_lock(&wl->mutex);
1488 ret = wl1271_ps_elp_wakeup(wl, false);
1492 switch (key_conf->alg) {
1496 key_conf->hw_key_idx = key_conf->keyidx;
1499 key_type = KEY_TKIP;
1501 key_conf->hw_key_idx = key_conf->keyidx;
1502 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1503 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1508 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1509 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1510 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1513 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1521 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1522 key_conf->keyidx, key_type,
1523 key_conf->keylen, key_conf->key,
1524 addr, tx_seq_32, tx_seq_16);
1526 wl1271_error("Could not add or replace key");
1530 /* the default WEP key needs to be configured at least once */
1531 if (key_type == KEY_WEP) {
1532 ret = wl1271_cmd_set_default_wep_key(wl,
1540 /* The wl1271 does not allow to remove unicast keys - they
1541 will be cleared automatically on next CMD_JOIN. Ignore the
1542 request silently, as we dont want the mac80211 to emit
1543 an error message. */
1544 if (!is_broadcast_ether_addr(addr))
1547 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1548 key_conf->keyidx, key_type,
1549 key_conf->keylen, key_conf->key,
1552 wl1271_error("Could not remove key");
1558 wl1271_error("Unsupported key cmd 0x%x", cmd);
1564 wl1271_ps_elp_sleep(wl);
1567 mutex_unlock(&wl->mutex);
1573 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1574 struct ieee80211_vif *vif,
1575 struct cfg80211_scan_request *req)
1577 struct wl1271 *wl = hw->priv;
1582 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1585 ssid = req->ssids[0].ssid;
1586 len = req->ssids[0].ssid_len;
1589 mutex_lock(&wl->mutex);
1591 ret = wl1271_ps_elp_wakeup(wl, false);
1595 if (wl1271_11a_enabled())
1596 ret = wl1271_cmd_scan(hw->priv, ssid, len, req,
1597 1, 0, WL1271_SCAN_BAND_DUAL, 3);
1599 ret = wl1271_cmd_scan(hw->priv, ssid, len, req,
1600 1, 0, WL1271_SCAN_BAND_2_4_GHZ, 3);
1602 wl1271_ps_elp_sleep(wl);
1605 mutex_unlock(&wl->mutex);
1610 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1612 struct wl1271 *wl = hw->priv;
1615 mutex_lock(&wl->mutex);
1617 if (unlikely(wl->state == WL1271_STATE_OFF))
1620 ret = wl1271_ps_elp_wakeup(wl, false);
1624 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1626 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1628 wl1271_ps_elp_sleep(wl);
1631 mutex_unlock(&wl->mutex);
1636 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1638 u8 *ptr = beacon->data +
1639 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1641 /* find the location of the ssid in the beacon */
1642 while (ptr < beacon->data + beacon->len) {
1643 if (ptr[0] == WLAN_EID_SSID) {
1644 wl->ssid_len = ptr[1];
1645 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1650 wl1271_error("ad-hoc beacon template has no SSID!\n");
1653 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1654 struct ieee80211_vif *vif,
1655 struct ieee80211_bss_conf *bss_conf,
1658 enum wl1271_cmd_ps_mode mode;
1659 struct wl1271 *wl = hw->priv;
1660 bool do_join = false;
1661 bool set_assoc = false;
1664 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1666 mutex_lock(&wl->mutex);
1668 ret = wl1271_ps_elp_wakeup(wl, false);
1672 if ((changed && BSS_CHANGED_BEACON_INT) &&
1673 (wl->bss_type == BSS_TYPE_IBSS)) {
1674 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1675 bss_conf->beacon_int);
1677 wl->beacon_int = bss_conf->beacon_int;
1681 if ((changed && BSS_CHANGED_BEACON) &&
1682 (wl->bss_type == BSS_TYPE_IBSS)) {
1683 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1685 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1688 struct ieee80211_hdr *hdr;
1690 wl1271_ssid_set(wl, beacon);
1691 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1694 wl1271_min_rate_get(wl));
1697 dev_kfree_skb(beacon);
1701 hdr = (struct ieee80211_hdr *) beacon->data;
1702 hdr->frame_control = cpu_to_le16(
1703 IEEE80211_FTYPE_MGMT |
1704 IEEE80211_STYPE_PROBE_RESP);
1706 ret = wl1271_cmd_template_set(wl,
1707 CMD_TEMPL_PROBE_RESPONSE,
1710 wl1271_min_rate_get(wl));
1711 dev_kfree_skb(beacon);
1715 /* Need to update the SSID (for filtering etc) */
1720 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1721 (wl->bss_type == BSS_TYPE_IBSS)) {
1722 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1723 bss_conf->enable_beacon ? "enabled" : "disabled");
1725 if (bss_conf->enable_beacon)
1726 wl->set_bss_type = BSS_TYPE_IBSS;
1728 wl->set_bss_type = BSS_TYPE_STA_BSS;
1732 if (changed & BSS_CHANGED_CQM) {
1733 bool enable = false;
1734 if (bss_conf->cqm_rssi_thold)
1736 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1737 bss_conf->cqm_rssi_thold,
1738 bss_conf->cqm_rssi_hyst);
1741 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1744 if ((changed & BSS_CHANGED_BSSID) &&
1746 * Now we know the correct bssid, so we send a new join command
1747 * and enable the BSSID filter
1749 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1750 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1752 ret = wl1271_cmd_build_null_data(wl);
1756 ret = wl1271_build_qos_null_data(wl);
1760 /* filter out all packets not from this BSSID */
1761 wl1271_configure_filters(wl, 0);
1763 /* Need to update the BSSID (for filtering etc) */
1767 if (changed & BSS_CHANGED_ASSOC) {
1768 if (bss_conf->assoc) {
1770 wl->aid = bss_conf->aid;
1773 wl->ps_poll_failures = 0;
1776 * use basic rates from AP, and determine lowest rate
1777 * to use with control frames.
1779 rates = bss_conf->basic_rates;
1780 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1782 wl->basic_rate = wl1271_min_rate_get(wl);
1783 ret = wl1271_acx_rate_policies(wl);
1788 * with wl1271, we don't need to update the
1789 * beacon_int and dtim_period, because the firmware
1790 * updates it by itself when the first beacon is
1791 * received after a join.
1793 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1798 * The SSID is intentionally set to NULL here - the
1799 * firmware will set the probe request with a
1800 * broadcast SSID regardless of what we set in the
1803 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1806 /* enable the connection monitoring feature */
1807 ret = wl1271_acx_conn_monit_params(wl, true);
1811 /* If we want to go in PSM but we're not there yet */
1812 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1813 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1814 mode = STATION_POWER_SAVE_MODE;
1815 ret = wl1271_ps_set_mode(wl, mode, true);
1820 /* use defaults when not associated */
1821 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1824 /* revert back to minimum rates for the current band */
1825 wl1271_set_band_rate(wl);
1826 wl->basic_rate = wl1271_min_rate_get(wl);
1827 ret = wl1271_acx_rate_policies(wl);
1831 /* disable connection monitor features */
1832 ret = wl1271_acx_conn_monit_params(wl, false);
1834 /* Disable the keep-alive feature */
1835 ret = wl1271_acx_keep_alive_mode(wl, false);
1843 if (changed & BSS_CHANGED_ERP_SLOT) {
1844 if (bss_conf->use_short_slot)
1845 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1847 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1849 wl1271_warning("Set slot time failed %d", ret);
1854 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1855 if (bss_conf->use_short_preamble)
1856 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1858 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1861 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1862 if (bss_conf->use_cts_prot)
1863 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1865 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1867 wl1271_warning("Set ctsprotect failed %d", ret);
1873 ret = wl1271_join(wl, set_assoc);
1875 wl1271_warning("cmd join failed %d", ret);
1881 wl1271_ps_elp_sleep(wl);
1884 mutex_unlock(&wl->mutex);
1887 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1888 const struct ieee80211_tx_queue_params *params)
1890 struct wl1271 *wl = hw->priv;
1894 mutex_lock(&wl->mutex);
1896 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1898 ret = wl1271_ps_elp_wakeup(wl, false);
1902 /* the txop is confed in units of 32us by the mac80211, we need us */
1903 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1904 params->cw_min, params->cw_max,
1905 params->aifs, params->txop << 5);
1910 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1912 ps_scheme = CONF_PS_SCHEME_LEGACY;
1914 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1915 CONF_CHANNEL_TYPE_EDCF,
1916 wl1271_tx_get_queue(queue),
1917 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1922 wl1271_ps_elp_sleep(wl);
1925 mutex_unlock(&wl->mutex);
1930 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1933 struct wl1271 *wl = hw->priv;
1934 u64 mactime = ULLONG_MAX;
1937 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1939 mutex_lock(&wl->mutex);
1941 ret = wl1271_ps_elp_wakeup(wl, false);
1945 ret = wl1271_acx_tsf_info(wl, &mactime);
1950 wl1271_ps_elp_sleep(wl);
1953 mutex_unlock(&wl->mutex);
1957 /* can't be const, mac80211 writes to this */
1958 static struct ieee80211_rate wl1271_rates[] = {
1960 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1961 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1963 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1964 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1965 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1967 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1968 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1969 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1971 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1972 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1973 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1975 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1976 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1978 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1979 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1981 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1982 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1984 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1985 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1987 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1988 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1990 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1991 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1993 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1994 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1996 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1997 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2000 /* can't be const, mac80211 writes to this */
2001 static struct ieee80211_channel wl1271_channels[] = {
2002 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2003 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2004 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2005 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2006 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2007 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2008 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2009 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2010 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2011 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2012 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2013 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2014 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2017 /* mapping to indexes for wl1271_rates */
2018 static const u8 wl1271_rate_to_idx_2ghz[] = {
2019 /* MCS rates are used only with 11n */
2020 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2021 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2022 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2023 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2024 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2025 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2026 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2027 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2029 11, /* CONF_HW_RXTX_RATE_54 */
2030 10, /* CONF_HW_RXTX_RATE_48 */
2031 9, /* CONF_HW_RXTX_RATE_36 */
2032 8, /* CONF_HW_RXTX_RATE_24 */
2034 /* TI-specific rate */
2035 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2037 7, /* CONF_HW_RXTX_RATE_18 */
2038 6, /* CONF_HW_RXTX_RATE_12 */
2039 3, /* CONF_HW_RXTX_RATE_11 */
2040 5, /* CONF_HW_RXTX_RATE_9 */
2041 4, /* CONF_HW_RXTX_RATE_6 */
2042 2, /* CONF_HW_RXTX_RATE_5_5 */
2043 1, /* CONF_HW_RXTX_RATE_2 */
2044 0 /* CONF_HW_RXTX_RATE_1 */
2047 /* can't be const, mac80211 writes to this */
2048 static struct ieee80211_supported_band wl1271_band_2ghz = {
2049 .channels = wl1271_channels,
2050 .n_channels = ARRAY_SIZE(wl1271_channels),
2051 .bitrates = wl1271_rates,
2052 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2055 /* 5 GHz data rates for WL1273 */
2056 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2058 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2059 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2061 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2062 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2064 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2065 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2067 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2068 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2070 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2071 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2073 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2074 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2076 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2077 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2079 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2080 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2083 /* 5 GHz band channels for WL1273 */
2084 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2085 { .hw_value = 183, .center_freq = 4915},
2086 { .hw_value = 184, .center_freq = 4920},
2087 { .hw_value = 185, .center_freq = 4925},
2088 { .hw_value = 187, .center_freq = 4935},
2089 { .hw_value = 188, .center_freq = 4940},
2090 { .hw_value = 189, .center_freq = 4945},
2091 { .hw_value = 192, .center_freq = 4960},
2092 { .hw_value = 196, .center_freq = 4980},
2093 { .hw_value = 7, .center_freq = 5035},
2094 { .hw_value = 8, .center_freq = 5040},
2095 { .hw_value = 9, .center_freq = 5045},
2096 { .hw_value = 11, .center_freq = 5055},
2097 { .hw_value = 12, .center_freq = 5060},
2098 { .hw_value = 16, .center_freq = 5080},
2099 { .hw_value = 34, .center_freq = 5170},
2100 { .hw_value = 36, .center_freq = 5180},
2101 { .hw_value = 38, .center_freq = 5190},
2102 { .hw_value = 40, .center_freq = 5200},
2103 { .hw_value = 42, .center_freq = 5210},
2104 { .hw_value = 44, .center_freq = 5220},
2105 { .hw_value = 46, .center_freq = 5230},
2106 { .hw_value = 48, .center_freq = 5240},
2107 { .hw_value = 52, .center_freq = 5260},
2108 { .hw_value = 56, .center_freq = 5280},
2109 { .hw_value = 60, .center_freq = 5300},
2110 { .hw_value = 64, .center_freq = 5320},
2111 { .hw_value = 100, .center_freq = 5500},
2112 { .hw_value = 104, .center_freq = 5520},
2113 { .hw_value = 108, .center_freq = 5540},
2114 { .hw_value = 112, .center_freq = 5560},
2115 { .hw_value = 116, .center_freq = 5580},
2116 { .hw_value = 120, .center_freq = 5600},
2117 { .hw_value = 124, .center_freq = 5620},
2118 { .hw_value = 128, .center_freq = 5640},
2119 { .hw_value = 132, .center_freq = 5660},
2120 { .hw_value = 136, .center_freq = 5680},
2121 { .hw_value = 140, .center_freq = 5700},
2122 { .hw_value = 149, .center_freq = 5745},
2123 { .hw_value = 153, .center_freq = 5765},
2124 { .hw_value = 157, .center_freq = 5785},
2125 { .hw_value = 161, .center_freq = 5805},
2126 { .hw_value = 165, .center_freq = 5825},
2129 /* mapping to indexes for wl1271_rates_5ghz */
2130 static const u8 wl1271_rate_to_idx_5ghz[] = {
2131 /* MCS rates are used only with 11n */
2132 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2133 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2134 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2135 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2136 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2137 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2138 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2139 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2141 7, /* CONF_HW_RXTX_RATE_54 */
2142 6, /* CONF_HW_RXTX_RATE_48 */
2143 5, /* CONF_HW_RXTX_RATE_36 */
2144 4, /* CONF_HW_RXTX_RATE_24 */
2146 /* TI-specific rate */
2147 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2149 3, /* CONF_HW_RXTX_RATE_18 */
2150 2, /* CONF_HW_RXTX_RATE_12 */
2151 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2152 1, /* CONF_HW_RXTX_RATE_9 */
2153 0, /* CONF_HW_RXTX_RATE_6 */
2154 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2155 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2156 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2159 static struct ieee80211_supported_band wl1271_band_5ghz = {
2160 .channels = wl1271_channels_5ghz,
2161 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2162 .bitrates = wl1271_rates_5ghz,
2163 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2166 static const u8 *wl1271_band_rate_to_idx[] = {
2167 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2168 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2171 static const struct ieee80211_ops wl1271_ops = {
2172 .start = wl1271_op_start,
2173 .stop = wl1271_op_stop,
2174 .add_interface = wl1271_op_add_interface,
2175 .remove_interface = wl1271_op_remove_interface,
2176 .config = wl1271_op_config,
2177 .configure_arp_filter = wl1271_op_configure_arp_filter,
2178 .prepare_multicast = wl1271_op_prepare_multicast,
2179 .configure_filter = wl1271_op_configure_filter,
2181 .set_key = wl1271_op_set_key,
2182 .hw_scan = wl1271_op_hw_scan,
2183 .bss_info_changed = wl1271_op_bss_info_changed,
2184 .set_rts_threshold = wl1271_op_set_rts_threshold,
2185 .conf_tx = wl1271_op_conf_tx,
2186 .get_tsf = wl1271_op_get_tsf,
2187 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2191 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2195 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2197 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2198 wl1271_error("Illegal RX rate from HW: %d", rate);
2202 idx = wl1271_band_rate_to_idx[wl->band][rate];
2203 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2204 wl1271_error("Unsupported RX rate from HW: %d", rate);
2211 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2212 struct device_attribute *attr,
2215 struct wl1271 *wl = dev_get_drvdata(dev);
2218 /* FIXME: what's the maximum length of buf? page size?*/
2221 mutex_lock(&wl->mutex);
2222 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2224 mutex_unlock(&wl->mutex);
2230 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2231 struct device_attribute *attr,
2232 const char *buf, size_t count)
2234 struct wl1271 *wl = dev_get_drvdata(dev);
2238 ret = strict_strtoul(buf, 10, &res);
2241 wl1271_warning("incorrect value written to bt_coex_mode");
2245 mutex_lock(&wl->mutex);
2249 if (res == wl->sg_enabled)
2252 wl->sg_enabled = res;
2254 if (wl->state == WL1271_STATE_OFF)
2257 ret = wl1271_ps_elp_wakeup(wl, false);
2261 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2262 wl1271_ps_elp_sleep(wl);
2265 mutex_unlock(&wl->mutex);
2269 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2270 wl1271_sysfs_show_bt_coex_state,
2271 wl1271_sysfs_store_bt_coex_state);
2273 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2274 struct device_attribute *attr,
2277 struct wl1271 *wl = dev_get_drvdata(dev);
2280 /* FIXME: what's the maximum length of buf? page size?*/
2283 mutex_lock(&wl->mutex);
2284 if (wl->hw_pg_ver >= 0)
2285 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2287 len = snprintf(buf, len, "n/a\n");
2288 mutex_unlock(&wl->mutex);
2293 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2294 wl1271_sysfs_show_hw_pg_ver, NULL);
2296 int wl1271_register_hw(struct wl1271 *wl)
2300 if (wl->mac80211_registered)
2303 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2305 ret = ieee80211_register_hw(wl->hw);
2307 wl1271_error("unable to register mac80211 hw: %d", ret);
2311 wl->mac80211_registered = true;
2313 wl1271_notice("loaded");
2317 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2319 void wl1271_unregister_hw(struct wl1271 *wl)
2321 ieee80211_unregister_hw(wl->hw);
2322 wl->mac80211_registered = false;
2325 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2327 int wl1271_init_ieee80211(struct wl1271 *wl)
2329 /* The tx descriptor buffer and the TKIP space. */
2330 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2331 sizeof(struct wl1271_tx_hw_descr);
2334 /* FIXME: find a proper value */
2335 wl->hw->channel_change_time = 10000;
2336 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2338 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2339 IEEE80211_HW_BEACON_FILTER |
2340 IEEE80211_HW_SUPPORTS_PS |
2341 IEEE80211_HW_SUPPORTS_UAPSD |
2342 IEEE80211_HW_HAS_RATE_CONTROL |
2343 IEEE80211_HW_CONNECTION_MONITOR |
2344 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2346 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2347 BIT(NL80211_IFTYPE_ADHOC);
2348 wl->hw->wiphy->max_scan_ssids = 1;
2349 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2351 if (wl1271_11a_enabled())
2352 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2355 wl->hw->max_rates = 1;
2357 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2361 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2363 #define WL1271_DEFAULT_CHANNEL 0
2365 struct ieee80211_hw *wl1271_alloc_hw(void)
2367 struct ieee80211_hw *hw;
2368 struct platform_device *plat_dev = NULL;
2372 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2374 wl1271_error("could not alloc ieee80211_hw");
2379 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2381 wl1271_error("could not allocate platform_device");
2383 goto err_plat_alloc;
2386 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2389 memset(wl, 0, sizeof(*wl));
2391 INIT_LIST_HEAD(&wl->list);
2394 wl->plat_dev = plat_dev;
2396 skb_queue_head_init(&wl->tx_queue);
2398 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2399 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2400 wl->channel = WL1271_DEFAULT_CHANNEL;
2401 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2402 wl->default_key = 0;
2404 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2405 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2406 wl->psm_entry_retry = 0;
2407 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2408 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2409 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2410 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2411 wl->sta_rate_set = 0;
2412 wl->band = IEEE80211_BAND_2GHZ;
2415 wl->sg_enabled = true;
2418 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2419 wl->tx_frames[i] = NULL;
2421 spin_lock_init(&wl->wl_lock);
2423 wl->state = WL1271_STATE_OFF;
2424 mutex_init(&wl->mutex);
2426 /* Apply default driver configuration. */
2427 wl1271_conf_init(wl);
2429 wl1271_debugfs_init(wl);
2431 /* Register platform device */
2432 ret = platform_device_register(wl->plat_dev);
2434 wl1271_error("couldn't register platform device");
2437 dev_set_drvdata(&wl->plat_dev->dev, wl);
2439 /* Create sysfs file to control bt coex state */
2440 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2442 wl1271_error("failed to create sysfs file bt_coex_state");
2446 /* Create sysfs file to get HW PG version */
2447 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2449 wl1271_error("failed to create sysfs file hw_pg_ver");
2450 goto err_bt_coex_state;
2456 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2459 platform_device_unregister(wl->plat_dev);
2462 wl1271_debugfs_exit(wl);
2466 ieee80211_free_hw(hw);
2470 return ERR_PTR(ret);
2472 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2474 int wl1271_free_hw(struct wl1271 *wl)
2476 platform_device_unregister(wl->plat_dev);
2477 kfree(wl->plat_dev);
2479 wl1271_debugfs_exit(wl);
2486 kfree(wl->fw_status);
2487 kfree(wl->tx_res_if);
2489 ieee80211_free_hw(wl->hw);
2493 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2495 MODULE_LICENSE("GPL");
2496 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2497 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");