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_join_channel(struct wl1271 *wl, int channel)
1124 /* we need to use a dummy BSSID for now */
1125 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1128 wl->channel = channel;
1129 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1131 /* pass through frames from all BSS */
1132 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1134 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1138 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1144 static int wl1271_unjoin_channel(struct wl1271 *wl)
1148 /* to stop listening to a channel, we disconnect */
1149 ret = wl1271_cmd_disconnect(wl);
1153 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1155 memset(wl->bssid, 0, ETH_ALEN);
1157 /* stop filterting packets based on bssid */
1158 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1164 static void wl1271_set_band_rate(struct wl1271 *wl)
1166 if (wl->band == IEEE80211_BAND_2GHZ)
1167 wl->basic_rate_set = wl->conf.tx.basic_rate;
1169 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1172 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1177 if (!wl->basic_rate_set) {
1179 wl->basic_rate_set = wl->conf.tx.basic_rate;
1182 for (i = 0; !rate; i++) {
1183 if ((wl->basic_rate_set >> i) & 0x1)
1190 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1192 struct wl1271 *wl = hw->priv;
1193 struct ieee80211_conf *conf = &hw->conf;
1194 int channel, ret = 0;
1196 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1198 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1200 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1202 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1204 mutex_lock(&wl->mutex);
1206 if (unlikely(wl->state == WL1271_STATE_OFF))
1209 ret = wl1271_ps_elp_wakeup(wl, false);
1213 /* if the channel changes while joined, join again */
1214 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1215 wl->band = conf->channel->band;
1216 wl->channel = channel;
1219 * FIXME: the mac80211 should really provide a fixed rate
1220 * to use here. for now, just use the smallest possible rate
1221 * for the band as a fixed rate for association frames and
1222 * other control messages.
1224 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1225 wl1271_set_band_rate(wl);
1227 wl->basic_rate = wl1271_min_rate_get(wl);
1228 ret = wl1271_acx_rate_policies(wl);
1230 wl1271_warning("rate policy for update channel "
1233 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1234 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1236 wl1271_warning("cmd join to update channel "
1241 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1242 if (conf->flags & IEEE80211_CONF_IDLE &&
1243 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1244 wl1271_unjoin_channel(wl);
1245 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1246 wl1271_join_channel(wl, channel);
1248 if (conf->flags & IEEE80211_CONF_IDLE) {
1249 wl->rate_set = wl1271_min_rate_get(wl);
1250 wl->sta_rate_set = 0;
1251 wl1271_acx_rate_policies(wl);
1252 wl1271_acx_keep_alive_config(
1253 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1254 ACX_KEEP_ALIVE_TPL_INVALID);
1255 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1257 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1260 if (conf->flags & IEEE80211_CONF_PS &&
1261 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1262 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1265 * We enter PSM only if we're already associated.
1266 * If we're not, we'll enter it when joining an SSID,
1267 * through the bss_info_changed() hook.
1269 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1270 wl1271_debug(DEBUG_PSM, "psm enabled");
1271 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1274 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1275 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1276 wl1271_debug(DEBUG_PSM, "psm disabled");
1278 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1280 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1281 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1285 if (conf->power_level != wl->power_level) {
1286 ret = wl1271_acx_tx_power(wl, conf->power_level);
1290 wl->power_level = conf->power_level;
1294 wl1271_ps_elp_sleep(wl);
1297 mutex_unlock(&wl->mutex);
1302 struct wl1271_filter_params {
1305 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1308 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1309 struct netdev_hw_addr_list *mc_list)
1311 struct wl1271_filter_params *fp;
1312 struct netdev_hw_addr *ha;
1313 struct wl1271 *wl = hw->priv;
1315 if (unlikely(wl->state == WL1271_STATE_OFF))
1318 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1320 wl1271_error("Out of memory setting filters.");
1324 /* update multicast filtering parameters */
1325 fp->mc_list_length = 0;
1326 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1327 fp->enabled = false;
1330 netdev_hw_addr_list_for_each(ha, mc_list) {
1331 memcpy(fp->mc_list[fp->mc_list_length],
1332 ha->addr, ETH_ALEN);
1333 fp->mc_list_length++;
1337 return (u64)(unsigned long)fp;
1340 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1343 FIF_BCN_PRBRESP_PROMISC | \
1347 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1348 unsigned int changed,
1349 unsigned int *total, u64 multicast)
1351 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1352 struct wl1271 *wl = hw->priv;
1355 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1357 mutex_lock(&wl->mutex);
1359 *total &= WL1271_SUPPORTED_FILTERS;
1360 changed &= WL1271_SUPPORTED_FILTERS;
1362 if (unlikely(wl->state == WL1271_STATE_OFF))
1365 ret = wl1271_ps_elp_wakeup(wl, false);
1370 if (*total & FIF_ALLMULTI)
1371 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1373 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1375 fp->mc_list_length);
1379 /* determine, whether supported filter values have changed */
1383 /* configure filters */
1384 wl->filters = *total;
1385 wl1271_configure_filters(wl, 0);
1387 /* apply configured filters */
1388 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1393 wl1271_ps_elp_sleep(wl);
1396 mutex_unlock(&wl->mutex);
1400 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1401 struct ieee80211_vif *vif,
1402 struct ieee80211_sta *sta,
1403 struct ieee80211_key_conf *key_conf)
1405 struct wl1271 *wl = hw->priv;
1412 static const u8 bcast_addr[ETH_ALEN] =
1413 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1415 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1417 addr = sta ? sta->addr : bcast_addr;
1419 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1420 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1421 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1422 key_conf->alg, key_conf->keyidx,
1423 key_conf->keylen, key_conf->flags);
1424 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1426 if (is_zero_ether_addr(addr)) {
1427 /* We dont support TX only encryption */
1432 mutex_lock(&wl->mutex);
1434 ret = wl1271_ps_elp_wakeup(wl, false);
1438 switch (key_conf->alg) {
1442 key_conf->hw_key_idx = key_conf->keyidx;
1445 key_type = KEY_TKIP;
1447 key_conf->hw_key_idx = key_conf->keyidx;
1448 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1449 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1454 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1455 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1456 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1459 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1467 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1468 key_conf->keyidx, key_type,
1469 key_conf->keylen, key_conf->key,
1470 addr, tx_seq_32, tx_seq_16);
1472 wl1271_error("Could not add or replace key");
1476 /* the default WEP key needs to be configured at least once */
1477 if (key_type == KEY_WEP) {
1478 ret = wl1271_cmd_set_default_wep_key(wl,
1486 /* The wl1271 does not allow to remove unicast keys - they
1487 will be cleared automatically on next CMD_JOIN. Ignore the
1488 request silently, as we dont want the mac80211 to emit
1489 an error message. */
1490 if (!is_broadcast_ether_addr(addr))
1493 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1494 key_conf->keyidx, key_type,
1495 key_conf->keylen, key_conf->key,
1498 wl1271_error("Could not remove key");
1504 wl1271_error("Unsupported key cmd 0x%x", cmd);
1512 wl1271_ps_elp_sleep(wl);
1515 mutex_unlock(&wl->mutex);
1521 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1522 struct cfg80211_scan_request *req)
1524 struct wl1271 *wl = hw->priv;
1529 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1532 ssid = req->ssids[0].ssid;
1533 len = req->ssids[0].ssid_len;
1536 mutex_lock(&wl->mutex);
1538 ret = wl1271_ps_elp_wakeup(wl, false);
1542 if (wl1271_11a_enabled())
1543 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1544 req->ie, req->ie_len, 1, 0,
1545 WL1271_SCAN_BAND_DUAL, 3);
1547 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1548 req->ie, req->ie_len, 1, 0,
1549 WL1271_SCAN_BAND_2_4_GHZ, 3);
1551 wl1271_ps_elp_sleep(wl);
1554 mutex_unlock(&wl->mutex);
1559 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1561 struct wl1271 *wl = hw->priv;
1564 mutex_lock(&wl->mutex);
1566 if (unlikely(wl->state == WL1271_STATE_OFF))
1569 ret = wl1271_ps_elp_wakeup(wl, false);
1573 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1575 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1577 wl1271_ps_elp_sleep(wl);
1580 mutex_unlock(&wl->mutex);
1585 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1587 u8 *ptr = beacon->data +
1588 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1590 /* find the location of the ssid in the beacon */
1591 while (ptr < beacon->data + beacon->len) {
1592 if (ptr[0] == WLAN_EID_SSID) {
1593 wl->ssid_len = ptr[1];
1594 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1599 wl1271_error("ad-hoc beacon template has no SSID!\n");
1602 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1603 struct ieee80211_vif *vif,
1604 struct ieee80211_bss_conf *bss_conf,
1607 enum wl1271_cmd_ps_mode mode;
1608 struct wl1271 *wl = hw->priv;
1609 bool do_join = false;
1610 bool do_keepalive = false;
1613 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1615 mutex_lock(&wl->mutex);
1617 ret = wl1271_ps_elp_wakeup(wl, false);
1621 if ((changed && BSS_CHANGED_BEACON_INT) &&
1622 (wl->bss_type == BSS_TYPE_IBSS)) {
1623 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1624 bss_conf->beacon_int);
1626 wl->beacon_int = bss_conf->beacon_int;
1630 if ((changed && BSS_CHANGED_BEACON) &&
1631 (wl->bss_type == BSS_TYPE_IBSS)) {
1632 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1634 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1637 struct ieee80211_hdr *hdr;
1639 wl1271_ssid_set(wl, beacon);
1640 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1643 wl1271_min_rate_get(wl));
1646 dev_kfree_skb(beacon);
1650 hdr = (struct ieee80211_hdr *) beacon->data;
1651 hdr->frame_control = cpu_to_le16(
1652 IEEE80211_FTYPE_MGMT |
1653 IEEE80211_STYPE_PROBE_RESP);
1655 ret = wl1271_cmd_template_set(wl,
1656 CMD_TEMPL_PROBE_RESPONSE,
1659 wl1271_min_rate_get(wl));
1660 dev_kfree_skb(beacon);
1664 /* Need to update the SSID (for filtering etc) */
1669 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1670 (wl->bss_type == BSS_TYPE_IBSS)) {
1671 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1672 bss_conf->enable_beacon ? "enabled" : "disabled");
1674 if (bss_conf->enable_beacon)
1675 wl->set_bss_type = BSS_TYPE_IBSS;
1677 wl->set_bss_type = BSS_TYPE_STA_BSS;
1681 if (changed & BSS_CHANGED_CQM) {
1682 bool enable = false;
1683 if (bss_conf->cqm_rssi_thold)
1685 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1686 bss_conf->cqm_rssi_thold,
1687 bss_conf->cqm_rssi_hyst);
1690 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1693 if ((changed & BSS_CHANGED_BSSID) &&
1695 * Now we know the correct bssid, so we send a new join command
1696 * and enable the BSSID filter
1698 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1699 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1701 ret = wl1271_cmd_build_null_data(wl);
1705 /* filter out all packets not from this BSSID */
1706 wl1271_configure_filters(wl, 0);
1708 /* Need to update the BSSID (for filtering etc) */
1712 if (changed & BSS_CHANGED_ASSOC) {
1713 if (bss_conf->assoc) {
1715 wl->aid = bss_conf->aid;
1716 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1719 * use basic rates from AP, and determine lowest rate
1720 * to use with control frames.
1722 rates = bss_conf->basic_rates;
1723 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1725 wl->basic_rate = wl1271_min_rate_get(wl);
1726 ret = wl1271_acx_rate_policies(wl);
1731 * with wl1271, we don't need to update the
1732 * beacon_int and dtim_period, because the firmware
1733 * updates it by itself when the first beacon is
1734 * received after a join.
1736 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1741 * The SSID is intentionally set to NULL here - the
1742 * firmware will set the probe request with a
1743 * broadcast SSID regardless of what we set in the
1746 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1749 /* Enable the keep-alive feature */
1750 ret = wl1271_acx_keep_alive_mode(wl, true);
1755 * This is awkward. The keep-alive configs must be done
1756 * *after* the join command, because otherwise it will
1757 * not work, but it must only be done *once* because
1758 * otherwise the firmware will start complaining.
1760 do_keepalive = true;
1762 /* enable the connection monitoring feature */
1763 ret = wl1271_acx_conn_monit_params(wl, true);
1767 /* If we want to go in PSM but we're not there yet */
1768 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1769 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1770 mode = STATION_POWER_SAVE_MODE;
1771 ret = wl1271_ps_set_mode(wl, mode, true);
1776 /* use defaults when not associated */
1777 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1780 /* revert back to minimum rates for the current band */
1781 wl1271_set_band_rate(wl);
1782 wl->basic_rate = wl1271_min_rate_get(wl);
1783 ret = wl1271_acx_rate_policies(wl);
1787 /* disable connection monitor features */
1788 ret = wl1271_acx_conn_monit_params(wl, false);
1790 /* Disable the keep-alive feature */
1791 ret = wl1271_acx_keep_alive_mode(wl, false);
1799 if (changed & BSS_CHANGED_ERP_SLOT) {
1800 if (bss_conf->use_short_slot)
1801 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1803 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1805 wl1271_warning("Set slot time failed %d", ret);
1810 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1811 if (bss_conf->use_short_preamble)
1812 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1814 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1817 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1818 if (bss_conf->use_cts_prot)
1819 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1821 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1823 wl1271_warning("Set ctsprotect failed %d", ret);
1829 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1831 wl1271_warning("cmd join failed %d", ret);
1834 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1838 * The JOIN operation shuts down the firmware keep-alive as a side
1839 * effect, and the ACX_AID will start the keep-alive as a side effect.
1840 * Hence, for non-IBSS, the ACX_AID must always happen *after* the
1841 * JOIN operation, and the template config after the ACX_AID.
1843 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1844 ret = wl1271_acx_aid(wl, wl->aid);
1850 ret = wl1271_cmd_build_klv_null_data(wl);
1853 ret = wl1271_acx_keep_alive_config(
1854 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1855 ACX_KEEP_ALIVE_TPL_VALID);
1861 wl1271_ps_elp_sleep(wl);
1864 mutex_unlock(&wl->mutex);
1867 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1868 const struct ieee80211_tx_queue_params *params)
1870 struct wl1271 *wl = hw->priv;
1874 mutex_lock(&wl->mutex);
1876 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1878 ret = wl1271_ps_elp_wakeup(wl, false);
1882 /* the txop is confed in units of 32us by the mac80211, we need us */
1883 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1884 params->cw_min, params->cw_max,
1885 params->aifs, params->txop << 5);
1890 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1892 ps_scheme = CONF_PS_SCHEME_LEGACY;
1894 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1895 CONF_CHANNEL_TYPE_EDCF,
1896 wl1271_tx_get_queue(queue),
1897 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1902 wl1271_ps_elp_sleep(wl);
1905 mutex_unlock(&wl->mutex);
1911 /* can't be const, mac80211 writes to this */
1912 static struct ieee80211_rate wl1271_rates[] = {
1914 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1915 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1917 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1918 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1919 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1921 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1922 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1923 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1925 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1926 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1927 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1929 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1930 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1932 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1933 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1935 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1936 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1938 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1939 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1941 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1942 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1944 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1945 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1947 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1948 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1950 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1951 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1954 /* can't be const, mac80211 writes to this */
1955 static struct ieee80211_channel wl1271_channels[] = {
1956 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1957 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1958 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1959 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1960 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1961 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1962 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1963 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1964 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1965 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1966 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1967 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1968 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1971 /* mapping to indexes for wl1271_rates */
1972 const static u8 wl1271_rate_to_idx_2ghz[] = {
1973 /* MCS rates are used only with 11n */
1974 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1975 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1976 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1977 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
1978 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
1979 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
1980 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
1981 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
1983 11, /* CONF_HW_RXTX_RATE_54 */
1984 10, /* CONF_HW_RXTX_RATE_48 */
1985 9, /* CONF_HW_RXTX_RATE_36 */
1986 8, /* CONF_HW_RXTX_RATE_24 */
1988 /* TI-specific rate */
1989 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
1991 7, /* CONF_HW_RXTX_RATE_18 */
1992 6, /* CONF_HW_RXTX_RATE_12 */
1993 3, /* CONF_HW_RXTX_RATE_11 */
1994 5, /* CONF_HW_RXTX_RATE_9 */
1995 4, /* CONF_HW_RXTX_RATE_6 */
1996 2, /* CONF_HW_RXTX_RATE_5_5 */
1997 1, /* CONF_HW_RXTX_RATE_2 */
1998 0 /* CONF_HW_RXTX_RATE_1 */
2001 /* can't be const, mac80211 writes to this */
2002 static struct ieee80211_supported_band wl1271_band_2ghz = {
2003 .channels = wl1271_channels,
2004 .n_channels = ARRAY_SIZE(wl1271_channels),
2005 .bitrates = wl1271_rates,
2006 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2009 /* 5 GHz data rates for WL1273 */
2010 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2012 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2013 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2015 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2016 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2018 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2019 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2021 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2022 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2024 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2025 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2027 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2028 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2030 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2031 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2033 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2034 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2037 /* 5 GHz band channels for WL1273 */
2038 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2039 { .hw_value = 183, .center_freq = 4915},
2040 { .hw_value = 184, .center_freq = 4920},
2041 { .hw_value = 185, .center_freq = 4925},
2042 { .hw_value = 187, .center_freq = 4935},
2043 { .hw_value = 188, .center_freq = 4940},
2044 { .hw_value = 189, .center_freq = 4945},
2045 { .hw_value = 192, .center_freq = 4960},
2046 { .hw_value = 196, .center_freq = 4980},
2047 { .hw_value = 7, .center_freq = 5035},
2048 { .hw_value = 8, .center_freq = 5040},
2049 { .hw_value = 9, .center_freq = 5045},
2050 { .hw_value = 11, .center_freq = 5055},
2051 { .hw_value = 12, .center_freq = 5060},
2052 { .hw_value = 16, .center_freq = 5080},
2053 { .hw_value = 34, .center_freq = 5170},
2054 { .hw_value = 36, .center_freq = 5180},
2055 { .hw_value = 38, .center_freq = 5190},
2056 { .hw_value = 40, .center_freq = 5200},
2057 { .hw_value = 42, .center_freq = 5210},
2058 { .hw_value = 44, .center_freq = 5220},
2059 { .hw_value = 46, .center_freq = 5230},
2060 { .hw_value = 48, .center_freq = 5240},
2061 { .hw_value = 52, .center_freq = 5260},
2062 { .hw_value = 56, .center_freq = 5280},
2063 { .hw_value = 60, .center_freq = 5300},
2064 { .hw_value = 64, .center_freq = 5320},
2065 { .hw_value = 100, .center_freq = 5500},
2066 { .hw_value = 104, .center_freq = 5520},
2067 { .hw_value = 108, .center_freq = 5540},
2068 { .hw_value = 112, .center_freq = 5560},
2069 { .hw_value = 116, .center_freq = 5580},
2070 { .hw_value = 120, .center_freq = 5600},
2071 { .hw_value = 124, .center_freq = 5620},
2072 { .hw_value = 128, .center_freq = 5640},
2073 { .hw_value = 132, .center_freq = 5660},
2074 { .hw_value = 136, .center_freq = 5680},
2075 { .hw_value = 140, .center_freq = 5700},
2076 { .hw_value = 149, .center_freq = 5745},
2077 { .hw_value = 153, .center_freq = 5765},
2078 { .hw_value = 157, .center_freq = 5785},
2079 { .hw_value = 161, .center_freq = 5805},
2080 { .hw_value = 165, .center_freq = 5825},
2083 /* mapping to indexes for wl1271_rates_5ghz */
2084 const static u8 wl1271_rate_to_idx_5ghz[] = {
2085 /* MCS rates are used only with 11n */
2086 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2087 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2088 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2089 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2090 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2091 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2092 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2093 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2095 7, /* CONF_HW_RXTX_RATE_54 */
2096 6, /* CONF_HW_RXTX_RATE_48 */
2097 5, /* CONF_HW_RXTX_RATE_36 */
2098 4, /* CONF_HW_RXTX_RATE_24 */
2100 /* TI-specific rate */
2101 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2103 3, /* CONF_HW_RXTX_RATE_18 */
2104 2, /* CONF_HW_RXTX_RATE_12 */
2105 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2106 1, /* CONF_HW_RXTX_RATE_9 */
2107 0, /* CONF_HW_RXTX_RATE_6 */
2108 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2109 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2110 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2113 static struct ieee80211_supported_band wl1271_band_5ghz = {
2114 .channels = wl1271_channels_5ghz,
2115 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2116 .bitrates = wl1271_rates_5ghz,
2117 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2120 const static u8 *wl1271_band_rate_to_idx[] = {
2121 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2122 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2125 static const struct ieee80211_ops wl1271_ops = {
2126 .start = wl1271_op_start,
2127 .stop = wl1271_op_stop,
2128 .add_interface = wl1271_op_add_interface,
2129 .remove_interface = wl1271_op_remove_interface,
2130 .config = wl1271_op_config,
2131 .prepare_multicast = wl1271_op_prepare_multicast,
2132 .configure_filter = wl1271_op_configure_filter,
2134 .set_key = wl1271_op_set_key,
2135 .hw_scan = wl1271_op_hw_scan,
2136 .bss_info_changed = wl1271_op_bss_info_changed,
2137 .set_rts_threshold = wl1271_op_set_rts_threshold,
2138 .conf_tx = wl1271_op_conf_tx,
2139 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2143 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2147 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2149 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2150 wl1271_error("Illegal RX rate from HW: %d", rate);
2154 idx = wl1271_band_rate_to_idx[wl->band][rate];
2155 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2156 wl1271_error("Unsupported RX rate from HW: %d", rate);
2163 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2164 struct device_attribute *attr,
2167 struct wl1271 *wl = dev_get_drvdata(dev);
2170 /* FIXME: what's the maximum length of buf? page size?*/
2173 mutex_lock(&wl->mutex);
2174 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2176 mutex_unlock(&wl->mutex);
2182 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2183 struct device_attribute *attr,
2184 const char *buf, size_t count)
2186 struct wl1271 *wl = dev_get_drvdata(dev);
2190 ret = strict_strtoul(buf, 10, &res);
2193 wl1271_warning("incorrect value written to bt_coex_mode");
2197 mutex_lock(&wl->mutex);
2201 if (res == wl->sg_enabled)
2204 wl->sg_enabled = res;
2206 if (wl->state == WL1271_STATE_OFF)
2209 ret = wl1271_ps_elp_wakeup(wl, false);
2213 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2214 wl1271_ps_elp_sleep(wl);
2217 mutex_unlock(&wl->mutex);
2221 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2222 wl1271_sysfs_show_bt_coex_state,
2223 wl1271_sysfs_store_bt_coex_state);
2225 int wl1271_register_hw(struct wl1271 *wl)
2229 if (wl->mac80211_registered)
2232 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2234 ret = ieee80211_register_hw(wl->hw);
2236 wl1271_error("unable to register mac80211 hw: %d", ret);
2240 wl->mac80211_registered = true;
2242 wl1271_notice("loaded");
2246 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2248 void wl1271_unregister_hw(struct wl1271 *wl)
2250 ieee80211_unregister_hw(wl->hw);
2251 wl->mac80211_registered = false;
2254 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2256 int wl1271_init_ieee80211(struct wl1271 *wl)
2258 /* The tx descriptor buffer and the TKIP space. */
2259 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2260 sizeof(struct wl1271_tx_hw_descr);
2263 /* FIXME: find a proper value */
2264 wl->hw->channel_change_time = 10000;
2265 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2267 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2268 IEEE80211_HW_NOISE_DBM |
2269 IEEE80211_HW_BEACON_FILTER |
2270 IEEE80211_HW_SUPPORTS_PS |
2271 IEEE80211_HW_SUPPORTS_UAPSD |
2272 IEEE80211_HW_HAS_RATE_CONTROL |
2273 IEEE80211_HW_CONNECTION_MONITOR |
2274 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2276 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2277 BIT(NL80211_IFTYPE_ADHOC);
2278 wl->hw->wiphy->max_scan_ssids = 1;
2279 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2281 if (wl1271_11a_enabled())
2282 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2285 wl->hw->max_rates = 1;
2287 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2291 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2293 #define WL1271_DEFAULT_CHANNEL 0
2295 struct ieee80211_hw *wl1271_alloc_hw(void)
2297 struct ieee80211_hw *hw;
2298 struct platform_device *plat_dev = NULL;
2302 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2304 wl1271_error("could not alloc ieee80211_hw");
2309 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2311 wl1271_error("could not allocate platform_device");
2313 goto err_plat_alloc;
2316 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2319 memset(wl, 0, sizeof(*wl));
2321 INIT_LIST_HEAD(&wl->list);
2324 wl->plat_dev = plat_dev;
2326 skb_queue_head_init(&wl->tx_queue);
2328 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2329 wl->channel = WL1271_DEFAULT_CHANNEL;
2330 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2331 wl->default_key = 0;
2333 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2334 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2335 wl->psm_entry_retry = 0;
2336 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2337 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2338 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2339 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2340 wl->sta_rate_set = 0;
2341 wl->band = IEEE80211_BAND_2GHZ;
2344 wl->sg_enabled = true;
2346 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2347 wl->tx_frames[i] = NULL;
2349 spin_lock_init(&wl->wl_lock);
2351 wl->state = WL1271_STATE_OFF;
2352 mutex_init(&wl->mutex);
2354 /* Apply default driver configuration. */
2355 wl1271_conf_init(wl);
2357 wl1271_debugfs_init(wl);
2359 /* Register platform device */
2360 ret = platform_device_register(wl->plat_dev);
2362 wl1271_error("couldn't register platform device");
2365 dev_set_drvdata(&wl->plat_dev->dev, wl);
2367 /* Create sysfs file to control bt coex state */
2368 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2370 wl1271_error("failed to create sysfs file bt_coex_state");
2377 platform_device_unregister(wl->plat_dev);
2380 wl1271_debugfs_exit(wl);
2384 ieee80211_free_hw(hw);
2388 return ERR_PTR(ret);
2390 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2392 int wl1271_free_hw(struct wl1271 *wl)
2394 platform_device_unregister(wl->plat_dev);
2395 kfree(wl->plat_dev);
2397 wl1271_debugfs_exit(wl);
2404 kfree(wl->fw_status);
2405 kfree(wl->tx_res_if);
2407 ieee80211_free_hw(wl->hw);
2411 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2413 MODULE_LICENSE("GPL");
2414 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2415 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");