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 = 3,
218 .keep_alive_interval = 55000,
219 .max_listen_interval = 20,
226 .host_clk_settling_time = 5000,
227 .host_fast_wakeup_support = false
231 .avg_weight_rssi_beacon = 20,
232 .avg_weight_rssi_data = 10,
233 .avg_weight_snr_beacon = 20,
234 .avg_weight_snr_data = 10
238 static void wl1271_device_release(struct device *dev)
243 static struct platform_device wl1271_device = {
247 /* device model insists to have a release function */
249 .release = wl1271_device_release,
253 static LIST_HEAD(wl_list);
255 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
258 struct net_device *dev = arg;
259 struct wireless_dev *wdev;
261 struct ieee80211_hw *hw;
263 struct wl1271 *wl_temp;
266 /* Check that this notification is for us. */
267 if (what != NETDEV_CHANGE)
270 wdev = dev->ieee80211_ptr;
278 hw = wiphy_priv(wiphy);
283 list_for_each_entry(wl, &wl_list, list) {
290 mutex_lock(&wl->mutex);
292 if (wl->state == WL1271_STATE_OFF)
295 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
298 ret = wl1271_ps_elp_wakeup(wl, false);
302 if ((dev->operstate == IF_OPER_UP) &&
303 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
304 wl1271_cmd_set_sta_state(wl);
305 wl1271_info("Association completed.");
308 wl1271_ps_elp_sleep(wl);
311 mutex_unlock(&wl->mutex);
316 static void wl1271_conf_init(struct wl1271 *wl)
320 * This function applies the default configuration to the driver. This
321 * function is invoked upon driver load (spi probe.)
323 * The configuration is stored in a run-time structure in order to
324 * facilitate for run-time adjustment of any of the parameters. Making
325 * changes to the configuration structure will apply the new values on
326 * the next interface up (wl1271_op_start.)
329 /* apply driver default configuration */
330 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
334 static int wl1271_plt_init(struct wl1271 *wl)
336 struct conf_tx_ac_category *conf_ac;
337 struct conf_tx_tid *conf_tid;
340 ret = wl1271_cmd_general_parms(wl);
344 ret = wl1271_cmd_radio_parms(wl);
348 ret = wl1271_init_templates_config(wl);
352 ret = wl1271_acx_init_mem_config(wl);
356 /* PHY layer config */
357 ret = wl1271_init_phy_config(wl);
359 goto out_free_memmap;
361 ret = wl1271_acx_dco_itrim_params(wl);
363 goto out_free_memmap;
365 /* Initialize connection monitoring thresholds */
366 ret = wl1271_acx_conn_monit_params(wl, false);
368 goto out_free_memmap;
370 /* Bluetooth WLAN coexistence */
371 ret = wl1271_init_pta(wl);
373 goto out_free_memmap;
375 /* Energy detection */
376 ret = wl1271_init_energy_detection(wl);
378 goto out_free_memmap;
380 /* Default fragmentation threshold */
381 ret = wl1271_acx_frag_threshold(wl);
383 goto out_free_memmap;
385 /* Default TID/AC configuration */
386 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
387 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
388 conf_ac = &wl->conf.tx.ac_conf[i];
389 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
390 conf_ac->cw_max, conf_ac->aifsn,
391 conf_ac->tx_op_limit);
393 goto out_free_memmap;
395 conf_tid = &wl->conf.tx.tid_conf[i];
396 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
397 conf_tid->channel_type,
400 conf_tid->ack_policy,
401 conf_tid->apsd_conf[0],
402 conf_tid->apsd_conf[1]);
404 goto out_free_memmap;
407 /* Enable data path */
408 ret = wl1271_cmd_data_path(wl, 1);
410 goto out_free_memmap;
412 /* Configure for CAM power saving (ie. always active) */
413 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
415 goto out_free_memmap;
418 ret = wl1271_acx_pm_config(wl);
420 goto out_free_memmap;
425 kfree(wl->target_mem_map);
426 wl->target_mem_map = NULL;
431 static void wl1271_fw_status(struct wl1271 *wl,
432 struct wl1271_fw_status *status)
438 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
440 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
441 "drv_rx_counter = %d, tx_results_counter = %d)",
443 status->fw_rx_counter,
444 status->drv_rx_counter,
445 status->tx_results_counter);
447 /* update number of available TX blocks */
448 for (i = 0; i < NUM_TX_QUEUES; i++) {
449 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
450 wl->tx_blocks_freed[i];
452 wl->tx_blocks_freed[i] =
453 le32_to_cpu(status->tx_released_blks[i]);
454 wl->tx_blocks_available += cnt;
458 /* if more blocks are available now, schedule some tx work */
459 if (total && !skb_queue_empty(&wl->tx_queue))
460 ieee80211_queue_work(wl->hw, &wl->tx_work);
462 /* update the host-chipset time offset */
464 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
465 (s64)le32_to_cpu(status->fw_localtime);
468 #define WL1271_IRQ_MAX_LOOPS 10
470 static void wl1271_irq_work(struct work_struct *work)
474 int loopcount = WL1271_IRQ_MAX_LOOPS;
477 container_of(work, struct wl1271, irq_work);
479 mutex_lock(&wl->mutex);
481 wl1271_debug(DEBUG_IRQ, "IRQ work");
483 if (unlikely(wl->state == WL1271_STATE_OFF))
486 ret = wl1271_ps_elp_wakeup(wl, true);
490 spin_lock_irqsave(&wl->wl_lock, flags);
491 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
492 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
493 spin_unlock_irqrestore(&wl->wl_lock, flags);
496 wl1271_fw_status(wl, wl->fw_status);
497 intr = le32_to_cpu(wl->fw_status->intr);
499 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
500 spin_lock_irqsave(&wl->wl_lock, flags);
504 intr &= WL1271_INTR_MASK;
506 if (intr & WL1271_ACX_INTR_DATA) {
507 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
509 /* check for tx results */
510 if (wl->fw_status->tx_results_counter !=
511 (wl->tx_results_count & 0xff))
512 wl1271_tx_complete(wl);
514 wl1271_rx(wl, wl->fw_status);
517 if (intr & WL1271_ACX_INTR_EVENT_A) {
518 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
519 wl1271_event_handle(wl, 0);
522 if (intr & WL1271_ACX_INTR_EVENT_B) {
523 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
524 wl1271_event_handle(wl, 1);
527 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
528 wl1271_debug(DEBUG_IRQ,
529 "WL1271_ACX_INTR_INIT_COMPLETE");
531 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
532 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
534 spin_lock_irqsave(&wl->wl_lock, flags);
537 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
538 ieee80211_queue_work(wl->hw, &wl->irq_work);
540 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
541 spin_unlock_irqrestore(&wl->wl_lock, flags);
543 wl1271_ps_elp_sleep(wl);
546 mutex_unlock(&wl->mutex);
549 static int wl1271_fetch_firmware(struct wl1271 *wl)
551 const struct firmware *fw;
554 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
557 wl1271_error("could not get firmware: %d", ret);
562 wl1271_error("firmware size is not multiple of 32 bits: %zu",
568 wl->fw_len = fw->size;
569 wl->fw = vmalloc(wl->fw_len);
572 wl1271_error("could not allocate memory for the firmware");
577 memcpy(wl->fw, fw->data, wl->fw_len);
582 release_firmware(fw);
587 static int wl1271_fetch_nvs(struct wl1271 *wl)
589 const struct firmware *fw;
592 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
595 wl1271_error("could not get nvs file: %d", ret);
599 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
602 wl1271_error("could not allocate memory for the nvs file");
607 wl->nvs_len = fw->size;
610 release_firmware(fw);
615 static void wl1271_fw_wakeup(struct wl1271 *wl)
619 elp_reg = ELPCTRL_WAKE_UP;
620 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
623 static int wl1271_setup(struct wl1271 *wl)
625 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
629 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
630 if (!wl->tx_res_if) {
631 kfree(wl->fw_status);
635 INIT_WORK(&wl->irq_work, wl1271_irq_work);
636 INIT_WORK(&wl->tx_work, wl1271_tx_work);
637 INIT_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
642 static int wl1271_chip_wakeup(struct wl1271 *wl)
644 struct wl1271_partition_set partition;
647 msleep(WL1271_PRE_POWER_ON_SLEEP);
648 ret = wl1271_power_on(wl);
651 msleep(WL1271_POWER_ON_SLEEP);
655 /* We don't need a real memory partition here, because we only want
656 * to use the registers at this point. */
657 memset(&partition, 0, sizeof(partition));
658 partition.reg.start = REGISTERS_BASE;
659 partition.reg.size = REGISTERS_DOWN_SIZE;
660 wl1271_set_partition(wl, &partition);
662 /* ELP module wake up */
663 wl1271_fw_wakeup(wl);
665 /* whal_FwCtrl_BootSm() */
667 /* 0. read chip id from CHIP_ID */
668 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
670 /* 1. check if chip id is valid */
672 switch (wl->chip.id) {
673 case CHIP_ID_1271_PG10:
674 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
677 ret = wl1271_setup(wl);
681 case CHIP_ID_1271_PG20:
682 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
685 ret = wl1271_setup(wl);
690 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
695 if (wl->fw == NULL) {
696 ret = wl1271_fetch_firmware(wl);
701 /* No NVS from netlink, try to get it from the filesystem */
702 if (wl->nvs == NULL) {
703 ret = wl1271_fetch_nvs(wl);
712 int wl1271_plt_start(struct wl1271 *wl)
714 int retries = WL1271_BOOT_RETRIES;
717 mutex_lock(&wl->mutex);
719 wl1271_notice("power up");
721 if (wl->state != WL1271_STATE_OFF) {
722 wl1271_error("cannot go into PLT state because not "
723 "in off state: %d", wl->state);
730 ret = wl1271_chip_wakeup(wl);
734 ret = wl1271_boot(wl);
738 ret = wl1271_plt_init(wl);
742 wl->state = WL1271_STATE_PLT;
743 wl1271_notice("firmware booted in PLT mode (%s)",
748 wl1271_disable_interrupts(wl);
749 mutex_unlock(&wl->mutex);
750 /* Unlocking the mutex in the middle of handling is
751 inherently unsafe. In this case we deem it safe to do,
752 because we need to let any possibly pending IRQ out of
753 the system (and while we are WL1271_STATE_OFF the IRQ
754 work function will not do anything.) Also, any other
755 possible concurrent operations will fail due to the
756 current state, hence the wl1271 struct should be safe. */
757 cancel_work_sync(&wl->irq_work);
758 mutex_lock(&wl->mutex);
760 wl1271_power_off(wl);
763 wl1271_error("firmware boot in PLT mode failed despite %d retries",
764 WL1271_BOOT_RETRIES);
766 mutex_unlock(&wl->mutex);
771 int wl1271_plt_stop(struct wl1271 *wl)
775 mutex_lock(&wl->mutex);
777 wl1271_notice("power down");
779 if (wl->state != WL1271_STATE_PLT) {
780 wl1271_error("cannot power down because not in PLT "
781 "state: %d", wl->state);
786 wl1271_disable_interrupts(wl);
787 wl1271_power_off(wl);
789 wl->state = WL1271_STATE_OFF;
793 mutex_unlock(&wl->mutex);
799 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
801 struct wl1271 *wl = hw->priv;
802 struct ieee80211_conf *conf = &hw->conf;
803 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
804 struct ieee80211_sta *sta = txinfo->control.sta;
807 /* peek into the rates configured in the STA entry */
808 spin_lock_irqsave(&wl->wl_lock, flags);
809 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
810 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
811 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
813 spin_unlock_irqrestore(&wl->wl_lock, flags);
815 /* queue the packet */
816 skb_queue_tail(&wl->tx_queue, skb);
819 * The chip specific setup must run before the first TX packet -
820 * before that, the tx_work will not be initialized!
823 ieee80211_queue_work(wl->hw, &wl->tx_work);
826 * The workqueue is slow to process the tx_queue and we need stop
827 * the queue here, otherwise the queue will get too long.
829 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
830 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
832 spin_lock_irqsave(&wl->wl_lock, flags);
833 ieee80211_stop_queues(wl->hw);
834 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
835 spin_unlock_irqrestore(&wl->wl_lock, flags);
841 static struct notifier_block wl1271_dev_notifier = {
842 .notifier_call = wl1271_dev_notify,
845 static int wl1271_op_start(struct ieee80211_hw *hw)
847 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
850 * We have to delay the booting of the hardware because
851 * we need to know the local MAC address before downloading and
852 * initializing the firmware. The MAC address cannot be changed
853 * after boot, and without the proper MAC address, the firmware
854 * will not function properly.
856 * The MAC address is first known when the corresponding interface
857 * is added. That is where we will initialize the hardware.
863 static void wl1271_op_stop(struct ieee80211_hw *hw)
865 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
868 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
869 struct ieee80211_vif *vif)
871 struct wl1271 *wl = hw->priv;
872 struct wiphy *wiphy = hw->wiphy;
873 int retries = WL1271_BOOT_RETRIES;
876 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
877 vif->type, vif->addr);
879 mutex_lock(&wl->mutex);
888 case NL80211_IFTYPE_STATION:
889 wl->bss_type = BSS_TYPE_STA_BSS;
890 wl->set_bss_type = BSS_TYPE_STA_BSS;
892 case NL80211_IFTYPE_ADHOC:
893 wl->bss_type = BSS_TYPE_IBSS;
894 wl->set_bss_type = BSS_TYPE_STA_BSS;
901 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
903 if (wl->state != WL1271_STATE_OFF) {
904 wl1271_error("cannot start because not in off state: %d",
912 ret = wl1271_chip_wakeup(wl);
916 ret = wl1271_boot(wl);
920 ret = wl1271_hw_init(wl);
924 wl->state = WL1271_STATE_ON;
925 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
927 /* update hw/fw version info in wiphy struct */
928 wiphy->hw_version = wl->chip.id;
929 strncpy(wiphy->fw_version, wl->chip.fw_ver,
930 sizeof(wiphy->fw_version));
935 wl1271_disable_interrupts(wl);
936 mutex_unlock(&wl->mutex);
937 /* Unlocking the mutex in the middle of handling is
938 inherently unsafe. In this case we deem it safe to do,
939 because we need to let any possibly pending IRQ out of
940 the system (and while we are WL1271_STATE_OFF the IRQ
941 work function will not do anything.) Also, any other
942 possible concurrent operations will fail due to the
943 current state, hence the wl1271 struct should be safe. */
944 cancel_work_sync(&wl->irq_work);
945 mutex_lock(&wl->mutex);
947 wl1271_power_off(wl);
950 wl1271_error("firmware boot failed despite %d retries",
951 WL1271_BOOT_RETRIES);
953 mutex_unlock(&wl->mutex);
956 list_add(&wl->list, &wl_list);
961 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
962 struct ieee80211_vif *vif)
964 struct wl1271 *wl = hw->priv;
967 cancel_work_sync(&wl->scan_complete_work);
969 mutex_lock(&wl->mutex);
970 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
976 WARN_ON(wl->state != WL1271_STATE_ON);
978 /* enable dyn ps just in case (if left on due to fw crash etc) */
979 if (wl->bss_type == BSS_TYPE_STA_BSS)
980 ieee80211_enable_dyn_ps(wl->vif);
982 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
983 wl->scan.state = WL1271_SCAN_STATE_IDLE;
984 kfree(wl->scan.scanned_ch);
985 wl->scan.scanned_ch = NULL;
986 ieee80211_scan_completed(wl->hw, true);
989 wl->state = WL1271_STATE_OFF;
991 wl1271_disable_interrupts(wl);
993 mutex_unlock(&wl->mutex);
995 cancel_work_sync(&wl->irq_work);
996 cancel_work_sync(&wl->tx_work);
997 cancel_delayed_work_sync(&wl->pspoll_work);
999 mutex_lock(&wl->mutex);
1001 /* let's notify MAC80211 about the remaining pending TX frames */
1002 wl1271_tx_reset(wl);
1003 wl1271_power_off(wl);
1005 memset(wl->bssid, 0, ETH_ALEN);
1006 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1008 wl->bss_type = MAX_BSS_TYPE;
1009 wl->set_bss_type = MAX_BSS_TYPE;
1010 wl->band = IEEE80211_BAND_2GHZ;
1013 wl->psm_entry_retry = 0;
1014 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1015 wl->tx_blocks_available = 0;
1016 wl->tx_results_count = 0;
1017 wl->tx_packets_count = 0;
1018 wl->tx_security_last_seq = 0;
1019 wl->tx_security_seq = 0;
1020 wl->time_offset = 0;
1021 wl->session_counter = 0;
1022 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1023 wl->sta_rate_set = 0;
1028 for (i = 0; i < NUM_TX_QUEUES; i++)
1029 wl->tx_blocks_freed[i] = 0;
1031 wl1271_debugfs_reset(wl);
1033 kfree(wl->fw_status);
1034 wl->fw_status = NULL;
1035 kfree(wl->tx_res_if);
1036 wl->tx_res_if = NULL;
1037 kfree(wl->target_mem_map);
1038 wl->target_mem_map = NULL;
1040 mutex_unlock(&wl->mutex);
1043 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1045 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1046 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1048 /* combine requested filters with current filter config */
1049 filters = wl->filters | filters;
1051 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1053 if (filters & FIF_PROMISC_IN_BSS) {
1054 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1055 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1056 wl->rx_config |= CFG_BSSID_FILTER_EN;
1058 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1059 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1060 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1061 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1063 if (filters & FIF_OTHER_BSS) {
1064 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1065 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1067 if (filters & FIF_CONTROL) {
1068 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1069 wl->rx_filter |= CFG_RX_CTL_EN;
1071 if (filters & FIF_FCSFAIL) {
1072 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1073 wl->rx_filter |= CFG_RX_FCS_ERROR;
1077 static int wl1271_dummy_join(struct wl1271 *wl)
1080 /* we need to use a dummy BSSID for now */
1081 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1084 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1086 /* pass through frames from all BSS */
1087 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1089 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1093 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1099 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1104 * One of the side effects of the JOIN command is that is clears
1105 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1106 * to a WPA/WPA2 access point will therefore kill the data-path.
1107 * Currently there is no supported scenario for JOIN during
1108 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1109 * must be handled somehow.
1112 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1113 wl1271_info("JOIN while associated.");
1116 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1118 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1122 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1124 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1128 * The join command disable the keep-alive mode, shut down its process,
1129 * and also clear the template config, so we need to reset it all after
1130 * the join. The acx_aid starts the keep-alive process, and the order
1131 * of the commands below is relevant.
1133 ret = wl1271_acx_keep_alive_mode(wl, true);
1137 ret = wl1271_acx_aid(wl, wl->aid);
1141 ret = wl1271_cmd_build_klv_null_data(wl);
1145 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1146 ACX_KEEP_ALIVE_TPL_VALID);
1154 static int wl1271_unjoin(struct wl1271 *wl)
1158 /* to stop listening to a channel, we disconnect */
1159 ret = wl1271_cmd_disconnect(wl);
1163 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1164 memset(wl->bssid, 0, ETH_ALEN);
1166 /* stop filterting packets based on bssid */
1167 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1173 static void wl1271_set_band_rate(struct wl1271 *wl)
1175 if (wl->band == IEEE80211_BAND_2GHZ)
1176 wl->basic_rate_set = wl->conf.tx.basic_rate;
1178 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1181 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1186 if (!wl->basic_rate_set) {
1188 wl->basic_rate_set = wl->conf.tx.basic_rate;
1191 for (i = 0; !rate; i++) {
1192 if ((wl->basic_rate_set >> i) & 0x1)
1199 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1204 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1205 ret = wl1271_unjoin(wl);
1209 wl->rate_set = wl1271_min_rate_get(wl);
1210 wl->sta_rate_set = 0;
1211 ret = wl1271_acx_rate_policies(wl);
1214 ret = wl1271_acx_keep_alive_config(
1215 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1216 ACX_KEEP_ALIVE_TPL_INVALID);
1219 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1221 /* increment the session counter */
1222 wl->session_counter++;
1223 if (wl->session_counter >= SESSION_COUNTER_MAX)
1224 wl->session_counter = 0;
1225 ret = wl1271_dummy_join(wl);
1228 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1235 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1237 struct wl1271 *wl = hw->priv;
1238 struct ieee80211_conf *conf = &hw->conf;
1239 int channel, ret = 0;
1241 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1243 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1245 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1247 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1250 * mac80211 will go to idle nearly immediately after transmitting some
1251 * frames, such as the deauth. To make sure those frames reach the air,
1252 * wait here until the TX queue is fully flushed.
1254 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1255 (conf->flags & IEEE80211_CONF_IDLE))
1256 wl1271_tx_flush(wl);
1258 mutex_lock(&wl->mutex);
1260 if (unlikely(wl->state == WL1271_STATE_OFF))
1263 ret = wl1271_ps_elp_wakeup(wl, false);
1267 /* if the channel changes while joined, join again */
1268 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1269 ((wl->band != conf->channel->band) ||
1270 (wl->channel != channel))) {
1271 wl->band = conf->channel->band;
1272 wl->channel = channel;
1275 * FIXME: the mac80211 should really provide a fixed rate
1276 * to use here. for now, just use the smallest possible rate
1277 * for the band as a fixed rate for association frames and
1278 * other control messages.
1280 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1281 wl1271_set_band_rate(wl);
1283 wl->basic_rate = wl1271_min_rate_get(wl);
1284 ret = wl1271_acx_rate_policies(wl);
1286 wl1271_warning("rate policy for update channel "
1289 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1290 ret = wl1271_join(wl, false);
1292 wl1271_warning("cmd join to update channel "
1297 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1298 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1300 wl1271_warning("idle mode change failed %d", ret);
1304 * if mac80211 changes the PSM mode, make sure the mode is not
1305 * incorrectly changed after the pspoll failure active window.
1307 if (changed & IEEE80211_CONF_CHANGE_PS)
1308 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1310 if (conf->flags & IEEE80211_CONF_PS &&
1311 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1312 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1315 * We enter PSM only if we're already associated.
1316 * If we're not, we'll enter it when joining an SSID,
1317 * through the bss_info_changed() hook.
1319 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1320 wl1271_debug(DEBUG_PSM, "psm enabled");
1321 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1322 wl->basic_rate_set, true);
1324 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1325 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1326 wl1271_debug(DEBUG_PSM, "psm disabled");
1328 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1330 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1331 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1332 wl->basic_rate_set, true);
1335 if (conf->power_level != wl->power_level) {
1336 ret = wl1271_acx_tx_power(wl, conf->power_level);
1340 wl->power_level = conf->power_level;
1344 wl1271_ps_elp_sleep(wl);
1347 mutex_unlock(&wl->mutex);
1352 struct wl1271_filter_params {
1355 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1358 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1359 struct netdev_hw_addr_list *mc_list)
1361 struct wl1271_filter_params *fp;
1362 struct netdev_hw_addr *ha;
1363 struct wl1271 *wl = hw->priv;
1365 if (unlikely(wl->state == WL1271_STATE_OFF))
1368 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1370 wl1271_error("Out of memory setting filters.");
1374 /* update multicast filtering parameters */
1375 fp->mc_list_length = 0;
1376 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1377 fp->enabled = false;
1380 netdev_hw_addr_list_for_each(ha, mc_list) {
1381 memcpy(fp->mc_list[fp->mc_list_length],
1382 ha->addr, ETH_ALEN);
1383 fp->mc_list_length++;
1387 return (u64)(unsigned long)fp;
1390 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1393 FIF_BCN_PRBRESP_PROMISC | \
1397 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1398 unsigned int changed,
1399 unsigned int *total, u64 multicast)
1401 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1402 struct wl1271 *wl = hw->priv;
1405 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1407 mutex_lock(&wl->mutex);
1409 *total &= WL1271_SUPPORTED_FILTERS;
1410 changed &= WL1271_SUPPORTED_FILTERS;
1412 if (unlikely(wl->state == WL1271_STATE_OFF))
1415 ret = wl1271_ps_elp_wakeup(wl, false);
1420 if (*total & FIF_ALLMULTI)
1421 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1423 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1425 fp->mc_list_length);
1429 /* determine, whether supported filter values have changed */
1433 /* configure filters */
1434 wl->filters = *total;
1435 wl1271_configure_filters(wl, 0);
1437 /* apply configured filters */
1438 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1443 wl1271_ps_elp_sleep(wl);
1446 mutex_unlock(&wl->mutex);
1450 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1451 struct ieee80211_vif *vif,
1452 struct ieee80211_sta *sta,
1453 struct ieee80211_key_conf *key_conf)
1455 struct wl1271 *wl = hw->priv;
1462 static const u8 bcast_addr[ETH_ALEN] =
1463 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1465 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1467 addr = sta ? sta->addr : bcast_addr;
1469 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1470 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1471 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1472 key_conf->cipher, key_conf->keyidx,
1473 key_conf->keylen, key_conf->flags);
1474 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1476 if (is_zero_ether_addr(addr)) {
1477 /* We dont support TX only encryption */
1482 mutex_lock(&wl->mutex);
1484 ret = wl1271_ps_elp_wakeup(wl, false);
1488 switch (key_conf->cipher) {
1489 case WLAN_CIPHER_SUITE_WEP40:
1490 case WLAN_CIPHER_SUITE_WEP104:
1493 key_conf->hw_key_idx = key_conf->keyidx;
1495 case WLAN_CIPHER_SUITE_TKIP:
1496 key_type = KEY_TKIP;
1498 key_conf->hw_key_idx = key_conf->keyidx;
1499 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1500 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1502 case WLAN_CIPHER_SUITE_CCMP:
1505 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1506 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1507 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1510 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1518 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1519 key_conf->keyidx, key_type,
1520 key_conf->keylen, key_conf->key,
1521 addr, tx_seq_32, tx_seq_16);
1523 wl1271_error("Could not add or replace key");
1527 /* the default WEP key needs to be configured at least once */
1528 if (key_type == KEY_WEP) {
1529 ret = wl1271_cmd_set_default_wep_key(wl,
1537 /* The wl1271 does not allow to remove unicast keys - they
1538 will be cleared automatically on next CMD_JOIN. Ignore the
1539 request silently, as we dont want the mac80211 to emit
1540 an error message. */
1541 if (!is_broadcast_ether_addr(addr))
1544 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1545 key_conf->keyidx, key_type,
1546 key_conf->keylen, key_conf->key,
1549 wl1271_error("Could not remove key");
1555 wl1271_error("Unsupported key cmd 0x%x", cmd);
1561 wl1271_ps_elp_sleep(wl);
1564 mutex_unlock(&wl->mutex);
1570 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1571 struct ieee80211_vif *vif,
1572 struct cfg80211_scan_request *req)
1574 struct wl1271 *wl = hw->priv;
1579 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1582 ssid = req->ssids[0].ssid;
1583 len = req->ssids[0].ssid_len;
1586 mutex_lock(&wl->mutex);
1588 ret = wl1271_ps_elp_wakeup(wl, false);
1592 ret = wl1271_scan(hw->priv, ssid, len, req);
1594 wl1271_ps_elp_sleep(wl);
1597 mutex_unlock(&wl->mutex);
1602 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1604 struct wl1271 *wl = hw->priv;
1607 mutex_lock(&wl->mutex);
1609 if (unlikely(wl->state == WL1271_STATE_OFF))
1612 ret = wl1271_ps_elp_wakeup(wl, false);
1616 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1618 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1620 wl1271_ps_elp_sleep(wl);
1623 mutex_unlock(&wl->mutex);
1628 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1630 u8 *ptr = beacon->data +
1631 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1633 /* find the location of the ssid in the beacon */
1634 while (ptr < beacon->data + beacon->len) {
1635 if (ptr[0] == WLAN_EID_SSID) {
1636 wl->ssid_len = ptr[1];
1637 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1642 wl1271_error("ad-hoc beacon template has no SSID!\n");
1645 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1646 struct ieee80211_vif *vif,
1647 struct ieee80211_bss_conf *bss_conf,
1650 enum wl1271_cmd_ps_mode mode;
1651 struct wl1271 *wl = hw->priv;
1652 bool do_join = false;
1653 bool set_assoc = false;
1656 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1658 mutex_lock(&wl->mutex);
1660 ret = wl1271_ps_elp_wakeup(wl, false);
1664 if ((changed & BSS_CHANGED_BEACON_INT) &&
1665 (wl->bss_type == BSS_TYPE_IBSS)) {
1666 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1667 bss_conf->beacon_int);
1669 wl->beacon_int = bss_conf->beacon_int;
1673 if ((changed & BSS_CHANGED_BEACON) &&
1674 (wl->bss_type == BSS_TYPE_IBSS)) {
1675 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1677 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1680 struct ieee80211_hdr *hdr;
1682 wl1271_ssid_set(wl, beacon);
1683 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1686 wl1271_min_rate_get(wl));
1689 dev_kfree_skb(beacon);
1693 hdr = (struct ieee80211_hdr *) beacon->data;
1694 hdr->frame_control = cpu_to_le16(
1695 IEEE80211_FTYPE_MGMT |
1696 IEEE80211_STYPE_PROBE_RESP);
1698 ret = wl1271_cmd_template_set(wl,
1699 CMD_TEMPL_PROBE_RESPONSE,
1702 wl1271_min_rate_get(wl));
1703 dev_kfree_skb(beacon);
1707 /* Need to update the SSID (for filtering etc) */
1712 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1713 (wl->bss_type == BSS_TYPE_IBSS)) {
1714 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1715 bss_conf->enable_beacon ? "enabled" : "disabled");
1717 if (bss_conf->enable_beacon)
1718 wl->set_bss_type = BSS_TYPE_IBSS;
1720 wl->set_bss_type = BSS_TYPE_STA_BSS;
1724 if (changed & BSS_CHANGED_CQM) {
1725 bool enable = false;
1726 if (bss_conf->cqm_rssi_thold)
1728 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1729 bss_conf->cqm_rssi_thold,
1730 bss_conf->cqm_rssi_hyst);
1733 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1736 if ((changed & BSS_CHANGED_BSSID) &&
1738 * Now we know the correct bssid, so we send a new join command
1739 * and enable the BSSID filter
1741 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1742 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1744 ret = wl1271_cmd_build_null_data(wl);
1748 ret = wl1271_build_qos_null_data(wl);
1752 /* filter out all packets not from this BSSID */
1753 wl1271_configure_filters(wl, 0);
1755 /* Need to update the BSSID (for filtering etc) */
1759 if (changed & BSS_CHANGED_ASSOC) {
1760 if (bss_conf->assoc) {
1762 wl->aid = bss_conf->aid;
1765 wl->ps_poll_failures = 0;
1768 * use basic rates from AP, and determine lowest rate
1769 * to use with control frames.
1771 rates = bss_conf->basic_rates;
1772 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1774 wl->basic_rate = wl1271_min_rate_get(wl);
1775 ret = wl1271_acx_rate_policies(wl);
1780 * with wl1271, we don't need to update the
1781 * beacon_int and dtim_period, because the firmware
1782 * updates it by itself when the first beacon is
1783 * received after a join.
1785 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1790 * The SSID is intentionally set to NULL here - the
1791 * firmware will set the probe request with a
1792 * broadcast SSID regardless of what we set in the
1795 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1798 /* enable the connection monitoring feature */
1799 ret = wl1271_acx_conn_monit_params(wl, true);
1803 /* If we want to go in PSM but we're not there yet */
1804 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1805 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1806 mode = STATION_POWER_SAVE_MODE;
1807 ret = wl1271_ps_set_mode(wl, mode,
1814 /* use defaults when not associated */
1815 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1816 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1819 /* re-enable dynamic ps - just in case */
1820 ieee80211_enable_dyn_ps(wl->vif);
1822 /* revert back to minimum rates for the current band */
1823 wl1271_set_band_rate(wl);
1824 wl->basic_rate = wl1271_min_rate_get(wl);
1825 ret = wl1271_acx_rate_policies(wl);
1829 /* disable connection monitor features */
1830 ret = wl1271_acx_conn_monit_params(wl, false);
1832 /* Disable the keep-alive feature */
1833 ret = wl1271_acx_keep_alive_mode(wl, false);
1841 if (changed & BSS_CHANGED_ERP_SLOT) {
1842 if (bss_conf->use_short_slot)
1843 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1845 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1847 wl1271_warning("Set slot time failed %d", ret);
1852 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1853 if (bss_conf->use_short_preamble)
1854 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1856 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1859 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1860 if (bss_conf->use_cts_prot)
1861 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1863 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1865 wl1271_warning("Set ctsprotect failed %d", ret);
1870 if (changed & BSS_CHANGED_ARP_FILTER) {
1871 __be32 addr = bss_conf->arp_addr_list[0];
1872 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1874 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1875 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1877 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1884 ret = wl1271_join(wl, set_assoc);
1886 wl1271_warning("cmd join failed %d", ret);
1892 wl1271_ps_elp_sleep(wl);
1895 mutex_unlock(&wl->mutex);
1898 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1899 const struct ieee80211_tx_queue_params *params)
1901 struct wl1271 *wl = hw->priv;
1905 mutex_lock(&wl->mutex);
1907 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1909 ret = wl1271_ps_elp_wakeup(wl, false);
1913 /* the txop is confed in units of 32us by the mac80211, we need us */
1914 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1915 params->cw_min, params->cw_max,
1916 params->aifs, params->txop << 5);
1921 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1923 ps_scheme = CONF_PS_SCHEME_LEGACY;
1925 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1926 CONF_CHANNEL_TYPE_EDCF,
1927 wl1271_tx_get_queue(queue),
1928 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1933 wl1271_ps_elp_sleep(wl);
1936 mutex_unlock(&wl->mutex);
1941 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1944 struct wl1271 *wl = hw->priv;
1945 u64 mactime = ULLONG_MAX;
1948 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1950 mutex_lock(&wl->mutex);
1952 ret = wl1271_ps_elp_wakeup(wl, false);
1956 ret = wl1271_acx_tsf_info(wl, &mactime);
1961 wl1271_ps_elp_sleep(wl);
1964 mutex_unlock(&wl->mutex);
1968 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1969 struct survey_info *survey)
1971 struct wl1271 *wl = hw->priv;
1972 struct ieee80211_conf *conf = &hw->conf;
1977 survey->channel = conf->channel;
1978 survey->filled = SURVEY_INFO_NOISE_DBM;
1979 survey->noise = wl->noise;
1984 /* can't be const, mac80211 writes to this */
1985 static struct ieee80211_rate wl1271_rates[] = {
1987 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1988 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1990 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1991 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1992 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1994 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1995 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1996 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1998 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1999 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2000 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2002 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2003 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2005 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2006 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2008 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2009 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2011 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2012 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2014 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2015 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2017 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2018 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2020 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2021 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2023 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2024 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2028 * Can't be const, mac80211 writes to this. The order of the channels here
2029 * is designed to improve scanning.
2031 static struct ieee80211_channel wl1271_channels[] = {
2032 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2033 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2034 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2035 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2036 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2037 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2038 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2039 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2040 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2041 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2042 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2043 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2044 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2047 /* mapping to indexes for wl1271_rates */
2048 static const u8 wl1271_rate_to_idx_2ghz[] = {
2049 /* MCS rates are used only with 11n */
2050 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2051 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2052 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2053 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2054 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2055 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2056 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2057 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2059 11, /* CONF_HW_RXTX_RATE_54 */
2060 10, /* CONF_HW_RXTX_RATE_48 */
2061 9, /* CONF_HW_RXTX_RATE_36 */
2062 8, /* CONF_HW_RXTX_RATE_24 */
2064 /* TI-specific rate */
2065 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2067 7, /* CONF_HW_RXTX_RATE_18 */
2068 6, /* CONF_HW_RXTX_RATE_12 */
2069 3, /* CONF_HW_RXTX_RATE_11 */
2070 5, /* CONF_HW_RXTX_RATE_9 */
2071 4, /* CONF_HW_RXTX_RATE_6 */
2072 2, /* CONF_HW_RXTX_RATE_5_5 */
2073 1, /* CONF_HW_RXTX_RATE_2 */
2074 0 /* CONF_HW_RXTX_RATE_1 */
2077 /* can't be const, mac80211 writes to this */
2078 static struct ieee80211_supported_band wl1271_band_2ghz = {
2079 .channels = wl1271_channels,
2080 .n_channels = ARRAY_SIZE(wl1271_channels),
2081 .bitrates = wl1271_rates,
2082 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2085 /* 5 GHz data rates for WL1273 */
2086 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2088 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2089 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2091 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2092 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2094 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2095 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2097 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2098 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2100 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2101 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2103 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2104 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2106 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2107 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2109 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2110 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2114 * 5 GHz band channels for WL1273 - can't be const, mac80211 writes to this.
2115 * The order of the channels here is designed to improve scanning.
2117 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2118 { .hw_value = 183, .center_freq = 4915},
2119 { .hw_value = 188, .center_freq = 4940},
2120 { .hw_value = 8, .center_freq = 5040},
2121 { .hw_value = 34, .center_freq = 5170},
2122 { .hw_value = 44, .center_freq = 5220},
2123 { .hw_value = 60, .center_freq = 5300},
2124 { .hw_value = 112, .center_freq = 5560},
2125 { .hw_value = 132, .center_freq = 5660},
2126 { .hw_value = 157, .center_freq = 5785},
2127 { .hw_value = 184, .center_freq = 4920},
2128 { .hw_value = 189, .center_freq = 4945},
2129 { .hw_value = 9, .center_freq = 5045},
2130 { .hw_value = 36, .center_freq = 5180},
2131 { .hw_value = 46, .center_freq = 5230},
2132 { .hw_value = 64, .center_freq = 5320},
2133 { .hw_value = 116, .center_freq = 5580},
2134 { .hw_value = 136, .center_freq = 5680},
2135 { .hw_value = 192, .center_freq = 4960},
2136 { .hw_value = 11, .center_freq = 5055},
2137 { .hw_value = 38, .center_freq = 5190},
2138 { .hw_value = 48, .center_freq = 5240},
2139 { .hw_value = 100, .center_freq = 5500},
2140 { .hw_value = 120, .center_freq = 5600},
2141 { .hw_value = 140, .center_freq = 5700},
2142 { .hw_value = 185, .center_freq = 4925},
2143 { .hw_value = 196, .center_freq = 4980},
2144 { .hw_value = 12, .center_freq = 5060},
2145 { .hw_value = 40, .center_freq = 5200},
2146 { .hw_value = 52, .center_freq = 5260},
2147 { .hw_value = 104, .center_freq = 5520},
2148 { .hw_value = 124, .center_freq = 5620},
2149 { .hw_value = 149, .center_freq = 5745},
2150 { .hw_value = 161, .center_freq = 5805},
2151 { .hw_value = 187, .center_freq = 4935},
2152 { .hw_value = 7, .center_freq = 5035},
2153 { .hw_value = 16, .center_freq = 5080},
2154 { .hw_value = 42, .center_freq = 5210},
2155 { .hw_value = 56, .center_freq = 5280},
2156 { .hw_value = 108, .center_freq = 5540},
2157 { .hw_value = 128, .center_freq = 5640},
2158 { .hw_value = 153, .center_freq = 5765},
2159 { .hw_value = 165, .center_freq = 5825},
2162 /* mapping to indexes for wl1271_rates_5ghz */
2163 static const u8 wl1271_rate_to_idx_5ghz[] = {
2164 /* MCS rates are used only with 11n */
2165 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2166 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2167 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2168 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2169 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2170 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2171 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2172 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2174 7, /* CONF_HW_RXTX_RATE_54 */
2175 6, /* CONF_HW_RXTX_RATE_48 */
2176 5, /* CONF_HW_RXTX_RATE_36 */
2177 4, /* CONF_HW_RXTX_RATE_24 */
2179 /* TI-specific rate */
2180 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2182 3, /* CONF_HW_RXTX_RATE_18 */
2183 2, /* CONF_HW_RXTX_RATE_12 */
2184 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2185 1, /* CONF_HW_RXTX_RATE_9 */
2186 0, /* CONF_HW_RXTX_RATE_6 */
2187 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2188 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2189 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2192 static struct ieee80211_supported_band wl1271_band_5ghz = {
2193 .channels = wl1271_channels_5ghz,
2194 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2195 .bitrates = wl1271_rates_5ghz,
2196 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2199 static const u8 *wl1271_band_rate_to_idx[] = {
2200 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2201 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2204 static const struct ieee80211_ops wl1271_ops = {
2205 .start = wl1271_op_start,
2206 .stop = wl1271_op_stop,
2207 .add_interface = wl1271_op_add_interface,
2208 .remove_interface = wl1271_op_remove_interface,
2209 .config = wl1271_op_config,
2210 .prepare_multicast = wl1271_op_prepare_multicast,
2211 .configure_filter = wl1271_op_configure_filter,
2213 .set_key = wl1271_op_set_key,
2214 .hw_scan = wl1271_op_hw_scan,
2215 .bss_info_changed = wl1271_op_bss_info_changed,
2216 .set_rts_threshold = wl1271_op_set_rts_threshold,
2217 .conf_tx = wl1271_op_conf_tx,
2218 .get_tsf = wl1271_op_get_tsf,
2219 .get_survey = wl1271_op_get_survey,
2220 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2224 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2228 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2230 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2231 wl1271_error("Illegal RX rate from HW: %d", rate);
2235 idx = wl1271_band_rate_to_idx[wl->band][rate];
2236 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2237 wl1271_error("Unsupported RX rate from HW: %d", rate);
2244 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2245 struct device_attribute *attr,
2248 struct wl1271 *wl = dev_get_drvdata(dev);
2253 mutex_lock(&wl->mutex);
2254 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2256 mutex_unlock(&wl->mutex);
2262 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2263 struct device_attribute *attr,
2264 const char *buf, size_t count)
2266 struct wl1271 *wl = dev_get_drvdata(dev);
2270 ret = strict_strtoul(buf, 10, &res);
2273 wl1271_warning("incorrect value written to bt_coex_mode");
2277 mutex_lock(&wl->mutex);
2281 if (res == wl->sg_enabled)
2284 wl->sg_enabled = res;
2286 if (wl->state == WL1271_STATE_OFF)
2289 ret = wl1271_ps_elp_wakeup(wl, false);
2293 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2294 wl1271_ps_elp_sleep(wl);
2297 mutex_unlock(&wl->mutex);
2301 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2302 wl1271_sysfs_show_bt_coex_state,
2303 wl1271_sysfs_store_bt_coex_state);
2305 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2306 struct device_attribute *attr,
2309 struct wl1271 *wl = dev_get_drvdata(dev);
2314 mutex_lock(&wl->mutex);
2315 if (wl->hw_pg_ver >= 0)
2316 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2318 len = snprintf(buf, len, "n/a\n");
2319 mutex_unlock(&wl->mutex);
2324 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2325 wl1271_sysfs_show_hw_pg_ver, NULL);
2327 int wl1271_register_hw(struct wl1271 *wl)
2331 if (wl->mac80211_registered)
2334 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2336 ret = ieee80211_register_hw(wl->hw);
2338 wl1271_error("unable to register mac80211 hw: %d", ret);
2342 wl->mac80211_registered = true;
2344 register_netdevice_notifier(&wl1271_dev_notifier);
2346 wl1271_notice("loaded");
2350 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2352 void wl1271_unregister_hw(struct wl1271 *wl)
2354 unregister_netdevice_notifier(&wl1271_dev_notifier);
2355 ieee80211_unregister_hw(wl->hw);
2356 wl->mac80211_registered = false;
2359 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2361 int wl1271_init_ieee80211(struct wl1271 *wl)
2363 /* The tx descriptor buffer and the TKIP space. */
2364 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2365 sizeof(struct wl1271_tx_hw_descr);
2368 /* FIXME: find a proper value */
2369 wl->hw->channel_change_time = 10000;
2370 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2372 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2373 IEEE80211_HW_BEACON_FILTER |
2374 IEEE80211_HW_SUPPORTS_PS |
2375 IEEE80211_HW_SUPPORTS_UAPSD |
2376 IEEE80211_HW_HAS_RATE_CONTROL |
2377 IEEE80211_HW_CONNECTION_MONITOR |
2378 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2380 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2381 BIT(NL80211_IFTYPE_ADHOC);
2382 wl->hw->wiphy->max_scan_ssids = 1;
2383 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2384 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2387 wl->hw->max_rates = 1;
2389 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2393 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2395 #define WL1271_DEFAULT_CHANNEL 0
2397 struct ieee80211_hw *wl1271_alloc_hw(void)
2399 struct ieee80211_hw *hw;
2400 struct platform_device *plat_dev = NULL;
2404 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2406 wl1271_error("could not alloc ieee80211_hw");
2411 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2413 wl1271_error("could not allocate platform_device");
2415 goto err_plat_alloc;
2419 memset(wl, 0, sizeof(*wl));
2421 INIT_LIST_HEAD(&wl->list);
2424 wl->plat_dev = plat_dev;
2426 skb_queue_head_init(&wl->tx_queue);
2428 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2429 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2430 wl->channel = WL1271_DEFAULT_CHANNEL;
2431 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2432 wl->default_key = 0;
2434 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2435 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2436 wl->psm_entry_retry = 0;
2437 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2438 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2439 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2440 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2441 wl->sta_rate_set = 0;
2442 wl->band = IEEE80211_BAND_2GHZ;
2445 wl->sg_enabled = true;
2448 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2449 wl->tx_frames[i] = NULL;
2451 spin_lock_init(&wl->wl_lock);
2453 wl->state = WL1271_STATE_OFF;
2454 mutex_init(&wl->mutex);
2456 /* Apply default driver configuration. */
2457 wl1271_conf_init(wl);
2459 wl1271_debugfs_init(wl);
2461 /* Register platform device */
2462 ret = platform_device_register(wl->plat_dev);
2464 wl1271_error("couldn't register platform device");
2467 dev_set_drvdata(&wl->plat_dev->dev, wl);
2469 /* Create sysfs file to control bt coex state */
2470 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2472 wl1271_error("failed to create sysfs file bt_coex_state");
2476 /* Create sysfs file to get HW PG version */
2477 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2479 wl1271_error("failed to create sysfs file hw_pg_ver");
2480 goto err_bt_coex_state;
2486 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2489 platform_device_unregister(wl->plat_dev);
2492 wl1271_debugfs_exit(wl);
2496 ieee80211_free_hw(hw);
2500 return ERR_PTR(ret);
2502 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2504 int wl1271_free_hw(struct wl1271 *wl)
2506 platform_device_unregister(wl->plat_dev);
2507 kfree(wl->plat_dev);
2509 wl1271_debugfs_exit(wl);
2516 kfree(wl->fw_status);
2517 kfree(wl->tx_res_if);
2519 ieee80211_free_hw(wl->hw);
2523 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2525 MODULE_LICENSE("GPL");
2526 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2527 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");