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>
35 #include "wl12xx_80211.h"
36 #include "wl1271_reg.h"
37 #include "wl1271_io.h"
38 #include "wl1271_event.h"
39 #include "wl1271_tx.h"
40 #include "wl1271_rx.h"
41 #include "wl1271_ps.h"
42 #include "wl1271_init.h"
43 #include "wl1271_debugfs.h"
44 #include "wl1271_cmd.h"
45 #include "wl1271_boot.h"
46 #include "wl1271_testmode.h"
48 #define WL1271_BOOT_RETRIES 3
50 static struct conf_drv_settings default_conf = {
53 [CONF_SG_BT_PER_THRESHOLD] = 7500,
54 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
55 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
56 [CONF_SG_BT_LOAD_RATIO] = 50,
57 [CONF_SG_AUTO_PS_MODE] = 0,
58 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
59 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
60 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
61 [CONF_SG_BEACON_MISS_PERCENT] = 60,
62 [CONF_SG_RATE_ADAPT_THRESH] = 12,
63 [CONF_SG_RATE_ADAPT_SNR] = 0,
64 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
66 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
67 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
69 /* Note: with UPSD, this should be 4 */
70 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
71 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
73 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
74 /* Note: with UPDS, this should be 15 */
75 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
76 /* Note: with UPDS, this should be 50 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
78 /* Note: with UPDS, this should be 10 */
79 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
82 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
83 [CONF_SG_PS_POLL_TIMEOUT] = 10,
84 [CONF_SG_UPSD_TIMEOUT] = 10,
85 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
87 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
90 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
93 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
94 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
96 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
97 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
98 [CONF_SG_HV3_MAX_SERVED] = 6,
99 [CONF_SG_DHCP_TIME] = 5000,
100 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 .state = CONF_SG_PROTECTIVE,
105 .rx_msdu_life_time = 512000,
106 .packet_detection_threshold = 0,
107 .ps_poll_timeout = 15,
109 .rts_threshold = 2347,
110 .rx_cca_threshold = 0,
111 .irq_blk_threshold = 0xFFFF,
112 .irq_pkt_threshold = 0,
114 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
117 .tx_energy_detection = 0,
120 .short_retry_limit = 10,
121 .long_retry_limit = 10,
144 .aifsn = CONF_TX_AIFS_PIFS,
151 .aifsn = CONF_TX_AIFS_PIFS,
159 .channel_type = CONF_CHANNEL_TYPE_DCF,
160 .tsid = CONF_TX_AC_BE,
161 .ps_scheme = CONF_PS_SCHEME_LEGACY,
162 .ack_policy = CONF_ACK_POLICY_LEGACY,
167 .channel_type = CONF_CHANNEL_TYPE_DCF,
168 .tsid = CONF_TX_AC_BE,
169 .ps_scheme = CONF_PS_SCHEME_LEGACY,
170 .ack_policy = CONF_ACK_POLICY_LEGACY,
175 .channel_type = CONF_CHANNEL_TYPE_DCF,
176 .tsid = CONF_TX_AC_BE,
177 .ps_scheme = CONF_PS_SCHEME_LEGACY,
178 .ack_policy = CONF_ACK_POLICY_LEGACY,
183 .channel_type = CONF_CHANNEL_TYPE_DCF,
184 .tsid = CONF_TX_AC_BE,
185 .ps_scheme = CONF_PS_SCHEME_LEGACY,
186 .ack_policy = CONF_ACK_POLICY_LEGACY,
191 .channel_type = CONF_CHANNEL_TYPE_DCF,
192 .tsid = CONF_TX_AC_BE,
193 .ps_scheme = CONF_PS_SCHEME_LEGACY,
194 .ack_policy = CONF_ACK_POLICY_LEGACY,
199 .channel_type = CONF_CHANNEL_TYPE_DCF,
200 .tsid = CONF_TX_AC_BE,
201 .ps_scheme = CONF_PS_SCHEME_LEGACY,
202 .ack_policy = CONF_ACK_POLICY_LEGACY,
207 .channel_type = CONF_CHANNEL_TYPE_DCF,
208 .tsid = CONF_TX_AC_BE,
209 .ps_scheme = CONF_PS_SCHEME_LEGACY,
210 .ack_policy = CONF_ACK_POLICY_LEGACY,
214 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
215 .tx_compl_timeout = 700,
216 .tx_compl_threshold = 4,
217 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
218 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
221 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
222 .listen_interval = 1,
223 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
224 .bcn_filt_ie_count = 1,
227 .ie = WLAN_EID_CHANNEL_SWITCH,
228 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
231 .synch_fail_thold = 10,
232 .bss_lose_timeout = 100,
233 .beacon_rx_timeout = 10000,
234 .broadcast_timeout = 20000,
235 .rx_broadcast_in_ps = 1,
236 .ps_poll_threshold = 20,
237 .sig_trigger_count = 2,
242 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
243 .type = CONF_TRIG_EVENT_TYPE_EDGE,
244 .direction = CONF_TRIG_EVENT_DIR_LOW,
252 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
253 .type = CONF_TRIG_EVENT_TYPE_EDGE,
254 .direction = CONF_TRIG_EVENT_DIR_HIGH,
261 .rssi_bcn_avg_weight = 10,
262 .rssi_pkt_avg_weight = 10,
263 .snr_bcn_avg_weight = 10,
264 .snr_pkt_avg_weight = 10
266 .bet_enable = CONF_BET_MODE_ENABLE,
267 .bet_max_consecutive = 10,
268 .psm_entry_retries = 3,
269 .keep_alive_interval = 55000,
270 .max_listen_interval = 20,
282 .host_clk_settling_time = 5000,
283 .host_fast_wakeup_support = false
287 static void wl1271_device_release(struct device *dev)
292 static struct platform_device wl1271_device = {
296 /* device model insists to have a release function */
298 .release = wl1271_device_release,
302 static LIST_HEAD(wl_list);
304 static void wl1271_conf_init(struct wl1271 *wl)
308 * This function applies the default configuration to the driver. This
309 * function is invoked upon driver load (spi probe.)
311 * The configuration is stored in a run-time structure in order to
312 * facilitate for run-time adjustment of any of the parameters. Making
313 * changes to the configuration structure will apply the new values on
314 * the next interface up (wl1271_op_start.)
317 /* apply driver default configuration */
318 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
322 static int wl1271_plt_init(struct wl1271 *wl)
324 struct conf_tx_ac_category *conf_ac;
325 struct conf_tx_tid *conf_tid;
328 ret = wl1271_cmd_general_parms(wl);
332 ret = wl1271_cmd_radio_parms(wl);
336 ret = wl1271_init_templates_config(wl);
340 ret = wl1271_acx_init_mem_config(wl);
344 /* PHY layer config */
345 ret = wl1271_init_phy_config(wl);
347 goto out_free_memmap;
349 ret = wl1271_acx_dco_itrim_params(wl);
351 goto out_free_memmap;
353 /* Initialize connection monitoring thresholds */
354 ret = wl1271_acx_conn_monit_params(wl, false);
356 goto out_free_memmap;
358 /* Bluetooth WLAN coexistence */
359 ret = wl1271_init_pta(wl);
361 goto out_free_memmap;
363 /* Energy detection */
364 ret = wl1271_init_energy_detection(wl);
366 goto out_free_memmap;
368 /* Default fragmentation threshold */
369 ret = wl1271_acx_frag_threshold(wl);
371 goto out_free_memmap;
373 /* Default TID configuration */
374 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
375 conf_tid = &wl->conf.tx.tid_conf[i];
376 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
377 conf_tid->channel_type,
380 conf_tid->ack_policy,
381 conf_tid->apsd_conf[0],
382 conf_tid->apsd_conf[1]);
384 goto out_free_memmap;
387 /* Default AC configuration */
388 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
389 conf_ac = &wl->conf.tx.ac_conf[i];
390 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
391 conf_ac->cw_max, conf_ac->aifsn,
392 conf_ac->tx_op_limit);
394 goto out_free_memmap;
397 /* Enable data path */
398 ret = wl1271_cmd_data_path(wl, 1);
400 goto out_free_memmap;
402 /* Configure for CAM power saving (ie. always active) */
403 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
405 goto out_free_memmap;
408 ret = wl1271_acx_pm_config(wl);
410 goto out_free_memmap;
415 kfree(wl->target_mem_map);
416 wl->target_mem_map = NULL;
421 static void wl1271_fw_status(struct wl1271 *wl,
422 struct wl1271_fw_status *status)
428 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
430 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
431 "drv_rx_counter = %d, tx_results_counter = %d)",
433 status->fw_rx_counter,
434 status->drv_rx_counter,
435 status->tx_results_counter);
437 /* update number of available TX blocks */
438 for (i = 0; i < NUM_TX_QUEUES; i++) {
439 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
440 wl->tx_blocks_freed[i];
442 wl->tx_blocks_freed[i] =
443 le32_to_cpu(status->tx_released_blks[i]);
444 wl->tx_blocks_available += cnt;
448 /* if more blocks are available now, schedule some tx work */
449 if (total && !skb_queue_empty(&wl->tx_queue))
450 ieee80211_queue_work(wl->hw, &wl->tx_work);
452 /* update the host-chipset time offset */
454 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
455 (s64)le32_to_cpu(status->fw_localtime);
458 #define WL1271_IRQ_MAX_LOOPS 10
460 static void wl1271_irq_work(struct work_struct *work)
464 int loopcount = WL1271_IRQ_MAX_LOOPS;
467 container_of(work, struct wl1271, irq_work);
469 mutex_lock(&wl->mutex);
471 wl1271_debug(DEBUG_IRQ, "IRQ work");
473 if (unlikely(wl->state == WL1271_STATE_OFF))
476 ret = wl1271_ps_elp_wakeup(wl, true);
480 spin_lock_irqsave(&wl->wl_lock, flags);
481 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
482 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
483 spin_unlock_irqrestore(&wl->wl_lock, flags);
486 wl1271_fw_status(wl, wl->fw_status);
487 intr = le32_to_cpu(wl->fw_status->intr);
489 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
493 intr &= WL1271_INTR_MASK;
495 if (intr & WL1271_ACX_INTR_DATA) {
496 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
498 /* check for tx results */
499 if (wl->fw_status->tx_results_counter !=
500 (wl->tx_results_count & 0xff))
501 wl1271_tx_complete(wl);
503 wl1271_rx(wl, wl->fw_status);
506 if (intr & WL1271_ACX_INTR_EVENT_A) {
507 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
508 wl1271_event_handle(wl, 0);
511 if (intr & WL1271_ACX_INTR_EVENT_B) {
512 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
513 wl1271_event_handle(wl, 1);
516 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
517 wl1271_debug(DEBUG_IRQ,
518 "WL1271_ACX_INTR_INIT_COMPLETE");
520 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
521 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
523 spin_lock_irqsave(&wl->wl_lock, flags);
526 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
527 ieee80211_queue_work(wl->hw, &wl->irq_work);
529 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
530 spin_unlock_irqrestore(&wl->wl_lock, flags);
532 wl1271_ps_elp_sleep(wl);
535 mutex_unlock(&wl->mutex);
538 static int wl1271_fetch_firmware(struct wl1271 *wl)
540 const struct firmware *fw;
543 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
546 wl1271_error("could not get firmware: %d", ret);
551 wl1271_error("firmware size is not multiple of 32 bits: %zu",
557 wl->fw_len = fw->size;
558 wl->fw = vmalloc(wl->fw_len);
561 wl1271_error("could not allocate memory for the firmware");
566 memcpy(wl->fw, fw->data, wl->fw_len);
571 release_firmware(fw);
576 static int wl1271_fetch_nvs(struct wl1271 *wl)
578 const struct firmware *fw;
581 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
584 wl1271_error("could not get nvs file: %d", ret);
588 if (fw->size != sizeof(struct wl1271_nvs_file)) {
589 wl1271_error("nvs size is not as expected: %zu != %zu",
590 fw->size, sizeof(struct wl1271_nvs_file));
595 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
598 wl1271_error("could not allocate memory for the nvs file");
603 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
606 release_firmware(fw);
611 static void wl1271_fw_wakeup(struct wl1271 *wl)
615 elp_reg = ELPCTRL_WAKE_UP;
616 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
619 static int wl1271_setup(struct wl1271 *wl)
621 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
625 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
626 if (!wl->tx_res_if) {
627 kfree(wl->fw_status);
631 INIT_WORK(&wl->irq_work, wl1271_irq_work);
632 INIT_WORK(&wl->tx_work, wl1271_tx_work);
636 static int wl1271_chip_wakeup(struct wl1271 *wl)
638 struct wl1271_partition_set partition;
641 msleep(WL1271_PRE_POWER_ON_SLEEP);
643 msleep(WL1271_POWER_ON_SLEEP);
647 /* We don't need a real memory partition here, because we only want
648 * to use the registers at this point. */
649 memset(&partition, 0, sizeof(partition));
650 partition.reg.start = REGISTERS_BASE;
651 partition.reg.size = REGISTERS_DOWN_SIZE;
652 wl1271_set_partition(wl, &partition);
654 /* ELP module wake up */
655 wl1271_fw_wakeup(wl);
657 /* whal_FwCtrl_BootSm() */
659 /* 0. read chip id from CHIP_ID */
660 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
662 /* 1. check if chip id is valid */
664 switch (wl->chip.id) {
665 case CHIP_ID_1271_PG10:
666 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
669 ret = wl1271_setup(wl);
673 case CHIP_ID_1271_PG20:
674 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
677 ret = wl1271_setup(wl);
682 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
687 if (wl->fw == NULL) {
688 ret = wl1271_fetch_firmware(wl);
693 /* No NVS from netlink, try to get it from the filesystem */
694 if (wl->nvs == NULL) {
695 ret = wl1271_fetch_nvs(wl);
704 int wl1271_plt_start(struct wl1271 *wl)
706 int retries = WL1271_BOOT_RETRIES;
709 mutex_lock(&wl->mutex);
711 wl1271_notice("power up");
713 if (wl->state != WL1271_STATE_OFF) {
714 wl1271_error("cannot go into PLT state because not "
715 "in off state: %d", wl->state);
722 ret = wl1271_chip_wakeup(wl);
726 ret = wl1271_boot(wl);
730 ret = wl1271_plt_init(wl);
734 wl->state = WL1271_STATE_PLT;
735 wl1271_notice("firmware booted in PLT mode (%s)",
740 wl1271_disable_interrupts(wl);
741 mutex_unlock(&wl->mutex);
742 /* Unlocking the mutex in the middle of handling is
743 inherently unsafe. In this case we deem it safe to do,
744 because we need to let any possibly pending IRQ out of
745 the system (and while we are WL1271_STATE_OFF the IRQ
746 work function will not do anything.) Also, any other
747 possible concurrent operations will fail due to the
748 current state, hence the wl1271 struct should be safe. */
749 cancel_work_sync(&wl->irq_work);
750 mutex_lock(&wl->mutex);
752 wl1271_power_off(wl);
755 wl1271_error("firmware boot in PLT mode failed despite %d retries",
756 WL1271_BOOT_RETRIES);
758 mutex_unlock(&wl->mutex);
763 int wl1271_plt_stop(struct wl1271 *wl)
767 mutex_lock(&wl->mutex);
769 wl1271_notice("power down");
771 if (wl->state != WL1271_STATE_PLT) {
772 wl1271_error("cannot power down because not in PLT "
773 "state: %d", wl->state);
778 wl1271_disable_interrupts(wl);
779 wl1271_power_off(wl);
781 wl->state = WL1271_STATE_OFF;
785 mutex_unlock(&wl->mutex);
791 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
793 struct wl1271 *wl = hw->priv;
794 struct ieee80211_conf *conf = &hw->conf;
795 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
796 struct ieee80211_sta *sta = txinfo->control.sta;
799 /* peek into the rates configured in the STA entry */
800 spin_lock_irqsave(&wl->wl_lock, flags);
801 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
802 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
803 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
805 spin_unlock_irqrestore(&wl->wl_lock, flags);
807 /* queue the packet */
808 skb_queue_tail(&wl->tx_queue, skb);
811 * The chip specific setup must run before the first TX packet -
812 * before that, the tx_work will not be initialized!
815 ieee80211_queue_work(wl->hw, &wl->tx_work);
818 * The workqueue is slow to process the tx_queue and we need stop
819 * the queue here, otherwise the queue will get too long.
821 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
822 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
824 spin_lock_irqsave(&wl->wl_lock, flags);
825 ieee80211_stop_queues(wl->hw);
826 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
827 spin_unlock_irqrestore(&wl->wl_lock, flags);
833 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
836 struct net_device *dev;
837 struct wireless_dev *wdev;
839 struct ieee80211_hw *hw;
841 struct wl1271 *wl_temp;
842 struct in_device *idev;
843 struct in_ifaddr *ifa = arg;
846 /* FIXME: this ugly function should probably be implemented in the
847 * mac80211, and here should only be a simple callback handling actual
848 * setting of the filters. Now we need to dig up references to
849 * various structures to gain access to what we need.
850 * Also, because of this, there is no "initial" setting of the filter
851 * in "op_start", because we don't want to dig up struct net_device
852 * there - the filter will be set upon first change of the interface
855 dev = ifa->ifa_dev->dev;
857 wdev = dev->ieee80211_ptr;
865 hw = wiphy_priv(wiphy);
869 /* Check that the interface is one supported by this driver. */
871 list_for_each_entry(wl, &wl_list, list) {
878 /* Get the interface IP address for the device. "ifa" will become
880 - there is no IPV4 protocol address configured
881 - there are multiple (virtual) IPV4 addresses configured
882 When "ifa" is NULL, filtering will be disabled.
887 ifa = idev->ifa_list;
889 if (ifa && ifa->ifa_next)
892 mutex_lock(&wl->mutex);
894 if (wl->state == WL1271_STATE_OFF)
897 ret = wl1271_ps_elp_wakeup(wl, false);
901 ret = wl1271_acx_arp_ip_filter(wl, true,
902 (u8 *)&ifa->ifa_address,
905 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
907 wl1271_ps_elp_sleep(wl);
910 mutex_unlock(&wl->mutex);
915 static struct notifier_block wl1271_dev_notifier = {
916 .notifier_call = wl1271_dev_notify,
920 static int wl1271_op_start(struct ieee80211_hw *hw)
922 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
925 * We have to delay the booting of the hardware because
926 * we need to know the local MAC address before downloading and
927 * initializing the firmware. The MAC address cannot be changed
928 * after boot, and without the proper MAC address, the firmware
929 * will not function properly.
931 * The MAC address is first known when the corresponding interface
932 * is added. That is where we will initialize the hardware.
938 static void wl1271_op_stop(struct ieee80211_hw *hw)
940 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
943 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
944 struct ieee80211_vif *vif)
946 struct wl1271 *wl = hw->priv;
947 int retries = WL1271_BOOT_RETRIES;
950 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
951 vif->type, vif->addr);
953 mutex_lock(&wl->mutex);
962 case NL80211_IFTYPE_STATION:
963 wl->bss_type = BSS_TYPE_STA_BSS;
964 wl->set_bss_type = BSS_TYPE_STA_BSS;
966 case NL80211_IFTYPE_ADHOC:
967 wl->bss_type = BSS_TYPE_IBSS;
968 wl->set_bss_type = BSS_TYPE_STA_BSS;
975 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
977 if (wl->state != WL1271_STATE_OFF) {
978 wl1271_error("cannot start because not in off state: %d",
986 ret = wl1271_chip_wakeup(wl);
990 ret = wl1271_boot(wl);
994 ret = wl1271_hw_init(wl);
998 wl->state = WL1271_STATE_ON;
999 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
1003 wl1271_disable_interrupts(wl);
1004 mutex_unlock(&wl->mutex);
1005 /* Unlocking the mutex in the middle of handling is
1006 inherently unsafe. In this case we deem it safe to do,
1007 because we need to let any possibly pending IRQ out of
1008 the system (and while we are WL1271_STATE_OFF the IRQ
1009 work function will not do anything.) Also, any other
1010 possible concurrent operations will fail due to the
1011 current state, hence the wl1271 struct should be safe. */
1012 cancel_work_sync(&wl->irq_work);
1013 mutex_lock(&wl->mutex);
1015 wl1271_power_off(wl);
1018 wl1271_error("firmware boot failed despite %d retries",
1019 WL1271_BOOT_RETRIES);
1021 mutex_unlock(&wl->mutex);
1024 list_add(&wl->list, &wl_list);
1025 register_inetaddr_notifier(&wl1271_dev_notifier);
1031 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1032 struct ieee80211_vif *vif)
1034 struct wl1271 *wl = hw->priv;
1037 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1039 mutex_lock(&wl->mutex);
1040 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1042 wl1271_info("down");
1044 list_del(&wl->list);
1046 WARN_ON(wl->state != WL1271_STATE_ON);
1048 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1049 mutex_unlock(&wl->mutex);
1050 ieee80211_scan_completed(wl->hw, true);
1051 mutex_lock(&wl->mutex);
1054 wl->state = WL1271_STATE_OFF;
1056 wl1271_disable_interrupts(wl);
1058 mutex_unlock(&wl->mutex);
1060 cancel_work_sync(&wl->irq_work);
1061 cancel_work_sync(&wl->tx_work);
1063 mutex_lock(&wl->mutex);
1065 /* let's notify MAC80211 about the remaining pending TX frames */
1066 wl1271_tx_flush(wl);
1067 wl1271_power_off(wl);
1069 memset(wl->bssid, 0, ETH_ALEN);
1070 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1072 wl->bss_type = MAX_BSS_TYPE;
1073 wl->set_bss_type = MAX_BSS_TYPE;
1074 wl->band = IEEE80211_BAND_2GHZ;
1077 wl->psm_entry_retry = 0;
1078 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1079 wl->tx_blocks_available = 0;
1080 wl->tx_results_count = 0;
1081 wl->tx_packets_count = 0;
1082 wl->tx_security_last_seq = 0;
1083 wl->tx_security_seq = 0;
1084 wl->time_offset = 0;
1085 wl->session_counter = 0;
1086 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1087 wl->sta_rate_set = 0;
1092 for (i = 0; i < NUM_TX_QUEUES; i++)
1093 wl->tx_blocks_freed[i] = 0;
1095 wl1271_debugfs_reset(wl);
1097 kfree(wl->fw_status);
1098 wl->fw_status = NULL;
1099 kfree(wl->tx_res_if);
1100 wl->tx_res_if = NULL;
1101 kfree(wl->target_mem_map);
1102 wl->target_mem_map = NULL;
1104 mutex_unlock(&wl->mutex);
1107 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1109 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1110 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1112 /* combine requested filters with current filter config */
1113 filters = wl->filters | filters;
1115 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1117 if (filters & FIF_PROMISC_IN_BSS) {
1118 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1119 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1120 wl->rx_config |= CFG_BSSID_FILTER_EN;
1122 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1123 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1124 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1125 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1127 if (filters & FIF_OTHER_BSS) {
1128 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1129 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1131 if (filters & FIF_CONTROL) {
1132 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1133 wl->rx_filter |= CFG_RX_CTL_EN;
1135 if (filters & FIF_FCSFAIL) {
1136 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1137 wl->rx_filter |= CFG_RX_FCS_ERROR;
1141 static int wl1271_join_channel(struct wl1271 *wl, int channel)
1144 /* we need to use a dummy BSSID for now */
1145 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1148 wl->channel = channel;
1149 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1151 /* pass through frames from all BSS */
1152 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1154 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1158 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1164 static int wl1271_unjoin_channel(struct wl1271 *wl)
1168 /* to stop listening to a channel, we disconnect */
1169 ret = wl1271_cmd_disconnect(wl);
1173 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1175 memset(wl->bssid, 0, ETH_ALEN);
1177 /* stop filterting packets based on bssid */
1178 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1184 static void wl1271_set_band_rate(struct wl1271 *wl)
1186 if (wl->band == IEEE80211_BAND_2GHZ)
1187 wl->basic_rate_set = wl->conf.tx.basic_rate;
1189 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1192 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1197 if (!wl->basic_rate_set) {
1199 wl->basic_rate_set = wl->conf.tx.basic_rate;
1202 for (i = 0; !rate; i++) {
1203 if ((wl->basic_rate_set >> i) & 0x1)
1210 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1212 struct wl1271 *wl = hw->priv;
1213 struct ieee80211_conf *conf = &hw->conf;
1214 int channel, ret = 0;
1216 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1218 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1220 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1222 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1224 mutex_lock(&wl->mutex);
1226 if (unlikely(wl->state == WL1271_STATE_OFF))
1229 ret = wl1271_ps_elp_wakeup(wl, false);
1233 /* if the channel changes while joined, join again */
1234 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1235 wl->band = conf->channel->band;
1236 wl->channel = channel;
1239 * FIXME: the mac80211 should really provide a fixed rate
1240 * to use here. for now, just use the smallest possible rate
1241 * for the band as a fixed rate for association frames and
1242 * other control messages.
1244 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1245 wl1271_set_band_rate(wl);
1247 wl->basic_rate = wl1271_min_rate_get(wl);
1248 ret = wl1271_acx_rate_policies(wl);
1250 wl1271_warning("rate policy for update channel "
1253 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1254 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1256 wl1271_warning("cmd join to update channel "
1261 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1262 if (conf->flags & IEEE80211_CONF_IDLE &&
1263 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1264 wl1271_unjoin_channel(wl);
1265 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1266 wl1271_join_channel(wl, channel);
1268 if (conf->flags & IEEE80211_CONF_IDLE) {
1269 wl->rate_set = wl1271_min_rate_get(wl);
1270 wl->sta_rate_set = 0;
1271 wl1271_acx_rate_policies(wl);
1272 wl1271_acx_keep_alive_config(
1273 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1274 ACX_KEEP_ALIVE_TPL_INVALID);
1278 if (conf->flags & IEEE80211_CONF_PS &&
1279 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1280 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1283 * We enter PSM only if we're already associated.
1284 * If we're not, we'll enter it when joining an SSID,
1285 * through the bss_info_changed() hook.
1287 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1288 wl1271_debug(DEBUG_PSM, "psm enabled");
1289 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1292 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1293 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1294 wl1271_debug(DEBUG_PSM, "psm disabled");
1296 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1298 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1299 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1303 if (conf->power_level != wl->power_level) {
1304 ret = wl1271_acx_tx_power(wl, conf->power_level);
1308 wl->power_level = conf->power_level;
1312 wl1271_ps_elp_sleep(wl);
1315 mutex_unlock(&wl->mutex);
1320 struct wl1271_filter_params {
1323 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1326 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1327 struct dev_addr_list *mc_list)
1329 struct wl1271_filter_params *fp;
1330 struct wl1271 *wl = hw->priv;
1333 if (unlikely(wl->state == WL1271_STATE_OFF))
1336 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1338 wl1271_error("Out of memory setting filters.");
1342 /* update multicast filtering parameters */
1344 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1346 fp->enabled = false;
1349 fp->mc_list_length = 0;
1350 for (i = 0; i < mc_count; i++) {
1351 if (mc_list->da_addrlen == ETH_ALEN) {
1352 memcpy(fp->mc_list[fp->mc_list_length],
1353 mc_list->da_addr, ETH_ALEN);
1354 fp->mc_list_length++;
1356 wl1271_warning("Unknown mc address length.");
1357 mc_list = mc_list->next;
1360 return (u64)(unsigned long)fp;
1363 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1366 FIF_BCN_PRBRESP_PROMISC | \
1370 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1371 unsigned int changed,
1372 unsigned int *total, u64 multicast)
1374 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1375 struct wl1271 *wl = hw->priv;
1378 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1380 mutex_lock(&wl->mutex);
1382 *total &= WL1271_SUPPORTED_FILTERS;
1383 changed &= WL1271_SUPPORTED_FILTERS;
1385 if (unlikely(wl->state == WL1271_STATE_OFF))
1388 ret = wl1271_ps_elp_wakeup(wl, false);
1393 if (*total & FIF_ALLMULTI)
1394 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1396 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1398 fp->mc_list_length);
1402 /* determine, whether supported filter values have changed */
1406 /* configure filters */
1407 wl->filters = *total;
1408 wl1271_configure_filters(wl, 0);
1410 /* apply configured filters */
1411 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1416 wl1271_ps_elp_sleep(wl);
1419 mutex_unlock(&wl->mutex);
1423 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1424 struct ieee80211_vif *vif,
1425 struct ieee80211_sta *sta,
1426 struct ieee80211_key_conf *key_conf)
1428 struct wl1271 *wl = hw->priv;
1435 static const u8 bcast_addr[ETH_ALEN] =
1436 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1438 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1440 addr = sta ? sta->addr : bcast_addr;
1442 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1443 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1444 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1445 key_conf->alg, key_conf->keyidx,
1446 key_conf->keylen, key_conf->flags);
1447 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1449 if (is_zero_ether_addr(addr)) {
1450 /* We dont support TX only encryption */
1455 mutex_lock(&wl->mutex);
1457 ret = wl1271_ps_elp_wakeup(wl, false);
1461 switch (key_conf->alg) {
1465 key_conf->hw_key_idx = key_conf->keyidx;
1468 key_type = KEY_TKIP;
1470 key_conf->hw_key_idx = key_conf->keyidx;
1471 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1472 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1477 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1478 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1479 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1482 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1490 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1491 key_conf->keyidx, key_type,
1492 key_conf->keylen, key_conf->key,
1493 addr, tx_seq_32, tx_seq_16);
1495 wl1271_error("Could not add or replace key");
1499 /* the default WEP key needs to be configured at least once */
1500 if (key_type == KEY_WEP) {
1501 ret = wl1271_cmd_set_default_wep_key(wl,
1509 /* The wl1271 does not allow to remove unicast keys - they
1510 will be cleared automatically on next CMD_JOIN. Ignore the
1511 request silently, as we dont want the mac80211 to emit
1512 an error message. */
1513 if (!is_broadcast_ether_addr(addr))
1516 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1517 key_conf->keyidx, key_type,
1518 key_conf->keylen, key_conf->key,
1521 wl1271_error("Could not remove key");
1527 wl1271_error("Unsupported key cmd 0x%x", cmd);
1535 wl1271_ps_elp_sleep(wl);
1538 mutex_unlock(&wl->mutex);
1544 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1545 struct cfg80211_scan_request *req)
1547 struct wl1271 *wl = hw->priv;
1552 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1555 ssid = req->ssids[0].ssid;
1556 len = req->ssids[0].ssid_len;
1559 mutex_lock(&wl->mutex);
1561 ret = wl1271_ps_elp_wakeup(wl, false);
1565 if (wl1271_11a_enabled())
1566 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1567 req->ie, req->ie_len, 1, 0,
1568 WL1271_SCAN_BAND_DUAL, 3);
1570 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1571 req->ie, req->ie_len, 1, 0,
1572 WL1271_SCAN_BAND_2_4_GHZ, 3);
1574 wl1271_ps_elp_sleep(wl);
1577 mutex_unlock(&wl->mutex);
1582 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1584 struct wl1271 *wl = hw->priv;
1587 mutex_lock(&wl->mutex);
1589 ret = wl1271_ps_elp_wakeup(wl, false);
1593 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1595 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1597 wl1271_ps_elp_sleep(wl);
1600 mutex_unlock(&wl->mutex);
1605 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1607 u8 *ptr = beacon->data +
1608 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1610 /* find the location of the ssid in the beacon */
1611 while (ptr < beacon->data + beacon->len) {
1612 if (ptr[0] == WLAN_EID_SSID) {
1613 wl->ssid_len = ptr[1];
1614 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1619 wl1271_error("ad-hoc beacon template has no SSID!\n");
1622 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1623 struct ieee80211_vif *vif,
1624 struct ieee80211_bss_conf *bss_conf,
1627 enum wl1271_cmd_ps_mode mode;
1628 struct wl1271 *wl = hw->priv;
1629 bool do_join = false;
1630 bool do_keepalive = false;
1633 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1635 mutex_lock(&wl->mutex);
1637 ret = wl1271_ps_elp_wakeup(wl, false);
1641 if ((changed && BSS_CHANGED_BEACON_INT) &&
1642 (wl->bss_type == BSS_TYPE_IBSS)) {
1643 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1644 bss_conf->beacon_int);
1646 wl->beacon_int = bss_conf->beacon_int;
1650 if ((changed && BSS_CHANGED_BEACON) &&
1651 (wl->bss_type == BSS_TYPE_IBSS)) {
1652 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1654 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1657 struct ieee80211_hdr *hdr;
1659 wl1271_ssid_set(wl, beacon);
1660 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1663 wl1271_min_rate_get(wl));
1666 dev_kfree_skb(beacon);
1670 hdr = (struct ieee80211_hdr *) beacon->data;
1671 hdr->frame_control = cpu_to_le16(
1672 IEEE80211_FTYPE_MGMT |
1673 IEEE80211_STYPE_PROBE_RESP);
1675 ret = wl1271_cmd_template_set(wl,
1676 CMD_TEMPL_PROBE_RESPONSE,
1679 wl1271_min_rate_get(wl));
1680 dev_kfree_skb(beacon);
1684 /* Need to update the SSID (for filtering etc) */
1689 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1690 (wl->bss_type == BSS_TYPE_IBSS)) {
1691 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1692 bss_conf->enable_beacon ? "enabled" : "disabled");
1694 if (bss_conf->enable_beacon)
1695 wl->set_bss_type = BSS_TYPE_IBSS;
1697 wl->set_bss_type = BSS_TYPE_STA_BSS;
1701 if ((changed & BSS_CHANGED_BSSID) &&
1703 * Now we know the correct bssid, so we send a new join command
1704 * and enable the BSSID filter
1706 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1707 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1709 ret = wl1271_cmd_build_null_data(wl);
1713 /* filter out all packets not from this BSSID */
1714 wl1271_configure_filters(wl, 0);
1716 /* Need to update the BSSID (for filtering etc) */
1720 if (changed & BSS_CHANGED_ASSOC) {
1721 if (bss_conf->assoc) {
1723 wl->aid = bss_conf->aid;
1724 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1727 * use basic rates from AP, and determine lowest rate
1728 * to use with control frames.
1730 rates = bss_conf->basic_rates;
1731 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1733 wl->basic_rate = wl1271_min_rate_get(wl);
1734 ret = wl1271_acx_rate_policies(wl);
1739 * with wl1271, we don't need to update the
1740 * beacon_int and dtim_period, because the firmware
1741 * updates it by itself when the first beacon is
1742 * received after a join.
1744 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1749 * The SSID is intentionally set to NULL here - the
1750 * firmware will set the probe request with a
1751 * broadcast SSID regardless of what we set in the
1754 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1757 /* Enable the keep-alive feature */
1758 ret = wl1271_acx_keep_alive_mode(wl, true);
1763 * This is awkward. The keep-alive configs must be done
1764 * *after* the join command, because otherwise it will
1765 * not work, but it must only be done *once* because
1766 * otherwise the firmware will start complaining.
1768 do_keepalive = true;
1770 /* enable the connection monitoring feature */
1771 ret = wl1271_acx_conn_monit_params(wl, true);
1775 /* If we want to go in PSM but we're not there yet */
1776 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1777 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1778 mode = STATION_POWER_SAVE_MODE;
1779 ret = wl1271_ps_set_mode(wl, mode, true);
1784 /* use defaults when not associated */
1785 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1788 /* revert back to minimum rates for the current band */
1789 wl1271_set_band_rate(wl);
1790 wl->basic_rate = wl1271_min_rate_get(wl);
1791 ret = wl1271_acx_rate_policies(wl);
1795 /* disable connection monitor features */
1796 ret = wl1271_acx_conn_monit_params(wl, false);
1798 /* Disable the keep-alive feature */
1799 ret = wl1271_acx_keep_alive_mode(wl, false);
1807 if (changed & BSS_CHANGED_ERP_SLOT) {
1808 if (bss_conf->use_short_slot)
1809 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1811 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1813 wl1271_warning("Set slot time failed %d", ret);
1818 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1819 if (bss_conf->use_short_preamble)
1820 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1822 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1825 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1826 if (bss_conf->use_cts_prot)
1827 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1829 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1831 wl1271_warning("Set ctsprotect failed %d", ret);
1837 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1839 wl1271_warning("cmd join failed %d", ret);
1842 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1846 * The JOIN operation shuts down the firmware keep-alive as a side
1847 * effect, and the ACX_AID will start the keep-alive as a side effect.
1848 * Hence, for non-IBSS, the ACX_AID must always happen *after* the
1849 * JOIN operation, and the template config after the ACX_AID.
1851 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1852 ret = wl1271_acx_aid(wl, wl->aid);
1858 ret = wl1271_cmd_build_klv_null_data(wl);
1861 ret = wl1271_acx_keep_alive_config(
1862 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1863 ACX_KEEP_ALIVE_TPL_VALID);
1869 wl1271_ps_elp_sleep(wl);
1872 mutex_unlock(&wl->mutex);
1875 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1876 const struct ieee80211_tx_queue_params *params)
1878 struct wl1271 *wl = hw->priv;
1882 mutex_lock(&wl->mutex);
1884 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1886 ret = wl1271_ps_elp_wakeup(wl, false);
1890 /* the txop is confed in units of 32us by the mac80211, we need us */
1891 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1892 params->cw_min, params->cw_max,
1893 params->aifs, params->txop << 5);
1898 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1900 ps_scheme = CONF_PS_SCHEME_LEGACY;
1902 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1903 CONF_CHANNEL_TYPE_EDCF,
1904 wl1271_tx_get_queue(queue),
1905 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1910 wl1271_ps_elp_sleep(wl);
1913 mutex_unlock(&wl->mutex);
1919 /* can't be const, mac80211 writes to this */
1920 static struct ieee80211_rate wl1271_rates[] = {
1922 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1923 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1925 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1926 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1927 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1929 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1930 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1931 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1933 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1934 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1935 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1937 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1938 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1940 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1941 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1943 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1944 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1946 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1947 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1949 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1950 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1952 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1953 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1955 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1956 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1958 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1959 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1962 /* can't be const, mac80211 writes to this */
1963 static struct ieee80211_channel wl1271_channels[] = {
1964 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1965 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1966 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1967 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1968 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1969 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1970 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1971 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1972 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1973 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1974 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1975 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1976 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1979 /* mapping to indexes for wl1271_rates */
1980 const static u8 wl1271_rate_to_idx_2ghz[] = {
1981 /* MCS rates are used only with 11n */
1982 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1983 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1984 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1985 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
1986 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
1987 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
1988 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
1989 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
1991 11, /* CONF_HW_RXTX_RATE_54 */
1992 10, /* CONF_HW_RXTX_RATE_48 */
1993 9, /* CONF_HW_RXTX_RATE_36 */
1994 8, /* CONF_HW_RXTX_RATE_24 */
1996 /* TI-specific rate */
1997 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
1999 7, /* CONF_HW_RXTX_RATE_18 */
2000 6, /* CONF_HW_RXTX_RATE_12 */
2001 3, /* CONF_HW_RXTX_RATE_11 */
2002 5, /* CONF_HW_RXTX_RATE_9 */
2003 4, /* CONF_HW_RXTX_RATE_6 */
2004 2, /* CONF_HW_RXTX_RATE_5_5 */
2005 1, /* CONF_HW_RXTX_RATE_2 */
2006 0 /* CONF_HW_RXTX_RATE_1 */
2009 /* can't be const, mac80211 writes to this */
2010 static struct ieee80211_supported_band wl1271_band_2ghz = {
2011 .channels = wl1271_channels,
2012 .n_channels = ARRAY_SIZE(wl1271_channels),
2013 .bitrates = wl1271_rates,
2014 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2017 /* 5 GHz data rates for WL1273 */
2018 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2020 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2021 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2023 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2024 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2026 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2027 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2029 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2030 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2032 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2033 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2035 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2036 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2038 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2039 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2041 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2042 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2045 /* 5 GHz band channels for WL1273 */
2046 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2047 { .hw_value = 183, .center_freq = 4915},
2048 { .hw_value = 184, .center_freq = 4920},
2049 { .hw_value = 185, .center_freq = 4925},
2050 { .hw_value = 187, .center_freq = 4935},
2051 { .hw_value = 188, .center_freq = 4940},
2052 { .hw_value = 189, .center_freq = 4945},
2053 { .hw_value = 192, .center_freq = 4960},
2054 { .hw_value = 196, .center_freq = 4980},
2055 { .hw_value = 7, .center_freq = 5035},
2056 { .hw_value = 8, .center_freq = 5040},
2057 { .hw_value = 9, .center_freq = 5045},
2058 { .hw_value = 11, .center_freq = 5055},
2059 { .hw_value = 12, .center_freq = 5060},
2060 { .hw_value = 16, .center_freq = 5080},
2061 { .hw_value = 34, .center_freq = 5170},
2062 { .hw_value = 36, .center_freq = 5180},
2063 { .hw_value = 38, .center_freq = 5190},
2064 { .hw_value = 40, .center_freq = 5200},
2065 { .hw_value = 42, .center_freq = 5210},
2066 { .hw_value = 44, .center_freq = 5220},
2067 { .hw_value = 46, .center_freq = 5230},
2068 { .hw_value = 48, .center_freq = 5240},
2069 { .hw_value = 52, .center_freq = 5260},
2070 { .hw_value = 56, .center_freq = 5280},
2071 { .hw_value = 60, .center_freq = 5300},
2072 { .hw_value = 64, .center_freq = 5320},
2073 { .hw_value = 100, .center_freq = 5500},
2074 { .hw_value = 104, .center_freq = 5520},
2075 { .hw_value = 108, .center_freq = 5540},
2076 { .hw_value = 112, .center_freq = 5560},
2077 { .hw_value = 116, .center_freq = 5580},
2078 { .hw_value = 120, .center_freq = 5600},
2079 { .hw_value = 124, .center_freq = 5620},
2080 { .hw_value = 128, .center_freq = 5640},
2081 { .hw_value = 132, .center_freq = 5660},
2082 { .hw_value = 136, .center_freq = 5680},
2083 { .hw_value = 140, .center_freq = 5700},
2084 { .hw_value = 149, .center_freq = 5745},
2085 { .hw_value = 153, .center_freq = 5765},
2086 { .hw_value = 157, .center_freq = 5785},
2087 { .hw_value = 161, .center_freq = 5805},
2088 { .hw_value = 165, .center_freq = 5825},
2091 /* mapping to indexes for wl1271_rates_5ghz */
2092 const static u8 wl1271_rate_to_idx_5ghz[] = {
2093 /* MCS rates are used only with 11n */
2094 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2095 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2096 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2097 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2098 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2099 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2100 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2101 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2103 7, /* CONF_HW_RXTX_RATE_54 */
2104 6, /* CONF_HW_RXTX_RATE_48 */
2105 5, /* CONF_HW_RXTX_RATE_36 */
2106 4, /* CONF_HW_RXTX_RATE_24 */
2108 /* TI-specific rate */
2109 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2111 3, /* CONF_HW_RXTX_RATE_18 */
2112 2, /* CONF_HW_RXTX_RATE_12 */
2113 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2114 1, /* CONF_HW_RXTX_RATE_9 */
2115 0, /* CONF_HW_RXTX_RATE_6 */
2116 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2117 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2118 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2121 static struct ieee80211_supported_band wl1271_band_5ghz = {
2122 .channels = wl1271_channels_5ghz,
2123 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2124 .bitrates = wl1271_rates_5ghz,
2125 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2128 const static u8 *wl1271_band_rate_to_idx[] = {
2129 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2130 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2133 static const struct ieee80211_ops wl1271_ops = {
2134 .start = wl1271_op_start,
2135 .stop = wl1271_op_stop,
2136 .add_interface = wl1271_op_add_interface,
2137 .remove_interface = wl1271_op_remove_interface,
2138 .config = wl1271_op_config,
2139 .prepare_multicast = wl1271_op_prepare_multicast,
2140 .configure_filter = wl1271_op_configure_filter,
2142 .set_key = wl1271_op_set_key,
2143 .hw_scan = wl1271_op_hw_scan,
2144 .bss_info_changed = wl1271_op_bss_info_changed,
2145 .set_rts_threshold = wl1271_op_set_rts_threshold,
2146 .conf_tx = wl1271_op_conf_tx,
2147 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2151 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2155 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2157 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2158 wl1271_error("Illegal RX rate from HW: %d", rate);
2162 idx = wl1271_band_rate_to_idx[wl->band][rate];
2163 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2164 wl1271_error("Unsupported RX rate from HW: %d", rate);
2171 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2172 struct device_attribute *attr,
2175 struct wl1271 *wl = dev_get_drvdata(dev);
2178 /* FIXME: what's the maximum length of buf? page size?*/
2181 mutex_lock(&wl->mutex);
2182 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2184 mutex_unlock(&wl->mutex);
2190 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2191 struct device_attribute *attr,
2192 const char *buf, size_t count)
2194 struct wl1271 *wl = dev_get_drvdata(dev);
2198 ret = strict_strtoul(buf, 10, &res);
2201 wl1271_warning("incorrect value written to bt_coex_mode");
2205 mutex_lock(&wl->mutex);
2209 if (res == wl->sg_enabled)
2212 wl->sg_enabled = res;
2214 if (wl->state == WL1271_STATE_OFF)
2217 ret = wl1271_ps_elp_wakeup(wl, false);
2221 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2222 wl1271_ps_elp_sleep(wl);
2225 mutex_unlock(&wl->mutex);
2229 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2230 wl1271_sysfs_show_bt_coex_state,
2231 wl1271_sysfs_store_bt_coex_state);
2233 int wl1271_register_hw(struct wl1271 *wl)
2237 if (wl->mac80211_registered)
2240 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2242 ret = ieee80211_register_hw(wl->hw);
2244 wl1271_error("unable to register mac80211 hw: %d", ret);
2248 wl->mac80211_registered = true;
2250 wl1271_notice("loaded");
2254 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2256 void wl1271_unregister_hw(struct wl1271 *wl)
2258 ieee80211_unregister_hw(wl->hw);
2259 wl->mac80211_registered = false;
2262 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2264 int wl1271_init_ieee80211(struct wl1271 *wl)
2266 /* The tx descriptor buffer and the TKIP space. */
2267 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2268 sizeof(struct wl1271_tx_hw_descr);
2271 /* FIXME: find a proper value */
2272 wl->hw->channel_change_time = 10000;
2273 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2275 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2276 IEEE80211_HW_NOISE_DBM |
2277 IEEE80211_HW_BEACON_FILTER |
2278 IEEE80211_HW_SUPPORTS_PS |
2279 IEEE80211_HW_SUPPORTS_UAPSD |
2280 IEEE80211_HW_HAS_RATE_CONTROL |
2281 IEEE80211_HW_CONNECTION_MONITOR;
2283 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2284 BIT(NL80211_IFTYPE_ADHOC);
2285 wl->hw->wiphy->max_scan_ssids = 1;
2286 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2288 if (wl1271_11a_enabled())
2289 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2292 wl->hw->max_rates = 1;
2294 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2298 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2300 #define WL1271_DEFAULT_CHANNEL 0
2302 struct ieee80211_hw *wl1271_alloc_hw(void)
2304 struct ieee80211_hw *hw;
2305 struct platform_device *plat_dev = NULL;
2309 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2311 wl1271_error("could not alloc ieee80211_hw");
2316 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2318 wl1271_error("could not allocate platform_device");
2320 goto err_plat_alloc;
2323 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2326 memset(wl, 0, sizeof(*wl));
2328 INIT_LIST_HEAD(&wl->list);
2331 wl->plat_dev = plat_dev;
2333 skb_queue_head_init(&wl->tx_queue);
2335 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2336 wl->channel = WL1271_DEFAULT_CHANNEL;
2337 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2338 wl->default_key = 0;
2340 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2341 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2342 wl->psm_entry_retry = 0;
2343 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2344 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2345 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2346 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2347 wl->sta_rate_set = 0;
2348 wl->band = IEEE80211_BAND_2GHZ;
2351 wl->sg_enabled = true;
2353 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2354 wl->tx_frames[i] = NULL;
2356 spin_lock_init(&wl->wl_lock);
2358 wl->state = WL1271_STATE_OFF;
2359 mutex_init(&wl->mutex);
2361 /* Apply default driver configuration. */
2362 wl1271_conf_init(wl);
2364 wl1271_debugfs_init(wl);
2366 /* Register platform device */
2367 ret = platform_device_register(wl->plat_dev);
2369 wl1271_error("couldn't register platform device");
2372 dev_set_drvdata(&wl->plat_dev->dev, wl);
2374 /* Create sysfs file to control bt coex state */
2375 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2377 wl1271_error("failed to create sysfs file bt_coex_state");
2384 platform_device_unregister(wl->plat_dev);
2387 wl1271_debugfs_exit(wl);
2391 ieee80211_free_hw(hw);
2395 return ERR_PTR(ret);
2397 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2399 int wl1271_free_hw(struct wl1271 *wl)
2401 platform_device_unregister(wl->plat_dev);
2402 kfree(wl->plat_dev);
2404 wl1271_debugfs_exit(wl);
2411 kfree(wl->fw_status);
2412 kfree(wl->tx_res_if);
2414 ieee80211_free_hw(wl->hw);
2418 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2420 MODULE_LICENSE("GPL");
2421 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2422 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");