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/platform_device.h>
32 #include <linux/slab.h>
35 #include "wl12xx_80211.h"
36 #include "wl1271_reg.h"
37 #include "wl1271_io.h"
38 #include "wl1271_event.h"
39 #include "wl1271_tx.h"
40 #include "wl1271_rx.h"
41 #include "wl1271_ps.h"
42 #include "wl1271_init.h"
43 #include "wl1271_debugfs.h"
44 #include "wl1271_cmd.h"
45 #include "wl1271_boot.h"
46 #include "wl1271_testmode.h"
47 #include "wl1271_scan.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] = 1,
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 = 10,
238 .ps_poll_recovery_period = 700,
239 .bet_enable = CONF_BET_MODE_ENABLE,
240 .bet_max_consecutive = 10,
241 .psm_entry_retries = 3,
242 .keep_alive_interval = 55000,
243 .max_listen_interval = 20,
250 .host_clk_settling_time = 5000,
251 .host_fast_wakeup_support = false
255 .avg_weight_rssi_beacon = 20,
256 .avg_weight_rssi_data = 10,
257 .avg_weight_snr_beacon = 20,
258 .avg_weight_snr_data = 10
262 static void wl1271_device_release(struct device *dev)
267 static struct platform_device wl1271_device = {
271 /* device model insists to have a release function */
273 .release = wl1271_device_release,
277 static LIST_HEAD(wl_list);
279 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
282 struct net_device *dev = arg;
283 struct wireless_dev *wdev;
285 struct ieee80211_hw *hw;
287 struct wl1271 *wl_temp;
290 /* Check that this notification is for us. */
291 if (what != NETDEV_CHANGE)
294 wdev = dev->ieee80211_ptr;
302 hw = wiphy_priv(wiphy);
307 list_for_each_entry(wl, &wl_list, list) {
314 mutex_lock(&wl->mutex);
316 if (wl->state == WL1271_STATE_OFF)
319 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
322 ret = wl1271_ps_elp_wakeup(wl, false);
326 if ((dev->operstate == IF_OPER_UP) &&
327 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
328 wl1271_cmd_set_sta_state(wl);
329 wl1271_info("Association completed.");
332 wl1271_ps_elp_sleep(wl);
335 mutex_unlock(&wl->mutex);
340 static void wl1271_conf_init(struct wl1271 *wl)
344 * This function applies the default configuration to the driver. This
345 * function is invoked upon driver load (spi probe.)
347 * The configuration is stored in a run-time structure in order to
348 * facilitate for run-time adjustment of any of the parameters. Making
349 * changes to the configuration structure will apply the new values on
350 * the next interface up (wl1271_op_start.)
353 /* apply driver default configuration */
354 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
358 static int wl1271_plt_init(struct wl1271 *wl)
360 struct conf_tx_ac_category *conf_ac;
361 struct conf_tx_tid *conf_tid;
364 ret = wl1271_cmd_general_parms(wl);
368 ret = wl1271_cmd_radio_parms(wl);
372 ret = wl1271_init_templates_config(wl);
376 ret = wl1271_acx_init_mem_config(wl);
380 /* PHY layer config */
381 ret = wl1271_init_phy_config(wl);
383 goto out_free_memmap;
385 ret = wl1271_acx_dco_itrim_params(wl);
387 goto out_free_memmap;
389 /* Initialize connection monitoring thresholds */
390 ret = wl1271_acx_conn_monit_params(wl, false);
392 goto out_free_memmap;
394 /* Bluetooth WLAN coexistence */
395 ret = wl1271_init_pta(wl);
397 goto out_free_memmap;
399 /* Energy detection */
400 ret = wl1271_init_energy_detection(wl);
402 goto out_free_memmap;
404 /* Default fragmentation threshold */
405 ret = wl1271_acx_frag_threshold(wl);
407 goto out_free_memmap;
409 /* Default TID configuration */
410 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
411 conf_tid = &wl->conf.tx.tid_conf[i];
412 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
413 conf_tid->channel_type,
416 conf_tid->ack_policy,
417 conf_tid->apsd_conf[0],
418 conf_tid->apsd_conf[1]);
420 goto out_free_memmap;
423 /* Default AC configuration */
424 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
425 conf_ac = &wl->conf.tx.ac_conf[i];
426 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
427 conf_ac->cw_max, conf_ac->aifsn,
428 conf_ac->tx_op_limit);
430 goto out_free_memmap;
433 /* Enable data path */
434 ret = wl1271_cmd_data_path(wl, 1);
436 goto out_free_memmap;
438 /* Configure for CAM power saving (ie. always active) */
439 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
441 goto out_free_memmap;
444 ret = wl1271_acx_pm_config(wl);
446 goto out_free_memmap;
451 kfree(wl->target_mem_map);
452 wl->target_mem_map = NULL;
457 static void wl1271_fw_status(struct wl1271 *wl,
458 struct wl1271_fw_status *status)
464 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
466 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
467 "drv_rx_counter = %d, tx_results_counter = %d)",
469 status->fw_rx_counter,
470 status->drv_rx_counter,
471 status->tx_results_counter);
473 /* update number of available TX blocks */
474 for (i = 0; i < NUM_TX_QUEUES; i++) {
475 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
476 wl->tx_blocks_freed[i];
478 wl->tx_blocks_freed[i] =
479 le32_to_cpu(status->tx_released_blks[i]);
480 wl->tx_blocks_available += cnt;
484 /* if more blocks are available now, schedule some tx work */
485 if (total && !skb_queue_empty(&wl->tx_queue))
486 ieee80211_queue_work(wl->hw, &wl->tx_work);
488 /* update the host-chipset time offset */
490 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
491 (s64)le32_to_cpu(status->fw_localtime);
494 #define WL1271_IRQ_MAX_LOOPS 10
496 static void wl1271_irq_work(struct work_struct *work)
500 int loopcount = WL1271_IRQ_MAX_LOOPS;
503 container_of(work, struct wl1271, irq_work);
505 mutex_lock(&wl->mutex);
507 wl1271_debug(DEBUG_IRQ, "IRQ work");
509 if (unlikely(wl->state == WL1271_STATE_OFF))
512 ret = wl1271_ps_elp_wakeup(wl, true);
516 spin_lock_irqsave(&wl->wl_lock, flags);
517 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
518 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
519 spin_unlock_irqrestore(&wl->wl_lock, flags);
522 wl1271_fw_status(wl, wl->fw_status);
523 intr = le32_to_cpu(wl->fw_status->intr);
525 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
526 spin_lock_irqsave(&wl->wl_lock, flags);
530 intr &= WL1271_INTR_MASK;
532 if (intr & WL1271_ACX_INTR_DATA) {
533 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
535 /* check for tx results */
536 if (wl->fw_status->tx_results_counter !=
537 (wl->tx_results_count & 0xff))
538 wl1271_tx_complete(wl);
540 wl1271_rx(wl, wl->fw_status);
543 if (intr & WL1271_ACX_INTR_EVENT_A) {
544 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
545 wl1271_event_handle(wl, 0);
548 if (intr & WL1271_ACX_INTR_EVENT_B) {
549 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
550 wl1271_event_handle(wl, 1);
553 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
554 wl1271_debug(DEBUG_IRQ,
555 "WL1271_ACX_INTR_INIT_COMPLETE");
557 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
558 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
560 spin_lock_irqsave(&wl->wl_lock, flags);
563 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
564 ieee80211_queue_work(wl->hw, &wl->irq_work);
566 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
567 spin_unlock_irqrestore(&wl->wl_lock, flags);
569 wl1271_ps_elp_sleep(wl);
572 mutex_unlock(&wl->mutex);
575 static int wl1271_fetch_firmware(struct wl1271 *wl)
577 const struct firmware *fw;
580 ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
583 wl1271_error("could not get firmware: %d", ret);
588 wl1271_error("firmware size is not multiple of 32 bits: %zu",
594 wl->fw_len = fw->size;
595 wl->fw = vmalloc(wl->fw_len);
598 wl1271_error("could not allocate memory for the firmware");
603 memcpy(wl->fw, fw->data, wl->fw_len);
608 release_firmware(fw);
613 static int wl1271_fetch_nvs(struct wl1271 *wl)
615 const struct firmware *fw;
618 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
621 wl1271_error("could not get nvs file: %d", ret);
625 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
628 wl1271_error("could not allocate memory for the nvs file");
633 wl->nvs_len = fw->size;
636 release_firmware(fw);
641 static void wl1271_fw_wakeup(struct wl1271 *wl)
645 elp_reg = ELPCTRL_WAKE_UP;
646 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
649 static int wl1271_setup(struct wl1271 *wl)
651 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
655 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
656 if (!wl->tx_res_if) {
657 kfree(wl->fw_status);
661 INIT_WORK(&wl->irq_work, wl1271_irq_work);
662 INIT_WORK(&wl->tx_work, wl1271_tx_work);
666 static int wl1271_chip_wakeup(struct wl1271 *wl)
668 struct wl1271_partition_set partition;
671 msleep(WL1271_PRE_POWER_ON_SLEEP);
672 ret = wl1271_power_on(wl);
675 msleep(WL1271_POWER_ON_SLEEP);
679 /* We don't need a real memory partition here, because we only want
680 * to use the registers at this point. */
681 memset(&partition, 0, sizeof(partition));
682 partition.reg.start = REGISTERS_BASE;
683 partition.reg.size = REGISTERS_DOWN_SIZE;
684 wl1271_set_partition(wl, &partition);
686 /* ELP module wake up */
687 wl1271_fw_wakeup(wl);
689 /* whal_FwCtrl_BootSm() */
691 /* 0. read chip id from CHIP_ID */
692 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
694 /* 1. check if chip id is valid */
696 switch (wl->chip.id) {
697 case CHIP_ID_1271_PG10:
698 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
701 ret = wl1271_setup(wl);
705 case CHIP_ID_1271_PG20:
706 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
709 ret = wl1271_setup(wl);
714 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
719 if (wl->fw == NULL) {
720 ret = wl1271_fetch_firmware(wl);
725 /* No NVS from netlink, try to get it from the filesystem */
726 if (wl->nvs == NULL) {
727 ret = wl1271_fetch_nvs(wl);
736 int wl1271_plt_start(struct wl1271 *wl)
738 int retries = WL1271_BOOT_RETRIES;
741 mutex_lock(&wl->mutex);
743 wl1271_notice("power up");
745 if (wl->state != WL1271_STATE_OFF) {
746 wl1271_error("cannot go into PLT state because not "
747 "in off state: %d", wl->state);
754 ret = wl1271_chip_wakeup(wl);
758 ret = wl1271_boot(wl);
762 ret = wl1271_plt_init(wl);
766 wl->state = WL1271_STATE_PLT;
767 wl1271_notice("firmware booted in PLT mode (%s)",
772 wl1271_disable_interrupts(wl);
773 mutex_unlock(&wl->mutex);
774 /* Unlocking the mutex in the middle of handling is
775 inherently unsafe. In this case we deem it safe to do,
776 because we need to let any possibly pending IRQ out of
777 the system (and while we are WL1271_STATE_OFF the IRQ
778 work function will not do anything.) Also, any other
779 possible concurrent operations will fail due to the
780 current state, hence the wl1271 struct should be safe. */
781 cancel_work_sync(&wl->irq_work);
782 mutex_lock(&wl->mutex);
784 wl1271_power_off(wl);
787 wl1271_error("firmware boot in PLT mode failed despite %d retries",
788 WL1271_BOOT_RETRIES);
790 mutex_unlock(&wl->mutex);
795 int wl1271_plt_stop(struct wl1271 *wl)
799 mutex_lock(&wl->mutex);
801 wl1271_notice("power down");
803 if (wl->state != WL1271_STATE_PLT) {
804 wl1271_error("cannot power down because not in PLT "
805 "state: %d", wl->state);
810 wl1271_disable_interrupts(wl);
811 wl1271_power_off(wl);
813 wl->state = WL1271_STATE_OFF;
817 mutex_unlock(&wl->mutex);
823 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
825 struct wl1271 *wl = hw->priv;
826 struct ieee80211_conf *conf = &hw->conf;
827 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
828 struct ieee80211_sta *sta = txinfo->control.sta;
831 /* peek into the rates configured in the STA entry */
832 spin_lock_irqsave(&wl->wl_lock, flags);
833 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
834 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
835 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
837 spin_unlock_irqrestore(&wl->wl_lock, flags);
839 /* queue the packet */
840 skb_queue_tail(&wl->tx_queue, skb);
843 * The chip specific setup must run before the first TX packet -
844 * before that, the tx_work will not be initialized!
847 ieee80211_queue_work(wl->hw, &wl->tx_work);
850 * The workqueue is slow to process the tx_queue and we need stop
851 * the queue here, otherwise the queue will get too long.
853 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
854 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
856 spin_lock_irqsave(&wl->wl_lock, flags);
857 ieee80211_stop_queues(wl->hw);
858 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
859 spin_unlock_irqrestore(&wl->wl_lock, flags);
865 static struct notifier_block wl1271_dev_notifier = {
866 .notifier_call = wl1271_dev_notify,
869 static int wl1271_op_start(struct ieee80211_hw *hw)
871 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
874 * We have to delay the booting of the hardware because
875 * we need to know the local MAC address before downloading and
876 * initializing the firmware. The MAC address cannot be changed
877 * after boot, and without the proper MAC address, the firmware
878 * will not function properly.
880 * The MAC address is first known when the corresponding interface
881 * is added. That is where we will initialize the hardware.
887 static void wl1271_op_stop(struct ieee80211_hw *hw)
889 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
892 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
893 struct ieee80211_vif *vif)
895 struct wl1271 *wl = hw->priv;
896 struct wiphy *wiphy = hw->wiphy;
897 int retries = WL1271_BOOT_RETRIES;
900 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
901 vif->type, vif->addr);
903 mutex_lock(&wl->mutex);
912 case NL80211_IFTYPE_STATION:
913 wl->bss_type = BSS_TYPE_STA_BSS;
914 wl->set_bss_type = BSS_TYPE_STA_BSS;
916 case NL80211_IFTYPE_ADHOC:
917 wl->bss_type = BSS_TYPE_IBSS;
918 wl->set_bss_type = BSS_TYPE_STA_BSS;
925 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
927 if (wl->state != WL1271_STATE_OFF) {
928 wl1271_error("cannot start because not in off state: %d",
936 ret = wl1271_chip_wakeup(wl);
940 ret = wl1271_boot(wl);
944 ret = wl1271_hw_init(wl);
948 wl->state = WL1271_STATE_ON;
949 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
951 /* update hw/fw version info in wiphy struct */
952 wiphy->hw_version = wl->chip.id;
953 strncpy(wiphy->fw_version, wl->chip.fw_ver,
954 sizeof(wiphy->fw_version));
959 wl1271_disable_interrupts(wl);
960 mutex_unlock(&wl->mutex);
961 /* Unlocking the mutex in the middle of handling is
962 inherently unsafe. In this case we deem it safe to do,
963 because we need to let any possibly pending IRQ out of
964 the system (and while we are WL1271_STATE_OFF the IRQ
965 work function will not do anything.) Also, any other
966 possible concurrent operations will fail due to the
967 current state, hence the wl1271 struct should be safe. */
968 cancel_work_sync(&wl->irq_work);
969 mutex_lock(&wl->mutex);
971 wl1271_power_off(wl);
974 wl1271_error("firmware boot failed despite %d retries",
975 WL1271_BOOT_RETRIES);
977 mutex_unlock(&wl->mutex);
980 list_add(&wl->list, &wl_list);
985 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
986 struct ieee80211_vif *vif)
988 struct wl1271 *wl = hw->priv;
991 mutex_lock(&wl->mutex);
992 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
998 WARN_ON(wl->state != WL1271_STATE_ON);
1000 /* enable dyn ps just in case (if left on due to fw crash etc) */
1001 if (wl->bss_type == BSS_TYPE_STA_BSS)
1002 ieee80211_enable_dyn_ps(wl->vif);
1004 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1005 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1006 kfree(wl->scan.scanned_ch);
1007 wl->scan.scanned_ch = NULL;
1008 ieee80211_scan_completed(wl->hw, true);
1011 wl->state = WL1271_STATE_OFF;
1013 wl1271_disable_interrupts(wl);
1015 mutex_unlock(&wl->mutex);
1017 cancel_work_sync(&wl->irq_work);
1018 cancel_work_sync(&wl->tx_work);
1019 cancel_delayed_work_sync(&wl->pspoll_work);
1021 mutex_lock(&wl->mutex);
1023 /* let's notify MAC80211 about the remaining pending TX frames */
1024 wl1271_tx_reset(wl);
1025 wl1271_power_off(wl);
1027 memset(wl->bssid, 0, ETH_ALEN);
1028 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1030 wl->bss_type = MAX_BSS_TYPE;
1031 wl->set_bss_type = MAX_BSS_TYPE;
1032 wl->band = IEEE80211_BAND_2GHZ;
1035 wl->psm_entry_retry = 0;
1036 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1037 wl->tx_blocks_available = 0;
1038 wl->tx_results_count = 0;
1039 wl->tx_packets_count = 0;
1040 wl->tx_security_last_seq = 0;
1041 wl->tx_security_seq = 0;
1042 wl->time_offset = 0;
1043 wl->session_counter = 0;
1044 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1045 wl->sta_rate_set = 0;
1050 for (i = 0; i < NUM_TX_QUEUES; i++)
1051 wl->tx_blocks_freed[i] = 0;
1053 wl1271_debugfs_reset(wl);
1055 kfree(wl->fw_status);
1056 wl->fw_status = NULL;
1057 kfree(wl->tx_res_if);
1058 wl->tx_res_if = NULL;
1059 kfree(wl->target_mem_map);
1060 wl->target_mem_map = NULL;
1062 mutex_unlock(&wl->mutex);
1065 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1067 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1068 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1070 /* combine requested filters with current filter config */
1071 filters = wl->filters | filters;
1073 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1075 if (filters & FIF_PROMISC_IN_BSS) {
1076 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1077 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1078 wl->rx_config |= CFG_BSSID_FILTER_EN;
1080 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1081 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1082 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1083 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1085 if (filters & FIF_OTHER_BSS) {
1086 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1087 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1089 if (filters & FIF_CONTROL) {
1090 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1091 wl->rx_filter |= CFG_RX_CTL_EN;
1093 if (filters & FIF_FCSFAIL) {
1094 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1095 wl->rx_filter |= CFG_RX_FCS_ERROR;
1099 static int wl1271_dummy_join(struct wl1271 *wl)
1102 /* we need to use a dummy BSSID for now */
1103 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1106 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1108 /* pass through frames from all BSS */
1109 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1111 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1115 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1121 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1126 * One of the side effects of the JOIN command is that is clears
1127 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1128 * to a WPA/WPA2 access point will therefore kill the data-path.
1129 * Currently there is no supported scenario for JOIN during
1130 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1131 * must be handled somehow.
1134 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1135 wl1271_info("JOIN while associated.");
1138 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1140 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1144 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1146 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1150 * The join command disable the keep-alive mode, shut down its process,
1151 * and also clear the template config, so we need to reset it all after
1152 * the join. The acx_aid starts the keep-alive process, and the order
1153 * of the commands below is relevant.
1155 ret = wl1271_acx_keep_alive_mode(wl, true);
1159 ret = wl1271_acx_aid(wl, wl->aid);
1163 ret = wl1271_cmd_build_klv_null_data(wl);
1167 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1168 ACX_KEEP_ALIVE_TPL_VALID);
1176 static int wl1271_unjoin(struct wl1271 *wl)
1180 /* to stop listening to a channel, we disconnect */
1181 ret = wl1271_cmd_disconnect(wl);
1185 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1186 memset(wl->bssid, 0, ETH_ALEN);
1188 /* stop filterting packets based on bssid */
1189 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1195 static void wl1271_set_band_rate(struct wl1271 *wl)
1197 if (wl->band == IEEE80211_BAND_2GHZ)
1198 wl->basic_rate_set = wl->conf.tx.basic_rate;
1200 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1203 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1208 if (!wl->basic_rate_set) {
1210 wl->basic_rate_set = wl->conf.tx.basic_rate;
1213 for (i = 0; !rate; i++) {
1214 if ((wl->basic_rate_set >> i) & 0x1)
1221 static int wl1271_handle_idle(struct wl1271 *wl, bool idle)
1226 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1227 ret = wl1271_unjoin(wl);
1231 wl->rate_set = wl1271_min_rate_get(wl);
1232 wl->sta_rate_set = 0;
1233 ret = wl1271_acx_rate_policies(wl);
1236 ret = wl1271_acx_keep_alive_config(
1237 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1238 ACX_KEEP_ALIVE_TPL_INVALID);
1241 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1243 /* increment the session counter */
1244 wl->session_counter++;
1245 if (wl->session_counter >= SESSION_COUNTER_MAX)
1246 wl->session_counter = 0;
1247 ret = wl1271_dummy_join(wl);
1250 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1257 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1259 struct wl1271 *wl = hw->priv;
1260 struct ieee80211_conf *conf = &hw->conf;
1261 int channel, ret = 0;
1263 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1265 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1267 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1269 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1272 * mac80211 will go to idle nearly immediately after transmitting some
1273 * frames, such as the deauth. To make sure those frames reach the air,
1274 * wait here until the TX queue is fully flushed.
1276 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1277 (conf->flags & IEEE80211_CONF_IDLE))
1278 wl1271_tx_flush(wl);
1280 mutex_lock(&wl->mutex);
1282 if (unlikely(wl->state == WL1271_STATE_OFF))
1285 ret = wl1271_ps_elp_wakeup(wl, false);
1289 /* if the channel changes while joined, join again */
1290 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1291 ((wl->band != conf->channel->band) ||
1292 (wl->channel != channel))) {
1293 wl->band = conf->channel->band;
1294 wl->channel = channel;
1297 * FIXME: the mac80211 should really provide a fixed rate
1298 * to use here. for now, just use the smallest possible rate
1299 * for the band as a fixed rate for association frames and
1300 * other control messages.
1302 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1303 wl1271_set_band_rate(wl);
1305 wl->basic_rate = wl1271_min_rate_get(wl);
1306 ret = wl1271_acx_rate_policies(wl);
1308 wl1271_warning("rate policy for update channel "
1311 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1312 ret = wl1271_join(wl, false);
1314 wl1271_warning("cmd join to update channel "
1319 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1320 ret = wl1271_handle_idle(wl, conf->flags & IEEE80211_CONF_IDLE);
1322 wl1271_warning("idle mode change failed %d", ret);
1326 * if mac80211 changes the PSM mode, make sure the mode is not
1327 * incorrectly changed after the pspoll failure active window.
1329 if (changed & IEEE80211_CONF_CHANGE_PS)
1330 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1332 if (conf->flags & IEEE80211_CONF_PS &&
1333 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1334 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1337 * We enter PSM only if we're already associated.
1338 * If we're not, we'll enter it when joining an SSID,
1339 * through the bss_info_changed() hook.
1341 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1342 wl1271_debug(DEBUG_PSM, "psm enabled");
1343 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1344 wl->basic_rate_set, true);
1346 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1347 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1348 wl1271_debug(DEBUG_PSM, "psm disabled");
1350 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1352 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1353 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1354 wl->basic_rate_set, true);
1357 if (conf->power_level != wl->power_level) {
1358 ret = wl1271_acx_tx_power(wl, conf->power_level);
1362 wl->power_level = conf->power_level;
1366 wl1271_ps_elp_sleep(wl);
1369 mutex_unlock(&wl->mutex);
1374 struct wl1271_filter_params {
1377 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1380 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1381 struct netdev_hw_addr_list *mc_list)
1383 struct wl1271_filter_params *fp;
1384 struct netdev_hw_addr *ha;
1385 struct wl1271 *wl = hw->priv;
1387 if (unlikely(wl->state == WL1271_STATE_OFF))
1390 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1392 wl1271_error("Out of memory setting filters.");
1396 /* update multicast filtering parameters */
1397 fp->mc_list_length = 0;
1398 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1399 fp->enabled = false;
1402 netdev_hw_addr_list_for_each(ha, mc_list) {
1403 memcpy(fp->mc_list[fp->mc_list_length],
1404 ha->addr, ETH_ALEN);
1405 fp->mc_list_length++;
1409 return (u64)(unsigned long)fp;
1412 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1415 FIF_BCN_PRBRESP_PROMISC | \
1419 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1420 unsigned int changed,
1421 unsigned int *total, u64 multicast)
1423 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1424 struct wl1271 *wl = hw->priv;
1427 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1429 mutex_lock(&wl->mutex);
1431 *total &= WL1271_SUPPORTED_FILTERS;
1432 changed &= WL1271_SUPPORTED_FILTERS;
1434 if (unlikely(wl->state == WL1271_STATE_OFF))
1437 ret = wl1271_ps_elp_wakeup(wl, false);
1442 if (*total & FIF_ALLMULTI)
1443 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1445 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1447 fp->mc_list_length);
1451 /* determine, whether supported filter values have changed */
1455 /* configure filters */
1456 wl->filters = *total;
1457 wl1271_configure_filters(wl, 0);
1459 /* apply configured filters */
1460 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1465 wl1271_ps_elp_sleep(wl);
1468 mutex_unlock(&wl->mutex);
1472 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1473 struct ieee80211_vif *vif,
1474 struct ieee80211_sta *sta,
1475 struct ieee80211_key_conf *key_conf)
1477 struct wl1271 *wl = hw->priv;
1484 static const u8 bcast_addr[ETH_ALEN] =
1485 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1487 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1489 addr = sta ? sta->addr : bcast_addr;
1491 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1492 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1493 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1494 key_conf->cipher, key_conf->keyidx,
1495 key_conf->keylen, key_conf->flags);
1496 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1498 if (is_zero_ether_addr(addr)) {
1499 /* We dont support TX only encryption */
1504 mutex_lock(&wl->mutex);
1506 ret = wl1271_ps_elp_wakeup(wl, false);
1510 switch (key_conf->cipher) {
1511 case WLAN_CIPHER_SUITE_WEP40:
1512 case WLAN_CIPHER_SUITE_WEP104:
1515 key_conf->hw_key_idx = key_conf->keyidx;
1517 case WLAN_CIPHER_SUITE_TKIP:
1518 key_type = KEY_TKIP;
1520 key_conf->hw_key_idx = key_conf->keyidx;
1521 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1522 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1524 case WLAN_CIPHER_SUITE_CCMP:
1527 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1528 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1529 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1532 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1540 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1541 key_conf->keyidx, key_type,
1542 key_conf->keylen, key_conf->key,
1543 addr, tx_seq_32, tx_seq_16);
1545 wl1271_error("Could not add or replace key");
1549 /* the default WEP key needs to be configured at least once */
1550 if (key_type == KEY_WEP) {
1551 ret = wl1271_cmd_set_default_wep_key(wl,
1559 /* The wl1271 does not allow to remove unicast keys - they
1560 will be cleared automatically on next CMD_JOIN. Ignore the
1561 request silently, as we dont want the mac80211 to emit
1562 an error message. */
1563 if (!is_broadcast_ether_addr(addr))
1566 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1567 key_conf->keyidx, key_type,
1568 key_conf->keylen, key_conf->key,
1571 wl1271_error("Could not remove key");
1577 wl1271_error("Unsupported key cmd 0x%x", cmd);
1583 wl1271_ps_elp_sleep(wl);
1586 mutex_unlock(&wl->mutex);
1592 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1593 struct ieee80211_vif *vif,
1594 struct cfg80211_scan_request *req)
1596 struct wl1271 *wl = hw->priv;
1601 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1604 ssid = req->ssids[0].ssid;
1605 len = req->ssids[0].ssid_len;
1608 mutex_lock(&wl->mutex);
1610 ret = wl1271_ps_elp_wakeup(wl, false);
1614 ret = wl1271_scan(hw->priv, ssid, len, req);
1616 wl1271_ps_elp_sleep(wl);
1619 mutex_unlock(&wl->mutex);
1624 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1626 struct wl1271 *wl = hw->priv;
1629 mutex_lock(&wl->mutex);
1631 if (unlikely(wl->state == WL1271_STATE_OFF))
1634 ret = wl1271_ps_elp_wakeup(wl, false);
1638 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1640 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1642 wl1271_ps_elp_sleep(wl);
1645 mutex_unlock(&wl->mutex);
1650 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1652 u8 *ptr = beacon->data +
1653 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1655 /* find the location of the ssid in the beacon */
1656 while (ptr < beacon->data + beacon->len) {
1657 if (ptr[0] == WLAN_EID_SSID) {
1658 wl->ssid_len = ptr[1];
1659 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1664 wl1271_error("ad-hoc beacon template has no SSID!\n");
1667 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1668 struct ieee80211_vif *vif,
1669 struct ieee80211_bss_conf *bss_conf,
1672 enum wl1271_cmd_ps_mode mode;
1673 struct wl1271 *wl = hw->priv;
1674 bool do_join = false;
1675 bool set_assoc = false;
1678 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1680 mutex_lock(&wl->mutex);
1682 ret = wl1271_ps_elp_wakeup(wl, false);
1686 if ((changed & BSS_CHANGED_BEACON_INT) &&
1687 (wl->bss_type == BSS_TYPE_IBSS)) {
1688 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1689 bss_conf->beacon_int);
1691 wl->beacon_int = bss_conf->beacon_int;
1695 if ((changed & BSS_CHANGED_BEACON) &&
1696 (wl->bss_type == BSS_TYPE_IBSS)) {
1697 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1699 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1702 struct ieee80211_hdr *hdr;
1704 wl1271_ssid_set(wl, beacon);
1705 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1708 wl1271_min_rate_get(wl));
1711 dev_kfree_skb(beacon);
1715 hdr = (struct ieee80211_hdr *) beacon->data;
1716 hdr->frame_control = cpu_to_le16(
1717 IEEE80211_FTYPE_MGMT |
1718 IEEE80211_STYPE_PROBE_RESP);
1720 ret = wl1271_cmd_template_set(wl,
1721 CMD_TEMPL_PROBE_RESPONSE,
1724 wl1271_min_rate_get(wl));
1725 dev_kfree_skb(beacon);
1729 /* Need to update the SSID (for filtering etc) */
1734 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1735 (wl->bss_type == BSS_TYPE_IBSS)) {
1736 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1737 bss_conf->enable_beacon ? "enabled" : "disabled");
1739 if (bss_conf->enable_beacon)
1740 wl->set_bss_type = BSS_TYPE_IBSS;
1742 wl->set_bss_type = BSS_TYPE_STA_BSS;
1746 if (changed & BSS_CHANGED_CQM) {
1747 bool enable = false;
1748 if (bss_conf->cqm_rssi_thold)
1750 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1751 bss_conf->cqm_rssi_thold,
1752 bss_conf->cqm_rssi_hyst);
1755 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1758 if ((changed & BSS_CHANGED_BSSID) &&
1760 * Now we know the correct bssid, so we send a new join command
1761 * and enable the BSSID filter
1763 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1764 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1766 ret = wl1271_cmd_build_null_data(wl);
1770 ret = wl1271_build_qos_null_data(wl);
1774 /* filter out all packets not from this BSSID */
1775 wl1271_configure_filters(wl, 0);
1777 /* Need to update the BSSID (for filtering etc) */
1781 if (changed & BSS_CHANGED_ASSOC) {
1782 if (bss_conf->assoc) {
1784 wl->aid = bss_conf->aid;
1787 wl->ps_poll_failures = 0;
1790 * use basic rates from AP, and determine lowest rate
1791 * to use with control frames.
1793 rates = bss_conf->basic_rates;
1794 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1796 wl->basic_rate = wl1271_min_rate_get(wl);
1797 ret = wl1271_acx_rate_policies(wl);
1802 * with wl1271, we don't need to update the
1803 * beacon_int and dtim_period, because the firmware
1804 * updates it by itself when the first beacon is
1805 * received after a join.
1807 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1812 * The SSID is intentionally set to NULL here - the
1813 * firmware will set the probe request with a
1814 * broadcast SSID regardless of what we set in the
1817 ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1820 /* enable the connection monitoring feature */
1821 ret = wl1271_acx_conn_monit_params(wl, true);
1825 /* If we want to go in PSM but we're not there yet */
1826 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1827 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1828 mode = STATION_POWER_SAVE_MODE;
1829 ret = wl1271_ps_set_mode(wl, mode,
1836 /* use defaults when not associated */
1837 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
1838 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1841 /* re-enable dynamic ps - just in case */
1842 ieee80211_enable_dyn_ps(wl->vif);
1844 /* revert back to minimum rates for the current band */
1845 wl1271_set_band_rate(wl);
1846 wl->basic_rate = wl1271_min_rate_get(wl);
1847 ret = wl1271_acx_rate_policies(wl);
1851 /* disable connection monitor features */
1852 ret = wl1271_acx_conn_monit_params(wl, false);
1854 /* Disable the keep-alive feature */
1855 ret = wl1271_acx_keep_alive_mode(wl, false);
1863 if (changed & BSS_CHANGED_ERP_SLOT) {
1864 if (bss_conf->use_short_slot)
1865 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1867 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1869 wl1271_warning("Set slot time failed %d", ret);
1874 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1875 if (bss_conf->use_short_preamble)
1876 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1878 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1881 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1882 if (bss_conf->use_cts_prot)
1883 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1885 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1887 wl1271_warning("Set ctsprotect failed %d", ret);
1892 if (changed & BSS_CHANGED_ARP_FILTER) {
1893 __be32 addr = bss_conf->arp_addr_list[0];
1894 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
1896 if (bss_conf->arp_addr_cnt == 1 && bss_conf->arp_filter_enabled)
1897 ret = wl1271_acx_arp_ip_filter(wl, true, addr);
1899 ret = wl1271_acx_arp_ip_filter(wl, false, addr);
1906 ret = wl1271_join(wl, set_assoc);
1908 wl1271_warning("cmd join failed %d", ret);
1914 wl1271_ps_elp_sleep(wl);
1917 mutex_unlock(&wl->mutex);
1920 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1921 const struct ieee80211_tx_queue_params *params)
1923 struct wl1271 *wl = hw->priv;
1927 mutex_lock(&wl->mutex);
1929 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1931 ret = wl1271_ps_elp_wakeup(wl, false);
1935 /* the txop is confed in units of 32us by the mac80211, we need us */
1936 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1937 params->cw_min, params->cw_max,
1938 params->aifs, params->txop << 5);
1943 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1945 ps_scheme = CONF_PS_SCHEME_LEGACY;
1947 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1948 CONF_CHANNEL_TYPE_EDCF,
1949 wl1271_tx_get_queue(queue),
1950 ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1955 wl1271_ps_elp_sleep(wl);
1958 mutex_unlock(&wl->mutex);
1963 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
1966 struct wl1271 *wl = hw->priv;
1967 u64 mactime = ULLONG_MAX;
1970 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
1972 mutex_lock(&wl->mutex);
1974 ret = wl1271_ps_elp_wakeup(wl, false);
1978 ret = wl1271_acx_tsf_info(wl, &mactime);
1983 wl1271_ps_elp_sleep(wl);
1986 mutex_unlock(&wl->mutex);
1990 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
1991 struct survey_info *survey)
1993 struct wl1271 *wl = hw->priv;
1994 struct ieee80211_conf *conf = &hw->conf;
1999 survey->channel = conf->channel;
2000 survey->filled = SURVEY_INFO_NOISE_DBM;
2001 survey->noise = wl->noise;
2006 /* can't be const, mac80211 writes to this */
2007 static struct ieee80211_rate wl1271_rates[] = {
2009 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2010 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2012 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2013 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2014 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2016 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2017 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2018 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2020 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2021 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2022 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2024 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2025 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2027 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2028 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2030 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2031 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2033 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2034 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2036 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2037 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2039 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2040 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2042 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2043 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2045 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2046 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2050 * Can't be const, mac80211 writes to this. The order of the channels here
2051 * is designed to improve scanning.
2053 static struct ieee80211_channel wl1271_channels[] = {
2054 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2055 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2056 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2057 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2058 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2059 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2060 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2061 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2062 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2063 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2064 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2065 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2066 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2069 /* mapping to indexes for wl1271_rates */
2070 static const u8 wl1271_rate_to_idx_2ghz[] = {
2071 /* MCS rates are used only with 11n */
2072 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2073 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2074 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2075 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2076 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2077 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2078 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2079 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2081 11, /* CONF_HW_RXTX_RATE_54 */
2082 10, /* CONF_HW_RXTX_RATE_48 */
2083 9, /* CONF_HW_RXTX_RATE_36 */
2084 8, /* CONF_HW_RXTX_RATE_24 */
2086 /* TI-specific rate */
2087 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2089 7, /* CONF_HW_RXTX_RATE_18 */
2090 6, /* CONF_HW_RXTX_RATE_12 */
2091 3, /* CONF_HW_RXTX_RATE_11 */
2092 5, /* CONF_HW_RXTX_RATE_9 */
2093 4, /* CONF_HW_RXTX_RATE_6 */
2094 2, /* CONF_HW_RXTX_RATE_5_5 */
2095 1, /* CONF_HW_RXTX_RATE_2 */
2096 0 /* CONF_HW_RXTX_RATE_1 */
2099 /* can't be const, mac80211 writes to this */
2100 static struct ieee80211_supported_band wl1271_band_2ghz = {
2101 .channels = wl1271_channels,
2102 .n_channels = ARRAY_SIZE(wl1271_channels),
2103 .bitrates = wl1271_rates,
2104 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2107 /* 5 GHz data rates for WL1273 */
2108 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2110 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2111 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2113 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2114 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2116 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2117 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2119 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2120 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2122 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2123 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2125 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2126 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2128 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2129 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2131 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2132 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2136 * 5 GHz band channels for WL1273 - can't be const, mac80211 writes to this.
2137 * The order of the channels here is designed to improve scanning.
2139 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2140 { .hw_value = 183, .center_freq = 4915},
2141 { .hw_value = 188, .center_freq = 4940},
2142 { .hw_value = 8, .center_freq = 5040},
2143 { .hw_value = 34, .center_freq = 5170},
2144 { .hw_value = 44, .center_freq = 5220},
2145 { .hw_value = 60, .center_freq = 5300},
2146 { .hw_value = 112, .center_freq = 5560},
2147 { .hw_value = 132, .center_freq = 5660},
2148 { .hw_value = 157, .center_freq = 5785},
2149 { .hw_value = 184, .center_freq = 4920},
2150 { .hw_value = 189, .center_freq = 4945},
2151 { .hw_value = 9, .center_freq = 5045},
2152 { .hw_value = 36, .center_freq = 5180},
2153 { .hw_value = 46, .center_freq = 5230},
2154 { .hw_value = 64, .center_freq = 5320},
2155 { .hw_value = 116, .center_freq = 5580},
2156 { .hw_value = 136, .center_freq = 5680},
2157 { .hw_value = 192, .center_freq = 4960},
2158 { .hw_value = 11, .center_freq = 5055},
2159 { .hw_value = 38, .center_freq = 5190},
2160 { .hw_value = 48, .center_freq = 5240},
2161 { .hw_value = 100, .center_freq = 5500},
2162 { .hw_value = 120, .center_freq = 5600},
2163 { .hw_value = 140, .center_freq = 5700},
2164 { .hw_value = 185, .center_freq = 4925},
2165 { .hw_value = 196, .center_freq = 4980},
2166 { .hw_value = 12, .center_freq = 5060},
2167 { .hw_value = 40, .center_freq = 5200},
2168 { .hw_value = 52, .center_freq = 5260},
2169 { .hw_value = 104, .center_freq = 5520},
2170 { .hw_value = 124, .center_freq = 5620},
2171 { .hw_value = 149, .center_freq = 5745},
2172 { .hw_value = 161, .center_freq = 5805},
2173 { .hw_value = 187, .center_freq = 4935},
2174 { .hw_value = 7, .center_freq = 5035},
2175 { .hw_value = 16, .center_freq = 5080},
2176 { .hw_value = 42, .center_freq = 5210},
2177 { .hw_value = 56, .center_freq = 5280},
2178 { .hw_value = 108, .center_freq = 5540},
2179 { .hw_value = 128, .center_freq = 5640},
2180 { .hw_value = 153, .center_freq = 5765},
2181 { .hw_value = 165, .center_freq = 5825},
2184 /* mapping to indexes for wl1271_rates_5ghz */
2185 static const u8 wl1271_rate_to_idx_5ghz[] = {
2186 /* MCS rates are used only with 11n */
2187 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2188 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2189 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2190 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2191 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2192 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2193 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2194 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2196 7, /* CONF_HW_RXTX_RATE_54 */
2197 6, /* CONF_HW_RXTX_RATE_48 */
2198 5, /* CONF_HW_RXTX_RATE_36 */
2199 4, /* CONF_HW_RXTX_RATE_24 */
2201 /* TI-specific rate */
2202 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2204 3, /* CONF_HW_RXTX_RATE_18 */
2205 2, /* CONF_HW_RXTX_RATE_12 */
2206 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2207 1, /* CONF_HW_RXTX_RATE_9 */
2208 0, /* CONF_HW_RXTX_RATE_6 */
2209 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2210 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2211 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
2214 static struct ieee80211_supported_band wl1271_band_5ghz = {
2215 .channels = wl1271_channels_5ghz,
2216 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2217 .bitrates = wl1271_rates_5ghz,
2218 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2221 static const u8 *wl1271_band_rate_to_idx[] = {
2222 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2223 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2226 static const struct ieee80211_ops wl1271_ops = {
2227 .start = wl1271_op_start,
2228 .stop = wl1271_op_stop,
2229 .add_interface = wl1271_op_add_interface,
2230 .remove_interface = wl1271_op_remove_interface,
2231 .config = wl1271_op_config,
2232 .prepare_multicast = wl1271_op_prepare_multicast,
2233 .configure_filter = wl1271_op_configure_filter,
2235 .set_key = wl1271_op_set_key,
2236 .hw_scan = wl1271_op_hw_scan,
2237 .bss_info_changed = wl1271_op_bss_info_changed,
2238 .set_rts_threshold = wl1271_op_set_rts_threshold,
2239 .conf_tx = wl1271_op_conf_tx,
2240 .get_tsf = wl1271_op_get_tsf,
2241 .get_survey = wl1271_op_get_survey,
2242 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2246 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2250 BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2252 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2253 wl1271_error("Illegal RX rate from HW: %d", rate);
2257 idx = wl1271_band_rate_to_idx[wl->band][rate];
2258 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2259 wl1271_error("Unsupported RX rate from HW: %d", rate);
2266 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2267 struct device_attribute *attr,
2270 struct wl1271 *wl = dev_get_drvdata(dev);
2275 mutex_lock(&wl->mutex);
2276 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2278 mutex_unlock(&wl->mutex);
2284 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2285 struct device_attribute *attr,
2286 const char *buf, size_t count)
2288 struct wl1271 *wl = dev_get_drvdata(dev);
2292 ret = strict_strtoul(buf, 10, &res);
2295 wl1271_warning("incorrect value written to bt_coex_mode");
2299 mutex_lock(&wl->mutex);
2303 if (res == wl->sg_enabled)
2306 wl->sg_enabled = res;
2308 if (wl->state == WL1271_STATE_OFF)
2311 ret = wl1271_ps_elp_wakeup(wl, false);
2315 wl1271_acx_sg_enable(wl, wl->sg_enabled);
2316 wl1271_ps_elp_sleep(wl);
2319 mutex_unlock(&wl->mutex);
2323 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2324 wl1271_sysfs_show_bt_coex_state,
2325 wl1271_sysfs_store_bt_coex_state);
2327 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2328 struct device_attribute *attr,
2331 struct wl1271 *wl = dev_get_drvdata(dev);
2336 mutex_lock(&wl->mutex);
2337 if (wl->hw_pg_ver >= 0)
2338 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2340 len = snprintf(buf, len, "n/a\n");
2341 mutex_unlock(&wl->mutex);
2346 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2347 wl1271_sysfs_show_hw_pg_ver, NULL);
2349 int wl1271_register_hw(struct wl1271 *wl)
2353 if (wl->mac80211_registered)
2356 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2358 ret = ieee80211_register_hw(wl->hw);
2360 wl1271_error("unable to register mac80211 hw: %d", ret);
2364 wl->mac80211_registered = true;
2366 register_netdevice_notifier(&wl1271_dev_notifier);
2368 wl1271_notice("loaded");
2372 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2374 void wl1271_unregister_hw(struct wl1271 *wl)
2376 unregister_netdevice_notifier(&wl1271_dev_notifier);
2377 ieee80211_unregister_hw(wl->hw);
2378 wl->mac80211_registered = false;
2381 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2383 int wl1271_init_ieee80211(struct wl1271 *wl)
2385 /* The tx descriptor buffer and the TKIP space. */
2386 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2387 sizeof(struct wl1271_tx_hw_descr);
2390 /* FIXME: find a proper value */
2391 wl->hw->channel_change_time = 10000;
2392 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2394 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2395 IEEE80211_HW_BEACON_FILTER |
2396 IEEE80211_HW_SUPPORTS_PS |
2397 IEEE80211_HW_SUPPORTS_UAPSD |
2398 IEEE80211_HW_HAS_RATE_CONTROL |
2399 IEEE80211_HW_CONNECTION_MONITOR |
2400 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2402 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2403 BIT(NL80211_IFTYPE_ADHOC);
2404 wl->hw->wiphy->max_scan_ssids = 1;
2405 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2408 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2411 wl->hw->max_rates = 1;
2413 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2417 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2419 #define WL1271_DEFAULT_CHANNEL 0
2421 struct ieee80211_hw *wl1271_alloc_hw(void)
2423 struct ieee80211_hw *hw;
2424 struct platform_device *plat_dev = NULL;
2428 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2430 wl1271_error("could not alloc ieee80211_hw");
2435 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
2437 wl1271_error("could not allocate platform_device");
2439 goto err_plat_alloc;
2443 memset(wl, 0, sizeof(*wl));
2445 INIT_LIST_HEAD(&wl->list);
2448 wl->plat_dev = plat_dev;
2450 skb_queue_head_init(&wl->tx_queue);
2452 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2453 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
2454 wl->channel = WL1271_DEFAULT_CHANNEL;
2455 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2456 wl->default_key = 0;
2458 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2459 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2460 wl->psm_entry_retry = 0;
2461 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2462 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2463 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2464 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2465 wl->sta_rate_set = 0;
2466 wl->band = IEEE80211_BAND_2GHZ;
2469 wl->sg_enabled = true;
2472 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2473 wl->tx_frames[i] = NULL;
2475 spin_lock_init(&wl->wl_lock);
2477 wl->state = WL1271_STATE_OFF;
2478 mutex_init(&wl->mutex);
2480 /* Apply default driver configuration. */
2481 wl1271_conf_init(wl);
2483 wl1271_debugfs_init(wl);
2485 /* Register platform device */
2486 ret = platform_device_register(wl->plat_dev);
2488 wl1271_error("couldn't register platform device");
2491 dev_set_drvdata(&wl->plat_dev->dev, wl);
2493 /* Create sysfs file to control bt coex state */
2494 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2496 wl1271_error("failed to create sysfs file bt_coex_state");
2500 /* Create sysfs file to get HW PG version */
2501 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2503 wl1271_error("failed to create sysfs file hw_pg_ver");
2504 goto err_bt_coex_state;
2510 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2513 platform_device_unregister(wl->plat_dev);
2516 wl1271_debugfs_exit(wl);
2520 ieee80211_free_hw(hw);
2524 return ERR_PTR(ret);
2526 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2528 int wl1271_free_hw(struct wl1271 *wl)
2530 platform_device_unregister(wl->plat_dev);
2531 kfree(wl->plat_dev);
2533 wl1271_debugfs_exit(wl);
2540 kfree(wl->fw_status);
2541 kfree(wl->tx_res_if);
2543 ieee80211_free_hw(wl->hw);
2547 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2549 MODULE_LICENSE("GPL");
2550 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2551 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");