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 int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
283 struct net_device *dev = arg;
284 struct wireless_dev *wdev;
286 struct ieee80211_hw *hw;
288 struct wl1271 *wl_temp;
291 /* Check that this notification is for us. */
292 if (what != NETDEV_CHANGE)
295 wdev = dev->ieee80211_ptr;
303 hw = wiphy_priv(wiphy);
308 list_for_each_entry(wl, &wl_list, list) {
315 mutex_lock(&wl->mutex);
317 if (wl->state == WL1271_STATE_OFF)
320 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
323 ret = wl1271_ps_elp_wakeup(wl, false);
327 if ((dev->operstate == IF_OPER_UP) &&
328 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
329 wl1271_cmd_set_sta_state(wl);
330 wl1271_info("Association completed.");
333 wl1271_ps_elp_sleep(wl);
336 mutex_unlock(&wl->mutex);
341 static void wl1271_conf_init(struct wl1271 *wl)
345 * This function applies the default configuration to the driver. This
346 * function is invoked upon driver load (spi probe.)
348 * The configuration is stored in a run-time structure in order to
349 * facilitate for run-time adjustment of any of the parameters. Making
350 * changes to the configuration structure will apply the new values on
351 * the next interface up (wl1271_op_start.)
354 /* apply driver default configuration */
355 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
359 static int wl1271_plt_init(struct wl1271 *wl)
361 struct conf_tx_ac_category *conf_ac;
362 struct conf_tx_tid *conf_tid;
365 ret = wl1271_cmd_general_parms(wl);
369 ret = wl1271_cmd_radio_parms(wl);
373 ret = wl1271_init_templates_config(wl);
377 ret = wl1271_acx_init_mem_config(wl);
381 /* PHY layer config */
382 ret = wl1271_init_phy_config(wl);
384 goto out_free_memmap;
386 ret = wl1271_acx_dco_itrim_params(wl);
388 goto out_free_memmap;
390 /* Initialize connection monitoring thresholds */
391 ret = wl1271_acx_conn_monit_params(wl, false);
393 goto out_free_memmap;
395 /* Bluetooth WLAN coexistence */
396 ret = wl1271_init_pta(wl);
398 goto out_free_memmap;
400 /* Energy detection */
401 ret = wl1271_init_energy_detection(wl);
403 goto out_free_memmap;
405 /* Default fragmentation threshold */
406 ret = wl1271_acx_frag_threshold(wl);
408 goto out_free_memmap;
410 /* Default TID configuration */
411 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
412 conf_tid = &wl->conf.tx.tid_conf[i];
413 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
414 conf_tid->channel_type,
417 conf_tid->ack_policy,
418 conf_tid->apsd_conf[0],
419 conf_tid->apsd_conf[1]);
421 goto out_free_memmap;
424 /* Default AC configuration */
425 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
426 conf_ac = &wl->conf.tx.ac_conf[i];
427 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
428 conf_ac->cw_max, conf_ac->aifsn,
429 conf_ac->tx_op_limit);
431 goto out_free_memmap;
434 /* Enable data path */
435 ret = wl1271_cmd_data_path(wl, 1);
437 goto out_free_memmap;
439 /* Configure for CAM power saving (ie. always active) */
440 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
442 goto out_free_memmap;
445 ret = wl1271_acx_pm_config(wl);
447 goto out_free_memmap;
452 kfree(wl->target_mem_map);
453 wl->target_mem_map = NULL;
458 static void wl1271_fw_status(struct wl1271 *wl,
459 struct wl1271_fw_status *status)
465 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
467 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
468 "drv_rx_counter = %d, tx_results_counter = %d)",
470 status->fw_rx_counter,
471 status->drv_rx_counter,
472 status->tx_results_counter);
474 /* update number of available TX blocks */
475 for (i = 0; i < NUM_TX_QUEUES; i++) {
476 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
477 wl->tx_blocks_freed[i];
479 wl->tx_blocks_freed[i] =
480 le32_to_cpu(status->tx_released_blks[i]);
481 wl->tx_blocks_available += cnt;
485 /* if more blocks are available now, schedule some tx work */
486 if (total && !skb_queue_empty(&wl->tx_queue))
487 ieee80211_queue_work(wl->hw, &wl->tx_work);
489 /* update the host-chipset time offset */
491 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
492 (s64)le32_to_cpu(status->fw_localtime);
495 #define WL1271_IRQ_MAX_LOOPS 10
497 static void wl1271_irq_work(struct work_struct *work)
501 int loopcount = WL1271_IRQ_MAX_LOOPS;
504 container_of(work, struct wl1271, irq_work);
506 mutex_lock(&wl->mutex);
508 wl1271_debug(DEBUG_IRQ, "IRQ work");
510 if (unlikely(wl->state == WL1271_STATE_OFF))
513 ret = wl1271_ps_elp_wakeup(wl, true);
517 spin_lock_irqsave(&wl->wl_lock, flags);
518 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
519 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
520 spin_unlock_irqrestore(&wl->wl_lock, flags);
523 wl1271_fw_status(wl, wl->fw_status);
524 intr = le32_to_cpu(wl->fw_status->intr);
526 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
527 spin_lock_irqsave(&wl->wl_lock, flags);
531 intr &= WL1271_INTR_MASK;
533 if (intr & WL1271_ACX_INTR_DATA) {
534 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
536 /* check for tx results */
537 if (wl->fw_status->tx_results_counter !=
538 (wl->tx_results_count & 0xff))
539 wl1271_tx_complete(wl);
541 wl1271_rx(wl, wl->fw_status);
544 if (intr & WL1271_ACX_INTR_EVENT_A) {
545 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
546 wl1271_event_handle(wl, 0);
549 if (intr & WL1271_ACX_INTR_EVENT_B) {
550 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
551 wl1271_event_handle(wl, 1);
554 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
555 wl1271_debug(DEBUG_IRQ,
556 "WL1271_ACX_INTR_INIT_COMPLETE");
558 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
559 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
561 spin_lock_irqsave(&wl->wl_lock, flags);
564 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
565 ieee80211_queue_work(wl->hw, &wl->irq_work);
567 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
568 spin_unlock_irqrestore(&wl->wl_lock, flags);
570 wl1271_ps_elp_sleep(wl);
573 mutex_unlock(&wl->mutex);
576 static int wl1271_fetch_firmware(struct wl1271 *wl)
578 const struct firmware *fw;
581 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
584 wl1271_error("could not get firmware: %d", ret);
589 wl1271_error("firmware size is not multiple of 32 bits: %zu",
595 wl->fw_len = fw->size;
596 wl->fw = vmalloc(wl->fw_len);
599 wl1271_error("could not allocate memory for the firmware");
604 memcpy(wl->fw, fw->data, wl->fw_len);
609 release_firmware(fw);
614 static int wl1271_fetch_nvs(struct wl1271 *wl)
616 const struct firmware *fw;
619 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
622 wl1271_error("could not get nvs file: %d", ret);
627 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
628 * configurations) can be removed when those NVS files stop floating
631 if (fw->size != sizeof(struct wl1271_nvs_file) &&
632 (fw->size != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
633 wl1271_11a_enabled())) {
634 wl1271_error("nvs size is not as expected: %zu != %zu",
635 fw->size, sizeof(struct wl1271_nvs_file));
640 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
643 wl1271_error("could not allocate memory for the nvs file");
649 release_firmware(fw);
654 static void wl1271_fw_wakeup(struct wl1271 *wl)
658 elp_reg = ELPCTRL_WAKE_UP;
659 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
662 static int wl1271_setup(struct wl1271 *wl)
664 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
668 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
669 if (!wl->tx_res_if) {
670 kfree(wl->fw_status);
674 INIT_WORK(&wl->irq_work, wl1271_irq_work);
675 INIT_WORK(&wl->tx_work, wl1271_tx_work);
679 static int wl1271_chip_wakeup(struct wl1271 *wl)
681 struct wl1271_partition_set partition;
684 msleep(WL1271_PRE_POWER_ON_SLEEP);
685 ret = wl1271_power_on(wl);
688 msleep(WL1271_POWER_ON_SLEEP);
692 /* We don't need a real memory partition here, because we only want
693 * to use the registers at this point. */
694 memset(&partition, 0, sizeof(partition));
695 partition.reg.start = REGISTERS_BASE;
696 partition.reg.size = REGISTERS_DOWN_SIZE;
697 wl1271_set_partition(wl, &partition);
699 /* ELP module wake up */
700 wl1271_fw_wakeup(wl);
702 /* whal_FwCtrl_BootSm() */
704 /* 0. read chip id from CHIP_ID */
705 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
707 /* 1. check if chip id is valid */
709 switch (wl->chip.id) {
710 case CHIP_ID_1271_PG10:
711 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
714 ret = wl1271_setup(wl);
718 case CHIP_ID_1271_PG20:
719 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
722 ret = wl1271_setup(wl);
727 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
732 if (wl->fw == NULL) {
733 ret = wl1271_fetch_firmware(wl);
738 /* No NVS from netlink, try to get it from the filesystem */
739 if (wl->nvs == NULL) {
740 ret = wl1271_fetch_nvs(wl);
749 int wl1271_plt_start(struct wl1271 *wl)
751 int retries = WL1271_BOOT_RETRIES;
754 mutex_lock(&wl->mutex);
756 wl1271_notice("power up");
758 if (wl->state != WL1271_STATE_OFF) {
759 wl1271_error("cannot go into PLT state because not "
760 "in off state: %d", wl->state);
767 ret = wl1271_chip_wakeup(wl);
771 ret = wl1271_boot(wl);
775 ret = wl1271_plt_init(wl);
779 wl->state = WL1271_STATE_PLT;
780 wl1271_notice("firmware booted in PLT mode (%s)",
785 wl1271_disable_interrupts(wl);
786 mutex_unlock(&wl->mutex);
787 /* Unlocking the mutex in the middle of handling is
788 inherently unsafe. In this case we deem it safe to do,
789 because we need to let any possibly pending IRQ out of
790 the system (and while we are WL1271_STATE_OFF the IRQ
791 work function will not do anything.) Also, any other
792 possible concurrent operations will fail due to the
793 current state, hence the wl1271 struct should be safe. */
794 cancel_work_sync(&wl->irq_work);
795 mutex_lock(&wl->mutex);
797 wl1271_power_off(wl);
800 wl1271_error("firmware boot in PLT mode failed despite %d retries",
801 WL1271_BOOT_RETRIES);
803 mutex_unlock(&wl->mutex);
808 int wl1271_plt_stop(struct wl1271 *wl)
812 mutex_lock(&wl->mutex);
814 wl1271_notice("power down");
816 if (wl->state != WL1271_STATE_PLT) {
817 wl1271_error("cannot power down because not in PLT "
818 "state: %d", wl->state);
823 wl1271_disable_interrupts(wl);
824 wl1271_power_off(wl);
826 wl->state = WL1271_STATE_OFF;
830 mutex_unlock(&wl->mutex);
836 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
838 struct wl1271 *wl = hw->priv;
839 struct ieee80211_conf *conf = &hw->conf;
840 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
841 struct ieee80211_sta *sta = txinfo->control.sta;
844 /* peek into the rates configured in the STA entry */
845 spin_lock_irqsave(&wl->wl_lock, flags);
846 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
847 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
848 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
850 spin_unlock_irqrestore(&wl->wl_lock, flags);
852 /* queue the packet */
853 skb_queue_tail(&wl->tx_queue, skb);
856 * The chip specific setup must run before the first TX packet -
857 * before that, the tx_work will not be initialized!
860 ieee80211_queue_work(wl->hw, &wl->tx_work);
863 * The workqueue is slow to process the tx_queue and we need stop
864 * the queue here, otherwise the queue will get too long.
866 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
867 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
869 spin_lock_irqsave(&wl->wl_lock, flags);
870 ieee80211_stop_queues(wl->hw);
871 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
872 spin_unlock_irqrestore(&wl->wl_lock, flags);
878 static struct notifier_block wl1271_dev_notifier = {
879 .notifier_call = wl1271_dev_notify,
882 static int wl1271_op_start(struct ieee80211_hw *hw)
884 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
887 * We have to delay the booting of the hardware because
888 * we need to know the local MAC address before downloading and
889 * initializing the firmware. The MAC address cannot be changed
890 * after boot, and without the proper MAC address, the firmware
891 * will not function properly.
893 * The MAC address is first known when the corresponding interface
894 * is added. That is where we will initialize the hardware.
900 static void wl1271_op_stop(struct ieee80211_hw *hw)
902 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
905 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
906 struct ieee80211_vif *vif)
908 struct wl1271 *wl = hw->priv;
909 struct wiphy *wiphy = hw->wiphy;
910 int retries = WL1271_BOOT_RETRIES;
913 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
914 vif->type, vif->addr);
916 mutex_lock(&wl->mutex);
925 case NL80211_IFTYPE_STATION:
926 wl->bss_type = BSS_TYPE_STA_BSS;
927 wl->set_bss_type = BSS_TYPE_STA_BSS;
929 case NL80211_IFTYPE_ADHOC:
930 wl->bss_type = BSS_TYPE_IBSS;
931 wl->set_bss_type = BSS_TYPE_STA_BSS;
938 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
940 if (wl->state != WL1271_STATE_OFF) {
941 wl1271_error("cannot start because not in off state: %d",
949 ret = wl1271_chip_wakeup(wl);
953 ret = wl1271_boot(wl);
957 ret = wl1271_hw_init(wl);
961 wl->state = WL1271_STATE_ON;
962 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
964 /* update hw/fw version info in wiphy struct */
965 wiphy->hw_version = wl->chip.id;
966 strncpy(wiphy->fw_version, wl->chip.fw_ver,
967 sizeof(wiphy->fw_version));
972 wl1271_disable_interrupts(wl);
973 mutex_unlock(&wl->mutex);
974 /* Unlocking the mutex in the middle of handling is
975 inherently unsafe. In this case we deem it safe to do,
976 because we need to let any possibly pending IRQ out of
977 the system (and while we are WL1271_STATE_OFF the IRQ
978 work function will not do anything.) Also, any other
979 possible concurrent operations will fail due to the
980 current state, hence the wl1271 struct should be safe. */
981 cancel_work_sync(&wl->irq_work);
982 mutex_lock(&wl->mutex);
984 wl1271_power_off(wl);
987 wl1271_error("firmware boot failed despite %d retries",
988 WL1271_BOOT_RETRIES);
990 mutex_unlock(&wl->mutex);
993 list_add(&wl->list, &wl_list);
998 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
999 struct ieee80211_vif *vif)
1001 struct wl1271 *wl = hw->priv;
1004 mutex_lock(&wl->mutex);
1005 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1007 wl1271_info("down");
1009 list_del(&wl->list);
1011 WARN_ON(wl->state != WL1271_STATE_ON);
1013 /* enable dyn ps just in case (if left on due to fw crash etc) */
1014 if (wl->bss_type == BSS_TYPE_STA_BSS)
1015 ieee80211_enable_dyn_ps(wl->vif);
1017 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1018 ieee80211_scan_completed(wl->hw, true);
1019 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1020 kfree(wl->scan.scanned_ch);
1021 wl->scan.scanned_ch = NULL;
1024 wl->state = WL1271_STATE_OFF;
1026 wl1271_disable_interrupts(wl);
1028 mutex_unlock(&wl->mutex);
1030 cancel_work_sync(&wl->irq_work);
1031 cancel_work_sync(&wl->tx_work);
1032 cancel_delayed_work_sync(&wl->pspoll_work);
1034 mutex_lock(&wl->mutex);
1036 /* let's notify MAC80211 about the remaining pending TX frames */
1037 wl1271_tx_reset(wl);
1038 wl1271_power_off(wl);
1040 memset(wl->bssid, 0, ETH_ALEN);
1041 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1043 wl->bss_type = MAX_BSS_TYPE;
1044 wl->set_bss_type = MAX_BSS_TYPE;
1045 wl->band = IEEE80211_BAND_2GHZ;
1048 wl->psm_entry_retry = 0;
1049 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1050 wl->tx_blocks_available = 0;
1051 wl->tx_results_count = 0;
1052 wl->tx_packets_count = 0;
1053 wl->tx_security_last_seq = 0;
1054 wl->tx_security_seq = 0;
1055 wl->time_offset = 0;
1056 wl->session_counter = 0;
1057 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1058 wl->sta_rate_set = 0;
1063 for (i = 0; i < NUM_TX_QUEUES; i++)
1064 wl->tx_blocks_freed[i] = 0;
1066 wl1271_debugfs_reset(wl);
1068 kfree(wl->fw_status);
1069 wl->fw_status = NULL;
1070 kfree(wl->tx_res_if);
1071 wl->tx_res_if = NULL;
1072 kfree(wl->target_mem_map);
1073 wl->target_mem_map = NULL;
1075 mutex_unlock(&wl->mutex);
1078 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1080 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1081 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1083 /* combine requested filters with current filter config */
1084 filters = wl->filters | filters;
1086 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1088 if (filters & FIF_PROMISC_IN_BSS) {
1089 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1090 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1091 wl->rx_config |= CFG_BSSID_FILTER_EN;
1093 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1094 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1095 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1096 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1098 if (filters & FIF_OTHER_BSS) {
1099 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1100 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1102 if (filters & FIF_CONTROL) {
1103 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1104 wl->rx_filter |= CFG_RX_CTL_EN;
1106 if (filters & FIF_FCSFAIL) {
1107 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1108 wl->rx_filter |= CFG_RX_FCS_ERROR;
1112 static int wl1271_dummy_join(struct wl1271 *wl)
1115 /* we need to use a dummy BSSID for now */
1116 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1119 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1121 /* pass through frames from all BSS */
1122 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1124 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1128 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1134 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1139 * One of the side effects of the JOIN command is that is clears
1140 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1141 * to a WPA/WPA2 access point will therefore kill the data-path.
1142 * Currently there is no supported scenario for JOIN during
1143 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1144 * must be handled somehow.
1147 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1148 wl1271_info("JOIN while associated.");
1151 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1153 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1157 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1159 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1163 * The join command disable the keep-alive mode, shut down its process,
1164 * and also clear the template config, so we need to reset it all after
1165 * the join. The acx_aid starts the keep-alive process, and the order
1166 * of the commands below is relevant.
1168 ret = wl1271_acx_keep_alive_mode(wl, true);
1172 ret = wl1271_acx_aid(wl, wl->aid);
1176 ret = wl1271_cmd_build_klv_null_data(wl);
1180 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1181 ACX_KEEP_ALIVE_TPL_VALID);
1189 static int wl1271_unjoin(struct wl1271 *wl)
1193 /* to stop listening to a channel, we disconnect */
1194 ret = wl1271_cmd_disconnect(wl);
1198 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1199 memset(wl->bssid, 0, ETH_ALEN);
1201 /* stop filterting packets based on bssid */
1202 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1208 static void wl1271_set_band_rate(struct wl1271 *wl)
1210 if (wl->band == IEEE80211_BAND_2GHZ)
1211 wl->basic_rate_set = wl->conf.tx.basic_rate;
1213 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1216 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1221 if (!wl->basic_rate_set) {
1223 wl->basic_rate_set = wl->conf.tx.basic_rate;
1226 for (i = 0; !rate; i++) {
1227 if ((wl->basic_rate_set >> i) & 0x1)
1234 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1239 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1240 ret = wl1271_unjoin(wl);
1244 wl->rate_set = wl1271_min_rate_get(wl);
1245 wl->sta_rate_set = 0;
1246 ret = wl1271_acx_rate_policies(wl);
1249 ret = wl1271_acx_keep_alive_config(
1250 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1251 ACX_KEEP_ALIVE_TPL_INVALID);
1254 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1256 /* increment the session counter */
1257 wl->session_counter++;
1258 if (wl->session_counter >= SESSION_COUNTER_MAX)
1259 wl->session_counter = 0;
1260 ret = wl1271_dummy_join(wl);
1263 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1270 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1272 struct wl1271 *wl = hw->priv;
1273 struct ieee80211_conf *conf = &hw->conf;
1274 int channel, ret = 0;
1276 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1278 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1280 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1282 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1285 * mac80211 will go to idle nearly immediately after transmitting some
1286 * frames, such as the deauth. To make sure those frames reach the air,
1287 * wait here until the TX queue is fully flushed.
1289 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1290 (conf->flags & IEEE80211_CONF_IDLE))
1291 wl1271_tx_flush(wl);
1293 mutex_lock(&wl->mutex);
1295 if (unlikely(wl->state == WL1271_STATE_OFF))
1298 ret = wl1271_ps_elp_wakeup(wl, false);
1302 /* if the channel changes while joined, join again */
1303 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1304 ((wl->band != conf->channel->band) ||
1305 (wl->channel != channel))) {
1306 wl->band = conf->channel->band;
1307 wl->channel = channel;
1310 * FIXME: the mac80211 should really provide a fixed rate
1311 * to use here. for now, just use the smallest possible rate
1312 * for the band as a fixed rate for association frames and
1313 * other control messages.
1315 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1316 wl1271_set_band_rate(wl);
1318 wl->basic_rate = wl1271_min_rate_get(wl);
1319 ret = wl1271_acx_rate_policies(wl);
1321 wl1271_warning("rate policy for update channel "
1324 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1325 ret = wl1271_join(wl, false);
1327 wl1271_warning("cmd join to update channel "
1332 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1333 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1335 wl1271_warning("idle mode change failed %d", ret);
1339 * if mac80211 changes the PSM mode, make sure the mode is not
1340 * incorrectly changed after the pspoll failure active window.
1342 if (changed & IEEE80211_CONF_CHANGE_PS)
1343 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1345 if (conf->flags & IEEE80211_CONF_PS &&
1346 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1347 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1350 * We enter PSM only if we're already associated.
1351 * If we're not, we'll enter it when joining an SSID,
1352 * through the bss_info_changed() hook.
1354 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1355 wl1271_debug(DEBUG_PSM, "psm enabled");
1356 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1359 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1360 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1361 wl1271_debug(DEBUG_PSM, "psm disabled");
1363 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1365 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1366 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1370 if (conf->power_level != wl->power_level) {
1371 ret = wl1271_acx_tx_power(wl, conf->power_level);
1375 wl->power_level = conf->power_level;
1379 wl1271_ps_elp_sleep(wl);
1382 mutex_unlock(&wl->mutex);
1387 struct wl1271_filter_params {
1390 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1393 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1394 struct netdev_hw_addr_list *mc_list)
1396 struct wl1271_filter_params *fp;
1397 struct netdev_hw_addr *ha;
1398 struct wl1271 *wl = hw->priv;
1400 if (unlikely(wl->state == WL1271_STATE_OFF))
1403 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1405 wl1271_error("Out of memory setting filters.");
1409 /* update multicast filtering parameters */
1410 fp->mc_list_length = 0;
1411 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1412 fp->enabled = false;
1415 netdev_hw_addr_list_for_each(ha, mc_list) {
1416 memcpy(fp->mc_list[fp->mc_list_length],
1417 ha->addr, ETH_ALEN);
1418 fp->mc_list_length++;
1422 return (u64)(unsigned long)fp;
1425 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1428 FIF_BCN_PRBRESP_PROMISC | \
1432 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1433 unsigned int changed,
1434 unsigned int *total, u64 multicast)
1436 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1437 struct wl1271 *wl = hw->priv;
1440 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1442 mutex_lock(&wl->mutex);
1444 *total &= WL1271_SUPPORTED_FILTERS;
1445 changed &= WL1271_SUPPORTED_FILTERS;
1447 if (unlikely(wl->state == WL1271_STATE_OFF))
1450 ret = wl1271_ps_elp_wakeup(wl, false);
1455 if (*total & FIF_ALLMULTI)
1456 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1458 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1460 fp->mc_list_length);
1464 /* determine, whether supported filter values have changed */
1468 /* configure filters */
1469 wl->filters = *total;
1470 wl1271_configure_filters(wl, 0);
1472 /* apply configured filters */
1473 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1478 wl1271_ps_elp_sleep(wl);
1481 mutex_unlock(&wl->mutex);
1485 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1486 struct ieee80211_vif *vif,
1487 struct ieee80211_sta *sta,
1488 struct ieee80211_key_conf *key_conf)
1490 struct wl1271 *wl = hw->priv;
1497 static const u8 bcast_addr[ETH_ALEN] =
1498 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1500 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1502 addr = sta ? sta->addr : bcast_addr;
1504 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1505 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1506 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1507 key_conf->cipher, key_conf->keyidx,
1508 key_conf->keylen, key_conf->flags);
1509 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1511 if (is_zero_ether_addr(addr)) {
1512 /* We dont support TX only encryption */
1517 mutex_lock(&wl->mutex);
1519 ret = wl1271_ps_elp_wakeup(wl, false);
1523 switch (key_conf->cipher) {
1524 case WLAN_CIPHER_SUITE_WEP40:
1525 case WLAN_CIPHER_SUITE_WEP104:
1528 key_conf->hw_key_idx = key_conf->keyidx;
1530 case WLAN_CIPHER_SUITE_TKIP:
1531 key_type = KEY_TKIP;
1533 key_conf->hw_key_idx = key_conf->keyidx;
1534 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1535 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1537 case WLAN_CIPHER_SUITE_CCMP:
1540 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1541 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1542 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1545 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1553 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1554 key_conf->keyidx, key_type,
1555 key_conf->keylen, key_conf->key,
1556 addr, tx_seq_32, tx_seq_16);
1558 wl1271_error("Could not add or replace key");
1562 /* the default WEP key needs to be configured at least once */
1563 if (key_type == KEY_WEP) {
1564 ret = wl1271_cmd_set_default_wep_key(wl,
1572 /* The wl1271 does not allow to remove unicast keys - they
1573 will be cleared automatically on next CMD_JOIN. Ignore the
1574 request silently, as we dont want the mac80211 to emit
1575 an error message. */
1576 if (!is_broadcast_ether_addr(addr))
1579 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1580 key_conf->keyidx, key_type,
1581 key_conf->keylen, key_conf->key,
1584 wl1271_error("Could not remove key");
1590 wl1271_error("Unsupported key cmd 0x%x", cmd);
1596 wl1271_ps_elp_sleep(wl);
1599 mutex_unlock(&wl->mutex);
1605 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1606 struct ieee80211_vif *vif,
1607 struct cfg80211_scan_request *req)
1609 struct wl1271 *wl = hw->priv;
1614 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1617 ssid = req->ssids[0].ssid;
1618 len = req->ssids[0].ssid_len;
1621 mutex_lock(&wl->mutex);
1623 ret = wl1271_ps_elp_wakeup(wl, false);
1627 if (wl1271_11a_enabled())
1628 ret = wl1271_scan(hw->priv, ssid, len, req);
1630 ret = wl1271_scan(hw->priv, ssid, len, req);
1632 wl1271_ps_elp_sleep(wl);
1635 mutex_unlock(&wl->mutex);
1640 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1642 struct wl1271 *wl = hw->priv;
1645 mutex_lock(&wl->mutex);
1647 if (unlikely(wl->state == WL1271_STATE_OFF))
1650 ret = wl1271_ps_elp_wakeup(wl, false);
1654 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1656 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1658 wl1271_ps_elp_sleep(wl);
1661 mutex_unlock(&wl->mutex);
1666 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1668 u8 *ptr = beacon->data +
1669 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1671 /* find the location of the ssid in the beacon */
1672 while (ptr < beacon->data + beacon->len) {
1673 if (ptr[0] == WLAN_EID_SSID) {
1674 wl->ssid_len = ptr[1];
1675 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1680 wl1271_error("ad-hoc beacon template has no SSID!\n");
1683 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1684 struct ieee80211_vif *vif,
1685 struct ieee80211_bss_conf *bss_conf,
1688 enum wl1271_cmd_ps_mode mode;
1689 struct wl1271 *wl = hw->priv;
1690 bool do_join = false;
1691 bool set_assoc = false;
1694 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1696 mutex_lock(&wl->mutex);
1698 ret = wl1271_ps_elp_wakeup(wl, false);
1702 if ((changed & BSS_CHANGED_BEACON_INT) &&
1703 (wl->bss_type == BSS_TYPE_IBSS)) {
1704 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1705 bss_conf->beacon_int);
1707 wl->beacon_int = bss_conf->beacon_int;
1711 if ((changed & BSS_CHANGED_BEACON) &&
1712 (wl->bss_type == BSS_TYPE_IBSS)) {
1713 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1715 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1718 struct ieee80211_hdr *hdr;
1720 wl1271_ssid_set(wl, beacon);
1721 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1724 wl1271_min_rate_get(wl));
1727 dev_kfree_skb(beacon);
1731 hdr = (struct ieee80211_hdr *) beacon->data;
1732 hdr->frame_control = cpu_to_le16(
1733 IEEE80211_FTYPE_MGMT |
1734 IEEE80211_STYPE_PROBE_RESP);
1736 ret = wl1271_cmd_template_set(wl,
1737 CMD_TEMPL_PROBE_RESPONSE,
1740 wl1271_min_rate_get(wl));
1741 dev_kfree_skb(beacon);
1745 /* Need to update the SSID (for filtering etc) */
1750 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1751 (wl->bss_type == BSS_TYPE_IBSS)) {
1752 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1753 bss_conf->enable_beacon ? "enabled" : "disabled");
1755 if (bss_conf->enable_beacon)
1756 wl->set_bss_type = BSS_TYPE_IBSS;
1758 wl->set_bss_type = BSS_TYPE_STA_BSS;
1762 if (changed & BSS_CHANGED_CQM) {
1763 bool enable = false;
1764 if (bss_conf->cqm_rssi_thold)
1766 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1767 bss_conf->cqm_rssi_thold,
1768 bss_conf->cqm_rssi_hyst);
1771 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1774 if ((changed & BSS_CHANGED_BSSID) &&
1776 * Now we know the correct bssid, so we send a new join command
1777 * and enable the BSSID filter
1779 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1780 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1782 ret = wl1271_cmd_build_null_data(wl);
1786 ret = wl1271_build_qos_null_data(wl);
1790 /* filter out all packets not from this BSSID */
1791 wl1271_configure_filters(wl, 0);
1793 /* Need to update the BSSID (for filtering etc) */
1797 if (changed & BSS_CHANGED_ASSOC) {
1798 if (bss_conf->assoc) {
1800 wl->aid = bss_conf->aid;
1803 wl->ps_poll_failures = 0;
1806 * use basic rates from AP, and determine lowest rate
1807 * to use with control frames.
1809 rates = bss_conf->basic_rates;
1810 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1812 wl->basic_rate = wl1271_min_rate_get(wl);
1813 ret = wl1271_acx_rate_policies(wl);
1818 * with wl1271, we don't need to update the
1819 * beacon_int and dtim_period, because the firmware
1820 * updates it by itself when the first beacon is
1821 * received after a join.
1823 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1828 * The SSID is intentionally set to NULL here - the
1829 * firmware will set the probe request with a
1830 * broadcast SSID regardless of what we set in the
1833 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1836 /* enable the connection monitoring feature */
1837 ret = wl1271_acx_conn_monit_params(wl, true);
1841 /* If we want to go in PSM but we're not there yet */
1842 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1843 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1844 mode = STATION_POWER_SAVE_MODE;
1845 ret = wl1271_ps_set_mode(wl, mode, true);
1850 /* use defaults when not associated */
1851 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1852 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1855 /* re-enable dynamic ps - just in case */
1856 ieee80211_enable_dyn_ps(wl->vif);
1858 /* revert back to minimum rates for the current band */
1859 wl1271_set_band_rate(wl);
1860 wl->basic_rate = wl1271_min_rate_get(wl);
1861 ret = wl1271_acx_rate_policies(wl);
1865 /* disable connection monitor features */
1866 ret = wl1271_acx_conn_monit_params(wl, false);
1868 /* Disable the keep-alive feature */
1869 ret = wl1271_acx_keep_alive_mode(wl, false);
1877 if (changed & BSS_CHANGED_ERP_SLOT) {
1878 if (bss_conf->use_short_slot)
1879 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1881 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1883 wl1271_warning("Set slot time failed %d", ret);
1888 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1889 if (bss_conf->use_short_preamble)
1890 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1892 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1895 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1896 if (bss_conf->use_cts_prot)
1897 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1899 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1901 wl1271_warning("Set ctsprotect failed %d", ret);
1906 if (changed & BSS_CHANGED_ARP_FILTER) {
1907 __be32 addr = bss_conf->arp_addr_list[0];
1908 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1910 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1911 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1913 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1920 ret = wl1271_join(wl, set_assoc);
1922 wl1271_warning("cmd join failed %d", ret);
1928 wl1271_ps_elp_sleep(wl);
1931 mutex_unlock(&wl->mutex);
1934 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1935 const struct ieee80211_tx_queue_params *params)
1937 struct wl1271 *wl = hw->priv;
1941 mutex_lock(&wl->mutex);
1943 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1945 ret = wl1271_ps_elp_wakeup(wl, false);
1949 /* the txop is confed in units of 32us by the mac80211, we need us */
1950 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1951 params->cw_min, params->cw_max,
1952 params->aifs, params->txop << 5);
1957 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1959 ps_scheme = CONF_PS_SCHEME_LEGACY;
1961 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1962 CONF_CHANNEL_TYPE_EDCF,
1963 wl1271_tx_get_queue(queue),
1964 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1969 wl1271_ps_elp_sleep(wl);
1972 mutex_unlock(&wl->mutex);
1977 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1980 struct wl1271 *wl = hw->priv;
1981 u64 mactime = ULLONG_MAX;
1984 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1986 mutex_lock(&wl->mutex);
1988 ret = wl1271_ps_elp_wakeup(wl, false);
1992 ret = wl1271_acx_tsf_info(wl, &mactime);
1997 wl1271_ps_elp_sleep(wl);
2000 mutex_unlock(&wl->mutex);
2004 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2005 struct survey_info *survey)
2007 struct wl1271 *wl = hw->priv;
2008 struct ieee80211_conf *conf = &hw->conf;
2013 survey->channel = conf->channel;
2014 survey->filled = SURVEY_INFO_NOISE_DBM;
2015 survey->noise = wl->noise;
2020 /* can't be const, mac80211 writes to this */
2021 static struct ieee80211_rate wl1271_rates[] = {
2023 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2024 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2026 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2027 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2028 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2030 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2031 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2032 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2034 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2035 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2036 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2038 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2039 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2041 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2042 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2044 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2045 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2047 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2048 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2050 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2051 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2053 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2054 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2056 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2057 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2059 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2060 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2063 /* can't be const, mac80211 writes to this */
2064 static struct ieee80211_channel wl1271_channels[] = {
2065 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2066 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2067 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2068 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2069 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2070 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2071 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2072 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2073 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2074 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2075 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2076 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2077 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2080 /* mapping to indexes for wl1271_rates */
2081 static const u8 wl1271_rate_to_idx_2ghz[] = {
2082 /* MCS rates are used only with 11n */
2083 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2084 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2085 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2086 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2087 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2088 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2089 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2090 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2092 11, /* CONF_HW_RXTX_RATE_54 */
2093 10, /* CONF_HW_RXTX_RATE_48 */
2094 9, /* CONF_HW_RXTX_RATE_36 */
2095 8, /* CONF_HW_RXTX_RATE_24 */
2097 /* TI-specific rate */
2098 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2100 7, /* CONF_HW_RXTX_RATE_18 */
2101 6, /* CONF_HW_RXTX_RATE_12 */
2102 3, /* CONF_HW_RXTX_RATE_11 */
2103 5, /* CONF_HW_RXTX_RATE_9 */
2104 4, /* CONF_HW_RXTX_RATE_6 */
2105 2, /* CONF_HW_RXTX_RATE_5_5 */
2106 1, /* CONF_HW_RXTX_RATE_2 */
2107 0 /* CONF_HW_RXTX_RATE_1 */
2110 /* can't be const, mac80211 writes to this */
2111 static struct ieee80211_supported_band wl1271_band_2ghz = {
2112 .channels = wl1271_channels,
2113 .n_channels = ARRAY_SIZE(wl1271_channels),
2114 .bitrates = wl1271_rates,
2115 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2118 /* 5 GHz data rates for WL1273 */
2119 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2121 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2122 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2124 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2125 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2127 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2128 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2130 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2131 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2133 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2134 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2136 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2137 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2139 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2140 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2142 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2143 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2146 /* 5 GHz band channels for WL1273 */
2147 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2148 { .hw_value = 183, .center_freq = 4915},
2149 { .hw_value = 184, .center_freq = 4920},
2150 { .hw_value = 185, .center_freq = 4925},
2151 { .hw_value = 187, .center_freq = 4935},
2152 { .hw_value = 188, .center_freq = 4940},
2153 { .hw_value = 189, .center_freq = 4945},
2154 { .hw_value = 192, .center_freq = 4960},
2155 { .hw_value = 196, .center_freq = 4980},
2156 { .hw_value = 7, .center_freq = 5035},
2157 { .hw_value = 8, .center_freq = 5040},
2158 { .hw_value = 9, .center_freq = 5045},
2159 { .hw_value = 11, .center_freq = 5055},
2160 { .hw_value = 12, .center_freq = 5060},
2161 { .hw_value = 16, .center_freq = 5080},
2162 { .hw_value = 34, .center_freq = 5170},
2163 { .hw_value = 36, .center_freq = 5180},
2164 { .hw_value = 38, .center_freq = 5190},
2165 { .hw_value = 40, .center_freq = 5200},
2166 { .hw_value = 42, .center_freq = 5210},
2167 { .hw_value = 44, .center_freq = 5220},
2168 { .hw_value = 46, .center_freq = 5230},
2169 { .hw_value = 48, .center_freq = 5240},
2170 { .hw_value = 52, .center_freq = 5260},
2171 { .hw_value = 56, .center_freq = 5280},
2172 { .hw_value = 60, .center_freq = 5300},
2173 { .hw_value = 64, .center_freq = 5320},
2174 { .hw_value = 100, .center_freq = 5500},
2175 { .hw_value = 104, .center_freq = 5520},
2176 { .hw_value = 108, .center_freq = 5540},
2177 { .hw_value = 112, .center_freq = 5560},
2178 { .hw_value = 116, .center_freq = 5580},
2179 { .hw_value = 120, .center_freq = 5600},
2180 { .hw_value = 124, .center_freq = 5620},
2181 { .hw_value = 128, .center_freq = 5640},
2182 { .hw_value = 132, .center_freq = 5660},
2183 { .hw_value = 136, .center_freq = 5680},
2184 { .hw_value = 140, .center_freq = 5700},
2185 { .hw_value = 149, .center_freq = 5745},
2186 { .hw_value = 153, .center_freq = 5765},
2187 { .hw_value = 157, .center_freq = 5785},
2188 { .hw_value = 161, .center_freq = 5805},
2189 { .hw_value = 165, .center_freq = 5825},
2192 /* mapping to indexes for wl1271_rates_5ghz */
2193 static const u8 wl1271_rate_to_idx_5ghz[] = {
2194 /* MCS rates are used only with 11n */
2195 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2196 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2197 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2198 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2199 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2200 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2201 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2202 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2204 7, /* CONF_HW_RXTX_RATE_54 */
2205 6, /* CONF_HW_RXTX_RATE_48 */
2206 5, /* CONF_HW_RXTX_RATE_36 */
2207 4, /* CONF_HW_RXTX_RATE_24 */
2209 /* TI-specific rate */
2210 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2212 3, /* CONF_HW_RXTX_RATE_18 */
2213 2, /* CONF_HW_RXTX_RATE_12 */
2214 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2215 1, /* CONF_HW_RXTX_RATE_9 */
2216 0, /* CONF_HW_RXTX_RATE_6 */
2217 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2218 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2219 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2222 static struct ieee80211_supported_band wl1271_band_5ghz = {
2223 .channels = wl1271_channels_5ghz,
2224 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2225 .bitrates = wl1271_rates_5ghz,
2226 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2229 static const u8 *wl1271_band_rate_to_idx[] = {
2230 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2231 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2234 static const struct ieee80211_ops wl1271_ops = {
2235 .start = wl1271_op_start,
2236 .stop = wl1271_op_stop,
2237 .add_interface = wl1271_op_add_interface,
2238 .remove_interface = wl1271_op_remove_interface,
2239 .config = wl1271_op_config,
2240 .prepare_multicast = wl1271_op_prepare_multicast,
2241 .configure_filter = wl1271_op_configure_filter,
2243 .set_key = wl1271_op_set_key,
2244 .hw_scan = wl1271_op_hw_scan,
2245 .bss_info_changed = wl1271_op_bss_info_changed,
2246 .set_rts_threshold = wl1271_op_set_rts_threshold,
2247 .conf_tx = wl1271_op_conf_tx,
2248 .get_tsf = wl1271_op_get_tsf,
2249 .get_survey = wl1271_op_get_survey,
2250 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2254 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2258 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2260 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2261 wl1271_error("Illegal RX rate from HW: %d", rate);
2265 idx = wl1271_band_rate_to_idx[wl->band][rate];
2266 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2267 wl1271_error("Unsupported RX rate from HW: %d", rate);
2274 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2275 struct device_attribute *attr,
2278 struct wl1271 *wl = dev_get_drvdata(dev);
2281 /* FIXME: what's the maximum length of buf? page size?*/
2284 mutex_lock(&wl->mutex);
2285 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2287 mutex_unlock(&wl->mutex);
2293 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2294 struct device_attribute *attr,
2295 const char *buf, size_t count)
2297 struct wl1271 *wl = dev_get_drvdata(dev);
2301 ret = strict_strtoul(buf, 10, &res);
2304 wl1271_warning("incorrect value written to bt_coex_mode");
2308 mutex_lock(&wl->mutex);
2312 if (res == wl->sg_enabled)
2315 wl->sg_enabled = res;
2317 if (wl->state == WL1271_STATE_OFF)
2320 ret = wl1271_ps_elp_wakeup(wl, false);
2324 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2325 wl1271_ps_elp_sleep(wl);
2328 mutex_unlock(&wl->mutex);
2332 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2333 wl1271_sysfs_show_bt_coex_state,
2334 wl1271_sysfs_store_bt_coex_state);
2336 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2337 struct device_attribute *attr,
2340 struct wl1271 *wl = dev_get_drvdata(dev);
2343 /* FIXME: what's the maximum length of buf? page size?*/
2346 mutex_lock(&wl->mutex);
2347 if (wl->hw_pg_ver >= 0)
2348 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2350 len = snprintf(buf, len, "n/a\n");
2351 mutex_unlock(&wl->mutex);
2356 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2357 wl1271_sysfs_show_hw_pg_ver, NULL);
2359 int wl1271_register_hw(struct wl1271 *wl)
2363 if (wl->mac80211_registered)
2366 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2368 ret = ieee80211_register_hw(wl->hw);
2370 wl1271_error("unable to register mac80211 hw: %d", ret);
2374 wl->mac80211_registered = true;
2376 register_netdevice_notifier(&wl1271_dev_notifier);
2378 wl1271_notice("loaded");
2382 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2384 void wl1271_unregister_hw(struct wl1271 *wl)
2386 unregister_netdevice_notifier(&wl1271_dev_notifier);
2387 ieee80211_unregister_hw(wl->hw);
2388 wl->mac80211_registered = false;
2391 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2393 int wl1271_init_ieee80211(struct wl1271 *wl)
2395 /* The tx descriptor buffer and the TKIP space. */
2396 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2397 sizeof(struct wl1271_tx_hw_descr);
2400 /* FIXME: find a proper value */
2401 wl->hw->channel_change_time = 10000;
2402 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2404 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2405 IEEE80211_HW_BEACON_FILTER |
2406 IEEE80211_HW_SUPPORTS_PS |
2407 IEEE80211_HW_SUPPORTS_UAPSD |
2408 IEEE80211_HW_HAS_RATE_CONTROL |
2409 IEEE80211_HW_CONNECTION_MONITOR |
2410 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2412 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2413 BIT(NL80211_IFTYPE_ADHOC);
2414 wl->hw->wiphy->max_scan_ssids = 1;
2415 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2417 if (wl1271_11a_enabled())
2418 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2421 wl->hw->max_rates = 1;
2423 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2427 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2429 #define WL1271_DEFAULT_CHANNEL 0
2431 struct ieee80211_hw *wl1271_alloc_hw(void)
2433 struct ieee80211_hw *hw;
2434 struct platform_device *plat_dev = NULL;
2438 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2440 wl1271_error("could not alloc ieee80211_hw");
2445 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2447 wl1271_error("could not allocate platform_device");
2449 goto err_plat_alloc;
2453 memset(wl, 0, sizeof(*wl));
2455 INIT_LIST_HEAD(&wl->list);
2458 wl->plat_dev = plat_dev;
2460 skb_queue_head_init(&wl->tx_queue);
2462 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2463 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2464 wl->channel = WL1271_DEFAULT_CHANNEL;
2465 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2466 wl->default_key = 0;
2468 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2469 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2470 wl->psm_entry_retry = 0;
2471 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2472 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2473 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2474 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2475 wl->sta_rate_set = 0;
2476 wl->band = IEEE80211_BAND_2GHZ;
2479 wl->sg_enabled = true;
2482 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2483 wl->tx_frames[i] = NULL;
2485 spin_lock_init(&wl->wl_lock);
2487 wl->state = WL1271_STATE_OFF;
2488 mutex_init(&wl->mutex);
2490 /* Apply default driver configuration. */
2491 wl1271_conf_init(wl);
2493 wl1271_debugfs_init(wl);
2495 /* Register platform device */
2496 ret = platform_device_register(wl->plat_dev);
2498 wl1271_error("couldn't register platform device");
2501 dev_set_drvdata(&wl->plat_dev->dev, wl);
2503 /* Create sysfs file to control bt coex state */
2504 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2506 wl1271_error("failed to create sysfs file bt_coex_state");
2510 /* Create sysfs file to get HW PG version */
2511 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2513 wl1271_error("failed to create sysfs file hw_pg_ver");
2514 goto err_bt_coex_state;
2520 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2523 platform_device_unregister(wl->plat_dev);
2526 wl1271_debugfs_exit(wl);
2530 ieee80211_free_hw(hw);
2534 return ERR_PTR(ret);
2536 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2538 int wl1271_free_hw(struct wl1271 *wl)
2540 platform_device_unregister(wl->plat_dev);
2541 kfree(wl->plat_dev);
2543 wl1271_debugfs_exit(wl);
2550 kfree(wl->fw_status);
2551 kfree(wl->tx_res_if);
2553 ieee80211_free_hw(wl->hw);
2557 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2559 MODULE_LICENSE("GPL");
2560 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2561 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");