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,
159 .queue_id = CONF_TX_AC_BE,
160 .channel_type = CONF_CHANNEL_TYPE_EDCF,
161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
167 .queue_id = CONF_TX_AC_BK,
168 .channel_type = CONF_CHANNEL_TYPE_EDCF,
169 .tsid = CONF_TX_AC_BK,
170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
175 .queue_id = CONF_TX_AC_VI,
176 .channel_type = CONF_CHANNEL_TYPE_EDCF,
177 .tsid = CONF_TX_AC_VI,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
183 .queue_id = CONF_TX_AC_VO,
184 .channel_type = CONF_CHANNEL_TYPE_EDCF,
185 .tsid = CONF_TX_AC_VO,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
191 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
192 .tx_compl_timeout = 700,
193 .tx_compl_threshold = 4,
194 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
195 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
198 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
199 .listen_interval = 1,
200 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
201 .bcn_filt_ie_count = 1,
204 .ie = WLAN_EID_CHANNEL_SWITCH,
205 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
208 .synch_fail_thold = 10,
209 .bss_lose_timeout = 100,
210 .beacon_rx_timeout = 10000,
211 .broadcast_timeout = 20000,
212 .rx_broadcast_in_ps = 1,
213 .ps_poll_threshold = 10,
214 .ps_poll_recovery_period = 700,
215 .bet_enable = CONF_BET_MODE_ENABLE,
216 .bet_max_consecutive = 10,
217 .psm_entry_retries = 5,
218 .psm_entry_nullfunc_retries = 3,
219 .psm_entry_hangover_period = 1,
220 .keep_alive_interval = 55000,
221 .max_listen_interval = 20,
228 .host_clk_settling_time = 5000,
229 .host_fast_wakeup_support = false
233 .avg_weight_rssi_beacon = 20,
234 .avg_weight_rssi_data = 10,
235 .avg_weight_snr_beacon = 20,
236 .avg_weight_snr_data = 10
239 .min_dwell_time_active = 7500,
240 .max_dwell_time_active = 30000,
241 .min_dwell_time_passive = 30000,
242 .max_dwell_time_passive = 60000,
246 .tx_per_channel_power_compensation_2 = {
247 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
249 .tx_per_channel_power_compensation_5 = {
250 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
251 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
257 static void __wl1271_op_remove_interface(struct wl1271 *wl);
260 static void wl1271_device_release(struct device *dev)
265 static struct platform_device wl1271_device = {
269 /* device model insists to have a release function */
271 .release = wl1271_device_release,
275 static LIST_HEAD(wl_list);
277 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
280 struct net_device *dev = arg;
281 struct wireless_dev *wdev;
283 struct ieee80211_hw *hw;
285 struct wl1271 *wl_temp;
288 /* Check that this notification is for us. */
289 if (what != NETDEV_CHANGE)
292 wdev = dev->ieee80211_ptr;
300 hw = wiphy_priv(wiphy);
305 list_for_each_entry(wl, &wl_list, list) {
312 mutex_lock(&wl->mutex);
314 if (wl->state == WL1271_STATE_OFF)
317 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
320 ret = wl1271_ps_elp_wakeup(wl, false);
324 if ((dev->operstate == IF_OPER_UP) &&
325 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
326 wl1271_cmd_set_sta_state(wl);
327 wl1271_info("Association completed.");
330 wl1271_ps_elp_sleep(wl);
333 mutex_unlock(&wl->mutex);
338 static void wl1271_conf_init(struct wl1271 *wl)
342 * This function applies the default configuration to the driver. This
343 * function is invoked upon driver load (spi probe.)
345 * The configuration is stored in a run-time structure in order to
346 * facilitate for run-time adjustment of any of the parameters. Making
347 * changes to the configuration structure will apply the new values on
348 * the next interface up (wl1271_op_start.)
351 /* apply driver default configuration */
352 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
356 static int wl1271_plt_init(struct wl1271 *wl)
358 struct conf_tx_ac_category *conf_ac;
359 struct conf_tx_tid *conf_tid;
362 ret = wl1271_cmd_general_parms(wl);
366 ret = wl1271_cmd_radio_parms(wl);
370 ret = wl1271_cmd_ext_radio_parms(wl);
374 ret = wl1271_init_templates_config(wl);
378 ret = wl1271_acx_init_mem_config(wl);
382 /* PHY layer config */
383 ret = wl1271_init_phy_config(wl);
385 goto out_free_memmap;
387 ret = wl1271_acx_dco_itrim_params(wl);
389 goto out_free_memmap;
391 /* Initialize connection monitoring thresholds */
392 ret = wl1271_acx_conn_monit_params(wl, false);
394 goto out_free_memmap;
396 /* Bluetooth WLAN coexistence */
397 ret = wl1271_init_pta(wl);
399 goto out_free_memmap;
401 /* Energy detection */
402 ret = wl1271_init_energy_detection(wl);
404 goto out_free_memmap;
406 /* Default fragmentation threshold */
407 ret = wl1271_acx_frag_threshold(wl);
409 goto out_free_memmap;
411 /* Default TID/AC configuration */
412 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
413 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
414 conf_ac = &wl->conf.tx.ac_conf[i];
415 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
416 conf_ac->cw_max, conf_ac->aifsn,
417 conf_ac->tx_op_limit);
419 goto out_free_memmap;
421 conf_tid = &wl->conf.tx.tid_conf[i];
422 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
423 conf_tid->channel_type,
426 conf_tid->ack_policy,
427 conf_tid->apsd_conf[0],
428 conf_tid->apsd_conf[1]);
430 goto out_free_memmap;
433 /* Enable data path */
434 ret = wl1271_cmd_data_path(wl, 1);
436 goto out_free_memmap;
438 /* Configure for CAM power saving (ie. always active) */
439 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
441 goto out_free_memmap;
444 ret = wl1271_acx_pm_config(wl);
446 goto out_free_memmap;
451 kfree(wl->target_mem_map);
452 wl->target_mem_map = NULL;
457 static void wl1271_fw_status(struct wl1271 *wl,
458 struct wl1271_fw_status *status)
464 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
466 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
467 "drv_rx_counter = %d, tx_results_counter = %d)",
469 status->fw_rx_counter,
470 status->drv_rx_counter,
471 status->tx_results_counter);
473 /* update number of available TX blocks */
474 for (i = 0; i < NUM_TX_QUEUES; i++) {
475 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
476 wl->tx_blocks_freed[i];
478 wl->tx_blocks_freed[i] =
479 le32_to_cpu(status->tx_released_blks[i]);
480 wl->tx_blocks_available += cnt;
484 /* if more blocks are available now, schedule some tx work */
485 if (total && !skb_queue_empty(&wl->tx_queue))
486 ieee80211_queue_work(wl->hw, &wl->tx_work);
488 /* update the host-chipset time offset */
490 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
491 (s64)le32_to_cpu(status->fw_localtime);
494 #define WL1271_IRQ_MAX_LOOPS 10
496 static void wl1271_irq_work(struct work_struct *work)
500 int loopcount = WL1271_IRQ_MAX_LOOPS;
503 container_of(work, struct wl1271, irq_work);
505 mutex_lock(&wl->mutex);
507 wl1271_debug(DEBUG_IRQ, "IRQ work");
509 if (unlikely(wl->state == WL1271_STATE_OFF))
512 ret = wl1271_ps_elp_wakeup(wl, true);
516 spin_lock_irqsave(&wl->wl_lock, flags);
517 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
518 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
519 spin_unlock_irqrestore(&wl->wl_lock, flags);
522 wl1271_fw_status(wl, wl->fw_status);
523 intr = le32_to_cpu(wl->fw_status->intr);
525 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
526 spin_lock_irqsave(&wl->wl_lock, flags);
530 intr &= WL1271_INTR_MASK;
532 if (intr & WL1271_ACX_INTR_DATA) {
533 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
535 /* check for tx results */
536 if (wl->fw_status->tx_results_counter !=
537 (wl->tx_results_count & 0xff))
538 wl1271_tx_complete(wl);
540 wl1271_rx(wl, wl->fw_status);
543 if (intr & WL1271_ACX_INTR_EVENT_A) {
544 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
545 wl1271_event_handle(wl, 0);
548 if (intr & WL1271_ACX_INTR_EVENT_B) {
549 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
550 wl1271_event_handle(wl, 1);
553 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
554 wl1271_debug(DEBUG_IRQ,
555 "WL1271_ACX_INTR_INIT_COMPLETE");
557 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
558 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
560 spin_lock_irqsave(&wl->wl_lock, flags);
563 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
564 ieee80211_queue_work(wl->hw, &wl->irq_work);
566 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
567 spin_unlock_irqrestore(&wl->wl_lock, flags);
569 wl1271_ps_elp_sleep(wl);
572 mutex_unlock(&wl->mutex);
575 static int wl1271_fetch_firmware(struct wl1271 *wl)
577 const struct firmware *fw;
580 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
583 wl1271_error("could not get firmware: %d", ret);
588 wl1271_error("firmware size is not multiple of 32 bits: %zu",
594 wl->fw_len = fw->size;
595 wl->fw = vmalloc(wl->fw_len);
598 wl1271_error("could not allocate memory for the firmware");
603 memcpy(wl->fw, fw->data, wl->fw_len);
608 release_firmware(fw);
613 static int wl1271_fetch_nvs(struct wl1271 *wl)
615 const struct firmware *fw;
618 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
621 wl1271_error("could not get nvs file: %d", ret);
625 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
628 wl1271_error("could not allocate memory for the nvs file");
633 wl->nvs_len = fw->size;
636 release_firmware(fw);
641 static void wl1271_recovery_work(struct work_struct *work)
644 container_of(work, struct wl1271, recovery_work);
646 mutex_lock(&wl->mutex);
648 if (wl->state != WL1271_STATE_ON)
651 wl1271_info("Hardware recovery in progress.");
653 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
654 ieee80211_connection_loss(wl->vif);
656 /* reboot the chipset */
657 __wl1271_op_remove_interface(wl);
658 ieee80211_restart_hw(wl->hw);
661 mutex_unlock(&wl->mutex);
664 static void wl1271_fw_wakeup(struct wl1271 *wl)
668 elp_reg = ELPCTRL_WAKE_UP;
669 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
672 static int wl1271_setup(struct wl1271 *wl)
674 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
678 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
679 if (!wl->tx_res_if) {
680 kfree(wl->fw_status);
687 static int wl1271_chip_wakeup(struct wl1271 *wl)
689 struct wl1271_partition_set partition;
692 msleep(WL1271_PRE_POWER_ON_SLEEP);
693 ret = wl1271_power_on(wl);
696 msleep(WL1271_POWER_ON_SLEEP);
700 /* We don't need a real memory partition here, because we only want
701 * to use the registers at this point. */
702 memset(&partition, 0, sizeof(partition));
703 partition.reg.start = REGISTERS_BASE;
704 partition.reg.size = REGISTERS_DOWN_SIZE;
705 wl1271_set_partition(wl, &partition);
707 /* ELP module wake up */
708 wl1271_fw_wakeup(wl);
710 /* whal_FwCtrl_BootSm() */
712 /* 0. read chip id from CHIP_ID */
713 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
715 /* 1. check if chip id is valid */
717 switch (wl->chip.id) {
718 case CHIP_ID_1271_PG10:
719 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
722 ret = wl1271_setup(wl);
726 case CHIP_ID_1271_PG20:
727 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
730 ret = wl1271_setup(wl);
735 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
740 if (wl->fw == NULL) {
741 ret = wl1271_fetch_firmware(wl);
746 /* No NVS from netlink, try to get it from the filesystem */
747 if (wl->nvs == NULL) {
748 ret = wl1271_fetch_nvs(wl);
757 int wl1271_plt_start(struct wl1271 *wl)
759 int retries = WL1271_BOOT_RETRIES;
762 mutex_lock(&wl->mutex);
764 wl1271_notice("power up");
766 if (wl->state != WL1271_STATE_OFF) {
767 wl1271_error("cannot go into PLT state because not "
768 "in off state: %d", wl->state);
775 ret = wl1271_chip_wakeup(wl);
779 ret = wl1271_boot(wl);
783 ret = wl1271_plt_init(wl);
787 wl->state = WL1271_STATE_PLT;
788 wl1271_notice("firmware booted in PLT mode (%s)",
793 wl1271_disable_interrupts(wl);
794 mutex_unlock(&wl->mutex);
795 /* Unlocking the mutex in the middle of handling is
796 inherently unsafe. In this case we deem it safe to do,
797 because we need to let any possibly pending IRQ out of
798 the system (and while we are WL1271_STATE_OFF the IRQ
799 work function will not do anything.) Also, any other
800 possible concurrent operations will fail due to the
801 current state, hence the wl1271 struct should be safe. */
802 cancel_work_sync(&wl->irq_work);
803 mutex_lock(&wl->mutex);
805 wl1271_power_off(wl);
808 wl1271_error("firmware boot in PLT mode failed despite %d retries",
809 WL1271_BOOT_RETRIES);
811 mutex_unlock(&wl->mutex);
816 int wl1271_plt_stop(struct wl1271 *wl)
820 mutex_lock(&wl->mutex);
822 wl1271_notice("power down");
824 if (wl->state != WL1271_STATE_PLT) {
825 wl1271_error("cannot power down because not in PLT "
826 "state: %d", wl->state);
831 wl1271_disable_interrupts(wl);
832 wl1271_power_off(wl);
834 wl->state = WL1271_STATE_OFF;
838 mutex_unlock(&wl->mutex);
840 cancel_work_sync(&wl->irq_work);
841 cancel_work_sync(&wl->recovery_work);
846 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
848 struct wl1271 *wl = hw->priv;
849 struct ieee80211_conf *conf = &hw->conf;
850 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
851 struct ieee80211_sta *sta = txinfo->control.sta;
854 /* peek into the rates configured in the STA entry */
855 spin_lock_irqsave(&wl->wl_lock, flags);
856 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
857 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
858 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
860 spin_unlock_irqrestore(&wl->wl_lock, flags);
862 /* queue the packet */
863 skb_queue_tail(&wl->tx_queue, skb);
866 * The chip specific setup must run before the first TX packet -
867 * before that, the tx_work will not be initialized!
870 ieee80211_queue_work(wl->hw, &wl->tx_work);
873 * The workqueue is slow to process the tx_queue and we need stop
874 * the queue here, otherwise the queue will get too long.
876 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
877 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
879 spin_lock_irqsave(&wl->wl_lock, flags);
880 ieee80211_stop_queues(wl->hw);
881 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
882 spin_unlock_irqrestore(&wl->wl_lock, flags);
888 static struct notifier_block wl1271_dev_notifier = {
889 .notifier_call = wl1271_dev_notify,
892 static int wl1271_op_start(struct ieee80211_hw *hw)
894 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
897 * We have to delay the booting of the hardware because
898 * we need to know the local MAC address before downloading and
899 * initializing the firmware. The MAC address cannot be changed
900 * after boot, and without the proper MAC address, the firmware
901 * will not function properly.
903 * The MAC address is first known when the corresponding interface
904 * is added. That is where we will initialize the hardware.
910 static void wl1271_op_stop(struct ieee80211_hw *hw)
912 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
915 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
916 struct ieee80211_vif *vif)
918 struct wl1271 *wl = hw->priv;
919 struct wiphy *wiphy = hw->wiphy;
920 int retries = WL1271_BOOT_RETRIES;
923 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
924 vif->type, vif->addr);
926 mutex_lock(&wl->mutex);
935 case NL80211_IFTYPE_STATION:
936 wl->bss_type = BSS_TYPE_STA_BSS;
937 wl->set_bss_type = BSS_TYPE_STA_BSS;
939 case NL80211_IFTYPE_ADHOC:
940 wl->bss_type = BSS_TYPE_IBSS;
941 wl->set_bss_type = BSS_TYPE_STA_BSS;
948 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
950 if (wl->state != WL1271_STATE_OFF) {
951 wl1271_error("cannot start because not in off state: %d",
959 ret = wl1271_chip_wakeup(wl);
963 ret = wl1271_boot(wl);
967 ret = wl1271_hw_init(wl);
971 wl->state = WL1271_STATE_ON;
972 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
974 /* update hw/fw version info in wiphy struct */
975 wiphy->hw_version = wl->chip.id;
976 strncpy(wiphy->fw_version, wl->chip.fw_ver,
977 sizeof(wiphy->fw_version));
982 wl1271_disable_interrupts(wl);
983 mutex_unlock(&wl->mutex);
984 /* Unlocking the mutex in the middle of handling is
985 inherently unsafe. In this case we deem it safe to do,
986 because we need to let any possibly pending IRQ out of
987 the system (and while we are WL1271_STATE_OFF the IRQ
988 work function will not do anything.) Also, any other
989 possible concurrent operations will fail due to the
990 current state, hence the wl1271 struct should be safe. */
991 cancel_work_sync(&wl->irq_work);
992 mutex_lock(&wl->mutex);
994 wl1271_power_off(wl);
997 wl1271_error("firmware boot failed despite %d retries",
998 WL1271_BOOT_RETRIES);
1000 mutex_unlock(&wl->mutex);
1003 list_add(&wl->list, &wl_list);
1008 static void __wl1271_op_remove_interface(struct wl1271 *wl)
1012 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1014 wl1271_info("down");
1016 list_del(&wl->list);
1018 WARN_ON(wl->state != WL1271_STATE_ON);
1020 /* enable dyn ps just in case (if left on due to fw crash etc) */
1021 if (wl->bss_type == BSS_TYPE_STA_BSS)
1022 ieee80211_enable_dyn_ps(wl->vif);
1024 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1025 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1026 kfree(wl->scan.scanned_ch);
1027 wl->scan.scanned_ch = NULL;
1028 ieee80211_scan_completed(wl->hw, true);
1031 wl->state = WL1271_STATE_OFF;
1033 wl1271_disable_interrupts(wl);
1035 mutex_unlock(&wl->mutex);
1037 cancel_delayed_work_sync(&wl->scan_complete_work);
1038 cancel_work_sync(&wl->irq_work);
1039 cancel_work_sync(&wl->tx_work);
1040 cancel_delayed_work_sync(&wl->pspoll_work);
1041 cancel_delayed_work_sync(&wl->elp_work);
1043 mutex_lock(&wl->mutex);
1045 /* let's notify MAC80211 about the remaining pending TX frames */
1046 wl1271_tx_reset(wl);
1047 wl1271_power_off(wl);
1049 memset(wl->bssid, 0, ETH_ALEN);
1050 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1052 wl->bss_type = MAX_BSS_TYPE;
1053 wl->set_bss_type = MAX_BSS_TYPE;
1054 wl->band = IEEE80211_BAND_2GHZ;
1057 wl->psm_entry_retry = 0;
1058 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1059 wl->tx_blocks_available = 0;
1060 wl->tx_results_count = 0;
1061 wl->tx_packets_count = 0;
1062 wl->tx_security_last_seq = 0;
1063 wl->tx_security_seq = 0;
1064 wl->time_offset = 0;
1065 wl->session_counter = 0;
1066 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1067 wl->sta_rate_set = 0;
1072 for (i = 0; i < NUM_TX_QUEUES; i++)
1073 wl->tx_blocks_freed[i] = 0;
1075 wl1271_debugfs_reset(wl);
1077 kfree(wl->fw_status);
1078 wl->fw_status = NULL;
1079 kfree(wl->tx_res_if);
1080 wl->tx_res_if = NULL;
1081 kfree(wl->target_mem_map);
1082 wl->target_mem_map = NULL;
1085 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1086 struct ieee80211_vif *vif)
1088 struct wl1271 *wl = hw->priv;
1090 mutex_lock(&wl->mutex);
1091 WARN_ON(wl->vif != vif);
1092 __wl1271_op_remove_interface(wl);
1093 mutex_unlock(&wl->mutex);
1095 cancel_work_sync(&wl->recovery_work);
1098 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1100 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1101 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1103 /* combine requested filters with current filter config */
1104 filters = wl->filters | filters;
1106 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1108 if (filters & FIF_PROMISC_IN_BSS) {
1109 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1110 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1111 wl->rx_config |= CFG_BSSID_FILTER_EN;
1113 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1114 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1115 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1116 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1118 if (filters & FIF_OTHER_BSS) {
1119 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1120 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1122 if (filters & FIF_CONTROL) {
1123 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1124 wl->rx_filter |= CFG_RX_CTL_EN;
1126 if (filters & FIF_FCSFAIL) {
1127 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1128 wl->rx_filter |= CFG_RX_FCS_ERROR;
1132 static int wl1271_dummy_join(struct wl1271 *wl)
1135 /* we need to use a dummy BSSID for now */
1136 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1139 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1141 /* pass through frames from all BSS */
1142 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1144 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1148 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1154 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1159 * One of the side effects of the JOIN command is that is clears
1160 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1161 * to a WPA/WPA2 access point will therefore kill the data-path.
1162 * Currently there is no supported scenario for JOIN during
1163 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1164 * must be handled somehow.
1167 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1168 wl1271_info("JOIN while associated.");
1171 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1173 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1177 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1179 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1183 * The join command disable the keep-alive mode, shut down its process,
1184 * and also clear the template config, so we need to reset it all after
1185 * the join. The acx_aid starts the keep-alive process, and the order
1186 * of the commands below is relevant.
1188 ret = wl1271_acx_keep_alive_mode(wl, true);
1192 ret = wl1271_acx_aid(wl, wl->aid);
1196 ret = wl1271_cmd_build_klv_null_data(wl);
1200 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1201 ACX_KEEP_ALIVE_TPL_VALID);
1209 static int wl1271_unjoin(struct wl1271 *wl)
1213 /* to stop listening to a channel, we disconnect */
1214 ret = wl1271_cmd_disconnect(wl);
1218 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1219 memset(wl->bssid, 0, ETH_ALEN);
1221 /* stop filterting packets based on bssid */
1222 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1228 static void wl1271_set_band_rate(struct wl1271 *wl)
1230 if (wl->band == IEEE80211_BAND_2GHZ)
1231 wl->basic_rate_set = wl->conf.tx.basic_rate;
1233 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1236 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1241 if (!wl->basic_rate_set) {
1243 wl->basic_rate_set = wl->conf.tx.basic_rate;
1246 for (i = 0; !rate; i++) {
1247 if ((wl->basic_rate_set >> i) & 0x1)
1254 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1259 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1260 ret = wl1271_unjoin(wl);
1264 wl->rate_set = wl1271_min_rate_get(wl);
1265 wl->sta_rate_set = 0;
1266 ret = wl1271_acx_rate_policies(wl);
1269 ret = wl1271_acx_keep_alive_config(
1270 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1271 ACX_KEEP_ALIVE_TPL_INVALID);
1274 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1276 /* increment the session counter */
1277 wl->session_counter++;
1278 if (wl->session_counter >= SESSION_COUNTER_MAX)
1279 wl->session_counter = 0;
1280 ret = wl1271_dummy_join(wl);
1283 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1290 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1292 struct wl1271 *wl = hw->priv;
1293 struct ieee80211_conf *conf = &hw->conf;
1294 int channel, ret = 0;
1296 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1298 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1300 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1302 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1305 * mac80211 will go to idle nearly immediately after transmitting some
1306 * frames, such as the deauth. To make sure those frames reach the air,
1307 * wait here until the TX queue is fully flushed.
1309 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1310 (conf->flags & IEEE80211_CONF_IDLE))
1311 wl1271_tx_flush(wl);
1313 mutex_lock(&wl->mutex);
1315 if (unlikely(wl->state == WL1271_STATE_OFF))
1318 ret = wl1271_ps_elp_wakeup(wl, false);
1322 /* if the channel changes while joined, join again */
1323 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1324 ((wl->band != conf->channel->band) ||
1325 (wl->channel != channel))) {
1326 wl->band = conf->channel->band;
1327 wl->channel = channel;
1330 * FIXME: the mac80211 should really provide a fixed rate
1331 * to use here. for now, just use the smallest possible rate
1332 * for the band as a fixed rate for association frames and
1333 * other control messages.
1335 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1336 wl1271_set_band_rate(wl);
1338 wl->basic_rate = wl1271_min_rate_get(wl);
1339 ret = wl1271_acx_rate_policies(wl);
1341 wl1271_warning("rate policy for update channel "
1344 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1345 ret = wl1271_join(wl, false);
1347 wl1271_warning("cmd join to update channel "
1352 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1353 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1355 wl1271_warning("idle mode change failed %d", ret);
1359 * if mac80211 changes the PSM mode, make sure the mode is not
1360 * incorrectly changed after the pspoll failure active window.
1362 if (changed & IEEE80211_CONF_CHANGE_PS)
1363 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1365 if (conf->flags & IEEE80211_CONF_PS &&
1366 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1367 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1370 * We enter PSM only if we're already associated.
1371 * If we're not, we'll enter it when joining an SSID,
1372 * through the bss_info_changed() hook.
1374 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1375 wl1271_debug(DEBUG_PSM, "psm enabled");
1376 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1377 wl->basic_rate, true);
1379 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1380 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1381 wl1271_debug(DEBUG_PSM, "psm disabled");
1383 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1385 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1386 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1387 wl->basic_rate, true);
1390 if (conf->power_level != wl->power_level) {
1391 ret = wl1271_acx_tx_power(wl, conf->power_level);
1395 wl->power_level = conf->power_level;
1399 wl1271_ps_elp_sleep(wl);
1402 mutex_unlock(&wl->mutex);
1407 struct wl1271_filter_params {
1410 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1413 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1414 struct netdev_hw_addr_list *mc_list)
1416 struct wl1271_filter_params *fp;
1417 struct netdev_hw_addr *ha;
1418 struct wl1271 *wl = hw->priv;
1420 if (unlikely(wl->state == WL1271_STATE_OFF))
1423 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1425 wl1271_error("Out of memory setting filters.");
1429 /* update multicast filtering parameters */
1430 fp->mc_list_length = 0;
1431 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1432 fp->enabled = false;
1435 netdev_hw_addr_list_for_each(ha, mc_list) {
1436 memcpy(fp->mc_list[fp->mc_list_length],
1437 ha->addr, ETH_ALEN);
1438 fp->mc_list_length++;
1442 return (u64)(unsigned long)fp;
1445 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1448 FIF_BCN_PRBRESP_PROMISC | \
1452 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1453 unsigned int changed,
1454 unsigned int *total, u64 multicast)
1456 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1457 struct wl1271 *wl = hw->priv;
1460 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1462 mutex_lock(&wl->mutex);
1464 *total &= WL1271_SUPPORTED_FILTERS;
1465 changed &= WL1271_SUPPORTED_FILTERS;
1467 if (unlikely(wl->state == WL1271_STATE_OFF))
1470 ret = wl1271_ps_elp_wakeup(wl, false);
1475 if (*total & FIF_ALLMULTI)
1476 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1478 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1480 fp->mc_list_length);
1484 /* determine, whether supported filter values have changed */
1488 /* configure filters */
1489 wl->filters = *total;
1490 wl1271_configure_filters(wl, 0);
1492 /* apply configured filters */
1493 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1498 wl1271_ps_elp_sleep(wl);
1501 mutex_unlock(&wl->mutex);
1505 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1506 struct ieee80211_vif *vif,
1507 struct ieee80211_sta *sta,
1508 struct ieee80211_key_conf *key_conf)
1510 struct wl1271 *wl = hw->priv;
1517 static const u8 bcast_addr[ETH_ALEN] =
1518 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1520 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1522 addr = sta ? sta->addr : bcast_addr;
1524 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1525 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1526 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1527 key_conf->cipher, key_conf->keyidx,
1528 key_conf->keylen, key_conf->flags);
1529 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1531 if (is_zero_ether_addr(addr)) {
1532 /* We dont support TX only encryption */
1537 mutex_lock(&wl->mutex);
1539 ret = wl1271_ps_elp_wakeup(wl, false);
1543 switch (key_conf->cipher) {
1544 case WLAN_CIPHER_SUITE_WEP40:
1545 case WLAN_CIPHER_SUITE_WEP104:
1548 key_conf->hw_key_idx = key_conf->keyidx;
1550 case WLAN_CIPHER_SUITE_TKIP:
1551 key_type = KEY_TKIP;
1553 key_conf->hw_key_idx = key_conf->keyidx;
1554 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1555 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1557 case WLAN_CIPHER_SUITE_CCMP:
1560 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1561 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1562 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1564 case WL1271_CIPHER_SUITE_GEM:
1566 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1567 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1570 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1578 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1579 key_conf->keyidx, key_type,
1580 key_conf->keylen, key_conf->key,
1581 addr, tx_seq_32, tx_seq_16);
1583 wl1271_error("Could not add or replace key");
1587 /* the default WEP key needs to be configured at least once */
1588 if (key_type == KEY_WEP) {
1589 ret = wl1271_cmd_set_default_wep_key(wl,
1597 /* The wl1271 does not allow to remove unicast keys - they
1598 will be cleared automatically on next CMD_JOIN. Ignore the
1599 request silently, as we dont want the mac80211 to emit
1600 an error message. */
1601 if (!is_broadcast_ether_addr(addr))
1604 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1605 key_conf->keyidx, key_type,
1606 key_conf->keylen, key_conf->key,
1609 wl1271_error("Could not remove key");
1615 wl1271_error("Unsupported key cmd 0x%x", cmd);
1621 wl1271_ps_elp_sleep(wl);
1624 mutex_unlock(&wl->mutex);
1630 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1631 struct ieee80211_vif *vif,
1632 struct cfg80211_scan_request *req)
1634 struct wl1271 *wl = hw->priv;
1639 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1642 ssid = req->ssids[0].ssid;
1643 len = req->ssids[0].ssid_len;
1646 mutex_lock(&wl->mutex);
1648 ret = wl1271_ps_elp_wakeup(wl, false);
1652 ret = wl1271_scan(hw->priv, ssid, len, req);
1654 wl1271_ps_elp_sleep(wl);
1657 mutex_unlock(&wl->mutex);
1662 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1664 struct wl1271 *wl = hw->priv;
1667 mutex_lock(&wl->mutex);
1669 if (unlikely(wl->state == WL1271_STATE_OFF))
1672 ret = wl1271_ps_elp_wakeup(wl, false);
1676 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1678 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1680 wl1271_ps_elp_sleep(wl);
1683 mutex_unlock(&wl->mutex);
1688 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1690 u8 *ptr = beacon->data +
1691 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1693 /* find the location of the ssid in the beacon */
1694 while (ptr < beacon->data + beacon->len) {
1695 if (ptr[0] == WLAN_EID_SSID) {
1696 wl->ssid_len = ptr[1];
1697 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1702 wl1271_error("ad-hoc beacon template has no SSID!\n");
1705 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1706 struct ieee80211_vif *vif,
1707 struct ieee80211_bss_conf *bss_conf,
1710 enum wl1271_cmd_ps_mode mode;
1711 struct wl1271 *wl = hw->priv;
1712 bool do_join = false;
1713 bool set_assoc = false;
1716 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1718 mutex_lock(&wl->mutex);
1720 ret = wl1271_ps_elp_wakeup(wl, false);
1724 if ((changed & BSS_CHANGED_BEACON_INT) &&
1725 (wl->bss_type == BSS_TYPE_IBSS)) {
1726 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1727 bss_conf->beacon_int);
1729 wl->beacon_int = bss_conf->beacon_int;
1733 if ((changed & BSS_CHANGED_BEACON) &&
1734 (wl->bss_type == BSS_TYPE_IBSS)) {
1735 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1737 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1740 struct ieee80211_hdr *hdr;
1742 wl1271_ssid_set(wl, beacon);
1743 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1746 wl1271_min_rate_get(wl));
1749 dev_kfree_skb(beacon);
1753 hdr = (struct ieee80211_hdr *) beacon->data;
1754 hdr->frame_control = cpu_to_le16(
1755 IEEE80211_FTYPE_MGMT |
1756 IEEE80211_STYPE_PROBE_RESP);
1758 ret = wl1271_cmd_template_set(wl,
1759 CMD_TEMPL_PROBE_RESPONSE,
1762 wl1271_min_rate_get(wl));
1763 dev_kfree_skb(beacon);
1767 /* Need to update the SSID (for filtering etc) */
1772 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1773 (wl->bss_type == BSS_TYPE_IBSS)) {
1774 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1775 bss_conf->enable_beacon ? "enabled" : "disabled");
1777 if (bss_conf->enable_beacon)
1778 wl->set_bss_type = BSS_TYPE_IBSS;
1780 wl->set_bss_type = BSS_TYPE_STA_BSS;
1784 if (changed & BSS_CHANGED_CQM) {
1785 bool enable = false;
1786 if (bss_conf->cqm_rssi_thold)
1788 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1789 bss_conf->cqm_rssi_thold,
1790 bss_conf->cqm_rssi_hyst);
1793 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1796 if ((changed & BSS_CHANGED_BSSID) &&
1798 * Now we know the correct bssid, so we send a new join command
1799 * and enable the BSSID filter
1801 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1802 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1804 ret = wl1271_cmd_build_null_data(wl);
1808 ret = wl1271_build_qos_null_data(wl);
1812 /* filter out all packets not from this BSSID */
1813 wl1271_configure_filters(wl, 0);
1815 /* Need to update the BSSID (for filtering etc) */
1819 if (changed & BSS_CHANGED_ASSOC) {
1820 if (bss_conf->assoc) {
1822 wl->aid = bss_conf->aid;
1825 wl->ps_poll_failures = 0;
1828 * use basic rates from AP, and determine lowest rate
1829 * to use with control frames.
1831 rates = bss_conf->basic_rates;
1832 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1834 wl->basic_rate = wl1271_min_rate_get(wl);
1835 ret = wl1271_acx_rate_policies(wl);
1840 * with wl1271, we don't need to update the
1841 * beacon_int and dtim_period, because the firmware
1842 * updates it by itself when the first beacon is
1843 * received after a join.
1845 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1850 * The SSID is intentionally set to NULL here - the
1851 * firmware will set the probe request with a
1852 * broadcast SSID regardless of what we set in the
1855 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1858 /* enable the connection monitoring feature */
1859 ret = wl1271_acx_conn_monit_params(wl, true);
1863 /* If we want to go in PSM but we're not there yet */
1864 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1865 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1866 mode = STATION_POWER_SAVE_MODE;
1867 ret = wl1271_ps_set_mode(wl, mode,
1874 /* use defaults when not associated */
1875 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1876 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1879 /* re-enable dynamic ps - just in case */
1880 ieee80211_enable_dyn_ps(wl->vif);
1882 /* revert back to minimum rates for the current band */
1883 wl1271_set_band_rate(wl);
1884 wl->basic_rate = wl1271_min_rate_get(wl);
1885 ret = wl1271_acx_rate_policies(wl);
1889 /* disable connection monitor features */
1890 ret = wl1271_acx_conn_monit_params(wl, false);
1892 /* Disable the keep-alive feature */
1893 ret = wl1271_acx_keep_alive_mode(wl, false);
1901 if (changed & BSS_CHANGED_ERP_SLOT) {
1902 if (bss_conf->use_short_slot)
1903 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1905 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1907 wl1271_warning("Set slot time failed %d", ret);
1912 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1913 if (bss_conf->use_short_preamble)
1914 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1916 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1919 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1920 if (bss_conf->use_cts_prot)
1921 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1923 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1925 wl1271_warning("Set ctsprotect failed %d", ret);
1930 if (changed & BSS_CHANGED_ARP_FILTER) {
1931 __be32 addr = bss_conf->arp_addr_list[0];
1932 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1934 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1935 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1937 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1944 ret = wl1271_join(wl, set_assoc);
1946 wl1271_warning("cmd join failed %d", ret);
1952 wl1271_ps_elp_sleep(wl);
1955 mutex_unlock(&wl->mutex);
1958 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1959 const struct ieee80211_tx_queue_params *params)
1961 struct wl1271 *wl = hw->priv;
1965 mutex_lock(&wl->mutex);
1967 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1969 ret = wl1271_ps_elp_wakeup(wl, false);
1973 /* the txop is confed in units of 32us by the mac80211, we need us */
1974 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1975 params->cw_min, params->cw_max,
1976 params->aifs, params->txop << 5);
1981 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1983 ps_scheme = CONF_PS_SCHEME_LEGACY;
1985 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1986 CONF_CHANNEL_TYPE_EDCF,
1987 wl1271_tx_get_queue(queue),
1988 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1993 wl1271_ps_elp_sleep(wl);
1996 mutex_unlock(&wl->mutex);
2001 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2004 struct wl1271 *wl = hw->priv;
2005 u64 mactime = ULLONG_MAX;
2008 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2010 mutex_lock(&wl->mutex);
2012 ret = wl1271_ps_elp_wakeup(wl, false);
2016 ret = wl1271_acx_tsf_info(wl, &mactime);
2021 wl1271_ps_elp_sleep(wl);
2024 mutex_unlock(&wl->mutex);
2028 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2029 struct survey_info *survey)
2031 struct wl1271 *wl = hw->priv;
2032 struct ieee80211_conf *conf = &hw->conf;
2037 survey->channel = conf->channel;
2038 survey->filled = SURVEY_INFO_NOISE_DBM;
2039 survey->noise = wl->noise;
2044 /* can't be const, mac80211 writes to this */
2045 static struct ieee80211_rate wl1271_rates[] = {
2047 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2048 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2050 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2051 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2052 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2054 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2055 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2056 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2058 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2059 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2060 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2062 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2063 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2065 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2066 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2068 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2069 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2071 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2072 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2074 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2075 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2077 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2078 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2080 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2081 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2083 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2084 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2088 * Can't be const, mac80211 writes to this. The order of the channels here
2089 * is designed to improve scanning.
2091 static struct ieee80211_channel wl1271_channels[] = {
2092 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2093 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2094 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2095 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2096 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2097 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2098 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2099 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2100 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2101 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2102 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2103 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2104 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2107 /* mapping to indexes for wl1271_rates */
2108 static const u8 wl1271_rate_to_idx_2ghz[] = {
2109 /* MCS rates are used only with 11n */
2110 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2111 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2112 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2113 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2114 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2115 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2116 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2117 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2119 11, /* CONF_HW_RXTX_RATE_54 */
2120 10, /* CONF_HW_RXTX_RATE_48 */
2121 9, /* CONF_HW_RXTX_RATE_36 */
2122 8, /* CONF_HW_RXTX_RATE_24 */
2124 /* TI-specific rate */
2125 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2127 7, /* CONF_HW_RXTX_RATE_18 */
2128 6, /* CONF_HW_RXTX_RATE_12 */
2129 3, /* CONF_HW_RXTX_RATE_11 */
2130 5, /* CONF_HW_RXTX_RATE_9 */
2131 4, /* CONF_HW_RXTX_RATE_6 */
2132 2, /* CONF_HW_RXTX_RATE_5_5 */
2133 1, /* CONF_HW_RXTX_RATE_2 */
2134 0 /* CONF_HW_RXTX_RATE_1 */
2137 /* can't be const, mac80211 writes to this */
2138 static struct ieee80211_supported_band wl1271_band_2ghz = {
2139 .channels = wl1271_channels,
2140 .n_channels = ARRAY_SIZE(wl1271_channels),
2141 .bitrates = wl1271_rates,
2142 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2145 /* 5 GHz data rates for WL1273 */
2146 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2148 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2149 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2151 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2152 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2154 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2155 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2157 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2158 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2160 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2161 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2163 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2164 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2166 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2167 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2169 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2170 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2174 * 5 GHz band channels for WL1273 - can't be const, mac80211 writes to this.
2175 * The order of the channels here is designed to improve scanning.
2177 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2178 { .hw_value = 183, .center_freq = 4915},
2179 { .hw_value = 188, .center_freq = 4940},
2180 { .hw_value = 8, .center_freq = 5040},
2181 { .hw_value = 34, .center_freq = 5170},
2182 { .hw_value = 44, .center_freq = 5220},
2183 { .hw_value = 60, .center_freq = 5300},
2184 { .hw_value = 112, .center_freq = 5560},
2185 { .hw_value = 132, .center_freq = 5660},
2186 { .hw_value = 157, .center_freq = 5785},
2187 { .hw_value = 184, .center_freq = 4920},
2188 { .hw_value = 189, .center_freq = 4945},
2189 { .hw_value = 9, .center_freq = 5045},
2190 { .hw_value = 36, .center_freq = 5180},
2191 { .hw_value = 46, .center_freq = 5230},
2192 { .hw_value = 64, .center_freq = 5320},
2193 { .hw_value = 116, .center_freq = 5580},
2194 { .hw_value = 136, .center_freq = 5680},
2195 { .hw_value = 192, .center_freq = 4960},
2196 { .hw_value = 11, .center_freq = 5055},
2197 { .hw_value = 38, .center_freq = 5190},
2198 { .hw_value = 48, .center_freq = 5240},
2199 { .hw_value = 100, .center_freq = 5500},
2200 { .hw_value = 120, .center_freq = 5600},
2201 { .hw_value = 140, .center_freq = 5700},
2202 { .hw_value = 185, .center_freq = 4925},
2203 { .hw_value = 196, .center_freq = 4980},
2204 { .hw_value = 12, .center_freq = 5060},
2205 { .hw_value = 40, .center_freq = 5200},
2206 { .hw_value = 52, .center_freq = 5260},
2207 { .hw_value = 104, .center_freq = 5520},
2208 { .hw_value = 124, .center_freq = 5620},
2209 { .hw_value = 149, .center_freq = 5745},
2210 { .hw_value = 161, .center_freq = 5805},
2211 { .hw_value = 187, .center_freq = 4935},
2212 { .hw_value = 7, .center_freq = 5035},
2213 { .hw_value = 16, .center_freq = 5080},
2214 { .hw_value = 42, .center_freq = 5210},
2215 { .hw_value = 56, .center_freq = 5280},
2216 { .hw_value = 108, .center_freq = 5540},
2217 { .hw_value = 128, .center_freq = 5640},
2218 { .hw_value = 153, .center_freq = 5765},
2219 { .hw_value = 165, .center_freq = 5825},
2222 /* mapping to indexes for wl1271_rates_5ghz */
2223 static const u8 wl1271_rate_to_idx_5ghz[] = {
2224 /* MCS rates are used only with 11n */
2225 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2226 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2227 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2228 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2229 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2230 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2231 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2232 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2234 7, /* CONF_HW_RXTX_RATE_54 */
2235 6, /* CONF_HW_RXTX_RATE_48 */
2236 5, /* CONF_HW_RXTX_RATE_36 */
2237 4, /* CONF_HW_RXTX_RATE_24 */
2239 /* TI-specific rate */
2240 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2242 3, /* CONF_HW_RXTX_RATE_18 */
2243 2, /* CONF_HW_RXTX_RATE_12 */
2244 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2245 1, /* CONF_HW_RXTX_RATE_9 */
2246 0, /* CONF_HW_RXTX_RATE_6 */
2247 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2248 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2249 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2252 static struct ieee80211_supported_band wl1271_band_5ghz = {
2253 .channels = wl1271_channels_5ghz,
2254 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2255 .bitrates = wl1271_rates_5ghz,
2256 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2259 static const u8 *wl1271_band_rate_to_idx[] = {
2260 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2261 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2264 static const struct ieee80211_ops wl1271_ops = {
2265 .start = wl1271_op_start,
2266 .stop = wl1271_op_stop,
2267 .add_interface = wl1271_op_add_interface,
2268 .remove_interface = wl1271_op_remove_interface,
2269 .config = wl1271_op_config,
2270 .prepare_multicast = wl1271_op_prepare_multicast,
2271 .configure_filter = wl1271_op_configure_filter,
2273 .set_key = wl1271_op_set_key,
2274 .hw_scan = wl1271_op_hw_scan,
2275 .bss_info_changed = wl1271_op_bss_info_changed,
2276 .set_rts_threshold = wl1271_op_set_rts_threshold,
2277 .conf_tx = wl1271_op_conf_tx,
2278 .get_tsf = wl1271_op_get_tsf,
2279 .get_survey = wl1271_op_get_survey,
2280 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2284 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2288 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2290 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2291 wl1271_error("Illegal RX rate from HW: %d", rate);
2295 idx = wl1271_band_rate_to_idx[wl->band][rate];
2296 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2297 wl1271_error("Unsupported RX rate from HW: %d", rate);
2304 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2305 struct device_attribute *attr,
2308 struct wl1271 *wl = dev_get_drvdata(dev);
2313 mutex_lock(&wl->mutex);
2314 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2316 mutex_unlock(&wl->mutex);
2322 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2323 struct device_attribute *attr,
2324 const char *buf, size_t count)
2326 struct wl1271 *wl = dev_get_drvdata(dev);
2330 ret = strict_strtoul(buf, 10, &res);
2333 wl1271_warning("incorrect value written to bt_coex_mode");
2337 mutex_lock(&wl->mutex);
2341 if (res == wl->sg_enabled)
2344 wl->sg_enabled = res;
2346 if (wl->state == WL1271_STATE_OFF)
2349 ret = wl1271_ps_elp_wakeup(wl, false);
2353 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2354 wl1271_ps_elp_sleep(wl);
2357 mutex_unlock(&wl->mutex);
2361 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2362 wl1271_sysfs_show_bt_coex_state,
2363 wl1271_sysfs_store_bt_coex_state);
2365 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2366 struct device_attribute *attr,
2369 struct wl1271 *wl = dev_get_drvdata(dev);
2374 mutex_lock(&wl->mutex);
2375 if (wl->hw_pg_ver >= 0)
2376 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2378 len = snprintf(buf, len, "n/a\n");
2379 mutex_unlock(&wl->mutex);
2384 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2385 wl1271_sysfs_show_hw_pg_ver, NULL);
2387 int wl1271_register_hw(struct wl1271 *wl)
2391 if (wl->mac80211_registered)
2394 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2396 ret = ieee80211_register_hw(wl->hw);
2398 wl1271_error("unable to register mac80211 hw: %d", ret);
2402 wl->mac80211_registered = true;
2404 register_netdevice_notifier(&wl1271_dev_notifier);
2406 wl1271_notice("loaded");
2410 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2412 void wl1271_unregister_hw(struct wl1271 *wl)
2414 unregister_netdevice_notifier(&wl1271_dev_notifier);
2415 ieee80211_unregister_hw(wl->hw);
2416 wl->mac80211_registered = false;
2419 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2421 int wl1271_init_ieee80211(struct wl1271 *wl)
2423 static const u32 cipher_suites[] = {
2424 WLAN_CIPHER_SUITE_WEP40,
2425 WLAN_CIPHER_SUITE_WEP104,
2426 WLAN_CIPHER_SUITE_TKIP,
2427 WLAN_CIPHER_SUITE_CCMP,
2428 WL1271_CIPHER_SUITE_GEM,
2431 /* The tx descriptor buffer and the TKIP space. */
2432 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2433 sizeof(struct wl1271_tx_hw_descr);
2436 /* FIXME: find a proper value */
2437 wl->hw->channel_change_time = 10000;
2438 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2440 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2441 IEEE80211_HW_BEACON_FILTER |
2442 IEEE80211_HW_SUPPORTS_PS |
2443 IEEE80211_HW_SUPPORTS_UAPSD |
2444 IEEE80211_HW_HAS_RATE_CONTROL |
2445 IEEE80211_HW_CONNECTION_MONITOR |
2446 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2448 wl->hw->wiphy->cipher_suites = cipher_suites;
2449 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2451 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2452 BIT(NL80211_IFTYPE_ADHOC);
2453 wl->hw->wiphy->max_scan_ssids = 1;
2454 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2455 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2458 wl->hw->max_rates = 1;
2460 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2464 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2466 #define WL1271_DEFAULT_CHANNEL 0
2468 struct ieee80211_hw *wl1271_alloc_hw(void)
2470 struct ieee80211_hw *hw;
2471 struct platform_device *plat_dev = NULL;
2476 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2478 wl1271_error("could not alloc ieee80211_hw");
2483 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2485 wl1271_error("could not allocate platform_device");
2487 goto err_plat_alloc;
2491 memset(wl, 0, sizeof(*wl));
2493 INIT_LIST_HEAD(&wl->list);
2496 wl->plat_dev = plat_dev;
2498 skb_queue_head_init(&wl->tx_queue);
2500 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2501 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2502 INIT_WORK(&wl->irq_work, wl1271_irq_work);
2503 INIT_WORK(&wl->tx_work, wl1271_tx_work);
2504 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
2505 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
2506 wl->channel = WL1271_DEFAULT_CHANNEL;
2507 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2508 wl->default_key = 0;
2510 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2511 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2512 wl->psm_entry_retry = 0;
2513 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2514 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2515 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2516 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2517 wl->sta_rate_set = 0;
2518 wl->band = IEEE80211_BAND_2GHZ;
2521 wl->sg_enabled = true;
2524 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2525 wl->tx_frames[i] = NULL;
2527 spin_lock_init(&wl->wl_lock);
2529 wl->state = WL1271_STATE_OFF;
2530 mutex_init(&wl->mutex);
2532 /* Apply default driver configuration. */
2533 wl1271_conf_init(wl);
2535 wl1271_debugfs_init(wl);
2537 order = get_order(WL1271_AGGR_BUFFER_SIZE);
2538 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
2539 if (!wl->aggr_buf) {
2544 /* Register platform device */
2545 ret = platform_device_register(wl->plat_dev);
2547 wl1271_error("couldn't register platform device");
2550 dev_set_drvdata(&wl->plat_dev->dev, wl);
2552 /* Create sysfs file to control bt coex state */
2553 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2555 wl1271_error("failed to create sysfs file bt_coex_state");
2559 /* Create sysfs file to get HW PG version */
2560 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2562 wl1271_error("failed to create sysfs file hw_pg_ver");
2563 goto err_bt_coex_state;
2569 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2572 platform_device_unregister(wl->plat_dev);
2575 free_pages((unsigned long)wl->aggr_buf, order);
2578 wl1271_debugfs_exit(wl);
2582 ieee80211_free_hw(hw);
2586 return ERR_PTR(ret);
2588 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2590 int wl1271_free_hw(struct wl1271 *wl)
2592 platform_device_unregister(wl->plat_dev);
2593 free_pages((unsigned long)wl->aggr_buf,
2594 get_order(WL1271_AGGR_BUFFER_SIZE));
2595 kfree(wl->plat_dev);
2597 wl1271_debugfs_exit(wl);
2604 kfree(wl->fw_status);
2605 kfree(wl->tx_res_if);
2607 ieee80211_free_hw(wl->hw);
2611 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2613 MODULE_LICENSE("GPL");
2614 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2615 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");