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/inetdevice.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
36 #include "wl12xx_80211.h"
37 #include "wl1271_reg.h"
38 #include "wl1271_io.h"
39 #include "wl1271_event.h"
40 #include "wl1271_tx.h"
41 #include "wl1271_rx.h"
42 #include "wl1271_ps.h"
43 #include "wl1271_init.h"
44 #include "wl1271_debugfs.h"
45 #include "wl1271_cmd.h"
46 #include "wl1271_boot.h"
47 #include "wl1271_testmode.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] = 0,
59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
103 .state = CONF_SG_PROTECTIVE,
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
110 .rts_threshold = 2347,
111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
118 .tx_energy_detection = 0,
121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
145 .aifsn = CONF_TX_AIFS_PIFS,
152 .aifsn = CONF_TX_AIFS_PIFS,
160 .channel_type = CONF_CHANNEL_TYPE_DCF,
161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
168 .channel_type = CONF_CHANNEL_TYPE_DCF,
169 .tsid = CONF_TX_AC_BE,
170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
176 .channel_type = CONF_CHANNEL_TYPE_DCF,
177 .tsid = CONF_TX_AC_BE,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
184 .channel_type = CONF_CHANNEL_TYPE_DCF,
185 .tsid = CONF_TX_AC_BE,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
192 .channel_type = CONF_CHANNEL_TYPE_DCF,
193 .tsid = CONF_TX_AC_BE,
194 .ps_scheme = CONF_PS_SCHEME_LEGACY,
195 .ack_policy = CONF_ACK_POLICY_LEGACY,
200 .channel_type = CONF_CHANNEL_TYPE_DCF,
201 .tsid = CONF_TX_AC_BE,
202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
208 .channel_type = CONF_CHANNEL_TYPE_DCF,
209 .tsid = CONF_TX_AC_BE,
210 .ps_scheme = CONF_PS_SCHEME_LEGACY,
211 .ack_policy = CONF_ACK_POLICY_LEGACY,
215 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
216 .tx_compl_timeout = 700,
217 .tx_compl_threshold = 4,
218 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
219 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
222 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
223 .listen_interval = 1,
224 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
225 .bcn_filt_ie_count = 1,
228 .ie = WLAN_EID_CHANNEL_SWITCH,
229 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
232 .synch_fail_thold = 10,
233 .bss_lose_timeout = 100,
234 .beacon_rx_timeout = 10000,
235 .broadcast_timeout = 20000,
236 .rx_broadcast_in_ps = 1,
237 .ps_poll_threshold = 20,
238 .bet_enable = CONF_BET_MODE_ENABLE,
239 .bet_max_consecutive = 10,
240 .psm_entry_retries = 3,
241 .keep_alive_interval = 55000,
242 .max_listen_interval = 20,
254 .host_clk_settling_time = 5000,
255 .host_fast_wakeup_support = false
258 /* FIXME: due to firmware bug, must use value 1 for now */
260 .avg_weight_rssi_beacon = 20,
261 .avg_weight_rssi_data = 10,
262 .avg_weight_snr_beacon = 20,
263 .avg_weight_snr_data = 10
267 static void wl1271_device_release(struct device *dev)
272 static struct platform_device wl1271_device = {
276 /* device model insists to have a release function */
278 .release = wl1271_device_release,
282 static LIST_HEAD(wl_list);
284 static void wl1271_conf_init(struct wl1271 *wl)
288 * This function applies the default configuration to the driver. This
289 * function is invoked upon driver load (spi probe.)
291 * The configuration is stored in a run-time structure in order to
292 * facilitate for run-time adjustment of any of the parameters. Making
293 * changes to the configuration structure will apply the new values on
294 * the next interface up (wl1271_op_start.)
297 /* apply driver default configuration */
298 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
302 static int wl1271_plt_init(struct wl1271 *wl)
304 struct conf_tx_ac_category *conf_ac;
305 struct conf_tx_tid *conf_tid;
308 ret = wl1271_cmd_general_parms(wl);
312 ret = wl1271_cmd_radio_parms(wl);
316 ret = wl1271_init_templates_config(wl);
320 ret = wl1271_acx_init_mem_config(wl);
324 /* PHY layer config */
325 ret = wl1271_init_phy_config(wl);
327 goto out_free_memmap;
329 ret = wl1271_acx_dco_itrim_params(wl);
331 goto out_free_memmap;
333 /* Initialize connection monitoring thresholds */
334 ret = wl1271_acx_conn_monit_params(wl, false);
336 goto out_free_memmap;
338 /* Bluetooth WLAN coexistence */
339 ret = wl1271_init_pta(wl);
341 goto out_free_memmap;
343 /* Energy detection */
344 ret = wl1271_init_energy_detection(wl);
346 goto out_free_memmap;
348 /* Default fragmentation threshold */
349 ret = wl1271_acx_frag_threshold(wl);
351 goto out_free_memmap;
353 /* Default TID configuration */
354 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
355 conf_tid = &wl->conf.tx.tid_conf[i];
356 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
357 conf_tid->channel_type,
360 conf_tid->ack_policy,
361 conf_tid->apsd_conf[0],
362 conf_tid->apsd_conf[1]);
364 goto out_free_memmap;
367 /* Default AC configuration */
368 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
369 conf_ac = &wl->conf.tx.ac_conf[i];
370 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
371 conf_ac->cw_max, conf_ac->aifsn,
372 conf_ac->tx_op_limit);
374 goto out_free_memmap;
377 /* Enable data path */
378 ret = wl1271_cmd_data_path(wl, 1);
380 goto out_free_memmap;
382 /* Configure for CAM power saving (ie. always active) */
383 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
385 goto out_free_memmap;
388 ret = wl1271_acx_pm_config(wl);
390 goto out_free_memmap;
395 kfree(wl->target_mem_map);
396 wl->target_mem_map = NULL;
401 static void wl1271_fw_status(struct wl1271 *wl,
402 struct wl1271_fw_status *status)
408 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
410 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
411 "drv_rx_counter = %d, tx_results_counter = %d)",
413 status->fw_rx_counter,
414 status->drv_rx_counter,
415 status->tx_results_counter);
417 /* update number of available TX blocks */
418 for (i = 0; i < NUM_TX_QUEUES; i++) {
419 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
420 wl->tx_blocks_freed[i];
422 wl->tx_blocks_freed[i] =
423 le32_to_cpu(status->tx_released_blks[i]);
424 wl->tx_blocks_available += cnt;
428 /* if more blocks are available now, schedule some tx work */
429 if (total && !skb_queue_empty(&wl->tx_queue))
430 ieee80211_queue_work(wl->hw, &wl->tx_work);
432 /* update the host-chipset time offset */
434 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
435 (s64)le32_to_cpu(status->fw_localtime);
438 #define WL1271_IRQ_MAX_LOOPS 10
440 static void wl1271_irq_work(struct work_struct *work)
444 int loopcount = WL1271_IRQ_MAX_LOOPS;
447 container_of(work, struct wl1271, irq_work);
449 mutex_lock(&wl->mutex);
451 wl1271_debug(DEBUG_IRQ, "IRQ work");
453 if (unlikely(wl->state == WL1271_STATE_OFF))
456 ret = wl1271_ps_elp_wakeup(wl, true);
460 spin_lock_irqsave(&wl->wl_lock, flags);
461 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
462 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
463 spin_unlock_irqrestore(&wl->wl_lock, flags);
466 wl1271_fw_status(wl, wl->fw_status);
467 intr = le32_to_cpu(wl->fw_status->intr);
469 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
473 intr &= WL1271_INTR_MASK;
475 if (intr & WL1271_ACX_INTR_DATA) {
476 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
478 /* check for tx results */
479 if (wl->fw_status->tx_results_counter !=
480 (wl->tx_results_count & 0xff))
481 wl1271_tx_complete(wl);
483 wl1271_rx(wl, wl->fw_status);
486 if (intr & WL1271_ACX_INTR_EVENT_A) {
487 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
488 wl1271_event_handle(wl, 0);
491 if (intr & WL1271_ACX_INTR_EVENT_B) {
492 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
493 wl1271_event_handle(wl, 1);
496 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
497 wl1271_debug(DEBUG_IRQ,
498 "WL1271_ACX_INTR_INIT_COMPLETE");
500 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
501 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
503 spin_lock_irqsave(&wl->wl_lock, flags);
506 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
507 ieee80211_queue_work(wl->hw, &wl->irq_work);
509 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
510 spin_unlock_irqrestore(&wl->wl_lock, flags);
512 wl1271_ps_elp_sleep(wl);
515 mutex_unlock(&wl->mutex);
518 static int wl1271_fetch_firmware(struct wl1271 *wl)
520 const struct firmware *fw;
523 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
526 wl1271_error("could not get firmware: %d", ret);
531 wl1271_error("firmware size is not multiple of 32 bits: %zu",
537 wl->fw_len = fw->size;
538 wl->fw = vmalloc(wl->fw_len);
541 wl1271_error("could not allocate memory for the firmware");
546 memcpy(wl->fw, fw->data, wl->fw_len);
551 release_firmware(fw);
556 static int wl1271_fetch_nvs(struct wl1271 *wl)
558 const struct firmware *fw;
561 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
564 wl1271_error("could not get nvs file: %d", ret);
568 if (fw->size != sizeof(struct wl1271_nvs_file)) {
569 wl1271_error("nvs size is not as expected: %zu != %zu",
570 fw->size, sizeof(struct wl1271_nvs_file));
575 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
578 wl1271_error("could not allocate memory for the nvs file");
583 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
586 release_firmware(fw);
591 static void wl1271_fw_wakeup(struct wl1271 *wl)
595 elp_reg = ELPCTRL_WAKE_UP;
596 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
599 static int wl1271_setup(struct wl1271 *wl)
601 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
605 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
606 if (!wl->tx_res_if) {
607 kfree(wl->fw_status);
611 INIT_WORK(&wl->irq_work, wl1271_irq_work);
612 INIT_WORK(&wl->tx_work, wl1271_tx_work);
616 static int wl1271_chip_wakeup(struct wl1271 *wl)
618 struct wl1271_partition_set partition;
621 msleep(WL1271_PRE_POWER_ON_SLEEP);
623 msleep(WL1271_POWER_ON_SLEEP);
627 /* We don't need a real memory partition here, because we only want
628 * to use the registers at this point. */
629 memset(&partition, 0, sizeof(partition));
630 partition.reg.start = REGISTERS_BASE;
631 partition.reg.size = REGISTERS_DOWN_SIZE;
632 wl1271_set_partition(wl, &partition);
634 /* ELP module wake up */
635 wl1271_fw_wakeup(wl);
637 /* whal_FwCtrl_BootSm() */
639 /* 0. read chip id from CHIP_ID */
640 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
642 /* 1. check if chip id is valid */
644 switch (wl->chip.id) {
645 case CHIP_ID_1271_PG10:
646 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
649 ret = wl1271_setup(wl);
653 case CHIP_ID_1271_PG20:
654 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
657 ret = wl1271_setup(wl);
662 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
667 if (wl->fw == NULL) {
668 ret = wl1271_fetch_firmware(wl);
673 /* No NVS from netlink, try to get it from the filesystem */
674 if (wl->nvs == NULL) {
675 ret = wl1271_fetch_nvs(wl);
684 int wl1271_plt_start(struct wl1271 *wl)
686 int retries = WL1271_BOOT_RETRIES;
689 mutex_lock(&wl->mutex);
691 wl1271_notice("power up");
693 if (wl->state != WL1271_STATE_OFF) {
694 wl1271_error("cannot go into PLT state because not "
695 "in off state: %d", wl->state);
702 ret = wl1271_chip_wakeup(wl);
706 ret = wl1271_boot(wl);
710 ret = wl1271_plt_init(wl);
714 wl->state = WL1271_STATE_PLT;
715 wl1271_notice("firmware booted in PLT mode (%s)",
720 wl1271_disable_interrupts(wl);
721 mutex_unlock(&wl->mutex);
722 /* Unlocking the mutex in the middle of handling is
723 inherently unsafe. In this case we deem it safe to do,
724 because we need to let any possibly pending IRQ out of
725 the system (and while we are WL1271_STATE_OFF the IRQ
726 work function will not do anything.) Also, any other
727 possible concurrent operations will fail due to the
728 current state, hence the wl1271 struct should be safe. */
729 cancel_work_sync(&wl->irq_work);
730 mutex_lock(&wl->mutex);
732 wl1271_power_off(wl);
735 wl1271_error("firmware boot in PLT mode failed despite %d retries",
736 WL1271_BOOT_RETRIES);
738 mutex_unlock(&wl->mutex);
743 int wl1271_plt_stop(struct wl1271 *wl)
747 mutex_lock(&wl->mutex);
749 wl1271_notice("power down");
751 if (wl->state != WL1271_STATE_PLT) {
752 wl1271_error("cannot power down because not in PLT "
753 "state: %d", wl->state);
758 wl1271_disable_interrupts(wl);
759 wl1271_power_off(wl);
761 wl->state = WL1271_STATE_OFF;
765 mutex_unlock(&wl->mutex);
771 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
773 struct wl1271 *wl = hw->priv;
774 struct ieee80211_conf *conf = &hw->conf;
775 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
776 struct ieee80211_sta *sta = txinfo->control.sta;
779 /* peek into the rates configured in the STA entry */
780 spin_lock_irqsave(&wl->wl_lock, flags);
781 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
782 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
783 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
785 spin_unlock_irqrestore(&wl->wl_lock, flags);
787 /* queue the packet */
788 skb_queue_tail(&wl->tx_queue, skb);
791 * The chip specific setup must run before the first TX packet -
792 * before that, the tx_work will not be initialized!
795 ieee80211_queue_work(wl->hw, &wl->tx_work);
798 * The workqueue is slow to process the tx_queue and we need stop
799 * the queue here, otherwise the queue will get too long.
801 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
802 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
804 spin_lock_irqsave(&wl->wl_lock, flags);
805 ieee80211_stop_queues(wl->hw);
806 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
807 spin_unlock_irqrestore(&wl->wl_lock, flags);
813 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
816 struct net_device *dev;
817 struct wireless_dev *wdev;
819 struct ieee80211_hw *hw;
821 struct wl1271 *wl_temp;
822 struct in_device *idev;
823 struct in_ifaddr *ifa = arg;
826 /* FIXME: this ugly function should probably be implemented in the
827 * mac80211, and here should only be a simple callback handling actual
828 * setting of the filters. Now we need to dig up references to
829 * various structures to gain access to what we need.
830 * Also, because of this, there is no "initial" setting of the filter
831 * in "op_start", because we don't want to dig up struct net_device
832 * there - the filter will be set upon first change of the interface
835 dev = ifa->ifa_dev->dev;
837 wdev = dev->ieee80211_ptr;
845 hw = wiphy_priv(wiphy);
849 /* Check that the interface is one supported by this driver. */
851 list_for_each_entry(wl, &wl_list, list) {
858 /* Get the interface IP address for the device. "ifa" will become
860 - there is no IPV4 protocol address configured
861 - there are multiple (virtual) IPV4 addresses configured
862 When "ifa" is NULL, filtering will be disabled.
867 ifa = idev->ifa_list;
869 if (ifa && ifa->ifa_next)
872 mutex_lock(&wl->mutex);
874 if (wl->state == WL1271_STATE_OFF)
877 ret = wl1271_ps_elp_wakeup(wl, false);
881 ret = wl1271_acx_arp_ip_filter(wl, true,
882 (u8 *)&ifa->ifa_address,
885 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
887 wl1271_ps_elp_sleep(wl);
890 mutex_unlock(&wl->mutex);
895 static struct notifier_block wl1271_dev_notifier = {
896 .notifier_call = wl1271_dev_notify,
900 static int wl1271_op_start(struct ieee80211_hw *hw)
902 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
905 * We have to delay the booting of the hardware because
906 * we need to know the local MAC address before downloading and
907 * initializing the firmware. The MAC address cannot be changed
908 * after boot, and without the proper MAC address, the firmware
909 * will not function properly.
911 * The MAC address is first known when the corresponding interface
912 * is added. That is where we will initialize the hardware.
918 static void wl1271_op_stop(struct ieee80211_hw *hw)
920 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
923 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
924 struct ieee80211_vif *vif)
926 struct wl1271 *wl = hw->priv;
927 int retries = WL1271_BOOT_RETRIES;
930 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
931 vif->type, vif->addr);
933 mutex_lock(&wl->mutex);
942 case NL80211_IFTYPE_STATION:
943 wl->bss_type = BSS_TYPE_STA_BSS;
944 wl->set_bss_type = BSS_TYPE_STA_BSS;
946 case NL80211_IFTYPE_ADHOC:
947 wl->bss_type = BSS_TYPE_IBSS;
948 wl->set_bss_type = BSS_TYPE_STA_BSS;
955 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
957 if (wl->state != WL1271_STATE_OFF) {
958 wl1271_error("cannot start because not in off state: %d",
966 ret = wl1271_chip_wakeup(wl);
970 ret = wl1271_boot(wl);
974 ret = wl1271_hw_init(wl);
978 wl->state = WL1271_STATE_ON;
979 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
983 wl1271_disable_interrupts(wl);
984 mutex_unlock(&wl->mutex);
985 /* Unlocking the mutex in the middle of handling is
986 inherently unsafe. In this case we deem it safe to do,
987 because we need to let any possibly pending IRQ out of
988 the system (and while we are WL1271_STATE_OFF the IRQ
989 work function will not do anything.) Also, any other
990 possible concurrent operations will fail due to the
991 current state, hence the wl1271 struct should be safe. */
992 cancel_work_sync(&wl->irq_work);
993 mutex_lock(&wl->mutex);
995 wl1271_power_off(wl);
998 wl1271_error("firmware boot failed despite %d retries",
999 WL1271_BOOT_RETRIES);
1001 mutex_unlock(&wl->mutex);
1004 list_add(&wl->list, &wl_list);
1005 register_inetaddr_notifier(&wl1271_dev_notifier);
1011 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1012 struct ieee80211_vif *vif)
1014 struct wl1271 *wl = hw->priv;
1017 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1019 mutex_lock(&wl->mutex);
1020 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1022 wl1271_info("down");
1024 list_del(&wl->list);
1026 WARN_ON(wl->state != WL1271_STATE_ON);
1028 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1029 mutex_unlock(&wl->mutex);
1030 ieee80211_scan_completed(wl->hw, true);
1031 mutex_lock(&wl->mutex);
1034 wl->state = WL1271_STATE_OFF;
1036 wl1271_disable_interrupts(wl);
1038 mutex_unlock(&wl->mutex);
1040 cancel_work_sync(&wl->irq_work);
1041 cancel_work_sync(&wl->tx_work);
1043 mutex_lock(&wl->mutex);
1045 /* let's notify MAC80211 about the remaining pending TX frames */
1046 wl1271_tx_flush(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;
1084 mutex_unlock(&wl->mutex);
1087 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1089 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1090 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1092 /* combine requested filters with current filter config */
1093 filters = wl->filters | filters;
1095 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1097 if (filters & FIF_PROMISC_IN_BSS) {
1098 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1099 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1100 wl->rx_config |= CFG_BSSID_FILTER_EN;
1102 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1103 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1104 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1105 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1107 if (filters & FIF_OTHER_BSS) {
1108 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1109 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1111 if (filters & FIF_CONTROL) {
1112 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1113 wl->rx_filter |= CFG_RX_CTL_EN;
1115 if (filters & FIF_FCSFAIL) {
1116 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1117 wl->rx_filter |= CFG_RX_FCS_ERROR;
1121 static int wl1271_dummy_join(struct wl1271 *wl)
1124 /* we need to use a dummy BSSID for now */
1125 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1128 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1130 /* pass through frames from all BSS */
1131 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1133 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1137 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1143 static int wl1271_join(struct wl1271 *wl)
1147 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1151 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1153 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1157 * The join command disable the keep-alive mode, shut down its process,
1158 * and also clear the template config, so we need to reset it all after
1159 * the join. The acx_aid starts the keep-alive process, and the order
1160 * of the commands below is relevant.
1162 ret = wl1271_acx_keep_alive_mode(wl, true);
1166 ret = wl1271_acx_aid(wl, wl->aid);
1170 ret = wl1271_cmd_build_klv_null_data(wl);
1174 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1175 ACX_KEEP_ALIVE_TPL_VALID);
1183 static int wl1271_unjoin(struct wl1271 *wl)
1187 /* to stop listening to a channel, we disconnect */
1188 ret = wl1271_cmd_disconnect(wl);
1192 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1194 memset(wl->bssid, 0, ETH_ALEN);
1196 /* stop filterting packets based on bssid */
1197 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1203 static void wl1271_set_band_rate(struct wl1271 *wl)
1205 if (wl->band == IEEE80211_BAND_2GHZ)
1206 wl->basic_rate_set = wl->conf.tx.basic_rate;
1208 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1211 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1216 if (!wl->basic_rate_set) {
1218 wl->basic_rate_set = wl->conf.tx.basic_rate;
1221 for (i = 0; !rate; i++) {
1222 if ((wl->basic_rate_set >> i) & 0x1)
1229 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1231 struct wl1271 *wl = hw->priv;
1232 struct ieee80211_conf *conf = &hw->conf;
1233 int channel, ret = 0;
1235 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1237 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1239 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1241 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1243 mutex_lock(&wl->mutex);
1245 if (unlikely(wl->state == WL1271_STATE_OFF))
1248 ret = wl1271_ps_elp_wakeup(wl, false);
1252 /* if the channel changes while joined, join again */
1253 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1254 wl->band = conf->channel->band;
1255 wl->channel = channel;
1258 * FIXME: the mac80211 should really provide a fixed rate
1259 * to use here. for now, just use the smallest possible rate
1260 * for the band as a fixed rate for association frames and
1261 * other control messages.
1263 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1264 wl1271_set_band_rate(wl);
1266 wl->basic_rate = wl1271_min_rate_get(wl);
1267 ret = wl1271_acx_rate_policies(wl);
1269 wl1271_warning("rate policy for update channel "
1272 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1273 ret = wl1271_join(wl);
1275 wl1271_warning("cmd join to update channel "
1280 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1281 if (conf->flags & IEEE80211_CONF_IDLE &&
1282 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1284 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1285 wl1271_dummy_join(wl);
1287 if (conf->flags & IEEE80211_CONF_IDLE) {
1288 wl->rate_set = wl1271_min_rate_get(wl);
1289 wl->sta_rate_set = 0;
1290 wl1271_acx_rate_policies(wl);
1291 wl1271_acx_keep_alive_config(
1292 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1293 ACX_KEEP_ALIVE_TPL_INVALID);
1294 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1296 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1299 if (conf->flags & IEEE80211_CONF_PS &&
1300 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1301 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1304 * We enter PSM only if we're already associated.
1305 * If we're not, we'll enter it when joining an SSID,
1306 * through the bss_info_changed() hook.
1308 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1309 wl1271_debug(DEBUG_PSM, "psm enabled");
1310 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1313 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1314 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1315 wl1271_debug(DEBUG_PSM, "psm disabled");
1317 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1319 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1320 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1324 if (conf->power_level != wl->power_level) {
1325 ret = wl1271_acx_tx_power(wl, conf->power_level);
1329 wl->power_level = conf->power_level;
1333 wl1271_ps_elp_sleep(wl);
1336 mutex_unlock(&wl->mutex);
1341 struct wl1271_filter_params {
1344 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1347 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1348 struct netdev_hw_addr_list *mc_list)
1350 struct wl1271_filter_params *fp;
1351 struct netdev_hw_addr *ha;
1352 struct wl1271 *wl = hw->priv;
1354 if (unlikely(wl->state == WL1271_STATE_OFF))
1357 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1359 wl1271_error("Out of memory setting filters.");
1363 /* update multicast filtering parameters */
1364 fp->mc_list_length = 0;
1365 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1366 fp->enabled = false;
1369 netdev_hw_addr_list_for_each(ha, mc_list) {
1370 memcpy(fp->mc_list[fp->mc_list_length],
1371 ha->addr, ETH_ALEN);
1372 fp->mc_list_length++;
1376 return (u64)(unsigned long)fp;
1379 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1382 FIF_BCN_PRBRESP_PROMISC | \
1386 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1387 unsigned int changed,
1388 unsigned int *total, u64 multicast)
1390 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1391 struct wl1271 *wl = hw->priv;
1394 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1396 mutex_lock(&wl->mutex);
1398 *total &= WL1271_SUPPORTED_FILTERS;
1399 changed &= WL1271_SUPPORTED_FILTERS;
1401 if (unlikely(wl->state == WL1271_STATE_OFF))
1404 ret = wl1271_ps_elp_wakeup(wl, false);
1409 if (*total & FIF_ALLMULTI)
1410 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1412 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1414 fp->mc_list_length);
1418 /* determine, whether supported filter values have changed */
1422 /* configure filters */
1423 wl->filters = *total;
1424 wl1271_configure_filters(wl, 0);
1426 /* apply configured filters */
1427 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1432 wl1271_ps_elp_sleep(wl);
1435 mutex_unlock(&wl->mutex);
1439 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1440 struct ieee80211_vif *vif,
1441 struct ieee80211_sta *sta,
1442 struct ieee80211_key_conf *key_conf)
1444 struct wl1271 *wl = hw->priv;
1451 static const u8 bcast_addr[ETH_ALEN] =
1452 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1454 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1456 addr = sta ? sta->addr : bcast_addr;
1458 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1459 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1460 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1461 key_conf->alg, key_conf->keyidx,
1462 key_conf->keylen, key_conf->flags);
1463 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1465 if (is_zero_ether_addr(addr)) {
1466 /* We dont support TX only encryption */
1471 mutex_lock(&wl->mutex);
1473 ret = wl1271_ps_elp_wakeup(wl, false);
1477 switch (key_conf->alg) {
1481 key_conf->hw_key_idx = key_conf->keyidx;
1484 key_type = KEY_TKIP;
1486 key_conf->hw_key_idx = key_conf->keyidx;
1487 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1488 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1493 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1494 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1495 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1498 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1506 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1507 key_conf->keyidx, key_type,
1508 key_conf->keylen, key_conf->key,
1509 addr, tx_seq_32, tx_seq_16);
1511 wl1271_error("Could not add or replace key");
1515 /* the default WEP key needs to be configured at least once */
1516 if (key_type == KEY_WEP) {
1517 ret = wl1271_cmd_set_default_wep_key(wl,
1525 /* The wl1271 does not allow to remove unicast keys - they
1526 will be cleared automatically on next CMD_JOIN. Ignore the
1527 request silently, as we dont want the mac80211 to emit
1528 an error message. */
1529 if (!is_broadcast_ether_addr(addr))
1532 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1533 key_conf->keyidx, key_type,
1534 key_conf->keylen, key_conf->key,
1537 wl1271_error("Could not remove key");
1543 wl1271_error("Unsupported key cmd 0x%x", cmd);
1551 wl1271_ps_elp_sleep(wl);
1554 mutex_unlock(&wl->mutex);
1560 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1561 struct ieee80211_vif *vif,
1562 struct cfg80211_scan_request *req)
1564 struct wl1271 *wl = hw->priv;
1569 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1572 ssid = req->ssids[0].ssid;
1573 len = req->ssids[0].ssid_len;
1576 mutex_lock(&wl->mutex);
1578 ret = wl1271_ps_elp_wakeup(wl, false);
1582 if (wl1271_11a_enabled())
1583 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1584 req->ie, req->ie_len, 1, 0,
1585 WL1271_SCAN_BAND_DUAL, 3);
1587 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1588 req->ie, req->ie_len, 1, 0,
1589 WL1271_SCAN_BAND_2_4_GHZ, 3);
1591 wl1271_ps_elp_sleep(wl);
1594 mutex_unlock(&wl->mutex);
1599 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1601 struct wl1271 *wl = hw->priv;
1604 mutex_lock(&wl->mutex);
1606 if (unlikely(wl->state == WL1271_STATE_OFF))
1609 ret = wl1271_ps_elp_wakeup(wl, false);
1613 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1615 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1617 wl1271_ps_elp_sleep(wl);
1620 mutex_unlock(&wl->mutex);
1625 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1627 u8 *ptr = beacon->data +
1628 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1630 /* find the location of the ssid in the beacon */
1631 while (ptr < beacon->data + beacon->len) {
1632 if (ptr[0] == WLAN_EID_SSID) {
1633 wl->ssid_len = ptr[1];
1634 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1639 wl1271_error("ad-hoc beacon template has no SSID!\n");
1642 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1643 struct ieee80211_vif *vif,
1644 struct ieee80211_bss_conf *bss_conf,
1647 enum wl1271_cmd_ps_mode mode;
1648 struct wl1271 *wl = hw->priv;
1649 bool do_join = false;
1652 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1654 mutex_lock(&wl->mutex);
1656 ret = wl1271_ps_elp_wakeup(wl, false);
1660 if ((changed && BSS_CHANGED_BEACON_INT) &&
1661 (wl->bss_type == BSS_TYPE_IBSS)) {
1662 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1663 bss_conf->beacon_int);
1665 wl->beacon_int = bss_conf->beacon_int;
1669 if ((changed && BSS_CHANGED_BEACON) &&
1670 (wl->bss_type == BSS_TYPE_IBSS)) {
1671 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1673 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1676 struct ieee80211_hdr *hdr;
1678 wl1271_ssid_set(wl, beacon);
1679 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1682 wl1271_min_rate_get(wl));
1685 dev_kfree_skb(beacon);
1689 hdr = (struct ieee80211_hdr *) beacon->data;
1690 hdr->frame_control = cpu_to_le16(
1691 IEEE80211_FTYPE_MGMT |
1692 IEEE80211_STYPE_PROBE_RESP);
1694 ret = wl1271_cmd_template_set(wl,
1695 CMD_TEMPL_PROBE_RESPONSE,
1698 wl1271_min_rate_get(wl));
1699 dev_kfree_skb(beacon);
1703 /* Need to update the SSID (for filtering etc) */
1708 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1709 (wl->bss_type == BSS_TYPE_IBSS)) {
1710 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1711 bss_conf->enable_beacon ? "enabled" : "disabled");
1713 if (bss_conf->enable_beacon)
1714 wl->set_bss_type = BSS_TYPE_IBSS;
1716 wl->set_bss_type = BSS_TYPE_STA_BSS;
1720 if (changed & BSS_CHANGED_CQM) {
1721 bool enable = false;
1722 if (bss_conf->cqm_rssi_thold)
1724 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1725 bss_conf->cqm_rssi_thold,
1726 bss_conf->cqm_rssi_hyst);
1729 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1732 if ((changed & BSS_CHANGED_BSSID) &&
1734 * Now we know the correct bssid, so we send a new join command
1735 * and enable the BSSID filter
1737 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1738 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1740 ret = wl1271_cmd_build_null_data(wl);
1744 ret = wl1271_build_qos_null_data(wl);
1748 /* filter out all packets not from this BSSID */
1749 wl1271_configure_filters(wl, 0);
1751 /* Need to update the BSSID (for filtering etc) */
1755 if (changed & BSS_CHANGED_ASSOC) {
1756 if (bss_conf->assoc) {
1758 wl->aid = bss_conf->aid;
1759 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1762 * use basic rates from AP, and determine lowest rate
1763 * to use with control frames.
1765 rates = bss_conf->basic_rates;
1766 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1768 wl->basic_rate = wl1271_min_rate_get(wl);
1769 ret = wl1271_acx_rate_policies(wl);
1774 * with wl1271, we don't need to update the
1775 * beacon_int and dtim_period, because the firmware
1776 * updates it by itself when the first beacon is
1777 * received after a join.
1779 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1784 * The SSID is intentionally set to NULL here - the
1785 * firmware will set the probe request with a
1786 * broadcast SSID regardless of what we set in the
1789 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1792 /* enable the connection monitoring feature */
1793 ret = wl1271_acx_conn_monit_params(wl, true);
1797 /* If we want to go in PSM but we're not there yet */
1798 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1799 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1800 mode = STATION_POWER_SAVE_MODE;
1801 ret = wl1271_ps_set_mode(wl, mode, true);
1806 /* use defaults when not associated */
1807 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1810 /* revert back to minimum rates for the current band */
1811 wl1271_set_band_rate(wl);
1812 wl->basic_rate = wl1271_min_rate_get(wl);
1813 ret = wl1271_acx_rate_policies(wl);
1817 /* disable connection monitor features */
1818 ret = wl1271_acx_conn_monit_params(wl, false);
1820 /* Disable the keep-alive feature */
1821 ret = wl1271_acx_keep_alive_mode(wl, false);
1829 if (changed & BSS_CHANGED_ERP_SLOT) {
1830 if (bss_conf->use_short_slot)
1831 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1833 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1835 wl1271_warning("Set slot time failed %d", ret);
1840 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1841 if (bss_conf->use_short_preamble)
1842 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1844 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1847 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1848 if (bss_conf->use_cts_prot)
1849 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1851 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1853 wl1271_warning("Set ctsprotect failed %d", ret);
1859 ret = wl1271_join(wl);
1861 wl1271_warning("cmd join failed %d", ret);
1867 wl1271_ps_elp_sleep(wl);
1870 mutex_unlock(&wl->mutex);
1873 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1874 const struct ieee80211_tx_queue_params *params)
1876 struct wl1271 *wl = hw->priv;
1880 mutex_lock(&wl->mutex);
1882 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1884 ret = wl1271_ps_elp_wakeup(wl, false);
1888 /* the txop is confed in units of 32us by the mac80211, we need us */
1889 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1890 params->cw_min, params->cw_max,
1891 params->aifs, params->txop << 5);
1896 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1898 ps_scheme = CONF_PS_SCHEME_LEGACY;
1900 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1901 CONF_CHANNEL_TYPE_EDCF,
1902 wl1271_tx_get_queue(queue),
1903 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1908 wl1271_ps_elp_sleep(wl);
1911 mutex_unlock(&wl->mutex);
1917 /* can't be const, mac80211 writes to this */
1918 static struct ieee80211_rate wl1271_rates[] = {
1920 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1921 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1923 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1924 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1925 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1927 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1928 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1929 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1931 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1932 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1933 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1935 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1936 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1938 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1939 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1941 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1942 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1944 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1945 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1947 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1948 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1950 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1951 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1953 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1954 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1956 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1957 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1960 /* can't be const, mac80211 writes to this */
1961 static struct ieee80211_channel wl1271_channels[] = {
1962 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1963 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1964 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1965 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1966 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1967 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1968 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1969 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1970 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1971 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1972 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1973 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1974 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1977 /* mapping to indexes for wl1271_rates */
1978 const static u8 wl1271_rate_to_idx_2ghz[] = {
1979 /* MCS rates are used only with 11n */
1980 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1981 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1982 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1983 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
1984 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
1985 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
1986 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
1987 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
1989 11, /* CONF_HW_RXTX_RATE_54 */
1990 10, /* CONF_HW_RXTX_RATE_48 */
1991 9, /* CONF_HW_RXTX_RATE_36 */
1992 8, /* CONF_HW_RXTX_RATE_24 */
1994 /* TI-specific rate */
1995 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
1997 7, /* CONF_HW_RXTX_RATE_18 */
1998 6, /* CONF_HW_RXTX_RATE_12 */
1999 3, /* CONF_HW_RXTX_RATE_11 */
2000 5, /* CONF_HW_RXTX_RATE_9 */
2001 4, /* CONF_HW_RXTX_RATE_6 */
2002 2, /* CONF_HW_RXTX_RATE_5_5 */
2003 1, /* CONF_HW_RXTX_RATE_2 */
2004 0 /* CONF_HW_RXTX_RATE_1 */
2007 /* can't be const, mac80211 writes to this */
2008 static struct ieee80211_supported_band wl1271_band_2ghz = {
2009 .channels = wl1271_channels,
2010 .n_channels = ARRAY_SIZE(wl1271_channels),
2011 .bitrates = wl1271_rates,
2012 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2015 /* 5 GHz data rates for WL1273 */
2016 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2018 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2019 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2021 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2022 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2024 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2025 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2027 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2028 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2030 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2031 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2033 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2034 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2036 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2037 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2039 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2040 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2043 /* 5 GHz band channels for WL1273 */
2044 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2045 { .hw_value = 183, .center_freq = 4915},
2046 { .hw_value = 184, .center_freq = 4920},
2047 { .hw_value = 185, .center_freq = 4925},
2048 { .hw_value = 187, .center_freq = 4935},
2049 { .hw_value = 188, .center_freq = 4940},
2050 { .hw_value = 189, .center_freq = 4945},
2051 { .hw_value = 192, .center_freq = 4960},
2052 { .hw_value = 196, .center_freq = 4980},
2053 { .hw_value = 7, .center_freq = 5035},
2054 { .hw_value = 8, .center_freq = 5040},
2055 { .hw_value = 9, .center_freq = 5045},
2056 { .hw_value = 11, .center_freq = 5055},
2057 { .hw_value = 12, .center_freq = 5060},
2058 { .hw_value = 16, .center_freq = 5080},
2059 { .hw_value = 34, .center_freq = 5170},
2060 { .hw_value = 36, .center_freq = 5180},
2061 { .hw_value = 38, .center_freq = 5190},
2062 { .hw_value = 40, .center_freq = 5200},
2063 { .hw_value = 42, .center_freq = 5210},
2064 { .hw_value = 44, .center_freq = 5220},
2065 { .hw_value = 46, .center_freq = 5230},
2066 { .hw_value = 48, .center_freq = 5240},
2067 { .hw_value = 52, .center_freq = 5260},
2068 { .hw_value = 56, .center_freq = 5280},
2069 { .hw_value = 60, .center_freq = 5300},
2070 { .hw_value = 64, .center_freq = 5320},
2071 { .hw_value = 100, .center_freq = 5500},
2072 { .hw_value = 104, .center_freq = 5520},
2073 { .hw_value = 108, .center_freq = 5540},
2074 { .hw_value = 112, .center_freq = 5560},
2075 { .hw_value = 116, .center_freq = 5580},
2076 { .hw_value = 120, .center_freq = 5600},
2077 { .hw_value = 124, .center_freq = 5620},
2078 { .hw_value = 128, .center_freq = 5640},
2079 { .hw_value = 132, .center_freq = 5660},
2080 { .hw_value = 136, .center_freq = 5680},
2081 { .hw_value = 140, .center_freq = 5700},
2082 { .hw_value = 149, .center_freq = 5745},
2083 { .hw_value = 153, .center_freq = 5765},
2084 { .hw_value = 157, .center_freq = 5785},
2085 { .hw_value = 161, .center_freq = 5805},
2086 { .hw_value = 165, .center_freq = 5825},
2089 /* mapping to indexes for wl1271_rates_5ghz */
2090 const static u8 wl1271_rate_to_idx_5ghz[] = {
2091 /* MCS rates are used only with 11n */
2092 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2093 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2094 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2095 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2096 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2097 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2098 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2099 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2101 7, /* CONF_HW_RXTX_RATE_54 */
2102 6, /* CONF_HW_RXTX_RATE_48 */
2103 5, /* CONF_HW_RXTX_RATE_36 */
2104 4, /* CONF_HW_RXTX_RATE_24 */
2106 /* TI-specific rate */
2107 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2109 3, /* CONF_HW_RXTX_RATE_18 */
2110 2, /* CONF_HW_RXTX_RATE_12 */
2111 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2112 1, /* CONF_HW_RXTX_RATE_9 */
2113 0, /* CONF_HW_RXTX_RATE_6 */
2114 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2115 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2116 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2119 static struct ieee80211_supported_band wl1271_band_5ghz = {
2120 .channels = wl1271_channels_5ghz,
2121 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2122 .bitrates = wl1271_rates_5ghz,
2123 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2126 const static u8 *wl1271_band_rate_to_idx[] = {
2127 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2128 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2131 static const struct ieee80211_ops wl1271_ops = {
2132 .start = wl1271_op_start,
2133 .stop = wl1271_op_stop,
2134 .add_interface = wl1271_op_add_interface,
2135 .remove_interface = wl1271_op_remove_interface,
2136 .config = wl1271_op_config,
2137 .prepare_multicast = wl1271_op_prepare_multicast,
2138 .configure_filter = wl1271_op_configure_filter,
2140 .set_key = wl1271_op_set_key,
2141 .hw_scan = wl1271_op_hw_scan,
2142 .bss_info_changed = wl1271_op_bss_info_changed,
2143 .set_rts_threshold = wl1271_op_set_rts_threshold,
2144 .conf_tx = wl1271_op_conf_tx,
2145 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2149 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2153 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2155 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2156 wl1271_error("Illegal RX rate from HW: %d", rate);
2160 idx = wl1271_band_rate_to_idx[wl->band][rate];
2161 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2162 wl1271_error("Unsupported RX rate from HW: %d", rate);
2169 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2170 struct device_attribute *attr,
2173 struct wl1271 *wl = dev_get_drvdata(dev);
2176 /* FIXME: what's the maximum length of buf? page size?*/
2179 mutex_lock(&wl->mutex);
2180 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2182 mutex_unlock(&wl->mutex);
2188 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2189 struct device_attribute *attr,
2190 const char *buf, size_t count)
2192 struct wl1271 *wl = dev_get_drvdata(dev);
2196 ret = strict_strtoul(buf, 10, &res);
2199 wl1271_warning("incorrect value written to bt_coex_mode");
2203 mutex_lock(&wl->mutex);
2207 if (res == wl->sg_enabled)
2210 wl->sg_enabled = res;
2212 if (wl->state == WL1271_STATE_OFF)
2215 ret = wl1271_ps_elp_wakeup(wl, false);
2219 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2220 wl1271_ps_elp_sleep(wl);
2223 mutex_unlock(&wl->mutex);
2227 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2228 wl1271_sysfs_show_bt_coex_state,
2229 wl1271_sysfs_store_bt_coex_state);
2231 int wl1271_register_hw(struct wl1271 *wl)
2235 if (wl->mac80211_registered)
2238 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2240 ret = ieee80211_register_hw(wl->hw);
2242 wl1271_error("unable to register mac80211 hw: %d", ret);
2246 wl->mac80211_registered = true;
2248 wl1271_notice("loaded");
2252 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2254 void wl1271_unregister_hw(struct wl1271 *wl)
2256 ieee80211_unregister_hw(wl->hw);
2257 wl->mac80211_registered = false;
2260 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2262 int wl1271_init_ieee80211(struct wl1271 *wl)
2264 /* The tx descriptor buffer and the TKIP space. */
2265 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2266 sizeof(struct wl1271_tx_hw_descr);
2269 /* FIXME: find a proper value */
2270 wl->hw->channel_change_time = 10000;
2271 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2273 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2274 IEEE80211_HW_BEACON_FILTER |
2275 IEEE80211_HW_SUPPORTS_PS |
2276 IEEE80211_HW_SUPPORTS_UAPSD |
2277 IEEE80211_HW_HAS_RATE_CONTROL |
2278 IEEE80211_HW_CONNECTION_MONITOR |
2279 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2281 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2282 BIT(NL80211_IFTYPE_ADHOC);
2283 wl->hw->wiphy->max_scan_ssids = 1;
2284 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2286 if (wl1271_11a_enabled())
2287 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2290 wl->hw->max_rates = 1;
2292 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2296 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2298 #define WL1271_DEFAULT_CHANNEL 0
2300 struct ieee80211_hw *wl1271_alloc_hw(void)
2302 struct ieee80211_hw *hw;
2303 struct platform_device *plat_dev = NULL;
2307 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2309 wl1271_error("could not alloc ieee80211_hw");
2314 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2316 wl1271_error("could not allocate platform_device");
2318 goto err_plat_alloc;
2321 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2324 memset(wl, 0, sizeof(*wl));
2326 INIT_LIST_HEAD(&wl->list);
2329 wl->plat_dev = plat_dev;
2331 skb_queue_head_init(&wl->tx_queue);
2333 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2334 wl->channel = WL1271_DEFAULT_CHANNEL;
2335 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2336 wl->default_key = 0;
2338 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2339 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2340 wl->psm_entry_retry = 0;
2341 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2342 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2343 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2344 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2345 wl->sta_rate_set = 0;
2346 wl->band = IEEE80211_BAND_2GHZ;
2349 wl->sg_enabled = true;
2351 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2352 wl->tx_frames[i] = NULL;
2354 spin_lock_init(&wl->wl_lock);
2356 wl->state = WL1271_STATE_OFF;
2357 mutex_init(&wl->mutex);
2359 /* Apply default driver configuration. */
2360 wl1271_conf_init(wl);
2362 wl1271_debugfs_init(wl);
2364 /* Register platform device */
2365 ret = platform_device_register(wl->plat_dev);
2367 wl1271_error("couldn't register platform device");
2370 dev_set_drvdata(&wl->plat_dev->dev, wl);
2372 /* Create sysfs file to control bt coex state */
2373 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2375 wl1271_error("failed to create sysfs file bt_coex_state");
2382 platform_device_unregister(wl->plat_dev);
2385 wl1271_debugfs_exit(wl);
2389 ieee80211_free_hw(hw);
2393 return ERR_PTR(ret);
2395 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2397 int wl1271_free_hw(struct wl1271 *wl)
2399 platform_device_unregister(wl->plat_dev);
2400 kfree(wl->plat_dev);
2402 wl1271_debugfs_exit(wl);
2409 kfree(wl->fw_status);
2410 kfree(wl->tx_res_if);
2412 ieee80211_free_hw(wl->hw);
2416 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2418 MODULE_LICENSE("GPL");
2419 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2420 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");