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 .bet_enable = CONF_BET_MODE_ENABLE,
238 .bet_max_consecutive = 10,
239 .psm_entry_retries = 3,
240 .keep_alive_interval = 55000,
241 .max_listen_interval = 20,
253 .host_clk_settling_time = 5000,
254 .host_fast_wakeup_support = false
257 /* FIXME: due to firmware bug, must use value 1 for now */
259 .avg_weight_rssi_beacon = 20,
260 .avg_weight_rssi_data = 10,
261 .avg_weight_snr_beacon = 20,
262 .avg_weight_snr_data = 10
266 static void wl1271_device_release(struct device *dev)
271 static struct platform_device wl1271_device = {
275 /* device model insists to have a release function */
277 .release = wl1271_device_release,
281 static LIST_HEAD(wl_list);
283 static void wl1271_conf_init(struct wl1271 *wl)
287 * This function applies the default configuration to the driver. This
288 * function is invoked upon driver load (spi probe.)
290 * The configuration is stored in a run-time structure in order to
291 * facilitate for run-time adjustment of any of the parameters. Making
292 * changes to the configuration structure will apply the new values on
293 * the next interface up (wl1271_op_start.)
296 /* apply driver default configuration */
297 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
301 static int wl1271_plt_init(struct wl1271 *wl)
303 struct conf_tx_ac_category *conf_ac;
304 struct conf_tx_tid *conf_tid;
307 ret = wl1271_cmd_general_parms(wl);
311 ret = wl1271_cmd_radio_parms(wl);
315 ret = wl1271_init_templates_config(wl);
319 ret = wl1271_acx_init_mem_config(wl);
323 /* PHY layer config */
324 ret = wl1271_init_phy_config(wl);
326 goto out_free_memmap;
328 ret = wl1271_acx_dco_itrim_params(wl);
330 goto out_free_memmap;
332 /* Initialize connection monitoring thresholds */
333 ret = wl1271_acx_conn_monit_params(wl, false);
335 goto out_free_memmap;
337 /* Bluetooth WLAN coexistence */
338 ret = wl1271_init_pta(wl);
340 goto out_free_memmap;
342 /* Energy detection */
343 ret = wl1271_init_energy_detection(wl);
345 goto out_free_memmap;
347 /* Default fragmentation threshold */
348 ret = wl1271_acx_frag_threshold(wl);
350 goto out_free_memmap;
352 /* Default TID configuration */
353 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
354 conf_tid = &wl->conf.tx.tid_conf[i];
355 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
356 conf_tid->channel_type,
359 conf_tid->ack_policy,
360 conf_tid->apsd_conf[0],
361 conf_tid->apsd_conf[1]);
363 goto out_free_memmap;
366 /* Default AC configuration */
367 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
368 conf_ac = &wl->conf.tx.ac_conf[i];
369 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
370 conf_ac->cw_max, conf_ac->aifsn,
371 conf_ac->tx_op_limit);
373 goto out_free_memmap;
376 /* Enable data path */
377 ret = wl1271_cmd_data_path(wl, 1);
379 goto out_free_memmap;
381 /* Configure for CAM power saving (ie. always active) */
382 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
384 goto out_free_memmap;
387 ret = wl1271_acx_pm_config(wl);
389 goto out_free_memmap;
394 kfree(wl->target_mem_map);
395 wl->target_mem_map = NULL;
400 static void wl1271_fw_status(struct wl1271 *wl,
401 struct wl1271_fw_status *status)
407 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
409 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
410 "drv_rx_counter = %d, tx_results_counter = %d)",
412 status->fw_rx_counter,
413 status->drv_rx_counter,
414 status->tx_results_counter);
416 /* update number of available TX blocks */
417 for (i = 0; i < NUM_TX_QUEUES; i++) {
418 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
419 wl->tx_blocks_freed[i];
421 wl->tx_blocks_freed[i] =
422 le32_to_cpu(status->tx_released_blks[i]);
423 wl->tx_blocks_available += cnt;
427 /* if more blocks are available now, schedule some tx work */
428 if (total && !skb_queue_empty(&wl->tx_queue))
429 ieee80211_queue_work(wl->hw, &wl->tx_work);
431 /* update the host-chipset time offset */
433 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
434 (s64)le32_to_cpu(status->fw_localtime);
437 #define WL1271_IRQ_MAX_LOOPS 10
439 static void wl1271_irq_work(struct work_struct *work)
443 int loopcount = WL1271_IRQ_MAX_LOOPS;
446 container_of(work, struct wl1271, irq_work);
448 mutex_lock(&wl->mutex);
450 wl1271_debug(DEBUG_IRQ, "IRQ work");
452 if (unlikely(wl->state == WL1271_STATE_OFF))
455 ret = wl1271_ps_elp_wakeup(wl, true);
459 spin_lock_irqsave(&wl->wl_lock, flags);
460 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
461 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
462 spin_unlock_irqrestore(&wl->wl_lock, flags);
465 wl1271_fw_status(wl, wl->fw_status);
466 intr = le32_to_cpu(wl->fw_status->intr);
468 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
469 spin_lock_irqsave(&wl->wl_lock, flags);
473 intr &= WL1271_INTR_MASK;
475 if (intr & WL1271_ACX_INTR_DATA) {
476 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
478 /* check for tx results */
479 if (wl->fw_status->tx_results_counter !=
480 (wl->tx_results_count & 0xff))
481 wl1271_tx_complete(wl);
483 wl1271_rx(wl, wl->fw_status);
486 if (intr & WL1271_ACX_INTR_EVENT_A) {
487 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
488 wl1271_event_handle(wl, 0);
491 if (intr & WL1271_ACX_INTR_EVENT_B) {
492 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
493 wl1271_event_handle(wl, 1);
496 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
497 wl1271_debug(DEBUG_IRQ,
498 "WL1271_ACX_INTR_INIT_COMPLETE");
500 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
501 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
503 spin_lock_irqsave(&wl->wl_lock, flags);
506 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
507 ieee80211_queue_work(wl->hw, &wl->irq_work);
509 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
510 spin_unlock_irqrestore(&wl->wl_lock, flags);
512 wl1271_ps_elp_sleep(wl);
515 mutex_unlock(&wl->mutex);
518 static int wl1271_fetch_firmware(struct wl1271 *wl)
520 const struct firmware *fw;
523 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
526 wl1271_error("could not get firmware: %d", ret);
531 wl1271_error("firmware size is not multiple of 32 bits: %zu",
537 wl->fw_len = fw->size;
538 wl->fw = vmalloc(wl->fw_len);
541 wl1271_error("could not allocate memory for the firmware");
546 memcpy(wl->fw, fw->data, wl->fw_len);
551 release_firmware(fw);
556 static int wl1271_fetch_nvs(struct wl1271 *wl)
558 const struct firmware *fw;
561 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
564 wl1271_error("could not get nvs file: %d", ret);
568 if (fw->size != sizeof(struct wl1271_nvs_file)) {
569 wl1271_error("nvs size is not as expected: %zu != %zu",
570 fw->size, sizeof(struct wl1271_nvs_file));
575 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
578 wl1271_error("could not allocate memory for the nvs file");
583 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
586 release_firmware(fw);
591 static void wl1271_fw_wakeup(struct wl1271 *wl)
595 elp_reg = ELPCTRL_WAKE_UP;
596 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
599 static int wl1271_setup(struct wl1271 *wl)
601 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
605 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
606 if (!wl->tx_res_if) {
607 kfree(wl->fw_status);
611 INIT_WORK(&wl->irq_work, wl1271_irq_work);
612 INIT_WORK(&wl->tx_work, wl1271_tx_work);
616 static int wl1271_chip_wakeup(struct wl1271 *wl)
618 struct wl1271_partition_set partition;
621 msleep(WL1271_PRE_POWER_ON_SLEEP);
623 msleep(WL1271_POWER_ON_SLEEP);
627 /* We don't need a real memory partition here, because we only want
628 * to use the registers at this point. */
629 memset(&partition, 0, sizeof(partition));
630 partition.reg.start = REGISTERS_BASE;
631 partition.reg.size = REGISTERS_DOWN_SIZE;
632 wl1271_set_partition(wl, &partition);
634 /* ELP module wake up */
635 wl1271_fw_wakeup(wl);
637 /* whal_FwCtrl_BootSm() */
639 /* 0. read chip id from CHIP_ID */
640 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
642 /* 1. check if chip id is valid */
644 switch (wl->chip.id) {
645 case CHIP_ID_1271_PG10:
646 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
649 ret = wl1271_setup(wl);
653 case CHIP_ID_1271_PG20:
654 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
657 ret = wl1271_setup(wl);
662 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
667 if (wl->fw == NULL) {
668 ret = wl1271_fetch_firmware(wl);
673 /* No NVS from netlink, try to get it from the filesystem */
674 if (wl->nvs == NULL) {
675 ret = wl1271_fetch_nvs(wl);
684 int wl1271_plt_start(struct wl1271 *wl)
686 int retries = WL1271_BOOT_RETRIES;
689 mutex_lock(&wl->mutex);
691 wl1271_notice("power up");
693 if (wl->state != WL1271_STATE_OFF) {
694 wl1271_error("cannot go into PLT state because not "
695 "in off state: %d", wl->state);
702 ret = wl1271_chip_wakeup(wl);
706 ret = wl1271_boot(wl);
710 ret = wl1271_plt_init(wl);
714 wl->state = WL1271_STATE_PLT;
715 wl1271_notice("firmware booted in PLT mode (%s)",
720 wl1271_disable_interrupts(wl);
721 mutex_unlock(&wl->mutex);
722 /* Unlocking the mutex in the middle of handling is
723 inherently unsafe. In this case we deem it safe to do,
724 because we need to let any possibly pending IRQ out of
725 the system (and while we are WL1271_STATE_OFF the IRQ
726 work function will not do anything.) Also, any other
727 possible concurrent operations will fail due to the
728 current state, hence the wl1271 struct should be safe. */
729 cancel_work_sync(&wl->irq_work);
730 mutex_lock(&wl->mutex);
732 wl1271_power_off(wl);
735 wl1271_error("firmware boot in PLT mode failed despite %d retries",
736 WL1271_BOOT_RETRIES);
738 mutex_unlock(&wl->mutex);
743 int wl1271_plt_stop(struct wl1271 *wl)
747 mutex_lock(&wl->mutex);
749 wl1271_notice("power down");
751 if (wl->state != WL1271_STATE_PLT) {
752 wl1271_error("cannot power down because not in PLT "
753 "state: %d", wl->state);
758 wl1271_disable_interrupts(wl);
759 wl1271_power_off(wl);
761 wl->state = WL1271_STATE_OFF;
765 mutex_unlock(&wl->mutex);
771 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
773 struct wl1271 *wl = hw->priv;
774 struct ieee80211_conf *conf = &hw->conf;
775 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
776 struct ieee80211_sta *sta = txinfo->control.sta;
779 /* peek into the rates configured in the STA entry */
780 spin_lock_irqsave(&wl->wl_lock, flags);
781 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
782 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
783 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
785 spin_unlock_irqrestore(&wl->wl_lock, flags);
787 /* queue the packet */
788 skb_queue_tail(&wl->tx_queue, skb);
791 * The chip specific setup must run before the first TX packet -
792 * before that, the tx_work will not be initialized!
795 ieee80211_queue_work(wl->hw, &wl->tx_work);
798 * The workqueue is slow to process the tx_queue and we need stop
799 * the queue here, otherwise the queue will get too long.
801 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
802 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
804 spin_lock_irqsave(&wl->wl_lock, flags);
805 ieee80211_stop_queues(wl->hw);
806 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
807 spin_unlock_irqrestore(&wl->wl_lock, flags);
813 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
816 struct net_device *dev;
817 struct wireless_dev *wdev;
819 struct ieee80211_hw *hw;
821 struct wl1271 *wl_temp;
822 struct in_device *idev;
823 struct in_ifaddr *ifa = arg;
826 /* FIXME: this ugly function should probably be implemented in the
827 * mac80211, and here should only be a simple callback handling actual
828 * setting of the filters. Now we need to dig up references to
829 * various structures to gain access to what we need.
830 * Also, because of this, there is no "initial" setting of the filter
831 * in "op_start", because we don't want to dig up struct net_device
832 * there - the filter will be set upon first change of the interface
835 dev = ifa->ifa_dev->dev;
837 wdev = dev->ieee80211_ptr;
845 hw = wiphy_priv(wiphy);
849 /* Check that the interface is one supported by this driver. */
851 list_for_each_entry(wl, &wl_list, list) {
858 /* Get the interface IP address for the device. "ifa" will become
860 - there is no IPV4 protocol address configured
861 - there are multiple (virtual) IPV4 addresses configured
862 When "ifa" is NULL, filtering will be disabled.
867 ifa = idev->ifa_list;
869 if (ifa && ifa->ifa_next)
872 mutex_lock(&wl->mutex);
874 if (wl->state == WL1271_STATE_OFF)
877 ret = wl1271_ps_elp_wakeup(wl, false);
881 ret = wl1271_acx_arp_ip_filter(wl, true,
882 (u8 *)&ifa->ifa_address,
885 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
887 wl1271_ps_elp_sleep(wl);
890 mutex_unlock(&wl->mutex);
895 static struct notifier_block wl1271_dev_notifier = {
896 .notifier_call = wl1271_dev_notify,
900 static int wl1271_op_start(struct ieee80211_hw *hw)
902 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
905 * We have to delay the booting of the hardware because
906 * we need to know the local MAC address before downloading and
907 * initializing the firmware. The MAC address cannot be changed
908 * after boot, and without the proper MAC address, the firmware
909 * will not function properly.
911 * The MAC address is first known when the corresponding interface
912 * is added. That is where we will initialize the hardware.
918 static void wl1271_op_stop(struct ieee80211_hw *hw)
920 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
923 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
924 struct ieee80211_vif *vif)
926 struct wl1271 *wl = hw->priv;
927 int retries = WL1271_BOOT_RETRIES;
930 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
931 vif->type, vif->addr);
933 mutex_lock(&wl->mutex);
942 case NL80211_IFTYPE_STATION:
943 wl->bss_type = BSS_TYPE_STA_BSS;
944 wl->set_bss_type = BSS_TYPE_STA_BSS;
946 case NL80211_IFTYPE_ADHOC:
947 wl->bss_type = BSS_TYPE_IBSS;
948 wl->set_bss_type = BSS_TYPE_STA_BSS;
955 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
957 if (wl->state != WL1271_STATE_OFF) {
958 wl1271_error("cannot start because not in off state: %d",
966 ret = wl1271_chip_wakeup(wl);
970 ret = wl1271_boot(wl);
974 ret = wl1271_hw_init(wl);
978 wl->state = WL1271_STATE_ON;
979 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
983 wl1271_disable_interrupts(wl);
984 mutex_unlock(&wl->mutex);
985 /* Unlocking the mutex in the middle of handling is
986 inherently unsafe. In this case we deem it safe to do,
987 because we need to let any possibly pending IRQ out of
988 the system (and while we are WL1271_STATE_OFF the IRQ
989 work function will not do anything.) Also, any other
990 possible concurrent operations will fail due to the
991 current state, hence the wl1271 struct should be safe. */
992 cancel_work_sync(&wl->irq_work);
993 mutex_lock(&wl->mutex);
995 wl1271_power_off(wl);
998 wl1271_error("firmware boot failed despite %d retries",
999 WL1271_BOOT_RETRIES);
1001 mutex_unlock(&wl->mutex);
1004 list_add(&wl->list, &wl_list);
1005 register_inetaddr_notifier(&wl1271_dev_notifier);
1011 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1012 struct ieee80211_vif *vif)
1014 struct wl1271 *wl = hw->priv;
1017 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1019 mutex_lock(&wl->mutex);
1020 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1022 wl1271_info("down");
1024 list_del(&wl->list);
1026 WARN_ON(wl->state != WL1271_STATE_ON);
1028 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1029 mutex_unlock(&wl->mutex);
1030 ieee80211_scan_completed(wl->hw, true);
1031 mutex_lock(&wl->mutex);
1034 wl->state = WL1271_STATE_OFF;
1036 wl1271_disable_interrupts(wl);
1038 mutex_unlock(&wl->mutex);
1040 cancel_work_sync(&wl->irq_work);
1041 cancel_work_sync(&wl->tx_work);
1043 mutex_lock(&wl->mutex);
1045 /* let's notify MAC80211 about the remaining pending TX frames */
1046 wl1271_tx_flush(wl);
1047 wl1271_power_off(wl);
1049 memset(wl->bssid, 0, ETH_ALEN);
1050 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1052 wl->bss_type = MAX_BSS_TYPE;
1053 wl->set_bss_type = MAX_BSS_TYPE;
1054 wl->band = IEEE80211_BAND_2GHZ;
1057 wl->psm_entry_retry = 0;
1058 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1059 wl->tx_blocks_available = 0;
1060 wl->tx_results_count = 0;
1061 wl->tx_packets_count = 0;
1062 wl->tx_security_last_seq = 0;
1063 wl->tx_security_seq = 0;
1064 wl->time_offset = 0;
1065 wl->session_counter = 0;
1066 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1067 wl->sta_rate_set = 0;
1072 for (i = 0; i < NUM_TX_QUEUES; i++)
1073 wl->tx_blocks_freed[i] = 0;
1075 wl1271_debugfs_reset(wl);
1077 kfree(wl->fw_status);
1078 wl->fw_status = NULL;
1079 kfree(wl->tx_res_if);
1080 wl->tx_res_if = NULL;
1081 kfree(wl->target_mem_map);
1082 wl->target_mem_map = NULL;
1084 mutex_unlock(&wl->mutex);
1087 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1089 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1090 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1092 /* combine requested filters with current filter config */
1093 filters = wl->filters | filters;
1095 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1097 if (filters & FIF_PROMISC_IN_BSS) {
1098 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1099 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1100 wl->rx_config |= CFG_BSSID_FILTER_EN;
1102 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1103 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1104 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1105 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1107 if (filters & FIF_OTHER_BSS) {
1108 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1109 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1111 if (filters & FIF_CONTROL) {
1112 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1113 wl->rx_filter |= CFG_RX_CTL_EN;
1115 if (filters & FIF_FCSFAIL) {
1116 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1117 wl->rx_filter |= CFG_RX_FCS_ERROR;
1121 static int wl1271_dummy_join(struct wl1271 *wl)
1124 /* we need to use a dummy BSSID for now */
1125 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1128 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1130 /* pass through frames from all BSS */
1131 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1133 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1137 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1143 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1148 * One of the side effects of the JOIN command is that is clears
1149 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1150 * to a WPA/WPA2 access point will therefore kill the data-path.
1151 * Currently there is no supported scenario for JOIN during
1152 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1153 * must be handled somehow.
1156 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1157 wl1271_info("JOIN while associated.");
1160 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1162 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1166 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1168 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1172 * The join command disable the keep-alive mode, shut down its process,
1173 * and also clear the template config, so we need to reset it all after
1174 * the join. The acx_aid starts the keep-alive process, and the order
1175 * of the commands below is relevant.
1177 ret = wl1271_acx_keep_alive_mode(wl, true);
1181 ret = wl1271_acx_aid(wl, wl->aid);
1185 ret = wl1271_cmd_build_klv_null_data(wl);
1189 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1190 ACX_KEEP_ALIVE_TPL_VALID);
1198 static int wl1271_unjoin(struct wl1271 *wl)
1202 /* to stop listening to a channel, we disconnect */
1203 ret = wl1271_cmd_disconnect(wl);
1207 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1208 memset(wl->bssid, 0, ETH_ALEN);
1210 /* stop filterting packets based on bssid */
1211 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1217 static void wl1271_set_band_rate(struct wl1271 *wl)
1219 if (wl->band == IEEE80211_BAND_2GHZ)
1220 wl->basic_rate_set = wl->conf.tx.basic_rate;
1222 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1225 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1230 if (!wl->basic_rate_set) {
1232 wl->basic_rate_set = wl->conf.tx.basic_rate;
1235 for (i = 0; !rate; i++) {
1236 if ((wl->basic_rate_set >> i) & 0x1)
1243 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1245 struct wl1271 *wl = hw->priv;
1246 struct ieee80211_conf *conf = &hw->conf;
1247 int channel, ret = 0;
1249 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1251 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1253 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1255 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1257 mutex_lock(&wl->mutex);
1259 if (unlikely(wl->state == WL1271_STATE_OFF))
1262 ret = wl1271_ps_elp_wakeup(wl, false);
1266 /* if the channel changes while joined, join again */
1267 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1268 ((wl->band != conf->channel->band) ||
1269 (wl->channel != channel))) {
1270 wl->band = conf->channel->band;
1271 wl->channel = channel;
1274 * FIXME: the mac80211 should really provide a fixed rate
1275 * to use here. for now, just use the smallest possible rate
1276 * for the band as a fixed rate for association frames and
1277 * other control messages.
1279 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1280 wl1271_set_band_rate(wl);
1282 wl->basic_rate = wl1271_min_rate_get(wl);
1283 ret = wl1271_acx_rate_policies(wl);
1285 wl1271_warning("rate policy for update channel "
1288 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1289 ret = wl1271_join(wl, false);
1291 wl1271_warning("cmd join to update channel "
1296 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1297 if (conf->flags & IEEE80211_CONF_IDLE &&
1298 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1300 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1301 wl1271_dummy_join(wl);
1303 if (conf->flags & IEEE80211_CONF_IDLE) {
1304 wl->rate_set = wl1271_min_rate_get(wl);
1305 wl->sta_rate_set = 0;
1306 wl1271_acx_rate_policies(wl);
1307 wl1271_acx_keep_alive_config(
1308 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1309 ACX_KEEP_ALIVE_TPL_INVALID);
1310 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1312 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1315 if (conf->flags & IEEE80211_CONF_PS &&
1316 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1317 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1320 * We enter PSM only if we're already associated.
1321 * If we're not, we'll enter it when joining an SSID,
1322 * through the bss_info_changed() hook.
1324 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1325 wl1271_debug(DEBUG_PSM, "psm enabled");
1326 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1329 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1330 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1331 wl1271_debug(DEBUG_PSM, "psm disabled");
1333 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1335 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1336 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1340 if (conf->power_level != wl->power_level) {
1341 ret = wl1271_acx_tx_power(wl, conf->power_level);
1345 wl->power_level = conf->power_level;
1349 wl1271_ps_elp_sleep(wl);
1352 mutex_unlock(&wl->mutex);
1357 struct wl1271_filter_params {
1360 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1363 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1364 struct dev_addr_list *mc_list)
1366 struct wl1271_filter_params *fp;
1367 struct wl1271 *wl = hw->priv;
1370 if (unlikely(wl->state == WL1271_STATE_OFF))
1373 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1375 wl1271_error("Out of memory setting filters.");
1379 /* update multicast filtering parameters */
1381 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1383 fp->enabled = false;
1386 fp->mc_list_length = 0;
1387 for (i = 0; i < mc_count; i++) {
1388 if (mc_list->da_addrlen == ETH_ALEN) {
1389 memcpy(fp->mc_list[fp->mc_list_length],
1390 mc_list->da_addr, ETH_ALEN);
1391 fp->mc_list_length++;
1393 wl1271_warning("Unknown mc address length.");
1394 mc_list = mc_list->next;
1397 return (u64)(unsigned long)fp;
1400 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1403 FIF_BCN_PRBRESP_PROMISC | \
1407 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1408 unsigned int changed,
1409 unsigned int *total, u64 multicast)
1411 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1412 struct wl1271 *wl = hw->priv;
1415 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1417 mutex_lock(&wl->mutex);
1419 *total &= WL1271_SUPPORTED_FILTERS;
1420 changed &= WL1271_SUPPORTED_FILTERS;
1422 if (unlikely(wl->state == WL1271_STATE_OFF))
1425 ret = wl1271_ps_elp_wakeup(wl, false);
1430 if (*total & FIF_ALLMULTI)
1431 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1433 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1435 fp->mc_list_length);
1439 /* determine, whether supported filter values have changed */
1443 /* configure filters */
1444 wl->filters = *total;
1445 wl1271_configure_filters(wl, 0);
1447 /* apply configured filters */
1448 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1453 wl1271_ps_elp_sleep(wl);
1456 mutex_unlock(&wl->mutex);
1460 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1461 struct ieee80211_vif *vif,
1462 struct ieee80211_sta *sta,
1463 struct ieee80211_key_conf *key_conf)
1465 struct wl1271 *wl = hw->priv;
1472 static const u8 bcast_addr[ETH_ALEN] =
1473 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1475 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1477 addr = sta ? sta->addr : bcast_addr;
1479 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1480 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1481 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1482 key_conf->alg, key_conf->keyidx,
1483 key_conf->keylen, key_conf->flags);
1484 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1486 if (is_zero_ether_addr(addr)) {
1487 /* We dont support TX only encryption */
1492 mutex_lock(&wl->mutex);
1494 ret = wl1271_ps_elp_wakeup(wl, false);
1498 switch (key_conf->alg) {
1502 key_conf->hw_key_idx = key_conf->keyidx;
1505 key_type = KEY_TKIP;
1507 key_conf->hw_key_idx = key_conf->keyidx;
1508 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1509 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1514 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1515 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1516 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1519 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1527 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1528 key_conf->keyidx, key_type,
1529 key_conf->keylen, key_conf->key,
1530 addr, tx_seq_32, tx_seq_16);
1532 wl1271_error("Could not add or replace key");
1536 /* the default WEP key needs to be configured at least once */
1537 if (key_type == KEY_WEP) {
1538 ret = wl1271_cmd_set_default_wep_key(wl,
1546 /* The wl1271 does not allow to remove unicast keys - they
1547 will be cleared automatically on next CMD_JOIN. Ignore the
1548 request silently, as we dont want the mac80211 to emit
1549 an error message. */
1550 if (!is_broadcast_ether_addr(addr))
1553 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1554 key_conf->keyidx, key_type,
1555 key_conf->keylen, key_conf->key,
1558 wl1271_error("Could not remove key");
1564 wl1271_error("Unsupported key cmd 0x%x", cmd);
1572 wl1271_ps_elp_sleep(wl);
1575 mutex_unlock(&wl->mutex);
1581 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1582 struct ieee80211_vif *vif,
1583 struct cfg80211_scan_request *req)
1585 struct wl1271 *wl = hw->priv;
1590 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1593 ssid = req->ssids[0].ssid;
1594 len = req->ssids[0].ssid_len;
1597 mutex_lock(&wl->mutex);
1599 ret = wl1271_ps_elp_wakeup(wl, false);
1603 if (wl1271_11a_enabled())
1604 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1605 req->ie, req->ie_len, 1, 0,
1606 WL1271_SCAN_BAND_DUAL, 3);
1608 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1609 req->ie, req->ie_len, 1, 0,
1610 WL1271_SCAN_BAND_2_4_GHZ, 3);
1612 wl1271_ps_elp_sleep(wl);
1615 mutex_unlock(&wl->mutex);
1620 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1622 struct wl1271 *wl = hw->priv;
1625 mutex_lock(&wl->mutex);
1627 if (unlikely(wl->state == WL1271_STATE_OFF))
1630 ret = wl1271_ps_elp_wakeup(wl, false);
1634 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1636 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1638 wl1271_ps_elp_sleep(wl);
1641 mutex_unlock(&wl->mutex);
1646 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1648 u8 *ptr = beacon->data +
1649 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1651 /* find the location of the ssid in the beacon */
1652 while (ptr < beacon->data + beacon->len) {
1653 if (ptr[0] == WLAN_EID_SSID) {
1654 wl->ssid_len = ptr[1];
1655 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1660 wl1271_error("ad-hoc beacon template has no SSID!\n");
1663 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1664 struct ieee80211_vif *vif,
1665 struct ieee80211_bss_conf *bss_conf,
1668 enum wl1271_cmd_ps_mode mode;
1669 struct wl1271 *wl = hw->priv;
1670 bool do_join = false;
1671 bool set_assoc = false;
1674 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1676 mutex_lock(&wl->mutex);
1678 ret = wl1271_ps_elp_wakeup(wl, false);
1682 if ((changed && BSS_CHANGED_BEACON_INT) &&
1683 (wl->bss_type == BSS_TYPE_IBSS)) {
1684 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1685 bss_conf->beacon_int);
1687 wl->beacon_int = bss_conf->beacon_int;
1691 if ((changed && BSS_CHANGED_BEACON) &&
1692 (wl->bss_type == BSS_TYPE_IBSS)) {
1693 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1695 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1698 struct ieee80211_hdr *hdr;
1700 wl1271_ssid_set(wl, beacon);
1701 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1704 wl1271_min_rate_get(wl));
1707 dev_kfree_skb(beacon);
1711 hdr = (struct ieee80211_hdr *) beacon->data;
1712 hdr->frame_control = cpu_to_le16(
1713 IEEE80211_FTYPE_MGMT |
1714 IEEE80211_STYPE_PROBE_RESP);
1716 ret = wl1271_cmd_template_set(wl,
1717 CMD_TEMPL_PROBE_RESPONSE,
1720 wl1271_min_rate_get(wl));
1721 dev_kfree_skb(beacon);
1725 /* Need to update the SSID (for filtering etc) */
1730 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1731 (wl->bss_type == BSS_TYPE_IBSS)) {
1732 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1733 bss_conf->enable_beacon ? "enabled" : "disabled");
1735 if (bss_conf->enable_beacon)
1736 wl->set_bss_type = BSS_TYPE_IBSS;
1738 wl->set_bss_type = BSS_TYPE_STA_BSS;
1742 if (changed & BSS_CHANGED_CQM) {
1743 bool enable = false;
1744 if (bss_conf->cqm_rssi_thold)
1746 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1747 bss_conf->cqm_rssi_thold,
1748 bss_conf->cqm_rssi_hyst);
1751 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1754 if ((changed & BSS_CHANGED_BSSID) &&
1756 * Now we know the correct bssid, so we send a new join command
1757 * and enable the BSSID filter
1759 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1760 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1762 ret = wl1271_cmd_build_null_data(wl);
1766 ret = wl1271_build_qos_null_data(wl);
1770 /* filter out all packets not from this BSSID */
1771 wl1271_configure_filters(wl, 0);
1773 /* Need to update the BSSID (for filtering etc) */
1777 if (changed & BSS_CHANGED_ASSOC) {
1778 if (bss_conf->assoc) {
1780 wl->aid = bss_conf->aid;
1784 * use basic rates from AP, and determine lowest rate
1785 * to use with control frames.
1787 rates = bss_conf->basic_rates;
1788 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1790 wl->basic_rate = wl1271_min_rate_get(wl);
1791 ret = wl1271_acx_rate_policies(wl);
1796 * with wl1271, we don't need to update the
1797 * beacon_int and dtim_period, because the firmware
1798 * updates it by itself when the first beacon is
1799 * received after a join.
1801 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1806 * The SSID is intentionally set to NULL here - the
1807 * firmware will set the probe request with a
1808 * broadcast SSID regardless of what we set in the
1811 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1814 /* enable the connection monitoring feature */
1815 ret = wl1271_acx_conn_monit_params(wl, true);
1819 /* If we want to go in PSM but we're not there yet */
1820 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1821 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1822 mode = STATION_POWER_SAVE_MODE;
1823 ret = wl1271_ps_set_mode(wl, mode, true);
1828 /* use defaults when not associated */
1829 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1832 /* revert back to minimum rates for the current band */
1833 wl1271_set_band_rate(wl);
1834 wl->basic_rate = wl1271_min_rate_get(wl);
1835 ret = wl1271_acx_rate_policies(wl);
1839 /* disable connection monitor features */
1840 ret = wl1271_acx_conn_monit_params(wl, false);
1842 /* Disable the keep-alive feature */
1843 ret = wl1271_acx_keep_alive_mode(wl, false);
1851 if (changed & BSS_CHANGED_ERP_SLOT) {
1852 if (bss_conf->use_short_slot)
1853 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1855 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1857 wl1271_warning("Set slot time failed %d", ret);
1862 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1863 if (bss_conf->use_short_preamble)
1864 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1866 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1869 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1870 if (bss_conf->use_cts_prot)
1871 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1873 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1875 wl1271_warning("Set ctsprotect failed %d", ret);
1881 ret = wl1271_join(wl, set_assoc);
1883 wl1271_warning("cmd join failed %d", ret);
1889 wl1271_ps_elp_sleep(wl);
1892 mutex_unlock(&wl->mutex);
1895 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1896 const struct ieee80211_tx_queue_params *params)
1898 struct wl1271 *wl = hw->priv;
1902 mutex_lock(&wl->mutex);
1904 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1906 ret = wl1271_ps_elp_wakeup(wl, false);
1910 /* the txop is confed in units of 32us by the mac80211, we need us */
1911 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1912 params->cw_min, params->cw_max,
1913 params->aifs, params->txop << 5);
1918 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1920 ps_scheme = CONF_PS_SCHEME_LEGACY;
1922 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1923 CONF_CHANNEL_TYPE_EDCF,
1924 wl1271_tx_get_queue(queue),
1925 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1930 wl1271_ps_elp_sleep(wl);
1933 mutex_unlock(&wl->mutex);
1939 /* can't be const, mac80211 writes to this */
1940 static struct ieee80211_rate wl1271_rates[] = {
1942 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1943 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1945 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1946 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1947 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1949 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1950 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1951 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1953 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1954 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1955 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1957 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1958 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1960 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1961 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1963 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1964 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1966 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1967 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1969 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1970 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1972 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1973 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1975 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1976 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1978 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1979 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1982 /* can't be const, mac80211 writes to this */
1983 static struct ieee80211_channel wl1271_channels[] = {
1984 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1985 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1986 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1987 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1988 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1989 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1990 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1991 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1992 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1993 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1994 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1995 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1996 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1999 /* mapping to indexes for wl1271_rates */
2000 const static u8 wl1271_rate_to_idx_2ghz[] = {
2001 /* MCS rates are used only with 11n */
2002 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2003 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2004 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2005 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2006 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2007 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2008 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2009 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2011 11, /* CONF_HW_RXTX_RATE_54 */
2012 10, /* CONF_HW_RXTX_RATE_48 */
2013 9, /* CONF_HW_RXTX_RATE_36 */
2014 8, /* CONF_HW_RXTX_RATE_24 */
2016 /* TI-specific rate */
2017 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2019 7, /* CONF_HW_RXTX_RATE_18 */
2020 6, /* CONF_HW_RXTX_RATE_12 */
2021 3, /* CONF_HW_RXTX_RATE_11 */
2022 5, /* CONF_HW_RXTX_RATE_9 */
2023 4, /* CONF_HW_RXTX_RATE_6 */
2024 2, /* CONF_HW_RXTX_RATE_5_5 */
2025 1, /* CONF_HW_RXTX_RATE_2 */
2026 0 /* CONF_HW_RXTX_RATE_1 */
2029 /* can't be const, mac80211 writes to this */
2030 static struct ieee80211_supported_band wl1271_band_2ghz = {
2031 .channels = wl1271_channels,
2032 .n_channels = ARRAY_SIZE(wl1271_channels),
2033 .bitrates = wl1271_rates,
2034 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2037 /* 5 GHz data rates for WL1273 */
2038 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2040 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2041 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2043 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2044 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2046 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2047 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2049 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2050 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2052 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2053 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2055 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2056 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2058 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2059 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2061 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2062 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2065 /* 5 GHz band channels for WL1273 */
2066 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2067 { .hw_value = 183, .center_freq = 4915},
2068 { .hw_value = 184, .center_freq = 4920},
2069 { .hw_value = 185, .center_freq = 4925},
2070 { .hw_value = 187, .center_freq = 4935},
2071 { .hw_value = 188, .center_freq = 4940},
2072 { .hw_value = 189, .center_freq = 4945},
2073 { .hw_value = 192, .center_freq = 4960},
2074 { .hw_value = 196, .center_freq = 4980},
2075 { .hw_value = 7, .center_freq = 5035},
2076 { .hw_value = 8, .center_freq = 5040},
2077 { .hw_value = 9, .center_freq = 5045},
2078 { .hw_value = 11, .center_freq = 5055},
2079 { .hw_value = 12, .center_freq = 5060},
2080 { .hw_value = 16, .center_freq = 5080},
2081 { .hw_value = 34, .center_freq = 5170},
2082 { .hw_value = 36, .center_freq = 5180},
2083 { .hw_value = 38, .center_freq = 5190},
2084 { .hw_value = 40, .center_freq = 5200},
2085 { .hw_value = 42, .center_freq = 5210},
2086 { .hw_value = 44, .center_freq = 5220},
2087 { .hw_value = 46, .center_freq = 5230},
2088 { .hw_value = 48, .center_freq = 5240},
2089 { .hw_value = 52, .center_freq = 5260},
2090 { .hw_value = 56, .center_freq = 5280},
2091 { .hw_value = 60, .center_freq = 5300},
2092 { .hw_value = 64, .center_freq = 5320},
2093 { .hw_value = 100, .center_freq = 5500},
2094 { .hw_value = 104, .center_freq = 5520},
2095 { .hw_value = 108, .center_freq = 5540},
2096 { .hw_value = 112, .center_freq = 5560},
2097 { .hw_value = 116, .center_freq = 5580},
2098 { .hw_value = 120, .center_freq = 5600},
2099 { .hw_value = 124, .center_freq = 5620},
2100 { .hw_value = 128, .center_freq = 5640},
2101 { .hw_value = 132, .center_freq = 5660},
2102 { .hw_value = 136, .center_freq = 5680},
2103 { .hw_value = 140, .center_freq = 5700},
2104 { .hw_value = 149, .center_freq = 5745},
2105 { .hw_value = 153, .center_freq = 5765},
2106 { .hw_value = 157, .center_freq = 5785},
2107 { .hw_value = 161, .center_freq = 5805},
2108 { .hw_value = 165, .center_freq = 5825},
2111 /* mapping to indexes for wl1271_rates_5ghz */
2112 const static u8 wl1271_rate_to_idx_5ghz[] = {
2113 /* MCS rates are used only with 11n */
2114 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2115 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2116 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2117 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2118 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2119 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2120 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2121 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2123 7, /* CONF_HW_RXTX_RATE_54 */
2124 6, /* CONF_HW_RXTX_RATE_48 */
2125 5, /* CONF_HW_RXTX_RATE_36 */
2126 4, /* CONF_HW_RXTX_RATE_24 */
2128 /* TI-specific rate */
2129 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2131 3, /* CONF_HW_RXTX_RATE_18 */
2132 2, /* CONF_HW_RXTX_RATE_12 */
2133 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2134 1, /* CONF_HW_RXTX_RATE_9 */
2135 0, /* CONF_HW_RXTX_RATE_6 */
2136 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2137 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2138 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2141 static struct ieee80211_supported_band wl1271_band_5ghz = {
2142 .channels = wl1271_channels_5ghz,
2143 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2144 .bitrates = wl1271_rates_5ghz,
2145 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2148 const static u8 *wl1271_band_rate_to_idx[] = {
2149 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2150 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2153 static const struct ieee80211_ops wl1271_ops = {
2154 .start = wl1271_op_start,
2155 .stop = wl1271_op_stop,
2156 .add_interface = wl1271_op_add_interface,
2157 .remove_interface = wl1271_op_remove_interface,
2158 .config = wl1271_op_config,
2159 .prepare_multicast = wl1271_op_prepare_multicast,
2160 .configure_filter = wl1271_op_configure_filter,
2162 .set_key = wl1271_op_set_key,
2163 .hw_scan = wl1271_op_hw_scan,
2164 .bss_info_changed = wl1271_op_bss_info_changed,
2165 .set_rts_threshold = wl1271_op_set_rts_threshold,
2166 .conf_tx = wl1271_op_conf_tx,
2167 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2171 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2175 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2177 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2178 wl1271_error("Illegal RX rate from HW: %d", rate);
2182 idx = wl1271_band_rate_to_idx[wl->band][rate];
2183 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2184 wl1271_error("Unsupported RX rate from HW: %d", rate);
2191 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2192 struct device_attribute *attr,
2195 struct wl1271 *wl = dev_get_drvdata(dev);
2198 /* FIXME: what's the maximum length of buf? page size?*/
2201 mutex_lock(&wl->mutex);
2202 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2204 mutex_unlock(&wl->mutex);
2210 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2211 struct device_attribute *attr,
2212 const char *buf, size_t count)
2214 struct wl1271 *wl = dev_get_drvdata(dev);
2218 ret = strict_strtoul(buf, 10, &res);
2221 wl1271_warning("incorrect value written to bt_coex_mode");
2225 mutex_lock(&wl->mutex);
2229 if (res == wl->sg_enabled)
2232 wl->sg_enabled = res;
2234 if (wl->state == WL1271_STATE_OFF)
2237 ret = wl1271_ps_elp_wakeup(wl, false);
2241 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2242 wl1271_ps_elp_sleep(wl);
2245 mutex_unlock(&wl->mutex);
2249 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2250 wl1271_sysfs_show_bt_coex_state,
2251 wl1271_sysfs_store_bt_coex_state);
2253 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2254 struct device_attribute *attr,
2257 struct wl1271 *wl = dev_get_drvdata(dev);
2260 /* FIXME: what's the maximum length of buf? page size?*/
2263 mutex_lock(&wl->mutex);
2264 if (wl->hw_pg_ver >= 0)
2265 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2267 len = snprintf(buf, len, "n/a\n");
2268 mutex_unlock(&wl->mutex);
2273 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2274 wl1271_sysfs_show_hw_pg_ver, NULL);
2276 int wl1271_register_hw(struct wl1271 *wl)
2280 if (wl->mac80211_registered)
2283 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2285 ret = ieee80211_register_hw(wl->hw);
2287 wl1271_error("unable to register mac80211 hw: %d", ret);
2291 wl->mac80211_registered = true;
2293 wl1271_notice("loaded");
2297 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2299 void wl1271_unregister_hw(struct wl1271 *wl)
2301 ieee80211_unregister_hw(wl->hw);
2302 wl->mac80211_registered = false;
2305 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2307 int wl1271_init_ieee80211(struct wl1271 *wl)
2309 /* The tx descriptor buffer and the TKIP space. */
2310 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2311 sizeof(struct wl1271_tx_hw_descr);
2314 /* FIXME: find a proper value */
2315 wl->hw->channel_change_time = 10000;
2316 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2318 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2319 IEEE80211_HW_BEACON_FILTER |
2320 IEEE80211_HW_SUPPORTS_PS |
2321 IEEE80211_HW_SUPPORTS_UAPSD |
2322 IEEE80211_HW_HAS_RATE_CONTROL |
2323 IEEE80211_HW_CONNECTION_MONITOR |
2324 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2326 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2327 BIT(NL80211_IFTYPE_ADHOC);
2328 wl->hw->wiphy->max_scan_ssids = 1;
2329 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2331 if (wl1271_11a_enabled())
2332 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2335 wl->hw->max_rates = 1;
2337 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2341 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2343 #define WL1271_DEFAULT_CHANNEL 0
2345 struct ieee80211_hw *wl1271_alloc_hw(void)
2347 struct ieee80211_hw *hw;
2348 struct platform_device *plat_dev = NULL;
2352 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2354 wl1271_error("could not alloc ieee80211_hw");
2359 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2361 wl1271_error("could not allocate platform_device");
2363 goto err_plat_alloc;
2366 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2369 memset(wl, 0, sizeof(*wl));
2371 INIT_LIST_HEAD(&wl->list);
2374 wl->plat_dev = plat_dev;
2376 skb_queue_head_init(&wl->tx_queue);
2378 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2379 wl->channel = WL1271_DEFAULT_CHANNEL;
2380 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2381 wl->default_key = 0;
2383 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2384 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2385 wl->psm_entry_retry = 0;
2386 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2387 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2388 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2389 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2390 wl->sta_rate_set = 0;
2391 wl->band = IEEE80211_BAND_2GHZ;
2394 wl->sg_enabled = true;
2397 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2398 wl->tx_frames[i] = NULL;
2400 spin_lock_init(&wl->wl_lock);
2402 wl->state = WL1271_STATE_OFF;
2403 mutex_init(&wl->mutex);
2405 /* Apply default driver configuration. */
2406 wl1271_conf_init(wl);
2408 wl1271_debugfs_init(wl);
2410 /* Register platform device */
2411 ret = platform_device_register(wl->plat_dev);
2413 wl1271_error("couldn't register platform device");
2416 dev_set_drvdata(&wl->plat_dev->dev, wl);
2418 /* Create sysfs file to control bt coex state */
2419 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2421 wl1271_error("failed to create sysfs file bt_coex_state");
2425 /* Create sysfs file to get HW PG version */
2426 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2428 wl1271_error("failed to create sysfs file hw_pg_ver");
2429 goto err_bt_coex_state;
2435 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2438 platform_device_unregister(wl->plat_dev);
2441 wl1271_debugfs_exit(wl);
2445 ieee80211_free_hw(hw);
2449 return ERR_PTR(ret);
2451 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2453 int wl1271_free_hw(struct wl1271 *wl)
2455 platform_device_unregister(wl->plat_dev);
2456 kfree(wl->plat_dev);
2458 wl1271_debugfs_exit(wl);
2465 kfree(wl->fw_status);
2466 kfree(wl->tx_res_if);
2468 ieee80211_free_hw(wl->hw);
2472 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2474 MODULE_LICENSE("GPL");
2475 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2476 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");