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.");
470 spin_lock_irqsave(&wl->wl_lock, flags);
474 intr &= WL1271_INTR_MASK;
476 if (intr & WL1271_ACX_INTR_DATA) {
477 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
479 /* check for tx results */
480 if (wl->fw_status->tx_results_counter !=
481 (wl->tx_results_count & 0xff))
482 wl1271_tx_complete(wl);
484 wl1271_rx(wl, wl->fw_status);
487 if (intr & WL1271_ACX_INTR_EVENT_A) {
488 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
489 wl1271_event_handle(wl, 0);
492 if (intr & WL1271_ACX_INTR_EVENT_B) {
493 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
494 wl1271_event_handle(wl, 1);
497 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
498 wl1271_debug(DEBUG_IRQ,
499 "WL1271_ACX_INTR_INIT_COMPLETE");
501 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
502 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
504 spin_lock_irqsave(&wl->wl_lock, flags);
507 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
508 ieee80211_queue_work(wl->hw, &wl->irq_work);
510 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
511 spin_unlock_irqrestore(&wl->wl_lock, flags);
513 wl1271_ps_elp_sleep(wl);
516 mutex_unlock(&wl->mutex);
519 static int wl1271_fetch_firmware(struct wl1271 *wl)
521 const struct firmware *fw;
524 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
527 wl1271_error("could not get firmware: %d", ret);
532 wl1271_error("firmware size is not multiple of 32 bits: %zu",
538 wl->fw_len = fw->size;
539 wl->fw = vmalloc(wl->fw_len);
542 wl1271_error("could not allocate memory for the firmware");
547 memcpy(wl->fw, fw->data, wl->fw_len);
552 release_firmware(fw);
557 static int wl1271_fetch_nvs(struct wl1271 *wl)
559 const struct firmware *fw;
562 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
565 wl1271_error("could not get nvs file: %d", ret);
569 if (fw->size != sizeof(struct wl1271_nvs_file)) {
570 wl1271_error("nvs size is not as expected: %zu != %zu",
571 fw->size, sizeof(struct wl1271_nvs_file));
576 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
579 wl1271_error("could not allocate memory for the nvs file");
584 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
587 release_firmware(fw);
592 static void wl1271_fw_wakeup(struct wl1271 *wl)
596 elp_reg = ELPCTRL_WAKE_UP;
597 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
600 static int wl1271_setup(struct wl1271 *wl)
602 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
606 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
607 if (!wl->tx_res_if) {
608 kfree(wl->fw_status);
612 INIT_WORK(&wl->irq_work, wl1271_irq_work);
613 INIT_WORK(&wl->tx_work, wl1271_tx_work);
617 static int wl1271_chip_wakeup(struct wl1271 *wl)
619 struct wl1271_partition_set partition;
622 msleep(WL1271_PRE_POWER_ON_SLEEP);
624 msleep(WL1271_POWER_ON_SLEEP);
628 /* We don't need a real memory partition here, because we only want
629 * to use the registers at this point. */
630 memset(&partition, 0, sizeof(partition));
631 partition.reg.start = REGISTERS_BASE;
632 partition.reg.size = REGISTERS_DOWN_SIZE;
633 wl1271_set_partition(wl, &partition);
635 /* ELP module wake up */
636 wl1271_fw_wakeup(wl);
638 /* whal_FwCtrl_BootSm() */
640 /* 0. read chip id from CHIP_ID */
641 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
643 /* 1. check if chip id is valid */
645 switch (wl->chip.id) {
646 case CHIP_ID_1271_PG10:
647 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
650 ret = wl1271_setup(wl);
654 case CHIP_ID_1271_PG20:
655 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
658 ret = wl1271_setup(wl);
663 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
668 if (wl->fw == NULL) {
669 ret = wl1271_fetch_firmware(wl);
674 /* No NVS from netlink, try to get it from the filesystem */
675 if (wl->nvs == NULL) {
676 ret = wl1271_fetch_nvs(wl);
685 int wl1271_plt_start(struct wl1271 *wl)
687 int retries = WL1271_BOOT_RETRIES;
690 mutex_lock(&wl->mutex);
692 wl1271_notice("power up");
694 if (wl->state != WL1271_STATE_OFF) {
695 wl1271_error("cannot go into PLT state because not "
696 "in off state: %d", wl->state);
703 ret = wl1271_chip_wakeup(wl);
707 ret = wl1271_boot(wl);
711 ret = wl1271_plt_init(wl);
715 wl->state = WL1271_STATE_PLT;
716 wl1271_notice("firmware booted in PLT mode (%s)",
721 wl1271_disable_interrupts(wl);
722 mutex_unlock(&wl->mutex);
723 /* Unlocking the mutex in the middle of handling is
724 inherently unsafe. In this case we deem it safe to do,
725 because we need to let any possibly pending IRQ out of
726 the system (and while we are WL1271_STATE_OFF the IRQ
727 work function will not do anything.) Also, any other
728 possible concurrent operations will fail due to the
729 current state, hence the wl1271 struct should be safe. */
730 cancel_work_sync(&wl->irq_work);
731 mutex_lock(&wl->mutex);
733 wl1271_power_off(wl);
736 wl1271_error("firmware boot in PLT mode failed despite %d retries",
737 WL1271_BOOT_RETRIES);
739 mutex_unlock(&wl->mutex);
744 int wl1271_plt_stop(struct wl1271 *wl)
748 mutex_lock(&wl->mutex);
750 wl1271_notice("power down");
752 if (wl->state != WL1271_STATE_PLT) {
753 wl1271_error("cannot power down because not in PLT "
754 "state: %d", wl->state);
759 wl1271_disable_interrupts(wl);
760 wl1271_power_off(wl);
762 wl->state = WL1271_STATE_OFF;
766 mutex_unlock(&wl->mutex);
772 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
774 struct wl1271 *wl = hw->priv;
775 struct ieee80211_conf *conf = &hw->conf;
776 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
777 struct ieee80211_sta *sta = txinfo->control.sta;
780 /* peek into the rates configured in the STA entry */
781 spin_lock_irqsave(&wl->wl_lock, flags);
782 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
783 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
784 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
786 spin_unlock_irqrestore(&wl->wl_lock, flags);
788 /* queue the packet */
789 skb_queue_tail(&wl->tx_queue, skb);
792 * The chip specific setup must run before the first TX packet -
793 * before that, the tx_work will not be initialized!
796 ieee80211_queue_work(wl->hw, &wl->tx_work);
799 * The workqueue is slow to process the tx_queue and we need stop
800 * the queue here, otherwise the queue will get too long.
802 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
803 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
805 spin_lock_irqsave(&wl->wl_lock, flags);
806 ieee80211_stop_queues(wl->hw);
807 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
808 spin_unlock_irqrestore(&wl->wl_lock, flags);
814 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
817 struct net_device *dev;
818 struct wireless_dev *wdev;
820 struct ieee80211_hw *hw;
822 struct wl1271 *wl_temp;
823 struct in_device *idev;
824 struct in_ifaddr *ifa = arg;
827 /* FIXME: this ugly function should probably be implemented in the
828 * mac80211, and here should only be a simple callback handling actual
829 * setting of the filters. Now we need to dig up references to
830 * various structures to gain access to what we need.
831 * Also, because of this, there is no "initial" setting of the filter
832 * in "op_start", because we don't want to dig up struct net_device
833 * there - the filter will be set upon first change of the interface
836 dev = ifa->ifa_dev->dev;
838 wdev = dev->ieee80211_ptr;
846 hw = wiphy_priv(wiphy);
850 /* Check that the interface is one supported by this driver. */
852 list_for_each_entry(wl, &wl_list, list) {
859 /* Get the interface IP address for the device. "ifa" will become
861 - there is no IPV4 protocol address configured
862 - there are multiple (virtual) IPV4 addresses configured
863 When "ifa" is NULL, filtering will be disabled.
868 ifa = idev->ifa_list;
870 if (ifa && ifa->ifa_next)
873 mutex_lock(&wl->mutex);
875 if (wl->state == WL1271_STATE_OFF)
878 ret = wl1271_ps_elp_wakeup(wl, false);
882 ret = wl1271_acx_arp_ip_filter(wl, true,
883 (u8 *)&ifa->ifa_address,
886 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
888 wl1271_ps_elp_sleep(wl);
891 mutex_unlock(&wl->mutex);
896 static struct notifier_block wl1271_dev_notifier = {
897 .notifier_call = wl1271_dev_notify,
901 static int wl1271_op_start(struct ieee80211_hw *hw)
903 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
906 * We have to delay the booting of the hardware because
907 * we need to know the local MAC address before downloading and
908 * initializing the firmware. The MAC address cannot be changed
909 * after boot, and without the proper MAC address, the firmware
910 * will not function properly.
912 * The MAC address is first known when the corresponding interface
913 * is added. That is where we will initialize the hardware.
919 static void wl1271_op_stop(struct ieee80211_hw *hw)
921 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
924 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
925 struct ieee80211_vif *vif)
927 struct wl1271 *wl = hw->priv;
928 int retries = WL1271_BOOT_RETRIES;
931 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
932 vif->type, vif->addr);
934 mutex_lock(&wl->mutex);
943 case NL80211_IFTYPE_STATION:
944 wl->bss_type = BSS_TYPE_STA_BSS;
945 wl->set_bss_type = BSS_TYPE_STA_BSS;
947 case NL80211_IFTYPE_ADHOC:
948 wl->bss_type = BSS_TYPE_IBSS;
949 wl->set_bss_type = BSS_TYPE_STA_BSS;
956 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
958 if (wl->state != WL1271_STATE_OFF) {
959 wl1271_error("cannot start because not in off state: %d",
967 ret = wl1271_chip_wakeup(wl);
971 ret = wl1271_boot(wl);
975 ret = wl1271_hw_init(wl);
979 wl->state = WL1271_STATE_ON;
980 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
984 wl1271_disable_interrupts(wl);
985 mutex_unlock(&wl->mutex);
986 /* Unlocking the mutex in the middle of handling is
987 inherently unsafe. In this case we deem it safe to do,
988 because we need to let any possibly pending IRQ out of
989 the system (and while we are WL1271_STATE_OFF the IRQ
990 work function will not do anything.) Also, any other
991 possible concurrent operations will fail due to the
992 current state, hence the wl1271 struct should be safe. */
993 cancel_work_sync(&wl->irq_work);
994 mutex_lock(&wl->mutex);
996 wl1271_power_off(wl);
999 wl1271_error("firmware boot failed despite %d retries",
1000 WL1271_BOOT_RETRIES);
1002 mutex_unlock(&wl->mutex);
1005 list_add(&wl->list, &wl_list);
1006 register_inetaddr_notifier(&wl1271_dev_notifier);
1012 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1013 struct ieee80211_vif *vif)
1015 struct wl1271 *wl = hw->priv;
1018 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1020 mutex_lock(&wl->mutex);
1021 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1023 wl1271_info("down");
1025 list_del(&wl->list);
1027 WARN_ON(wl->state != WL1271_STATE_ON);
1029 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1030 mutex_unlock(&wl->mutex);
1031 ieee80211_scan_completed(wl->hw, true);
1032 mutex_lock(&wl->mutex);
1035 wl->state = WL1271_STATE_OFF;
1037 wl1271_disable_interrupts(wl);
1039 mutex_unlock(&wl->mutex);
1041 cancel_work_sync(&wl->irq_work);
1042 cancel_work_sync(&wl->tx_work);
1044 mutex_lock(&wl->mutex);
1046 /* let's notify MAC80211 about the remaining pending TX frames */
1047 wl1271_tx_flush(wl);
1048 wl1271_power_off(wl);
1050 memset(wl->bssid, 0, ETH_ALEN);
1051 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1053 wl->bss_type = MAX_BSS_TYPE;
1054 wl->set_bss_type = MAX_BSS_TYPE;
1055 wl->band = IEEE80211_BAND_2GHZ;
1058 wl->psm_entry_retry = 0;
1059 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1060 wl->tx_blocks_available = 0;
1061 wl->tx_results_count = 0;
1062 wl->tx_packets_count = 0;
1063 wl->tx_security_last_seq = 0;
1064 wl->tx_security_seq = 0;
1065 wl->time_offset = 0;
1066 wl->session_counter = 0;
1067 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1068 wl->sta_rate_set = 0;
1073 for (i = 0; i < NUM_TX_QUEUES; i++)
1074 wl->tx_blocks_freed[i] = 0;
1076 wl1271_debugfs_reset(wl);
1078 kfree(wl->fw_status);
1079 wl->fw_status = NULL;
1080 kfree(wl->tx_res_if);
1081 wl->tx_res_if = NULL;
1082 kfree(wl->target_mem_map);
1083 wl->target_mem_map = NULL;
1085 mutex_unlock(&wl->mutex);
1088 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1090 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1091 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1093 /* combine requested filters with current filter config */
1094 filters = wl->filters | filters;
1096 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1098 if (filters & FIF_PROMISC_IN_BSS) {
1099 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1100 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1101 wl->rx_config |= CFG_BSSID_FILTER_EN;
1103 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1104 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1105 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1106 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1108 if (filters & FIF_OTHER_BSS) {
1109 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1110 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1112 if (filters & FIF_CONTROL) {
1113 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1114 wl->rx_filter |= CFG_RX_CTL_EN;
1116 if (filters & FIF_FCSFAIL) {
1117 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1118 wl->rx_filter |= CFG_RX_FCS_ERROR;
1122 static int wl1271_dummy_join(struct wl1271 *wl)
1125 /* we need to use a dummy BSSID for now */
1126 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
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_join(struct wl1271 *wl, bool set_assoc)
1149 * One of the side effects of the JOIN command is that is clears
1150 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1151 * to a WPA/WPA2 access point will therefore kill the data-path.
1152 * Currently there is no supported scenario for JOIN during
1153 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1154 * must be handled somehow.
1157 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1158 wl1271_info("JOIN while associated.");
1161 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1163 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1167 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1169 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1173 * The join command disable the keep-alive mode, shut down its process,
1174 * and also clear the template config, so we need to reset it all after
1175 * the join. The acx_aid starts the keep-alive process, and the order
1176 * of the commands below is relevant.
1178 ret = wl1271_acx_keep_alive_mode(wl, true);
1182 ret = wl1271_acx_aid(wl, wl->aid);
1186 ret = wl1271_cmd_build_klv_null_data(wl);
1190 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1191 ACX_KEEP_ALIVE_TPL_VALID);
1199 static int wl1271_unjoin(struct wl1271 *wl)
1203 /* to stop listening to a channel, we disconnect */
1204 ret = wl1271_cmd_disconnect(wl);
1208 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1209 memset(wl->bssid, 0, ETH_ALEN);
1211 /* stop filterting packets based on bssid */
1212 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1218 static void wl1271_set_band_rate(struct wl1271 *wl)
1220 if (wl->band == IEEE80211_BAND_2GHZ)
1221 wl->basic_rate_set = wl->conf.tx.basic_rate;
1223 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1226 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1231 if (!wl->basic_rate_set) {
1233 wl->basic_rate_set = wl->conf.tx.basic_rate;
1236 for (i = 0; !rate; i++) {
1237 if ((wl->basic_rate_set >> i) & 0x1)
1244 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1246 struct wl1271 *wl = hw->priv;
1247 struct ieee80211_conf *conf = &hw->conf;
1248 int channel, ret = 0;
1250 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1252 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1254 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1256 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1258 mutex_lock(&wl->mutex);
1260 if (unlikely(wl->state == WL1271_STATE_OFF))
1263 ret = wl1271_ps_elp_wakeup(wl, false);
1267 /* if the channel changes while joined, join again */
1268 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1269 ((wl->band != conf->channel->band) ||
1270 (wl->channel != channel))) {
1271 wl->band = conf->channel->band;
1272 wl->channel = channel;
1275 * FIXME: the mac80211 should really provide a fixed rate
1276 * to use here. for now, just use the smallest possible rate
1277 * for the band as a fixed rate for association frames and
1278 * other control messages.
1280 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1281 wl1271_set_band_rate(wl);
1283 wl->basic_rate = wl1271_min_rate_get(wl);
1284 ret = wl1271_acx_rate_policies(wl);
1286 wl1271_warning("rate policy for update channel "
1289 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1290 ret = wl1271_join(wl, false);
1292 wl1271_warning("cmd join to update channel "
1297 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1298 if (conf->flags & IEEE80211_CONF_IDLE &&
1299 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1301 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1302 wl1271_dummy_join(wl);
1304 if (conf->flags & IEEE80211_CONF_IDLE) {
1305 wl->rate_set = wl1271_min_rate_get(wl);
1306 wl->sta_rate_set = 0;
1307 wl1271_acx_rate_policies(wl);
1308 wl1271_acx_keep_alive_config(
1309 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1310 ACX_KEEP_ALIVE_TPL_INVALID);
1311 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1313 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1316 if (conf->flags & IEEE80211_CONF_PS &&
1317 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1318 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1321 * We enter PSM only if we're already associated.
1322 * If we're not, we'll enter it when joining an SSID,
1323 * through the bss_info_changed() hook.
1325 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1326 wl1271_debug(DEBUG_PSM, "psm enabled");
1327 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1330 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1331 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1332 wl1271_debug(DEBUG_PSM, "psm disabled");
1334 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1336 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1337 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1341 if (conf->power_level != wl->power_level) {
1342 ret = wl1271_acx_tx_power(wl, conf->power_level);
1346 wl->power_level = conf->power_level;
1350 wl1271_ps_elp_sleep(wl);
1353 mutex_unlock(&wl->mutex);
1358 struct wl1271_filter_params {
1361 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1364 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1365 struct netdev_hw_addr_list *mc_list)
1367 struct wl1271_filter_params *fp;
1368 struct netdev_hw_addr *ha;
1369 struct wl1271 *wl = hw->priv;
1371 if (unlikely(wl->state == WL1271_STATE_OFF))
1374 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1376 wl1271_error("Out of memory setting filters.");
1380 /* update multicast filtering parameters */
1381 fp->mc_list_length = 0;
1382 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1383 fp->enabled = false;
1386 netdev_hw_addr_list_for_each(ha, mc_list) {
1387 memcpy(fp->mc_list[fp->mc_list_length],
1388 ha->addr, ETH_ALEN);
1389 fp->mc_list_length++;
1393 return (u64)(unsigned long)fp;
1396 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1399 FIF_BCN_PRBRESP_PROMISC | \
1403 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1404 unsigned int changed,
1405 unsigned int *total, u64 multicast)
1407 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1408 struct wl1271 *wl = hw->priv;
1411 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1413 mutex_lock(&wl->mutex);
1415 *total &= WL1271_SUPPORTED_FILTERS;
1416 changed &= WL1271_SUPPORTED_FILTERS;
1418 if (unlikely(wl->state == WL1271_STATE_OFF))
1421 ret = wl1271_ps_elp_wakeup(wl, false);
1426 if (*total & FIF_ALLMULTI)
1427 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1429 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1431 fp->mc_list_length);
1435 /* determine, whether supported filter values have changed */
1439 /* configure filters */
1440 wl->filters = *total;
1441 wl1271_configure_filters(wl, 0);
1443 /* apply configured filters */
1444 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1449 wl1271_ps_elp_sleep(wl);
1452 mutex_unlock(&wl->mutex);
1456 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1457 struct ieee80211_vif *vif,
1458 struct ieee80211_sta *sta,
1459 struct ieee80211_key_conf *key_conf)
1461 struct wl1271 *wl = hw->priv;
1468 static const u8 bcast_addr[ETH_ALEN] =
1469 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1471 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1473 addr = sta ? sta->addr : bcast_addr;
1475 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1476 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1477 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1478 key_conf->alg, key_conf->keyidx,
1479 key_conf->keylen, key_conf->flags);
1480 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1482 if (is_zero_ether_addr(addr)) {
1483 /* We dont support TX only encryption */
1488 mutex_lock(&wl->mutex);
1490 ret = wl1271_ps_elp_wakeup(wl, false);
1494 switch (key_conf->alg) {
1498 key_conf->hw_key_idx = key_conf->keyidx;
1501 key_type = KEY_TKIP;
1503 key_conf->hw_key_idx = key_conf->keyidx;
1504 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1505 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1510 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1511 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1512 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1515 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1523 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1524 key_conf->keyidx, key_type,
1525 key_conf->keylen, key_conf->key,
1526 addr, tx_seq_32, tx_seq_16);
1528 wl1271_error("Could not add or replace key");
1532 /* the default WEP key needs to be configured at least once */
1533 if (key_type == KEY_WEP) {
1534 ret = wl1271_cmd_set_default_wep_key(wl,
1542 /* The wl1271 does not allow to remove unicast keys - they
1543 will be cleared automatically on next CMD_JOIN. Ignore the
1544 request silently, as we dont want the mac80211 to emit
1545 an error message. */
1546 if (!is_broadcast_ether_addr(addr))
1549 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1550 key_conf->keyidx, key_type,
1551 key_conf->keylen, key_conf->key,
1554 wl1271_error("Could not remove key");
1560 wl1271_error("Unsupported key cmd 0x%x", cmd);
1566 wl1271_ps_elp_sleep(wl);
1569 mutex_unlock(&wl->mutex);
1575 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1576 struct ieee80211_vif *vif,
1577 struct cfg80211_scan_request *req)
1579 struct wl1271 *wl = hw->priv;
1584 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1587 ssid = req->ssids[0].ssid;
1588 len = req->ssids[0].ssid_len;
1591 mutex_lock(&wl->mutex);
1593 ret = wl1271_ps_elp_wakeup(wl, false);
1597 if (wl1271_11a_enabled())
1598 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1599 req->ie, req->ie_len, 1, 0,
1600 WL1271_SCAN_BAND_DUAL, 3);
1602 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1603 req->ie, req->ie_len, 1, 0,
1604 WL1271_SCAN_BAND_2_4_GHZ, 3);
1606 wl1271_ps_elp_sleep(wl);
1609 mutex_unlock(&wl->mutex);
1614 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1616 struct wl1271 *wl = hw->priv;
1619 mutex_lock(&wl->mutex);
1621 if (unlikely(wl->state == WL1271_STATE_OFF))
1624 ret = wl1271_ps_elp_wakeup(wl, false);
1628 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1630 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1632 wl1271_ps_elp_sleep(wl);
1635 mutex_unlock(&wl->mutex);
1640 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1642 u8 *ptr = beacon->data +
1643 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1645 /* find the location of the ssid in the beacon */
1646 while (ptr < beacon->data + beacon->len) {
1647 if (ptr[0] == WLAN_EID_SSID) {
1648 wl->ssid_len = ptr[1];
1649 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1654 wl1271_error("ad-hoc beacon template has no SSID!\n");
1657 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1658 struct ieee80211_vif *vif,
1659 struct ieee80211_bss_conf *bss_conf,
1662 enum wl1271_cmd_ps_mode mode;
1663 struct wl1271 *wl = hw->priv;
1664 bool do_join = false;
1665 bool set_assoc = false;
1668 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1670 mutex_lock(&wl->mutex);
1672 ret = wl1271_ps_elp_wakeup(wl, false);
1676 if ((changed && BSS_CHANGED_BEACON_INT) &&
1677 (wl->bss_type == BSS_TYPE_IBSS)) {
1678 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1679 bss_conf->beacon_int);
1681 wl->beacon_int = bss_conf->beacon_int;
1685 if ((changed && BSS_CHANGED_BEACON) &&
1686 (wl->bss_type == BSS_TYPE_IBSS)) {
1687 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1689 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1692 struct ieee80211_hdr *hdr;
1694 wl1271_ssid_set(wl, beacon);
1695 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1698 wl1271_min_rate_get(wl));
1701 dev_kfree_skb(beacon);
1705 hdr = (struct ieee80211_hdr *) beacon->data;
1706 hdr->frame_control = cpu_to_le16(
1707 IEEE80211_FTYPE_MGMT |
1708 IEEE80211_STYPE_PROBE_RESP);
1710 ret = wl1271_cmd_template_set(wl,
1711 CMD_TEMPL_PROBE_RESPONSE,
1714 wl1271_min_rate_get(wl));
1715 dev_kfree_skb(beacon);
1719 /* Need to update the SSID (for filtering etc) */
1724 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1725 (wl->bss_type == BSS_TYPE_IBSS)) {
1726 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1727 bss_conf->enable_beacon ? "enabled" : "disabled");
1729 if (bss_conf->enable_beacon)
1730 wl->set_bss_type = BSS_TYPE_IBSS;
1732 wl->set_bss_type = BSS_TYPE_STA_BSS;
1736 if (changed & BSS_CHANGED_CQM) {
1737 bool enable = false;
1738 if (bss_conf->cqm_rssi_thold)
1740 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1741 bss_conf->cqm_rssi_thold,
1742 bss_conf->cqm_rssi_hyst);
1745 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1748 if ((changed & BSS_CHANGED_BSSID) &&
1750 * Now we know the correct bssid, so we send a new join command
1751 * and enable the BSSID filter
1753 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1754 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1756 ret = wl1271_cmd_build_null_data(wl);
1760 ret = wl1271_build_qos_null_data(wl);
1764 /* filter out all packets not from this BSSID */
1765 wl1271_configure_filters(wl, 0);
1767 /* Need to update the BSSID (for filtering etc) */
1771 if (changed & BSS_CHANGED_ASSOC) {
1772 if (bss_conf->assoc) {
1774 wl->aid = bss_conf->aid;
1778 * use basic rates from AP, and determine lowest rate
1779 * to use with control frames.
1781 rates = bss_conf->basic_rates;
1782 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1784 wl->basic_rate = wl1271_min_rate_get(wl);
1785 ret = wl1271_acx_rate_policies(wl);
1790 * with wl1271, we don't need to update the
1791 * beacon_int and dtim_period, because the firmware
1792 * updates it by itself when the first beacon is
1793 * received after a join.
1795 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1800 * The SSID is intentionally set to NULL here - the
1801 * firmware will set the probe request with a
1802 * broadcast SSID regardless of what we set in the
1805 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1808 /* enable the connection monitoring feature */
1809 ret = wl1271_acx_conn_monit_params(wl, true);
1813 /* If we want to go in PSM but we're not there yet */
1814 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1815 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1816 mode = STATION_POWER_SAVE_MODE;
1817 ret = wl1271_ps_set_mode(wl, mode, true);
1822 /* use defaults when not associated */
1823 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1826 /* revert back to minimum rates for the current band */
1827 wl1271_set_band_rate(wl);
1828 wl->basic_rate = wl1271_min_rate_get(wl);
1829 ret = wl1271_acx_rate_policies(wl);
1833 /* disable connection monitor features */
1834 ret = wl1271_acx_conn_monit_params(wl, false);
1836 /* Disable the keep-alive feature */
1837 ret = wl1271_acx_keep_alive_mode(wl, false);
1845 if (changed & BSS_CHANGED_ERP_SLOT) {
1846 if (bss_conf->use_short_slot)
1847 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1849 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1851 wl1271_warning("Set slot time failed %d", ret);
1856 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1857 if (bss_conf->use_short_preamble)
1858 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1860 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1863 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1864 if (bss_conf->use_cts_prot)
1865 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1867 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1869 wl1271_warning("Set ctsprotect failed %d", ret);
1875 ret = wl1271_join(wl, set_assoc);
1877 wl1271_warning("cmd join failed %d", ret);
1883 wl1271_ps_elp_sleep(wl);
1886 mutex_unlock(&wl->mutex);
1889 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1890 const struct ieee80211_tx_queue_params *params)
1892 struct wl1271 *wl = hw->priv;
1896 mutex_lock(&wl->mutex);
1898 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1900 ret = wl1271_ps_elp_wakeup(wl, false);
1904 /* the txop is confed in units of 32us by the mac80211, we need us */
1905 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1906 params->cw_min, params->cw_max,
1907 params->aifs, params->txop << 5);
1912 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1914 ps_scheme = CONF_PS_SCHEME_LEGACY;
1916 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1917 CONF_CHANNEL_TYPE_EDCF,
1918 wl1271_tx_get_queue(queue),
1919 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1924 wl1271_ps_elp_sleep(wl);
1927 mutex_unlock(&wl->mutex);
1933 /* can't be const, mac80211 writes to this */
1934 static struct ieee80211_rate wl1271_rates[] = {
1936 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1937 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1939 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1940 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1941 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1943 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1944 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1945 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1947 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1948 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1949 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1951 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1952 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1954 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1955 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1957 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1958 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1960 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1961 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1963 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1964 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1966 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1967 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1969 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1970 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1972 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1973 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1976 /* can't be const, mac80211 writes to this */
1977 static struct ieee80211_channel wl1271_channels[] = {
1978 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1979 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1980 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1981 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1982 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1983 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1984 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1985 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1986 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1987 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1988 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1989 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1990 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1993 /* mapping to indexes for wl1271_rates */
1994 const static u8 wl1271_rate_to_idx_2ghz[] = {
1995 /* MCS rates are used only with 11n */
1996 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1997 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1998 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1999 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2000 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2001 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2002 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2003 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2005 11, /* CONF_HW_RXTX_RATE_54 */
2006 10, /* CONF_HW_RXTX_RATE_48 */
2007 9, /* CONF_HW_RXTX_RATE_36 */
2008 8, /* CONF_HW_RXTX_RATE_24 */
2010 /* TI-specific rate */
2011 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2013 7, /* CONF_HW_RXTX_RATE_18 */
2014 6, /* CONF_HW_RXTX_RATE_12 */
2015 3, /* CONF_HW_RXTX_RATE_11 */
2016 5, /* CONF_HW_RXTX_RATE_9 */
2017 4, /* CONF_HW_RXTX_RATE_6 */
2018 2, /* CONF_HW_RXTX_RATE_5_5 */
2019 1, /* CONF_HW_RXTX_RATE_2 */
2020 0 /* CONF_HW_RXTX_RATE_1 */
2023 /* can't be const, mac80211 writes to this */
2024 static struct ieee80211_supported_band wl1271_band_2ghz = {
2025 .channels = wl1271_channels,
2026 .n_channels = ARRAY_SIZE(wl1271_channels),
2027 .bitrates = wl1271_rates,
2028 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2031 /* 5 GHz data rates for WL1273 */
2032 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2034 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2035 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2037 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2038 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2040 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2041 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2043 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2044 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2046 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2047 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2049 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2050 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2052 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2053 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2055 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2056 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2059 /* 5 GHz band channels for WL1273 */
2060 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2061 { .hw_value = 183, .center_freq = 4915},
2062 { .hw_value = 184, .center_freq = 4920},
2063 { .hw_value = 185, .center_freq = 4925},
2064 { .hw_value = 187, .center_freq = 4935},
2065 { .hw_value = 188, .center_freq = 4940},
2066 { .hw_value = 189, .center_freq = 4945},
2067 { .hw_value = 192, .center_freq = 4960},
2068 { .hw_value = 196, .center_freq = 4980},
2069 { .hw_value = 7, .center_freq = 5035},
2070 { .hw_value = 8, .center_freq = 5040},
2071 { .hw_value = 9, .center_freq = 5045},
2072 { .hw_value = 11, .center_freq = 5055},
2073 { .hw_value = 12, .center_freq = 5060},
2074 { .hw_value = 16, .center_freq = 5080},
2075 { .hw_value = 34, .center_freq = 5170},
2076 { .hw_value = 36, .center_freq = 5180},
2077 { .hw_value = 38, .center_freq = 5190},
2078 { .hw_value = 40, .center_freq = 5200},
2079 { .hw_value = 42, .center_freq = 5210},
2080 { .hw_value = 44, .center_freq = 5220},
2081 { .hw_value = 46, .center_freq = 5230},
2082 { .hw_value = 48, .center_freq = 5240},
2083 { .hw_value = 52, .center_freq = 5260},
2084 { .hw_value = 56, .center_freq = 5280},
2085 { .hw_value = 60, .center_freq = 5300},
2086 { .hw_value = 64, .center_freq = 5320},
2087 { .hw_value = 100, .center_freq = 5500},
2088 { .hw_value = 104, .center_freq = 5520},
2089 { .hw_value = 108, .center_freq = 5540},
2090 { .hw_value = 112, .center_freq = 5560},
2091 { .hw_value = 116, .center_freq = 5580},
2092 { .hw_value = 120, .center_freq = 5600},
2093 { .hw_value = 124, .center_freq = 5620},
2094 { .hw_value = 128, .center_freq = 5640},
2095 { .hw_value = 132, .center_freq = 5660},
2096 { .hw_value = 136, .center_freq = 5680},
2097 { .hw_value = 140, .center_freq = 5700},
2098 { .hw_value = 149, .center_freq = 5745},
2099 { .hw_value = 153, .center_freq = 5765},
2100 { .hw_value = 157, .center_freq = 5785},
2101 { .hw_value = 161, .center_freq = 5805},
2102 { .hw_value = 165, .center_freq = 5825},
2105 /* mapping to indexes for wl1271_rates_5ghz */
2106 const static u8 wl1271_rate_to_idx_5ghz[] = {
2107 /* MCS rates are used only with 11n */
2108 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2109 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2110 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2111 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2112 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2113 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2114 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2115 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2117 7, /* CONF_HW_RXTX_RATE_54 */
2118 6, /* CONF_HW_RXTX_RATE_48 */
2119 5, /* CONF_HW_RXTX_RATE_36 */
2120 4, /* CONF_HW_RXTX_RATE_24 */
2122 /* TI-specific rate */
2123 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2125 3, /* CONF_HW_RXTX_RATE_18 */
2126 2, /* CONF_HW_RXTX_RATE_12 */
2127 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2128 1, /* CONF_HW_RXTX_RATE_9 */
2129 0, /* CONF_HW_RXTX_RATE_6 */
2130 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2131 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2132 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2135 static struct ieee80211_supported_band wl1271_band_5ghz = {
2136 .channels = wl1271_channels_5ghz,
2137 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2138 .bitrates = wl1271_rates_5ghz,
2139 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2142 const static u8 *wl1271_band_rate_to_idx[] = {
2143 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2144 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2147 static const struct ieee80211_ops wl1271_ops = {
2148 .start = wl1271_op_start,
2149 .stop = wl1271_op_stop,
2150 .add_interface = wl1271_op_add_interface,
2151 .remove_interface = wl1271_op_remove_interface,
2152 .config = wl1271_op_config,
2153 .prepare_multicast = wl1271_op_prepare_multicast,
2154 .configure_filter = wl1271_op_configure_filter,
2156 .set_key = wl1271_op_set_key,
2157 .hw_scan = wl1271_op_hw_scan,
2158 .bss_info_changed = wl1271_op_bss_info_changed,
2159 .set_rts_threshold = wl1271_op_set_rts_threshold,
2160 .conf_tx = wl1271_op_conf_tx,
2161 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2165 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2169 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2171 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2172 wl1271_error("Illegal RX rate from HW: %d", rate);
2176 idx = wl1271_band_rate_to_idx[wl->band][rate];
2177 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2178 wl1271_error("Unsupported RX rate from HW: %d", rate);
2185 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2186 struct device_attribute *attr,
2189 struct wl1271 *wl = dev_get_drvdata(dev);
2192 /* FIXME: what's the maximum length of buf? page size?*/
2195 mutex_lock(&wl->mutex);
2196 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2198 mutex_unlock(&wl->mutex);
2204 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2205 struct device_attribute *attr,
2206 const char *buf, size_t count)
2208 struct wl1271 *wl = dev_get_drvdata(dev);
2212 ret = strict_strtoul(buf, 10, &res);
2215 wl1271_warning("incorrect value written to bt_coex_mode");
2219 mutex_lock(&wl->mutex);
2223 if (res == wl->sg_enabled)
2226 wl->sg_enabled = res;
2228 if (wl->state == WL1271_STATE_OFF)
2231 ret = wl1271_ps_elp_wakeup(wl, false);
2235 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2236 wl1271_ps_elp_sleep(wl);
2239 mutex_unlock(&wl->mutex);
2243 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2244 wl1271_sysfs_show_bt_coex_state,
2245 wl1271_sysfs_store_bt_coex_state);
2247 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2248 struct device_attribute *attr,
2251 struct wl1271 *wl = dev_get_drvdata(dev);
2254 /* FIXME: what's the maximum length of buf? page size?*/
2257 mutex_lock(&wl->mutex);
2258 if (wl->hw_pg_ver >= 0)
2259 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2261 len = snprintf(buf, len, "n/a\n");
2262 mutex_unlock(&wl->mutex);
2267 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2268 wl1271_sysfs_show_hw_pg_ver, NULL);
2270 int wl1271_register_hw(struct wl1271 *wl)
2274 if (wl->mac80211_registered)
2277 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2279 ret = ieee80211_register_hw(wl->hw);
2281 wl1271_error("unable to register mac80211 hw: %d", ret);
2285 wl->mac80211_registered = true;
2287 wl1271_notice("loaded");
2291 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2293 void wl1271_unregister_hw(struct wl1271 *wl)
2295 ieee80211_unregister_hw(wl->hw);
2296 wl->mac80211_registered = false;
2299 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2301 int wl1271_init_ieee80211(struct wl1271 *wl)
2303 /* The tx descriptor buffer and the TKIP space. */
2304 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2305 sizeof(struct wl1271_tx_hw_descr);
2308 /* FIXME: find a proper value */
2309 wl->hw->channel_change_time = 10000;
2310 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2312 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2313 IEEE80211_HW_BEACON_FILTER |
2314 IEEE80211_HW_SUPPORTS_PS |
2315 IEEE80211_HW_SUPPORTS_UAPSD |
2316 IEEE80211_HW_HAS_RATE_CONTROL |
2317 IEEE80211_HW_CONNECTION_MONITOR |
2318 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2320 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2321 BIT(NL80211_IFTYPE_ADHOC);
2322 wl->hw->wiphy->max_scan_ssids = 1;
2323 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2325 if (wl1271_11a_enabled())
2326 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2329 wl->hw->max_rates = 1;
2331 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2335 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2337 #define WL1271_DEFAULT_CHANNEL 0
2339 struct ieee80211_hw *wl1271_alloc_hw(void)
2341 struct ieee80211_hw *hw;
2342 struct platform_device *plat_dev = NULL;
2346 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2348 wl1271_error("could not alloc ieee80211_hw");
2353 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2355 wl1271_error("could not allocate platform_device");
2357 goto err_plat_alloc;
2360 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2363 memset(wl, 0, sizeof(*wl));
2365 INIT_LIST_HEAD(&wl->list);
2368 wl->plat_dev = plat_dev;
2370 skb_queue_head_init(&wl->tx_queue);
2372 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2373 wl->channel = WL1271_DEFAULT_CHANNEL;
2374 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2375 wl->default_key = 0;
2377 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2378 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2379 wl->psm_entry_retry = 0;
2380 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2381 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2382 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2383 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2384 wl->sta_rate_set = 0;
2385 wl->band = IEEE80211_BAND_2GHZ;
2388 wl->sg_enabled = true;
2391 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2392 wl->tx_frames[i] = NULL;
2394 spin_lock_init(&wl->wl_lock);
2396 wl->state = WL1271_STATE_OFF;
2397 mutex_init(&wl->mutex);
2399 /* Apply default driver configuration. */
2400 wl1271_conf_init(wl);
2402 wl1271_debugfs_init(wl);
2404 /* Register platform device */
2405 ret = platform_device_register(wl->plat_dev);
2407 wl1271_error("couldn't register platform device");
2410 dev_set_drvdata(&wl->plat_dev->dev, wl);
2412 /* Create sysfs file to control bt coex state */
2413 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2415 wl1271_error("failed to create sysfs file bt_coex_state");
2419 /* Create sysfs file to get HW PG version */
2420 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2422 wl1271_error("failed to create sysfs file hw_pg_ver");
2423 goto err_bt_coex_state;
2429 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2432 platform_device_unregister(wl->plat_dev);
2435 wl1271_debugfs_exit(wl);
2439 ieee80211_free_hw(hw);
2443 return ERR_PTR(ret);
2445 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2447 int wl1271_free_hw(struct wl1271 *wl)
2449 platform_device_unregister(wl->plat_dev);
2450 kfree(wl->plat_dev);
2452 wl1271_debugfs_exit(wl);
2459 kfree(wl->fw_status);
2460 kfree(wl->tx_res_if);
2462 ieee80211_free_hw(wl->hw);
2466 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2468 MODULE_LICENSE("GPL");
2469 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2470 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");