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);
570 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz band
571 * configurations) can be removed when those NVS files stop floating
574 if (fw->size != sizeof(struct wl1271_nvs_file) &&
575 (fw->size != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
576 wl1271_11a_enabled())) {
577 wl1271_error("nvs size is not as expected: %zu != %zu",
578 fw->size, sizeof(struct wl1271_nvs_file));
583 wl->nvs = kzalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
586 wl1271_error("could not allocate memory for the nvs file");
591 memcpy(wl->nvs, fw->data, fw->size);
594 release_firmware(fw);
599 static void wl1271_fw_wakeup(struct wl1271 *wl)
603 elp_reg = ELPCTRL_WAKE_UP;
604 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
607 static int wl1271_setup(struct wl1271 *wl)
609 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
613 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
614 if (!wl->tx_res_if) {
615 kfree(wl->fw_status);
619 INIT_WORK(&wl->irq_work, wl1271_irq_work);
620 INIT_WORK(&wl->tx_work, wl1271_tx_work);
624 static int wl1271_chip_wakeup(struct wl1271 *wl)
626 struct wl1271_partition_set partition;
629 msleep(WL1271_PRE_POWER_ON_SLEEP);
631 msleep(WL1271_POWER_ON_SLEEP);
635 /* We don't need a real memory partition here, because we only want
636 * to use the registers at this point. */
637 memset(&partition, 0, sizeof(partition));
638 partition.reg.start = REGISTERS_BASE;
639 partition.reg.size = REGISTERS_DOWN_SIZE;
640 wl1271_set_partition(wl, &partition);
642 /* ELP module wake up */
643 wl1271_fw_wakeup(wl);
645 /* whal_FwCtrl_BootSm() */
647 /* 0. read chip id from CHIP_ID */
648 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
650 /* 1. check if chip id is valid */
652 switch (wl->chip.id) {
653 case CHIP_ID_1271_PG10:
654 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
657 ret = wl1271_setup(wl);
661 case CHIP_ID_1271_PG20:
662 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
665 ret = wl1271_setup(wl);
670 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
675 if (wl->fw == NULL) {
676 ret = wl1271_fetch_firmware(wl);
681 /* No NVS from netlink, try to get it from the filesystem */
682 if (wl->nvs == NULL) {
683 ret = wl1271_fetch_nvs(wl);
692 int wl1271_plt_start(struct wl1271 *wl)
694 int retries = WL1271_BOOT_RETRIES;
697 mutex_lock(&wl->mutex);
699 wl1271_notice("power up");
701 if (wl->state != WL1271_STATE_OFF) {
702 wl1271_error("cannot go into PLT state because not "
703 "in off state: %d", wl->state);
710 ret = wl1271_chip_wakeup(wl);
714 ret = wl1271_boot(wl);
718 ret = wl1271_plt_init(wl);
722 wl->state = WL1271_STATE_PLT;
723 wl1271_notice("firmware booted in PLT mode (%s)",
728 wl1271_disable_interrupts(wl);
729 mutex_unlock(&wl->mutex);
730 /* Unlocking the mutex in the middle of handling is
731 inherently unsafe. In this case we deem it safe to do,
732 because we need to let any possibly pending IRQ out of
733 the system (and while we are WL1271_STATE_OFF the IRQ
734 work function will not do anything.) Also, any other
735 possible concurrent operations will fail due to the
736 current state, hence the wl1271 struct should be safe. */
737 cancel_work_sync(&wl->irq_work);
738 mutex_lock(&wl->mutex);
740 wl1271_power_off(wl);
743 wl1271_error("firmware boot in PLT mode failed despite %d retries",
744 WL1271_BOOT_RETRIES);
746 mutex_unlock(&wl->mutex);
751 int wl1271_plt_stop(struct wl1271 *wl)
755 mutex_lock(&wl->mutex);
757 wl1271_notice("power down");
759 if (wl->state != WL1271_STATE_PLT) {
760 wl1271_error("cannot power down because not in PLT "
761 "state: %d", wl->state);
766 wl1271_disable_interrupts(wl);
767 wl1271_power_off(wl);
769 wl->state = WL1271_STATE_OFF;
773 mutex_unlock(&wl->mutex);
779 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
781 struct wl1271 *wl = hw->priv;
782 struct ieee80211_conf *conf = &hw->conf;
783 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
784 struct ieee80211_sta *sta = txinfo->control.sta;
787 /* peek into the rates configured in the STA entry */
788 spin_lock_irqsave(&wl->wl_lock, flags);
789 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
790 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
791 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
793 spin_unlock_irqrestore(&wl->wl_lock, flags);
795 /* queue the packet */
796 skb_queue_tail(&wl->tx_queue, skb);
799 * The chip specific setup must run before the first TX packet -
800 * before that, the tx_work will not be initialized!
803 ieee80211_queue_work(wl->hw, &wl->tx_work);
806 * The workqueue is slow to process the tx_queue and we need stop
807 * the queue here, otherwise the queue will get too long.
809 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
810 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
812 spin_lock_irqsave(&wl->wl_lock, flags);
813 ieee80211_stop_queues(wl->hw);
814 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
815 spin_unlock_irqrestore(&wl->wl_lock, flags);
821 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
824 struct net_device *dev;
825 struct wireless_dev *wdev;
827 struct ieee80211_hw *hw;
829 struct wl1271 *wl_temp;
830 struct in_device *idev;
831 struct in_ifaddr *ifa = arg;
834 /* FIXME: this ugly function should probably be implemented in the
835 * mac80211, and here should only be a simple callback handling actual
836 * setting of the filters. Now we need to dig up references to
837 * various structures to gain access to what we need.
838 * Also, because of this, there is no "initial" setting of the filter
839 * in "op_start", because we don't want to dig up struct net_device
840 * there - the filter will be set upon first change of the interface
843 dev = ifa->ifa_dev->dev;
845 wdev = dev->ieee80211_ptr;
853 hw = wiphy_priv(wiphy);
857 /* Check that the interface is one supported by this driver. */
859 list_for_each_entry(wl, &wl_list, list) {
866 /* Get the interface IP address for the device. "ifa" will become
868 - there is no IPV4 protocol address configured
869 - there are multiple (virtual) IPV4 addresses configured
870 When "ifa" is NULL, filtering will be disabled.
875 ifa = idev->ifa_list;
877 if (ifa && ifa->ifa_next)
880 mutex_lock(&wl->mutex);
882 if (wl->state == WL1271_STATE_OFF)
885 ret = wl1271_ps_elp_wakeup(wl, false);
889 ret = wl1271_acx_arp_ip_filter(wl, true,
890 (u8 *)&ifa->ifa_address,
893 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
895 wl1271_ps_elp_sleep(wl);
898 mutex_unlock(&wl->mutex);
903 static struct notifier_block wl1271_dev_notifier = {
904 .notifier_call = wl1271_dev_notify,
908 static int wl1271_op_start(struct ieee80211_hw *hw)
910 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
913 * We have to delay the booting of the hardware because
914 * we need to know the local MAC address before downloading and
915 * initializing the firmware. The MAC address cannot be changed
916 * after boot, and without the proper MAC address, the firmware
917 * will not function properly.
919 * The MAC address is first known when the corresponding interface
920 * is added. That is where we will initialize the hardware.
926 static void wl1271_op_stop(struct ieee80211_hw *hw)
928 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
931 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
932 struct ieee80211_vif *vif)
934 struct wl1271 *wl = hw->priv;
935 int retries = WL1271_BOOT_RETRIES;
938 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
939 vif->type, vif->addr);
941 mutex_lock(&wl->mutex);
950 case NL80211_IFTYPE_STATION:
951 wl->bss_type = BSS_TYPE_STA_BSS;
952 wl->set_bss_type = BSS_TYPE_STA_BSS;
954 case NL80211_IFTYPE_ADHOC:
955 wl->bss_type = BSS_TYPE_IBSS;
956 wl->set_bss_type = BSS_TYPE_STA_BSS;
963 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
965 if (wl->state != WL1271_STATE_OFF) {
966 wl1271_error("cannot start because not in off state: %d",
974 ret = wl1271_chip_wakeup(wl);
978 ret = wl1271_boot(wl);
982 ret = wl1271_hw_init(wl);
986 wl->state = WL1271_STATE_ON;
987 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
991 wl1271_disable_interrupts(wl);
992 mutex_unlock(&wl->mutex);
993 /* Unlocking the mutex in the middle of handling is
994 inherently unsafe. In this case we deem it safe to do,
995 because we need to let any possibly pending IRQ out of
996 the system (and while we are WL1271_STATE_OFF the IRQ
997 work function will not do anything.) Also, any other
998 possible concurrent operations will fail due to the
999 current state, hence the wl1271 struct should be safe. */
1000 cancel_work_sync(&wl->irq_work);
1001 mutex_lock(&wl->mutex);
1003 wl1271_power_off(wl);
1006 wl1271_error("firmware boot failed despite %d retries",
1007 WL1271_BOOT_RETRIES);
1009 mutex_unlock(&wl->mutex);
1012 list_add(&wl->list, &wl_list);
1013 register_inetaddr_notifier(&wl1271_dev_notifier);
1019 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1020 struct ieee80211_vif *vif)
1022 struct wl1271 *wl = hw->priv;
1025 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1027 mutex_lock(&wl->mutex);
1028 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1030 wl1271_info("down");
1032 list_del(&wl->list);
1034 WARN_ON(wl->state != WL1271_STATE_ON);
1036 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1037 mutex_unlock(&wl->mutex);
1038 ieee80211_scan_completed(wl->hw, true);
1039 mutex_lock(&wl->mutex);
1042 wl->state = WL1271_STATE_OFF;
1044 wl1271_disable_interrupts(wl);
1046 mutex_unlock(&wl->mutex);
1048 cancel_work_sync(&wl->irq_work);
1049 cancel_work_sync(&wl->tx_work);
1051 mutex_lock(&wl->mutex);
1053 /* let's notify MAC80211 about the remaining pending TX frames */
1054 wl1271_tx_reset(wl);
1055 wl1271_power_off(wl);
1057 memset(wl->bssid, 0, ETH_ALEN);
1058 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1060 wl->bss_type = MAX_BSS_TYPE;
1061 wl->set_bss_type = MAX_BSS_TYPE;
1062 wl->band = IEEE80211_BAND_2GHZ;
1065 wl->psm_entry_retry = 0;
1066 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1067 wl->tx_blocks_available = 0;
1068 wl->tx_results_count = 0;
1069 wl->tx_packets_count = 0;
1070 wl->tx_security_last_seq = 0;
1071 wl->tx_security_seq = 0;
1072 wl->time_offset = 0;
1073 wl->session_counter = 0;
1074 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1075 wl->sta_rate_set = 0;
1080 for (i = 0; i < NUM_TX_QUEUES; i++)
1081 wl->tx_blocks_freed[i] = 0;
1083 wl1271_debugfs_reset(wl);
1085 kfree(wl->fw_status);
1086 wl->fw_status = NULL;
1087 kfree(wl->tx_res_if);
1088 wl->tx_res_if = NULL;
1089 kfree(wl->target_mem_map);
1090 wl->target_mem_map = NULL;
1092 mutex_unlock(&wl->mutex);
1095 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1097 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1098 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1100 /* combine requested filters with current filter config */
1101 filters = wl->filters | filters;
1103 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1105 if (filters & FIF_PROMISC_IN_BSS) {
1106 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1107 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1108 wl->rx_config |= CFG_BSSID_FILTER_EN;
1110 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1111 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1112 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1113 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1115 if (filters & FIF_OTHER_BSS) {
1116 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1117 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1119 if (filters & FIF_CONTROL) {
1120 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1121 wl->rx_filter |= CFG_RX_CTL_EN;
1123 if (filters & FIF_FCSFAIL) {
1124 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1125 wl->rx_filter |= CFG_RX_FCS_ERROR;
1129 static int wl1271_dummy_join(struct wl1271 *wl)
1132 /* we need to use a dummy BSSID for now */
1133 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1136 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1138 /* pass through frames from all BSS */
1139 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1141 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1145 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1151 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1156 * One of the side effects of the JOIN command is that is clears
1157 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1158 * to a WPA/WPA2 access point will therefore kill the data-path.
1159 * Currently there is no supported scenario for JOIN during
1160 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1161 * must be handled somehow.
1164 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1165 wl1271_info("JOIN while associated.");
1168 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1170 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1174 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1176 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1180 * The join command disable the keep-alive mode, shut down its process,
1181 * and also clear the template config, so we need to reset it all after
1182 * the join. The acx_aid starts the keep-alive process, and the order
1183 * of the commands below is relevant.
1185 ret = wl1271_acx_keep_alive_mode(wl, true);
1189 ret = wl1271_acx_aid(wl, wl->aid);
1193 ret = wl1271_cmd_build_klv_null_data(wl);
1197 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1198 ACX_KEEP_ALIVE_TPL_VALID);
1206 static int wl1271_unjoin(struct wl1271 *wl)
1210 /* to stop listening to a channel, we disconnect */
1211 ret = wl1271_cmd_disconnect(wl);
1215 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1216 memset(wl->bssid, 0, ETH_ALEN);
1218 /* stop filterting packets based on bssid */
1219 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1225 static void wl1271_set_band_rate(struct wl1271 *wl)
1227 if (wl->band == IEEE80211_BAND_2GHZ)
1228 wl->basic_rate_set = wl->conf.tx.basic_rate;
1230 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1233 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1238 if (!wl->basic_rate_set) {
1240 wl->basic_rate_set = wl->conf.tx.basic_rate;
1243 for (i = 0; !rate; i++) {
1244 if ((wl->basic_rate_set >> i) & 0x1)
1251 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1256 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1257 ret = wl1271_unjoin(wl);
1261 wl->rate_set = wl1271_min_rate_get(wl);
1262 wl->sta_rate_set = 0;
1263 ret = wl1271_acx_rate_policies(wl);
1266 ret = wl1271_acx_keep_alive_config(
1267 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1268 ACX_KEEP_ALIVE_TPL_INVALID);
1271 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1273 /* increment the session counter */
1274 wl->session_counter++;
1275 if (wl->session_counter >= SESSION_COUNTER_MAX)
1276 wl->session_counter = 0;
1277 ret = wl1271_dummy_join(wl);
1280 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1287 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1289 struct wl1271 *wl = hw->priv;
1290 struct ieee80211_conf *conf = &hw->conf;
1291 int channel, ret = 0;
1293 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1295 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1297 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1299 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1302 * mac80211 will go to idle nearly immediately after transmitting some
1303 * frames, such as the deauth. To make sure those frames reach the air,
1304 * wait here until the TX queue is fully flushed.
1306 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1307 (conf->flags & IEEE80211_CONF_IDLE))
1308 wl1271_tx_flush(wl);
1310 mutex_lock(&wl->mutex);
1312 if (unlikely(wl->state == WL1271_STATE_OFF))
1315 ret = wl1271_ps_elp_wakeup(wl, false);
1319 /* if the channel changes while joined, join again */
1320 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1321 ((wl->band != conf->channel->band) ||
1322 (wl->channel != channel))) {
1323 wl->band = conf->channel->band;
1324 wl->channel = channel;
1327 * FIXME: the mac80211 should really provide a fixed rate
1328 * to use here. for now, just use the smallest possible rate
1329 * for the band as a fixed rate for association frames and
1330 * other control messages.
1332 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1333 wl1271_set_band_rate(wl);
1335 wl->basic_rate = wl1271_min_rate_get(wl);
1336 ret = wl1271_acx_rate_policies(wl);
1338 wl1271_warning("rate policy for update channel "
1341 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1342 ret = wl1271_join(wl, false);
1344 wl1271_warning("cmd join to update channel "
1349 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1350 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1352 wl1271_warning("idle mode change failed %d", ret);
1355 if (conf->flags & IEEE80211_CONF_PS &&
1356 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1357 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1360 * We enter PSM only if we're already associated.
1361 * If we're not, we'll enter it when joining an SSID,
1362 * through the bss_info_changed() hook.
1364 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1365 wl1271_debug(DEBUG_PSM, "psm enabled");
1366 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1369 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1370 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1371 wl1271_debug(DEBUG_PSM, "psm disabled");
1373 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1375 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1376 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1380 if (conf->power_level != wl->power_level) {
1381 ret = wl1271_acx_tx_power(wl, conf->power_level);
1385 wl->power_level = conf->power_level;
1389 wl1271_ps_elp_sleep(wl);
1392 mutex_unlock(&wl->mutex);
1397 struct wl1271_filter_params {
1400 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1403 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1404 struct netdev_hw_addr_list *mc_list)
1406 struct wl1271_filter_params *fp;
1407 struct netdev_hw_addr *ha;
1408 struct wl1271 *wl = hw->priv;
1410 if (unlikely(wl->state == WL1271_STATE_OFF))
1413 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1415 wl1271_error("Out of memory setting filters.");
1419 /* update multicast filtering parameters */
1420 fp->mc_list_length = 0;
1421 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1422 fp->enabled = false;
1425 netdev_hw_addr_list_for_each(ha, mc_list) {
1426 memcpy(fp->mc_list[fp->mc_list_length],
1427 ha->addr, ETH_ALEN);
1428 fp->mc_list_length++;
1432 return (u64)(unsigned long)fp;
1435 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1438 FIF_BCN_PRBRESP_PROMISC | \
1442 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1443 unsigned int changed,
1444 unsigned int *total, u64 multicast)
1446 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1447 struct wl1271 *wl = hw->priv;
1450 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1452 mutex_lock(&wl->mutex);
1454 *total &= WL1271_SUPPORTED_FILTERS;
1455 changed &= WL1271_SUPPORTED_FILTERS;
1457 if (unlikely(wl->state == WL1271_STATE_OFF))
1460 ret = wl1271_ps_elp_wakeup(wl, false);
1465 if (*total & FIF_ALLMULTI)
1466 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1468 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1470 fp->mc_list_length);
1474 /* determine, whether supported filter values have changed */
1478 /* configure filters */
1479 wl->filters = *total;
1480 wl1271_configure_filters(wl, 0);
1482 /* apply configured filters */
1483 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1488 wl1271_ps_elp_sleep(wl);
1491 mutex_unlock(&wl->mutex);
1495 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1496 struct ieee80211_vif *vif,
1497 struct ieee80211_sta *sta,
1498 struct ieee80211_key_conf *key_conf)
1500 struct wl1271 *wl = hw->priv;
1507 static const u8 bcast_addr[ETH_ALEN] =
1508 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1510 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1512 addr = sta ? sta->addr : bcast_addr;
1514 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1515 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1516 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1517 key_conf->alg, key_conf->keyidx,
1518 key_conf->keylen, key_conf->flags);
1519 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1521 if (is_zero_ether_addr(addr)) {
1522 /* We dont support TX only encryption */
1527 mutex_lock(&wl->mutex);
1529 ret = wl1271_ps_elp_wakeup(wl, false);
1533 switch (key_conf->alg) {
1537 key_conf->hw_key_idx = key_conf->keyidx;
1540 key_type = KEY_TKIP;
1542 key_conf->hw_key_idx = key_conf->keyidx;
1543 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1544 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1549 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1550 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1551 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1554 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1562 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1563 key_conf->keyidx, key_type,
1564 key_conf->keylen, key_conf->key,
1565 addr, tx_seq_32, tx_seq_16);
1567 wl1271_error("Could not add or replace key");
1571 /* the default WEP key needs to be configured at least once */
1572 if (key_type == KEY_WEP) {
1573 ret = wl1271_cmd_set_default_wep_key(wl,
1581 /* The wl1271 does not allow to remove unicast keys - they
1582 will be cleared automatically on next CMD_JOIN. Ignore the
1583 request silently, as we dont want the mac80211 to emit
1584 an error message. */
1585 if (!is_broadcast_ether_addr(addr))
1588 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1589 key_conf->keyidx, key_type,
1590 key_conf->keylen, key_conf->key,
1593 wl1271_error("Could not remove key");
1599 wl1271_error("Unsupported key cmd 0x%x", cmd);
1605 wl1271_ps_elp_sleep(wl);
1608 mutex_unlock(&wl->mutex);
1614 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1615 struct ieee80211_vif *vif,
1616 struct cfg80211_scan_request *req)
1618 struct wl1271 *wl = hw->priv;
1623 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1626 ssid = req->ssids[0].ssid;
1627 len = req->ssids[0].ssid_len;
1630 mutex_lock(&wl->mutex);
1632 ret = wl1271_ps_elp_wakeup(wl, false);
1636 if (wl1271_11a_enabled())
1637 ret = wl1271_cmd_scan(hw->priv, ssid, len, req,
1638 1, 0, WL1271_SCAN_BAND_DUAL, 3);
1640 ret = wl1271_cmd_scan(hw->priv, ssid, len, req,
1641 1, 0, WL1271_SCAN_BAND_2_4_GHZ, 3);
1643 wl1271_ps_elp_sleep(wl);
1646 mutex_unlock(&wl->mutex);
1651 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1653 struct wl1271 *wl = hw->priv;
1656 mutex_lock(&wl->mutex);
1658 if (unlikely(wl->state == WL1271_STATE_OFF))
1661 ret = wl1271_ps_elp_wakeup(wl, false);
1665 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1667 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1669 wl1271_ps_elp_sleep(wl);
1672 mutex_unlock(&wl->mutex);
1677 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1679 u8 *ptr = beacon->data +
1680 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1682 /* find the location of the ssid in the beacon */
1683 while (ptr < beacon->data + beacon->len) {
1684 if (ptr[0] == WLAN_EID_SSID) {
1685 wl->ssid_len = ptr[1];
1686 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1691 wl1271_error("ad-hoc beacon template has no SSID!\n");
1694 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1695 struct ieee80211_vif *vif,
1696 struct ieee80211_bss_conf *bss_conf,
1699 enum wl1271_cmd_ps_mode mode;
1700 struct wl1271 *wl = hw->priv;
1701 bool do_join = false;
1702 bool set_assoc = false;
1705 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1707 mutex_lock(&wl->mutex);
1709 ret = wl1271_ps_elp_wakeup(wl, false);
1713 if ((changed && BSS_CHANGED_BEACON_INT) &&
1714 (wl->bss_type == BSS_TYPE_IBSS)) {
1715 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1716 bss_conf->beacon_int);
1718 wl->beacon_int = bss_conf->beacon_int;
1722 if ((changed && BSS_CHANGED_BEACON) &&
1723 (wl->bss_type == BSS_TYPE_IBSS)) {
1724 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1726 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1729 struct ieee80211_hdr *hdr;
1731 wl1271_ssid_set(wl, beacon);
1732 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1735 wl1271_min_rate_get(wl));
1738 dev_kfree_skb(beacon);
1742 hdr = (struct ieee80211_hdr *) beacon->data;
1743 hdr->frame_control = cpu_to_le16(
1744 IEEE80211_FTYPE_MGMT |
1745 IEEE80211_STYPE_PROBE_RESP);
1747 ret = wl1271_cmd_template_set(wl,
1748 CMD_TEMPL_PROBE_RESPONSE,
1751 wl1271_min_rate_get(wl));
1752 dev_kfree_skb(beacon);
1756 /* Need to update the SSID (for filtering etc) */
1761 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1762 (wl->bss_type == BSS_TYPE_IBSS)) {
1763 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1764 bss_conf->enable_beacon ? "enabled" : "disabled");
1766 if (bss_conf->enable_beacon)
1767 wl->set_bss_type = BSS_TYPE_IBSS;
1769 wl->set_bss_type = BSS_TYPE_STA_BSS;
1773 if (changed & BSS_CHANGED_CQM) {
1774 bool enable = false;
1775 if (bss_conf->cqm_rssi_thold)
1777 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1778 bss_conf->cqm_rssi_thold,
1779 bss_conf->cqm_rssi_hyst);
1782 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1785 if ((changed & BSS_CHANGED_BSSID) &&
1787 * Now we know the correct bssid, so we send a new join command
1788 * and enable the BSSID filter
1790 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1791 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1793 ret = wl1271_cmd_build_null_data(wl);
1797 ret = wl1271_build_qos_null_data(wl);
1801 /* filter out all packets not from this BSSID */
1802 wl1271_configure_filters(wl, 0);
1804 /* Need to update the BSSID (for filtering etc) */
1808 if (changed & BSS_CHANGED_ASSOC) {
1809 if (bss_conf->assoc) {
1811 wl->aid = bss_conf->aid;
1815 * use basic rates from AP, and determine lowest rate
1816 * to use with control frames.
1818 rates = bss_conf->basic_rates;
1819 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1821 wl->basic_rate = wl1271_min_rate_get(wl);
1822 ret = wl1271_acx_rate_policies(wl);
1827 * with wl1271, we don't need to update the
1828 * beacon_int and dtim_period, because the firmware
1829 * updates it by itself when the first beacon is
1830 * received after a join.
1832 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1837 * The SSID is intentionally set to NULL here - the
1838 * firmware will set the probe request with a
1839 * broadcast SSID regardless of what we set in the
1842 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1845 /* enable the connection monitoring feature */
1846 ret = wl1271_acx_conn_monit_params(wl, true);
1850 /* If we want to go in PSM but we're not there yet */
1851 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1852 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1853 mode = STATION_POWER_SAVE_MODE;
1854 ret = wl1271_ps_set_mode(wl, mode, true);
1859 /* use defaults when not associated */
1860 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1863 /* revert back to minimum rates for the current band */
1864 wl1271_set_band_rate(wl);
1865 wl->basic_rate = wl1271_min_rate_get(wl);
1866 ret = wl1271_acx_rate_policies(wl);
1870 /* disable connection monitor features */
1871 ret = wl1271_acx_conn_monit_params(wl, false);
1873 /* Disable the keep-alive feature */
1874 ret = wl1271_acx_keep_alive_mode(wl, false);
1882 if (changed & BSS_CHANGED_ERP_SLOT) {
1883 if (bss_conf->use_short_slot)
1884 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1886 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1888 wl1271_warning("Set slot time failed %d", ret);
1893 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1894 if (bss_conf->use_short_preamble)
1895 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1897 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1900 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1901 if (bss_conf->use_cts_prot)
1902 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1904 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1906 wl1271_warning("Set ctsprotect failed %d", ret);
1912 ret = wl1271_join(wl, set_assoc);
1914 wl1271_warning("cmd join failed %d", ret);
1920 wl1271_ps_elp_sleep(wl);
1923 mutex_unlock(&wl->mutex);
1926 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1927 const struct ieee80211_tx_queue_params *params)
1929 struct wl1271 *wl = hw->priv;
1933 mutex_lock(&wl->mutex);
1935 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1937 ret = wl1271_ps_elp_wakeup(wl, false);
1941 /* the txop is confed in units of 32us by the mac80211, we need us */
1942 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1943 params->cw_min, params->cw_max,
1944 params->aifs, params->txop << 5);
1949 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1951 ps_scheme = CONF_PS_SCHEME_LEGACY;
1953 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1954 CONF_CHANNEL_TYPE_EDCF,
1955 wl1271_tx_get_queue(queue),
1956 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1961 wl1271_ps_elp_sleep(wl);
1964 mutex_unlock(&wl->mutex);
1969 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1972 struct wl1271 *wl = hw->priv;
1973 u64 mactime = ULLONG_MAX;
1976 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1978 mutex_lock(&wl->mutex);
1980 ret = wl1271_ps_elp_wakeup(wl, false);
1984 ret = wl1271_acx_tsf_info(wl, &mactime);
1989 wl1271_ps_elp_sleep(wl);
1992 mutex_unlock(&wl->mutex);
1996 /* can't be const, mac80211 writes to this */
1997 static struct ieee80211_rate wl1271_rates[] = {
1999 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2000 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2002 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2003 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2004 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2006 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2007 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2008 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2010 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2011 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2012 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2014 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2015 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2017 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2018 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2020 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2021 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2023 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2024 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2026 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2027 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2029 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2030 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2032 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2033 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2035 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2036 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2039 /* can't be const, mac80211 writes to this */
2040 static struct ieee80211_channel wl1271_channels[] = {
2041 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2042 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2043 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2044 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2045 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2046 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2047 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2048 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2049 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2050 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2051 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2052 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2053 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2056 /* mapping to indexes for wl1271_rates */
2057 static const u8 wl1271_rate_to_idx_2ghz[] = {
2058 /* MCS rates are used only with 11n */
2059 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2060 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2061 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2062 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2063 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2064 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2065 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2066 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2068 11, /* CONF_HW_RXTX_RATE_54 */
2069 10, /* CONF_HW_RXTX_RATE_48 */
2070 9, /* CONF_HW_RXTX_RATE_36 */
2071 8, /* CONF_HW_RXTX_RATE_24 */
2073 /* TI-specific rate */
2074 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2076 7, /* CONF_HW_RXTX_RATE_18 */
2077 6, /* CONF_HW_RXTX_RATE_12 */
2078 3, /* CONF_HW_RXTX_RATE_11 */
2079 5, /* CONF_HW_RXTX_RATE_9 */
2080 4, /* CONF_HW_RXTX_RATE_6 */
2081 2, /* CONF_HW_RXTX_RATE_5_5 */
2082 1, /* CONF_HW_RXTX_RATE_2 */
2083 0 /* CONF_HW_RXTX_RATE_1 */
2086 /* can't be const, mac80211 writes to this */
2087 static struct ieee80211_supported_band wl1271_band_2ghz = {
2088 .channels = wl1271_channels,
2089 .n_channels = ARRAY_SIZE(wl1271_channels),
2090 .bitrates = wl1271_rates,
2091 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2094 /* 5 GHz data rates for WL1273 */
2095 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2097 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2098 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2100 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2101 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2103 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2104 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2106 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2107 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2109 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2110 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2112 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2113 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2115 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2116 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2118 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2119 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2122 /* 5 GHz band channels for WL1273 */
2123 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2124 { .hw_value = 183, .center_freq = 4915},
2125 { .hw_value = 184, .center_freq = 4920},
2126 { .hw_value = 185, .center_freq = 4925},
2127 { .hw_value = 187, .center_freq = 4935},
2128 { .hw_value = 188, .center_freq = 4940},
2129 { .hw_value = 189, .center_freq = 4945},
2130 { .hw_value = 192, .center_freq = 4960},
2131 { .hw_value = 196, .center_freq = 4980},
2132 { .hw_value = 7, .center_freq = 5035},
2133 { .hw_value = 8, .center_freq = 5040},
2134 { .hw_value = 9, .center_freq = 5045},
2135 { .hw_value = 11, .center_freq = 5055},
2136 { .hw_value = 12, .center_freq = 5060},
2137 { .hw_value = 16, .center_freq = 5080},
2138 { .hw_value = 34, .center_freq = 5170},
2139 { .hw_value = 36, .center_freq = 5180},
2140 { .hw_value = 38, .center_freq = 5190},
2141 { .hw_value = 40, .center_freq = 5200},
2142 { .hw_value = 42, .center_freq = 5210},
2143 { .hw_value = 44, .center_freq = 5220},
2144 { .hw_value = 46, .center_freq = 5230},
2145 { .hw_value = 48, .center_freq = 5240},
2146 { .hw_value = 52, .center_freq = 5260},
2147 { .hw_value = 56, .center_freq = 5280},
2148 { .hw_value = 60, .center_freq = 5300},
2149 { .hw_value = 64, .center_freq = 5320},
2150 { .hw_value = 100, .center_freq = 5500},
2151 { .hw_value = 104, .center_freq = 5520},
2152 { .hw_value = 108, .center_freq = 5540},
2153 { .hw_value = 112, .center_freq = 5560},
2154 { .hw_value = 116, .center_freq = 5580},
2155 { .hw_value = 120, .center_freq = 5600},
2156 { .hw_value = 124, .center_freq = 5620},
2157 { .hw_value = 128, .center_freq = 5640},
2158 { .hw_value = 132, .center_freq = 5660},
2159 { .hw_value = 136, .center_freq = 5680},
2160 { .hw_value = 140, .center_freq = 5700},
2161 { .hw_value = 149, .center_freq = 5745},
2162 { .hw_value = 153, .center_freq = 5765},
2163 { .hw_value = 157, .center_freq = 5785},
2164 { .hw_value = 161, .center_freq = 5805},
2165 { .hw_value = 165, .center_freq = 5825},
2168 /* mapping to indexes for wl1271_rates_5ghz */
2169 static const u8 wl1271_rate_to_idx_5ghz[] = {
2170 /* MCS rates are used only with 11n */
2171 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2172 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2173 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2174 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2175 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2176 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2177 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2178 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2180 7, /* CONF_HW_RXTX_RATE_54 */
2181 6, /* CONF_HW_RXTX_RATE_48 */
2182 5, /* CONF_HW_RXTX_RATE_36 */
2183 4, /* CONF_HW_RXTX_RATE_24 */
2185 /* TI-specific rate */
2186 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2188 3, /* CONF_HW_RXTX_RATE_18 */
2189 2, /* CONF_HW_RXTX_RATE_12 */
2190 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2191 1, /* CONF_HW_RXTX_RATE_9 */
2192 0, /* CONF_HW_RXTX_RATE_6 */
2193 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2194 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2195 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2198 static struct ieee80211_supported_band wl1271_band_5ghz = {
2199 .channels = wl1271_channels_5ghz,
2200 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2201 .bitrates = wl1271_rates_5ghz,
2202 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2205 static const u8 *wl1271_band_rate_to_idx[] = {
2206 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2207 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2210 static const struct ieee80211_ops wl1271_ops = {
2211 .start = wl1271_op_start,
2212 .stop = wl1271_op_stop,
2213 .add_interface = wl1271_op_add_interface,
2214 .remove_interface = wl1271_op_remove_interface,
2215 .config = wl1271_op_config,
2216 .prepare_multicast = wl1271_op_prepare_multicast,
2217 .configure_filter = wl1271_op_configure_filter,
2219 .set_key = wl1271_op_set_key,
2220 .hw_scan = wl1271_op_hw_scan,
2221 .bss_info_changed = wl1271_op_bss_info_changed,
2222 .set_rts_threshold = wl1271_op_set_rts_threshold,
2223 .conf_tx = wl1271_op_conf_tx,
2224 .get_tsf = wl1271_op_get_tsf,
2225 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2229 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2233 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2235 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2236 wl1271_error("Illegal RX rate from HW: %d", rate);
2240 idx = wl1271_band_rate_to_idx[wl->band][rate];
2241 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2242 wl1271_error("Unsupported RX rate from HW: %d", rate);
2249 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2250 struct device_attribute *attr,
2253 struct wl1271 *wl = dev_get_drvdata(dev);
2256 /* FIXME: what's the maximum length of buf? page size?*/
2259 mutex_lock(&wl->mutex);
2260 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2262 mutex_unlock(&wl->mutex);
2268 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2269 struct device_attribute *attr,
2270 const char *buf, size_t count)
2272 struct wl1271 *wl = dev_get_drvdata(dev);
2276 ret = strict_strtoul(buf, 10, &res);
2279 wl1271_warning("incorrect value written to bt_coex_mode");
2283 mutex_lock(&wl->mutex);
2287 if (res == wl->sg_enabled)
2290 wl->sg_enabled = res;
2292 if (wl->state == WL1271_STATE_OFF)
2295 ret = wl1271_ps_elp_wakeup(wl, false);
2299 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2300 wl1271_ps_elp_sleep(wl);
2303 mutex_unlock(&wl->mutex);
2307 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2308 wl1271_sysfs_show_bt_coex_state,
2309 wl1271_sysfs_store_bt_coex_state);
2311 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2312 struct device_attribute *attr,
2315 struct wl1271 *wl = dev_get_drvdata(dev);
2318 /* FIXME: what's the maximum length of buf? page size?*/
2321 mutex_lock(&wl->mutex);
2322 if (wl->hw_pg_ver >= 0)
2323 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2325 len = snprintf(buf, len, "n/a\n");
2326 mutex_unlock(&wl->mutex);
2331 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2332 wl1271_sysfs_show_hw_pg_ver, NULL);
2334 int wl1271_register_hw(struct wl1271 *wl)
2338 if (wl->mac80211_registered)
2341 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2343 ret = ieee80211_register_hw(wl->hw);
2345 wl1271_error("unable to register mac80211 hw: %d", ret);
2349 wl->mac80211_registered = true;
2351 wl1271_notice("loaded");
2355 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2357 void wl1271_unregister_hw(struct wl1271 *wl)
2359 ieee80211_unregister_hw(wl->hw);
2360 wl->mac80211_registered = false;
2363 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2365 int wl1271_init_ieee80211(struct wl1271 *wl)
2367 /* The tx descriptor buffer and the TKIP space. */
2368 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2369 sizeof(struct wl1271_tx_hw_descr);
2372 /* FIXME: find a proper value */
2373 wl->hw->channel_change_time = 10000;
2374 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2376 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2377 IEEE80211_HW_BEACON_FILTER |
2378 IEEE80211_HW_SUPPORTS_PS |
2379 IEEE80211_HW_SUPPORTS_UAPSD |
2380 IEEE80211_HW_HAS_RATE_CONTROL |
2381 IEEE80211_HW_CONNECTION_MONITOR |
2382 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2384 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2385 BIT(NL80211_IFTYPE_ADHOC);
2386 wl->hw->wiphy->max_scan_ssids = 1;
2387 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2389 if (wl1271_11a_enabled())
2390 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2393 wl->hw->max_rates = 1;
2395 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2399 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2401 #define WL1271_DEFAULT_CHANNEL 0
2403 struct ieee80211_hw *wl1271_alloc_hw(void)
2405 struct ieee80211_hw *hw;
2406 struct platform_device *plat_dev = NULL;
2410 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2412 wl1271_error("could not alloc ieee80211_hw");
2417 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2419 wl1271_error("could not allocate platform_device");
2421 goto err_plat_alloc;
2424 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2427 memset(wl, 0, sizeof(*wl));
2429 INIT_LIST_HEAD(&wl->list);
2432 wl->plat_dev = plat_dev;
2434 skb_queue_head_init(&wl->tx_queue);
2436 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2437 wl->channel = WL1271_DEFAULT_CHANNEL;
2438 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2439 wl->default_key = 0;
2441 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2442 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2443 wl->psm_entry_retry = 0;
2444 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2445 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2446 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2447 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2448 wl->sta_rate_set = 0;
2449 wl->band = IEEE80211_BAND_2GHZ;
2452 wl->sg_enabled = true;
2455 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2456 wl->tx_frames[i] = NULL;
2458 spin_lock_init(&wl->wl_lock);
2460 wl->state = WL1271_STATE_OFF;
2461 mutex_init(&wl->mutex);
2463 /* Apply default driver configuration. */
2464 wl1271_conf_init(wl);
2466 wl1271_debugfs_init(wl);
2468 /* Register platform device */
2469 ret = platform_device_register(wl->plat_dev);
2471 wl1271_error("couldn't register platform device");
2474 dev_set_drvdata(&wl->plat_dev->dev, wl);
2476 /* Create sysfs file to control bt coex state */
2477 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2479 wl1271_error("failed to create sysfs file bt_coex_state");
2483 /* Create sysfs file to get HW PG version */
2484 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2486 wl1271_error("failed to create sysfs file hw_pg_ver");
2487 goto err_bt_coex_state;
2493 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2496 platform_device_unregister(wl->plat_dev);
2499 wl1271_debugfs_exit(wl);
2503 ieee80211_free_hw(hw);
2507 return ERR_PTR(ret);
2509 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2511 int wl1271_free_hw(struct wl1271 *wl)
2513 platform_device_unregister(wl->plat_dev);
2514 kfree(wl->plat_dev);
2516 wl1271_debugfs_exit(wl);
2523 kfree(wl->fw_status);
2524 kfree(wl->tx_res_if);
2526 ieee80211_free_hw(wl->hw);
2530 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2532 MODULE_LICENSE("GPL");
2533 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2534 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");