2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/inetdevice.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
36 #include "wl12xx_80211.h"
37 #include "wl1271_reg.h"
38 #include "wl1271_io.h"
39 #include "wl1271_event.h"
40 #include "wl1271_tx.h"
41 #include "wl1271_rx.h"
42 #include "wl1271_ps.h"
43 #include "wl1271_init.h"
44 #include "wl1271_debugfs.h"
45 #include "wl1271_cmd.h"
46 #include "wl1271_boot.h"
47 #include "wl1271_testmode.h"
49 #define WL1271_BOOT_RETRIES 3
51 static struct conf_drv_settings default_conf = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
58 [CONF_SG_AUTO_PS_MODE] = 0,
59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
103 .state = CONF_SG_PROTECTIVE,
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
110 .rts_threshold = 2347,
111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
118 .tx_energy_detection = 0,
121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
145 .aifsn = CONF_TX_AIFS_PIFS,
152 .aifsn = CONF_TX_AIFS_PIFS,
160 .channel_type = CONF_CHANNEL_TYPE_DCF,
161 .tsid = CONF_TX_AC_BE,
162 .ps_scheme = CONF_PS_SCHEME_LEGACY,
163 .ack_policy = CONF_ACK_POLICY_LEGACY,
168 .channel_type = CONF_CHANNEL_TYPE_DCF,
169 .tsid = CONF_TX_AC_BE,
170 .ps_scheme = CONF_PS_SCHEME_LEGACY,
171 .ack_policy = CONF_ACK_POLICY_LEGACY,
176 .channel_type = CONF_CHANNEL_TYPE_DCF,
177 .tsid = CONF_TX_AC_BE,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
184 .channel_type = CONF_CHANNEL_TYPE_DCF,
185 .tsid = CONF_TX_AC_BE,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
192 .channel_type = CONF_CHANNEL_TYPE_DCF,
193 .tsid = CONF_TX_AC_BE,
194 .ps_scheme = CONF_PS_SCHEME_LEGACY,
195 .ack_policy = CONF_ACK_POLICY_LEGACY,
200 .channel_type = CONF_CHANNEL_TYPE_DCF,
201 .tsid = CONF_TX_AC_BE,
202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
208 .channel_type = CONF_CHANNEL_TYPE_DCF,
209 .tsid = CONF_TX_AC_BE,
210 .ps_scheme = CONF_PS_SCHEME_LEGACY,
211 .ack_policy = CONF_ACK_POLICY_LEGACY,
215 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
216 .tx_compl_timeout = 700,
217 .tx_compl_threshold = 4,
218 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
219 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
222 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
223 .listen_interval = 1,
224 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
225 .bcn_filt_ie_count = 1,
228 .ie = WLAN_EID_CHANNEL_SWITCH,
229 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
232 .synch_fail_thold = 10,
233 .bss_lose_timeout = 100,
234 .beacon_rx_timeout = 10000,
235 .broadcast_timeout = 20000,
236 .rx_broadcast_in_ps = 1,
237 .ps_poll_threshold = 20,
238 .bet_enable = CONF_BET_MODE_ENABLE,
239 .bet_max_consecutive = 10,
240 .psm_entry_retries = 3,
241 .keep_alive_interval = 55000,
242 .max_listen_interval = 20,
254 .host_clk_settling_time = 5000,
255 .host_fast_wakeup_support = false
258 /* FIXME: due to firmware bug, must use value 1 for now */
260 .avg_weight_rssi_beacon = 20,
261 .avg_weight_rssi_data = 10,
262 .avg_weight_snr_beacon = 20,
263 .avg_weight_snr_data = 10
267 static void wl1271_device_release(struct device *dev)
272 static struct platform_device wl1271_device = {
276 /* device model insists to have a release function */
278 .release = wl1271_device_release,
282 static LIST_HEAD(wl_list);
284 static void wl1271_conf_init(struct wl1271 *wl)
288 * This function applies the default configuration to the driver. This
289 * function is invoked upon driver load (spi probe.)
291 * The configuration is stored in a run-time structure in order to
292 * facilitate for run-time adjustment of any of the parameters. Making
293 * changes to the configuration structure will apply the new values on
294 * the next interface up (wl1271_op_start.)
297 /* apply driver default configuration */
298 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
302 static int wl1271_plt_init(struct wl1271 *wl)
304 struct conf_tx_ac_category *conf_ac;
305 struct conf_tx_tid *conf_tid;
308 ret = wl1271_cmd_general_parms(wl);
312 ret = wl1271_cmd_radio_parms(wl);
316 ret = wl1271_init_templates_config(wl);
320 ret = wl1271_acx_init_mem_config(wl);
324 /* PHY layer config */
325 ret = wl1271_init_phy_config(wl);
327 goto out_free_memmap;
329 ret = wl1271_acx_dco_itrim_params(wl);
331 goto out_free_memmap;
333 /* Initialize connection monitoring thresholds */
334 ret = wl1271_acx_conn_monit_params(wl, false);
336 goto out_free_memmap;
338 /* Bluetooth WLAN coexistence */
339 ret = wl1271_init_pta(wl);
341 goto out_free_memmap;
343 /* Energy detection */
344 ret = wl1271_init_energy_detection(wl);
346 goto out_free_memmap;
348 /* Default fragmentation threshold */
349 ret = wl1271_acx_frag_threshold(wl);
351 goto out_free_memmap;
353 /* Default TID configuration */
354 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
355 conf_tid = &wl->conf.tx.tid_conf[i];
356 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
357 conf_tid->channel_type,
360 conf_tid->ack_policy,
361 conf_tid->apsd_conf[0],
362 conf_tid->apsd_conf[1]);
364 goto out_free_memmap;
367 /* Default AC configuration */
368 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
369 conf_ac = &wl->conf.tx.ac_conf[i];
370 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
371 conf_ac->cw_max, conf_ac->aifsn,
372 conf_ac->tx_op_limit);
374 goto out_free_memmap;
377 /* Enable data path */
378 ret = wl1271_cmd_data_path(wl, 1);
380 goto out_free_memmap;
382 /* Configure for CAM power saving (ie. always active) */
383 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
385 goto out_free_memmap;
388 ret = wl1271_acx_pm_config(wl);
390 goto out_free_memmap;
395 kfree(wl->target_mem_map);
396 wl->target_mem_map = NULL;
401 static void wl1271_fw_status(struct wl1271 *wl,
402 struct wl1271_fw_status *status)
408 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
410 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
411 "drv_rx_counter = %d, tx_results_counter = %d)",
413 status->fw_rx_counter,
414 status->drv_rx_counter,
415 status->tx_results_counter);
417 /* update number of available TX blocks */
418 for (i = 0; i < NUM_TX_QUEUES; i++) {
419 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
420 wl->tx_blocks_freed[i];
422 wl->tx_blocks_freed[i] =
423 le32_to_cpu(status->tx_released_blks[i]);
424 wl->tx_blocks_available += cnt;
428 /* if more blocks are available now, schedule some tx work */
429 if (total && !skb_queue_empty(&wl->tx_queue))
430 ieee80211_queue_work(wl->hw, &wl->tx_work);
432 /* update the host-chipset time offset */
434 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
435 (s64)le32_to_cpu(status->fw_localtime);
438 #define WL1271_IRQ_MAX_LOOPS 10
440 static void wl1271_irq_work(struct work_struct *work)
444 int loopcount = WL1271_IRQ_MAX_LOOPS;
447 container_of(work, struct wl1271, irq_work);
449 mutex_lock(&wl->mutex);
451 wl1271_debug(DEBUG_IRQ, "IRQ work");
453 if (unlikely(wl->state == WL1271_STATE_OFF))
456 ret = wl1271_ps_elp_wakeup(wl, true);
460 spin_lock_irqsave(&wl->wl_lock, flags);
461 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
462 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
463 spin_unlock_irqrestore(&wl->wl_lock, flags);
466 wl1271_fw_status(wl, wl->fw_status);
467 intr = le32_to_cpu(wl->fw_status->intr);
469 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
473 intr &= WL1271_INTR_MASK;
475 if (intr & WL1271_ACX_INTR_DATA) {
476 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
478 /* check for tx results */
479 if (wl->fw_status->tx_results_counter !=
480 (wl->tx_results_count & 0xff))
481 wl1271_tx_complete(wl);
483 wl1271_rx(wl, wl->fw_status);
486 if (intr & WL1271_ACX_INTR_EVENT_A) {
487 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
488 wl1271_event_handle(wl, 0);
491 if (intr & WL1271_ACX_INTR_EVENT_B) {
492 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
493 wl1271_event_handle(wl, 1);
496 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
497 wl1271_debug(DEBUG_IRQ,
498 "WL1271_ACX_INTR_INIT_COMPLETE");
500 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
501 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
503 spin_lock_irqsave(&wl->wl_lock, flags);
506 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
507 ieee80211_queue_work(wl->hw, &wl->irq_work);
509 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
510 spin_unlock_irqrestore(&wl->wl_lock, flags);
512 wl1271_ps_elp_sleep(wl);
515 mutex_unlock(&wl->mutex);
518 static int wl1271_fetch_firmware(struct wl1271 *wl)
520 const struct firmware *fw;
523 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
526 wl1271_error("could not get firmware: %d", ret);
531 wl1271_error("firmware size is not multiple of 32 bits: %zu",
537 wl->fw_len = fw->size;
538 wl->fw = vmalloc(wl->fw_len);
541 wl1271_error("could not allocate memory for the firmware");
546 memcpy(wl->fw, fw->data, wl->fw_len);
551 release_firmware(fw);
556 static int wl1271_fetch_nvs(struct wl1271 *wl)
558 const struct firmware *fw;
561 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
564 wl1271_error("could not get nvs file: %d", ret);
568 if (fw->size != sizeof(struct wl1271_nvs_file)) {
569 wl1271_error("nvs size is not as expected: %zu != %zu",
570 fw->size, sizeof(struct wl1271_nvs_file));
575 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
578 wl1271_error("could not allocate memory for the nvs file");
583 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
586 release_firmware(fw);
591 static void wl1271_fw_wakeup(struct wl1271 *wl)
595 elp_reg = ELPCTRL_WAKE_UP;
596 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
599 static int wl1271_setup(struct wl1271 *wl)
601 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
605 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
606 if (!wl->tx_res_if) {
607 kfree(wl->fw_status);
611 INIT_WORK(&wl->irq_work, wl1271_irq_work);
612 INIT_WORK(&wl->tx_work, wl1271_tx_work);
616 static int wl1271_chip_wakeup(struct wl1271 *wl)
618 struct wl1271_partition_set partition;
621 msleep(WL1271_PRE_POWER_ON_SLEEP);
623 msleep(WL1271_POWER_ON_SLEEP);
627 /* We don't need a real memory partition here, because we only want
628 * to use the registers at this point. */
629 memset(&partition, 0, sizeof(partition));
630 partition.reg.start = REGISTERS_BASE;
631 partition.reg.size = REGISTERS_DOWN_SIZE;
632 wl1271_set_partition(wl, &partition);
634 /* ELP module wake up */
635 wl1271_fw_wakeup(wl);
637 /* whal_FwCtrl_BootSm() */
639 /* 0. read chip id from CHIP_ID */
640 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
642 /* 1. check if chip id is valid */
644 switch (wl->chip.id) {
645 case CHIP_ID_1271_PG10:
646 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
649 ret = wl1271_setup(wl);
653 case CHIP_ID_1271_PG20:
654 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
657 ret = wl1271_setup(wl);
662 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
667 if (wl->fw == NULL) {
668 ret = wl1271_fetch_firmware(wl);
673 /* No NVS from netlink, try to get it from the filesystem */
674 if (wl->nvs == NULL) {
675 ret = wl1271_fetch_nvs(wl);
684 int wl1271_plt_start(struct wl1271 *wl)
686 int retries = WL1271_BOOT_RETRIES;
689 mutex_lock(&wl->mutex);
691 wl1271_notice("power up");
693 if (wl->state != WL1271_STATE_OFF) {
694 wl1271_error("cannot go into PLT state because not "
695 "in off state: %d", wl->state);
702 ret = wl1271_chip_wakeup(wl);
706 ret = wl1271_boot(wl);
710 ret = wl1271_plt_init(wl);
714 wl->state = WL1271_STATE_PLT;
715 wl1271_notice("firmware booted in PLT mode (%s)",
720 wl1271_disable_interrupts(wl);
721 mutex_unlock(&wl->mutex);
722 /* Unlocking the mutex in the middle of handling is
723 inherently unsafe. In this case we deem it safe to do,
724 because we need to let any possibly pending IRQ out of
725 the system (and while we are WL1271_STATE_OFF the IRQ
726 work function will not do anything.) Also, any other
727 possible concurrent operations will fail due to the
728 current state, hence the wl1271 struct should be safe. */
729 cancel_work_sync(&wl->irq_work);
730 mutex_lock(&wl->mutex);
732 wl1271_power_off(wl);
735 wl1271_error("firmware boot in PLT mode failed despite %d retries",
736 WL1271_BOOT_RETRIES);
738 mutex_unlock(&wl->mutex);
743 int wl1271_plt_stop(struct wl1271 *wl)
747 mutex_lock(&wl->mutex);
749 wl1271_notice("power down");
751 if (wl->state != WL1271_STATE_PLT) {
752 wl1271_error("cannot power down because not in PLT "
753 "state: %d", wl->state);
758 wl1271_disable_interrupts(wl);
759 wl1271_power_off(wl);
761 wl->state = WL1271_STATE_OFF;
765 mutex_unlock(&wl->mutex);
771 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
773 struct wl1271 *wl = hw->priv;
774 struct ieee80211_conf *conf = &hw->conf;
775 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
776 struct ieee80211_sta *sta = txinfo->control.sta;
779 /* peek into the rates configured in the STA entry */
780 spin_lock_irqsave(&wl->wl_lock, flags);
781 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
782 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
783 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
785 spin_unlock_irqrestore(&wl->wl_lock, flags);
787 /* queue the packet */
788 skb_queue_tail(&wl->tx_queue, skb);
791 * The chip specific setup must run before the first TX packet -
792 * before that, the tx_work will not be initialized!
795 ieee80211_queue_work(wl->hw, &wl->tx_work);
798 * The workqueue is slow to process the tx_queue and we need stop
799 * the queue here, otherwise the queue will get too long.
801 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
802 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
804 spin_lock_irqsave(&wl->wl_lock, flags);
805 ieee80211_stop_queues(wl->hw);
806 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
807 spin_unlock_irqrestore(&wl->wl_lock, flags);
813 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
816 struct net_device *dev;
817 struct wireless_dev *wdev;
819 struct ieee80211_hw *hw;
821 struct wl1271 *wl_temp;
822 struct in_device *idev;
823 struct in_ifaddr *ifa = arg;
826 /* FIXME: this ugly function should probably be implemented in the
827 * mac80211, and here should only be a simple callback handling actual
828 * setting of the filters. Now we need to dig up references to
829 * various structures to gain access to what we need.
830 * Also, because of this, there is no "initial" setting of the filter
831 * in "op_start", because we don't want to dig up struct net_device
832 * there - the filter will be set upon first change of the interface
835 dev = ifa->ifa_dev->dev;
837 wdev = dev->ieee80211_ptr;
845 hw = wiphy_priv(wiphy);
849 /* Check that the interface is one supported by this driver. */
851 list_for_each_entry(wl, &wl_list, list) {
858 /* Get the interface IP address for the device. "ifa" will become
860 - there is no IPV4 protocol address configured
861 - there are multiple (virtual) IPV4 addresses configured
862 When "ifa" is NULL, filtering will be disabled.
867 ifa = idev->ifa_list;
869 if (ifa && ifa->ifa_next)
872 mutex_lock(&wl->mutex);
874 if (wl->state == WL1271_STATE_OFF)
877 ret = wl1271_ps_elp_wakeup(wl, false);
881 ret = wl1271_acx_arp_ip_filter(wl, true,
882 (u8 *)&ifa->ifa_address,
885 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
887 wl1271_ps_elp_sleep(wl);
890 mutex_unlock(&wl->mutex);
895 static struct notifier_block wl1271_dev_notifier = {
896 .notifier_call = wl1271_dev_notify,
900 static int wl1271_op_start(struct ieee80211_hw *hw)
902 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
905 * We have to delay the booting of the hardware because
906 * we need to know the local MAC address before downloading and
907 * initializing the firmware. The MAC address cannot be changed
908 * after boot, and without the proper MAC address, the firmware
909 * will not function properly.
911 * The MAC address is first known when the corresponding interface
912 * is added. That is where we will initialize the hardware.
918 static void wl1271_op_stop(struct ieee80211_hw *hw)
920 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
923 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
924 struct ieee80211_vif *vif)
926 struct wl1271 *wl = hw->priv;
927 int retries = WL1271_BOOT_RETRIES;
930 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
931 vif->type, vif->addr);
933 mutex_lock(&wl->mutex);
942 case NL80211_IFTYPE_STATION:
943 wl->bss_type = BSS_TYPE_STA_BSS;
944 wl->set_bss_type = BSS_TYPE_STA_BSS;
946 case NL80211_IFTYPE_ADHOC:
947 wl->bss_type = BSS_TYPE_IBSS;
948 wl->set_bss_type = BSS_TYPE_STA_BSS;
955 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
957 if (wl->state != WL1271_STATE_OFF) {
958 wl1271_error("cannot start because not in off state: %d",
966 ret = wl1271_chip_wakeup(wl);
970 ret = wl1271_boot(wl);
974 ret = wl1271_hw_init(wl);
978 wl->state = WL1271_STATE_ON;
979 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
983 wl1271_disable_interrupts(wl);
984 mutex_unlock(&wl->mutex);
985 /* Unlocking the mutex in the middle of handling is
986 inherently unsafe. In this case we deem it safe to do,
987 because we need to let any possibly pending IRQ out of
988 the system (and while we are WL1271_STATE_OFF the IRQ
989 work function will not do anything.) Also, any other
990 possible concurrent operations will fail due to the
991 current state, hence the wl1271 struct should be safe. */
992 cancel_work_sync(&wl->irq_work);
993 mutex_lock(&wl->mutex);
995 wl1271_power_off(wl);
998 wl1271_error("firmware boot failed despite %d retries",
999 WL1271_BOOT_RETRIES);
1001 mutex_unlock(&wl->mutex);
1004 list_add(&wl->list, &wl_list);
1005 register_inetaddr_notifier(&wl1271_dev_notifier);
1011 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1012 struct ieee80211_vif *vif)
1014 struct wl1271 *wl = hw->priv;
1017 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1019 mutex_lock(&wl->mutex);
1020 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1022 wl1271_info("down");
1024 list_del(&wl->list);
1026 WARN_ON(wl->state != WL1271_STATE_ON);
1028 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1029 mutex_unlock(&wl->mutex);
1030 ieee80211_scan_completed(wl->hw, true);
1031 mutex_lock(&wl->mutex);
1034 wl->state = WL1271_STATE_OFF;
1036 wl1271_disable_interrupts(wl);
1038 mutex_unlock(&wl->mutex);
1040 cancel_work_sync(&wl->irq_work);
1041 cancel_work_sync(&wl->tx_work);
1043 mutex_lock(&wl->mutex);
1045 /* let's notify MAC80211 about the remaining pending TX frames */
1046 wl1271_tx_flush(wl);
1047 wl1271_power_off(wl);
1049 memset(wl->bssid, 0, ETH_ALEN);
1050 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1052 wl->bss_type = MAX_BSS_TYPE;
1053 wl->set_bss_type = MAX_BSS_TYPE;
1054 wl->band = IEEE80211_BAND_2GHZ;
1057 wl->psm_entry_retry = 0;
1058 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1059 wl->tx_blocks_available = 0;
1060 wl->tx_results_count = 0;
1061 wl->tx_packets_count = 0;
1062 wl->tx_security_last_seq = 0;
1063 wl->tx_security_seq = 0;
1064 wl->time_offset = 0;
1065 wl->session_counter = 0;
1066 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1067 wl->sta_rate_set = 0;
1072 for (i = 0; i < NUM_TX_QUEUES; i++)
1073 wl->tx_blocks_freed[i] = 0;
1075 wl1271_debugfs_reset(wl);
1077 kfree(wl->fw_status);
1078 wl->fw_status = NULL;
1079 kfree(wl->tx_res_if);
1080 wl->tx_res_if = NULL;
1081 kfree(wl->target_mem_map);
1082 wl->target_mem_map = NULL;
1084 mutex_unlock(&wl->mutex);
1087 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1089 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1090 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1092 /* combine requested filters with current filter config */
1093 filters = wl->filters | filters;
1095 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1097 if (filters & FIF_PROMISC_IN_BSS) {
1098 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1099 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1100 wl->rx_config |= CFG_BSSID_FILTER_EN;
1102 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1103 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1104 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1105 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1107 if (filters & FIF_OTHER_BSS) {
1108 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1109 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1111 if (filters & FIF_CONTROL) {
1112 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1113 wl->rx_filter |= CFG_RX_CTL_EN;
1115 if (filters & FIF_FCSFAIL) {
1116 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1117 wl->rx_filter |= CFG_RX_FCS_ERROR;
1121 static int wl1271_dummy_join(struct wl1271 *wl)
1124 /* we need to use a dummy BSSID for now */
1125 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1128 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1130 /* pass through frames from all BSS */
1131 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1133 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1137 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1143 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1148 * One of the side effects of the JOIN command is that is clears
1149 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1150 * to a WPA/WPA2 access point will therefore kill the data-path.
1151 * Currently there is no supported scenario for JOIN during
1152 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1153 * must be handled somehow.
1156 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1157 wl1271_info("JOIN while associated.");
1160 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1162 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1166 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1168 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1172 * The join command disable the keep-alive mode, shut down its process,
1173 * and also clear the template config, so we need to reset it all after
1174 * the join. The acx_aid starts the keep-alive process, and the order
1175 * of the commands below is relevant.
1177 ret = wl1271_acx_keep_alive_mode(wl, true);
1181 ret = wl1271_acx_aid(wl, wl->aid);
1185 ret = wl1271_cmd_build_klv_null_data(wl);
1189 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1190 ACX_KEEP_ALIVE_TPL_VALID);
1198 static int wl1271_unjoin(struct wl1271 *wl)
1202 /* to stop listening to a channel, we disconnect */
1203 ret = wl1271_cmd_disconnect(wl);
1207 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1208 memset(wl->bssid, 0, ETH_ALEN);
1210 /* stop filterting packets based on bssid */
1211 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1217 static void wl1271_set_band_rate(struct wl1271 *wl)
1219 if (wl->band == IEEE80211_BAND_2GHZ)
1220 wl->basic_rate_set = wl->conf.tx.basic_rate;
1222 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1225 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1230 if (!wl->basic_rate_set) {
1232 wl->basic_rate_set = wl->conf.tx.basic_rate;
1235 for (i = 0; !rate; i++) {
1236 if ((wl->basic_rate_set >> i) & 0x1)
1243 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1245 struct wl1271 *wl = hw->priv;
1246 struct ieee80211_conf *conf = &hw->conf;
1247 int channel, ret = 0;
1249 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1251 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1253 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1255 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1257 mutex_lock(&wl->mutex);
1259 if (unlikely(wl->state == WL1271_STATE_OFF))
1262 ret = wl1271_ps_elp_wakeup(wl, false);
1266 /* if the channel changes while joined, join again */
1267 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1268 ((wl->band != conf->channel->band) ||
1269 (wl->channel != channel))) {
1270 wl->band = conf->channel->band;
1271 wl->channel = channel;
1274 * FIXME: the mac80211 should really provide a fixed rate
1275 * to use here. for now, just use the smallest possible rate
1276 * for the band as a fixed rate for association frames and
1277 * other control messages.
1279 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1280 wl1271_set_band_rate(wl);
1282 wl->basic_rate = wl1271_min_rate_get(wl);
1283 ret = wl1271_acx_rate_policies(wl);
1285 wl1271_warning("rate policy for update channel "
1288 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1289 ret = wl1271_join(wl, false);
1291 wl1271_warning("cmd join to update channel "
1296 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1297 if (conf->flags & IEEE80211_CONF_IDLE &&
1298 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1300 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1301 wl1271_dummy_join(wl);
1303 if (conf->flags & IEEE80211_CONF_IDLE) {
1304 wl->rate_set = wl1271_min_rate_get(wl);
1305 wl->sta_rate_set = 0;
1306 wl1271_acx_rate_policies(wl);
1307 wl1271_acx_keep_alive_config(
1308 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1309 ACX_KEEP_ALIVE_TPL_INVALID);
1310 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1312 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1315 if (conf->flags & IEEE80211_CONF_PS &&
1316 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1317 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1320 * We enter PSM only if we're already associated.
1321 * If we're not, we'll enter it when joining an SSID,
1322 * through the bss_info_changed() hook.
1324 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1325 wl1271_debug(DEBUG_PSM, "psm enabled");
1326 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1329 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1330 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1331 wl1271_debug(DEBUG_PSM, "psm disabled");
1333 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1335 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1336 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1340 if (conf->power_level != wl->power_level) {
1341 ret = wl1271_acx_tx_power(wl, conf->power_level);
1345 wl->power_level = conf->power_level;
1349 wl1271_ps_elp_sleep(wl);
1352 mutex_unlock(&wl->mutex);
1357 struct wl1271_filter_params {
1360 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1363 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1364 struct netdev_hw_addr_list *mc_list)
1366 struct wl1271_filter_params *fp;
1367 struct netdev_hw_addr *ha;
1368 struct wl1271 *wl = hw->priv;
1370 if (unlikely(wl->state == WL1271_STATE_OFF))
1373 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1375 wl1271_error("Out of memory setting filters.");
1379 /* update multicast filtering parameters */
1380 fp->mc_list_length = 0;
1381 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1382 fp->enabled = false;
1385 netdev_hw_addr_list_for_each(ha, mc_list) {
1386 memcpy(fp->mc_list[fp->mc_list_length],
1387 ha->addr, ETH_ALEN);
1388 fp->mc_list_length++;
1392 return (u64)(unsigned long)fp;
1395 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1398 FIF_BCN_PRBRESP_PROMISC | \
1402 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1403 unsigned int changed,
1404 unsigned int *total, u64 multicast)
1406 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1407 struct wl1271 *wl = hw->priv;
1410 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1412 mutex_lock(&wl->mutex);
1414 *total &= WL1271_SUPPORTED_FILTERS;
1415 changed &= WL1271_SUPPORTED_FILTERS;
1417 if (unlikely(wl->state == WL1271_STATE_OFF))
1420 ret = wl1271_ps_elp_wakeup(wl, false);
1425 if (*total & FIF_ALLMULTI)
1426 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1428 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1430 fp->mc_list_length);
1434 /* determine, whether supported filter values have changed */
1438 /* configure filters */
1439 wl->filters = *total;
1440 wl1271_configure_filters(wl, 0);
1442 /* apply configured filters */
1443 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1448 wl1271_ps_elp_sleep(wl);
1451 mutex_unlock(&wl->mutex);
1455 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1456 struct ieee80211_vif *vif,
1457 struct ieee80211_sta *sta,
1458 struct ieee80211_key_conf *key_conf)
1460 struct wl1271 *wl = hw->priv;
1467 static const u8 bcast_addr[ETH_ALEN] =
1468 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1470 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1472 addr = sta ? sta->addr : bcast_addr;
1474 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1475 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1476 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1477 key_conf->alg, key_conf->keyidx,
1478 key_conf->keylen, key_conf->flags);
1479 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1481 if (is_zero_ether_addr(addr)) {
1482 /* We dont support TX only encryption */
1487 mutex_lock(&wl->mutex);
1489 ret = wl1271_ps_elp_wakeup(wl, false);
1493 switch (key_conf->alg) {
1497 key_conf->hw_key_idx = key_conf->keyidx;
1500 key_type = KEY_TKIP;
1502 key_conf->hw_key_idx = key_conf->keyidx;
1503 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1504 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1509 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1510 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1511 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1514 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1522 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1523 key_conf->keyidx, key_type,
1524 key_conf->keylen, key_conf->key,
1525 addr, tx_seq_32, tx_seq_16);
1527 wl1271_error("Could not add or replace key");
1531 /* the default WEP key needs to be configured at least once */
1532 if (key_type == KEY_WEP) {
1533 ret = wl1271_cmd_set_default_wep_key(wl,
1541 /* The wl1271 does not allow to remove unicast keys - they
1542 will be cleared automatically on next CMD_JOIN. Ignore the
1543 request silently, as we dont want the mac80211 to emit
1544 an error message. */
1545 if (!is_broadcast_ether_addr(addr))
1548 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1549 key_conf->keyidx, key_type,
1550 key_conf->keylen, key_conf->key,
1553 wl1271_error("Could not remove key");
1559 wl1271_error("Unsupported key cmd 0x%x", cmd);
1567 wl1271_ps_elp_sleep(wl);
1570 mutex_unlock(&wl->mutex);
1576 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1577 struct ieee80211_vif *vif,
1578 struct cfg80211_scan_request *req)
1580 struct wl1271 *wl = hw->priv;
1585 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1588 ssid = req->ssids[0].ssid;
1589 len = req->ssids[0].ssid_len;
1592 mutex_lock(&wl->mutex);
1594 ret = wl1271_ps_elp_wakeup(wl, false);
1598 if (wl1271_11a_enabled())
1599 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1600 req->ie, req->ie_len, 1, 0,
1601 WL1271_SCAN_BAND_DUAL, 3);
1603 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1604 req->ie, req->ie_len, 1, 0,
1605 WL1271_SCAN_BAND_2_4_GHZ, 3);
1607 wl1271_ps_elp_sleep(wl);
1610 mutex_unlock(&wl->mutex);
1615 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1617 struct wl1271 *wl = hw->priv;
1620 mutex_lock(&wl->mutex);
1622 if (unlikely(wl->state == WL1271_STATE_OFF))
1625 ret = wl1271_ps_elp_wakeup(wl, false);
1629 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1631 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1633 wl1271_ps_elp_sleep(wl);
1636 mutex_unlock(&wl->mutex);
1641 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1643 u8 *ptr = beacon->data +
1644 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1646 /* find the location of the ssid in the beacon */
1647 while (ptr < beacon->data + beacon->len) {
1648 if (ptr[0] == WLAN_EID_SSID) {
1649 wl->ssid_len = ptr[1];
1650 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1655 wl1271_error("ad-hoc beacon template has no SSID!\n");
1658 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1659 struct ieee80211_vif *vif,
1660 struct ieee80211_bss_conf *bss_conf,
1663 enum wl1271_cmd_ps_mode mode;
1664 struct wl1271 *wl = hw->priv;
1665 bool do_join = false;
1666 bool set_assoc = false;
1669 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1671 mutex_lock(&wl->mutex);
1673 ret = wl1271_ps_elp_wakeup(wl, false);
1677 if ((changed && BSS_CHANGED_BEACON_INT) &&
1678 (wl->bss_type == BSS_TYPE_IBSS)) {
1679 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1680 bss_conf->beacon_int);
1682 wl->beacon_int = bss_conf->beacon_int;
1686 if ((changed && BSS_CHANGED_BEACON) &&
1687 (wl->bss_type == BSS_TYPE_IBSS)) {
1688 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1690 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1693 struct ieee80211_hdr *hdr;
1695 wl1271_ssid_set(wl, beacon);
1696 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1699 wl1271_min_rate_get(wl));
1702 dev_kfree_skb(beacon);
1706 hdr = (struct ieee80211_hdr *) beacon->data;
1707 hdr->frame_control = cpu_to_le16(
1708 IEEE80211_FTYPE_MGMT |
1709 IEEE80211_STYPE_PROBE_RESP);
1711 ret = wl1271_cmd_template_set(wl,
1712 CMD_TEMPL_PROBE_RESPONSE,
1715 wl1271_min_rate_get(wl));
1716 dev_kfree_skb(beacon);
1720 /* Need to update the SSID (for filtering etc) */
1725 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1726 (wl->bss_type == BSS_TYPE_IBSS)) {
1727 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1728 bss_conf->enable_beacon ? "enabled" : "disabled");
1730 if (bss_conf->enable_beacon)
1731 wl->set_bss_type = BSS_TYPE_IBSS;
1733 wl->set_bss_type = BSS_TYPE_STA_BSS;
1737 if (changed & BSS_CHANGED_CQM) {
1738 bool enable = false;
1739 if (bss_conf->cqm_rssi_thold)
1741 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1742 bss_conf->cqm_rssi_thold,
1743 bss_conf->cqm_rssi_hyst);
1746 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1749 if ((changed & BSS_CHANGED_BSSID) &&
1751 * Now we know the correct bssid, so we send a new join command
1752 * and enable the BSSID filter
1754 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1755 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1757 ret = wl1271_cmd_build_null_data(wl);
1761 ret = wl1271_build_qos_null_data(wl);
1765 /* filter out all packets not from this BSSID */
1766 wl1271_configure_filters(wl, 0);
1768 /* Need to update the BSSID (for filtering etc) */
1772 if (changed & BSS_CHANGED_ASSOC) {
1773 if (bss_conf->assoc) {
1775 wl->aid = bss_conf->aid;
1779 * use basic rates from AP, and determine lowest rate
1780 * to use with control frames.
1782 rates = bss_conf->basic_rates;
1783 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1785 wl->basic_rate = wl1271_min_rate_get(wl);
1786 ret = wl1271_acx_rate_policies(wl);
1791 * with wl1271, we don't need to update the
1792 * beacon_int and dtim_period, because the firmware
1793 * updates it by itself when the first beacon is
1794 * received after a join.
1796 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1801 * The SSID is intentionally set to NULL here - the
1802 * firmware will set the probe request with a
1803 * broadcast SSID regardless of what we set in the
1806 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1809 /* enable the connection monitoring feature */
1810 ret = wl1271_acx_conn_monit_params(wl, true);
1814 /* If we want to go in PSM but we're not there yet */
1815 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1816 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1817 mode = STATION_POWER_SAVE_MODE;
1818 ret = wl1271_ps_set_mode(wl, mode, true);
1823 /* use defaults when not associated */
1824 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1827 /* revert back to minimum rates for the current band */
1828 wl1271_set_band_rate(wl);
1829 wl->basic_rate = wl1271_min_rate_get(wl);
1830 ret = wl1271_acx_rate_policies(wl);
1834 /* disable connection monitor features */
1835 ret = wl1271_acx_conn_monit_params(wl, false);
1837 /* Disable the keep-alive feature */
1838 ret = wl1271_acx_keep_alive_mode(wl, false);
1846 if (changed & BSS_CHANGED_ERP_SLOT) {
1847 if (bss_conf->use_short_slot)
1848 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1850 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1852 wl1271_warning("Set slot time failed %d", ret);
1857 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1858 if (bss_conf->use_short_preamble)
1859 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1861 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1864 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1865 if (bss_conf->use_cts_prot)
1866 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1868 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1870 wl1271_warning("Set ctsprotect failed %d", ret);
1876 ret = wl1271_join(wl, set_assoc);
1878 wl1271_warning("cmd join failed %d", ret);
1884 wl1271_ps_elp_sleep(wl);
1887 mutex_unlock(&wl->mutex);
1890 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1891 const struct ieee80211_tx_queue_params *params)
1893 struct wl1271 *wl = hw->priv;
1897 mutex_lock(&wl->mutex);
1899 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1901 ret = wl1271_ps_elp_wakeup(wl, false);
1905 /* the txop is confed in units of 32us by the mac80211, we need us */
1906 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1907 params->cw_min, params->cw_max,
1908 params->aifs, params->txop << 5);
1913 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1915 ps_scheme = CONF_PS_SCHEME_LEGACY;
1917 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1918 CONF_CHANNEL_TYPE_EDCF,
1919 wl1271_tx_get_queue(queue),
1920 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1925 wl1271_ps_elp_sleep(wl);
1928 mutex_unlock(&wl->mutex);
1934 /* can't be const, mac80211 writes to this */
1935 static struct ieee80211_rate wl1271_rates[] = {
1937 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1938 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1940 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1941 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1942 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1944 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1945 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1946 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1948 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1949 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1950 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1952 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1953 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1955 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1956 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1958 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1959 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1961 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1962 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1964 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1965 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1967 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1968 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1970 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1971 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1973 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1974 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1977 /* can't be const, mac80211 writes to this */
1978 static struct ieee80211_channel wl1271_channels[] = {
1979 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1980 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1981 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1982 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1983 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1984 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1985 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1986 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1987 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1988 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1989 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1990 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1991 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1994 /* mapping to indexes for wl1271_rates */
1995 const static u8 wl1271_rate_to_idx_2ghz[] = {
1996 /* MCS rates are used only with 11n */
1997 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1998 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1999 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2000 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2001 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2002 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2003 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2004 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2006 11, /* CONF_HW_RXTX_RATE_54 */
2007 10, /* CONF_HW_RXTX_RATE_48 */
2008 9, /* CONF_HW_RXTX_RATE_36 */
2009 8, /* CONF_HW_RXTX_RATE_24 */
2011 /* TI-specific rate */
2012 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2014 7, /* CONF_HW_RXTX_RATE_18 */
2015 6, /* CONF_HW_RXTX_RATE_12 */
2016 3, /* CONF_HW_RXTX_RATE_11 */
2017 5, /* CONF_HW_RXTX_RATE_9 */
2018 4, /* CONF_HW_RXTX_RATE_6 */
2019 2, /* CONF_HW_RXTX_RATE_5_5 */
2020 1, /* CONF_HW_RXTX_RATE_2 */
2021 0 /* CONF_HW_RXTX_RATE_1 */
2024 /* can't be const, mac80211 writes to this */
2025 static struct ieee80211_supported_band wl1271_band_2ghz = {
2026 .channels = wl1271_channels,
2027 .n_channels = ARRAY_SIZE(wl1271_channels),
2028 .bitrates = wl1271_rates,
2029 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2032 /* 5 GHz data rates for WL1273 */
2033 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2035 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2036 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2038 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2039 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2041 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2042 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2044 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2045 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2047 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2048 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2050 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2051 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2053 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2054 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2056 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2057 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2060 /* 5 GHz band channels for WL1273 */
2061 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2062 { .hw_value = 183, .center_freq = 4915},
2063 { .hw_value = 184, .center_freq = 4920},
2064 { .hw_value = 185, .center_freq = 4925},
2065 { .hw_value = 187, .center_freq = 4935},
2066 { .hw_value = 188, .center_freq = 4940},
2067 { .hw_value = 189, .center_freq = 4945},
2068 { .hw_value = 192, .center_freq = 4960},
2069 { .hw_value = 196, .center_freq = 4980},
2070 { .hw_value = 7, .center_freq = 5035},
2071 { .hw_value = 8, .center_freq = 5040},
2072 { .hw_value = 9, .center_freq = 5045},
2073 { .hw_value = 11, .center_freq = 5055},
2074 { .hw_value = 12, .center_freq = 5060},
2075 { .hw_value = 16, .center_freq = 5080},
2076 { .hw_value = 34, .center_freq = 5170},
2077 { .hw_value = 36, .center_freq = 5180},
2078 { .hw_value = 38, .center_freq = 5190},
2079 { .hw_value = 40, .center_freq = 5200},
2080 { .hw_value = 42, .center_freq = 5210},
2081 { .hw_value = 44, .center_freq = 5220},
2082 { .hw_value = 46, .center_freq = 5230},
2083 { .hw_value = 48, .center_freq = 5240},
2084 { .hw_value = 52, .center_freq = 5260},
2085 { .hw_value = 56, .center_freq = 5280},
2086 { .hw_value = 60, .center_freq = 5300},
2087 { .hw_value = 64, .center_freq = 5320},
2088 { .hw_value = 100, .center_freq = 5500},
2089 { .hw_value = 104, .center_freq = 5520},
2090 { .hw_value = 108, .center_freq = 5540},
2091 { .hw_value = 112, .center_freq = 5560},
2092 { .hw_value = 116, .center_freq = 5580},
2093 { .hw_value = 120, .center_freq = 5600},
2094 { .hw_value = 124, .center_freq = 5620},
2095 { .hw_value = 128, .center_freq = 5640},
2096 { .hw_value = 132, .center_freq = 5660},
2097 { .hw_value = 136, .center_freq = 5680},
2098 { .hw_value = 140, .center_freq = 5700},
2099 { .hw_value = 149, .center_freq = 5745},
2100 { .hw_value = 153, .center_freq = 5765},
2101 { .hw_value = 157, .center_freq = 5785},
2102 { .hw_value = 161, .center_freq = 5805},
2103 { .hw_value = 165, .center_freq = 5825},
2106 /* mapping to indexes for wl1271_rates_5ghz */
2107 const static u8 wl1271_rate_to_idx_5ghz[] = {
2108 /* MCS rates are used only with 11n */
2109 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2110 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2111 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2112 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2113 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2114 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2115 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2116 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2118 7, /* CONF_HW_RXTX_RATE_54 */
2119 6, /* CONF_HW_RXTX_RATE_48 */
2120 5, /* CONF_HW_RXTX_RATE_36 */
2121 4, /* CONF_HW_RXTX_RATE_24 */
2123 /* TI-specific rate */
2124 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2126 3, /* CONF_HW_RXTX_RATE_18 */
2127 2, /* CONF_HW_RXTX_RATE_12 */
2128 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2129 1, /* CONF_HW_RXTX_RATE_9 */
2130 0, /* CONF_HW_RXTX_RATE_6 */
2131 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2132 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2133 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2136 static struct ieee80211_supported_band wl1271_band_5ghz = {
2137 .channels = wl1271_channels_5ghz,
2138 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2139 .bitrates = wl1271_rates_5ghz,
2140 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2143 const static u8 *wl1271_band_rate_to_idx[] = {
2144 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2145 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2148 static const struct ieee80211_ops wl1271_ops = {
2149 .start = wl1271_op_start,
2150 .stop = wl1271_op_stop,
2151 .add_interface = wl1271_op_add_interface,
2152 .remove_interface = wl1271_op_remove_interface,
2153 .config = wl1271_op_config,
2154 .prepare_multicast = wl1271_op_prepare_multicast,
2155 .configure_filter = wl1271_op_configure_filter,
2157 .set_key = wl1271_op_set_key,
2158 .hw_scan = wl1271_op_hw_scan,
2159 .bss_info_changed = wl1271_op_bss_info_changed,
2160 .set_rts_threshold = wl1271_op_set_rts_threshold,
2161 .conf_tx = wl1271_op_conf_tx,
2162 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2166 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2170 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2172 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2173 wl1271_error("Illegal RX rate from HW: %d", rate);
2177 idx = wl1271_band_rate_to_idx[wl->band][rate];
2178 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2179 wl1271_error("Unsupported RX rate from HW: %d", rate);
2186 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2187 struct device_attribute *attr,
2190 struct wl1271 *wl = dev_get_drvdata(dev);
2193 /* FIXME: what's the maximum length of buf? page size?*/
2196 mutex_lock(&wl->mutex);
2197 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2199 mutex_unlock(&wl->mutex);
2205 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2206 struct device_attribute *attr,
2207 const char *buf, size_t count)
2209 struct wl1271 *wl = dev_get_drvdata(dev);
2213 ret = strict_strtoul(buf, 10, &res);
2216 wl1271_warning("incorrect value written to bt_coex_mode");
2220 mutex_lock(&wl->mutex);
2224 if (res == wl->sg_enabled)
2227 wl->sg_enabled = res;
2229 if (wl->state == WL1271_STATE_OFF)
2232 ret = wl1271_ps_elp_wakeup(wl, false);
2236 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2237 wl1271_ps_elp_sleep(wl);
2240 mutex_unlock(&wl->mutex);
2244 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2245 wl1271_sysfs_show_bt_coex_state,
2246 wl1271_sysfs_store_bt_coex_state);
2248 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2249 struct device_attribute *attr,
2252 struct wl1271 *wl = dev_get_drvdata(dev);
2255 /* FIXME: what's the maximum length of buf? page size?*/
2258 mutex_lock(&wl->mutex);
2259 if (wl->hw_pg_ver >= 0)
2260 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2262 len = snprintf(buf, len, "n/a\n");
2263 mutex_unlock(&wl->mutex);
2268 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2269 wl1271_sysfs_show_hw_pg_ver, NULL);
2271 int wl1271_register_hw(struct wl1271 *wl)
2275 if (wl->mac80211_registered)
2278 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2280 ret = ieee80211_register_hw(wl->hw);
2282 wl1271_error("unable to register mac80211 hw: %d", ret);
2286 wl->mac80211_registered = true;
2288 wl1271_notice("loaded");
2292 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2294 void wl1271_unregister_hw(struct wl1271 *wl)
2296 ieee80211_unregister_hw(wl->hw);
2297 wl->mac80211_registered = false;
2300 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2302 int wl1271_init_ieee80211(struct wl1271 *wl)
2304 /* The tx descriptor buffer and the TKIP space. */
2305 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2306 sizeof(struct wl1271_tx_hw_descr);
2309 /* FIXME: find a proper value */
2310 wl->hw->channel_change_time = 10000;
2311 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2313 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2314 IEEE80211_HW_BEACON_FILTER |
2315 IEEE80211_HW_SUPPORTS_PS |
2316 IEEE80211_HW_SUPPORTS_UAPSD |
2317 IEEE80211_HW_HAS_RATE_CONTROL |
2318 IEEE80211_HW_CONNECTION_MONITOR |
2319 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2321 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2322 BIT(NL80211_IFTYPE_ADHOC);
2323 wl->hw->wiphy->max_scan_ssids = 1;
2324 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2326 if (wl1271_11a_enabled())
2327 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2330 wl->hw->max_rates = 1;
2332 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2336 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2338 #define WL1271_DEFAULT_CHANNEL 0
2340 struct ieee80211_hw *wl1271_alloc_hw(void)
2342 struct ieee80211_hw *hw;
2343 struct platform_device *plat_dev = NULL;
2347 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2349 wl1271_error("could not alloc ieee80211_hw");
2354 plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2356 wl1271_error("could not allocate platform_device");
2358 goto err_plat_alloc;
2361 memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2364 memset(wl, 0, sizeof(*wl));
2366 INIT_LIST_HEAD(&wl->list);
2369 wl->plat_dev = plat_dev;
2371 skb_queue_head_init(&wl->tx_queue);
2373 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2374 wl->channel = WL1271_DEFAULT_CHANNEL;
2375 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2376 wl->default_key = 0;
2378 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2379 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2380 wl->psm_entry_retry = 0;
2381 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2382 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2383 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2384 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2385 wl->sta_rate_set = 0;
2386 wl->band = IEEE80211_BAND_2GHZ;
2389 wl->sg_enabled = true;
2392 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2393 wl->tx_frames[i] = NULL;
2395 spin_lock_init(&wl->wl_lock);
2397 wl->state = WL1271_STATE_OFF;
2398 mutex_init(&wl->mutex);
2400 /* Apply default driver configuration. */
2401 wl1271_conf_init(wl);
2403 wl1271_debugfs_init(wl);
2405 /* Register platform device */
2406 ret = platform_device_register(wl->plat_dev);
2408 wl1271_error("couldn't register platform device");
2411 dev_set_drvdata(&wl->plat_dev->dev, wl);
2413 /* Create sysfs file to control bt coex state */
2414 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2416 wl1271_error("failed to create sysfs file bt_coex_state");
2420 /* Create sysfs file to get HW PG version */
2421 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2423 wl1271_error("failed to create sysfs file hw_pg_ver");
2424 goto err_bt_coex_state;
2430 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2433 platform_device_unregister(wl->plat_dev);
2436 wl1271_debugfs_exit(wl);
2440 ieee80211_free_hw(hw);
2444 return ERR_PTR(ret);
2446 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2448 int wl1271_free_hw(struct wl1271 *wl)
2450 platform_device_unregister(wl->plat_dev);
2451 kfree(wl->plat_dev);
2453 wl1271_debugfs_exit(wl);
2460 kfree(wl->fw_status);
2461 kfree(wl->tx_res_if);
2463 ieee80211_free_hw(wl->hw);
2467 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2469 MODULE_LICENSE("GPL");
2470 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2471 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");