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>
33 #include <linux/wl12xx.h>
34 #include <linux/sched.h>
37 #include "wl12xx_80211.h"
51 #define WL1271_BOOT_RETRIES 3
53 static struct conf_drv_settings default_conf = {
56 [CONF_SG_ACL_BT_MASTER_MIN_BR] = 10,
57 [CONF_SG_ACL_BT_MASTER_MAX_BR] = 180,
58 [CONF_SG_ACL_BT_SLAVE_MIN_BR] = 10,
59 [CONF_SG_ACL_BT_SLAVE_MAX_BR] = 180,
60 [CONF_SG_ACL_BT_MASTER_MIN_EDR] = 10,
61 [CONF_SG_ACL_BT_MASTER_MAX_EDR] = 80,
62 [CONF_SG_ACL_BT_SLAVE_MIN_EDR] = 10,
63 [CONF_SG_ACL_BT_SLAVE_MAX_EDR] = 80,
64 [CONF_SG_ACL_WLAN_PS_MASTER_BR] = 8,
65 [CONF_SG_ACL_WLAN_PS_SLAVE_BR] = 8,
66 [CONF_SG_ACL_WLAN_PS_MASTER_EDR] = 20,
67 [CONF_SG_ACL_WLAN_PS_SLAVE_EDR] = 20,
68 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_BR] = 20,
69 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_BR] = 35,
70 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_BR] = 16,
71 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_BR] = 35,
72 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_EDR] = 32,
73 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_EDR] = 50,
74 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_EDR] = 28,
75 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_EDR] = 50,
76 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_BR] = 10,
77 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_EDR] = 20,
78 [CONF_SG_ACL_PASSIVE_SCAN_BT_BR] = 75,
79 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_BR] = 15,
80 [CONF_SG_ACL_PASSIVE_SCAN_BT_EDR] = 27,
81 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_EDR] = 17,
82 /* active scan params */
83 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
84 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
85 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
86 /* passive scan params */
87 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_BR] = 800,
88 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_EDR] = 200,
89 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
90 /* passive scan in dual antenna params */
91 [CONF_SG_CONSECUTIVE_HV3_IN_PASSIVE_SCAN] = 0,
92 [CONF_SG_BCN_HV3_COLLISION_THRESH_IN_PASSIVE_SCAN] = 0,
93 [CONF_SG_TX_RX_PROTECTION_BWIDTH_IN_PASSIVE_SCAN] = 0,
95 [CONF_SG_STA_FORCE_PS_IN_BT_SCO] = 1,
96 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
97 [CONF_SG_BEACON_MISS_PERCENT] = 60,
98 [CONF_SG_DHCP_TIME] = 5000,
100 [CONF_SG_TXT] = 1000,
101 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
102 [CONF_SG_GENERAL_USAGE_BIT_MAP] = 3,
103 [CONF_SG_HV3_MAX_SERVED] = 6,
104 [CONF_SG_PS_POLL_TIMEOUT] = 10,
105 [CONF_SG_UPSD_TIMEOUT] = 10,
106 [CONF_SG_CONSECUTIVE_CTS_THRESHOLD] = 2,
107 [CONF_SG_STA_RX_WINDOW_AFTER_DTIM] = 5,
108 [CONF_SG_STA_CONNECTION_PROTECTION_TIME] = 30,
110 [CONF_AP_BEACON_MISS_TX] = 3,
111 [CONF_AP_RX_WINDOW_AFTER_BEACON] = 10,
112 [CONF_AP_BEACON_WINDOW_INTERVAL] = 2,
113 [CONF_AP_CONNECTION_PROTECTION_TIME] = 0,
114 [CONF_AP_BT_ACL_VAL_BT_SERVE_TIME] = 25,
115 [CONF_AP_BT_ACL_VAL_WL_SERVE_TIME] = 25,
117 .state = CONF_SG_PROTECTIVE,
120 .rx_msdu_life_time = 512000,
121 .packet_detection_threshold = 0,
122 .ps_poll_timeout = 15,
124 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
125 .rx_cca_threshold = 0,
126 .irq_blk_threshold = 0xFFFF,
127 .irq_pkt_threshold = 0,
129 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
132 .tx_energy_detection = 0,
135 .short_retry_limit = 10,
136 .long_retry_limit = 10,
159 .aifsn = CONF_TX_AIFS_PIFS,
166 .aifsn = CONF_TX_AIFS_PIFS,
170 .max_tx_retries = 100,
171 .ap_aging_period = 300,
175 .queue_id = CONF_TX_AC_BE,
176 .channel_type = CONF_CHANNEL_TYPE_EDCF,
177 .tsid = CONF_TX_AC_BE,
178 .ps_scheme = CONF_PS_SCHEME_LEGACY,
179 .ack_policy = CONF_ACK_POLICY_LEGACY,
183 .queue_id = CONF_TX_AC_BK,
184 .channel_type = CONF_CHANNEL_TYPE_EDCF,
185 .tsid = CONF_TX_AC_BK,
186 .ps_scheme = CONF_PS_SCHEME_LEGACY,
187 .ack_policy = CONF_ACK_POLICY_LEGACY,
191 .queue_id = CONF_TX_AC_VI,
192 .channel_type = CONF_CHANNEL_TYPE_EDCF,
193 .tsid = CONF_TX_AC_VI,
194 .ps_scheme = CONF_PS_SCHEME_LEGACY,
195 .ack_policy = CONF_ACK_POLICY_LEGACY,
199 .queue_id = CONF_TX_AC_VO,
200 .channel_type = CONF_CHANNEL_TYPE_EDCF,
201 .tsid = CONF_TX_AC_VO,
202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
207 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
208 .tx_compl_timeout = 700,
209 .tx_compl_threshold = 4,
210 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
211 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
212 .tmpl_short_retry_limit = 10,
213 .tmpl_long_retry_limit = 10,
216 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
217 .listen_interval = 1,
218 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
219 .bcn_filt_ie_count = 2,
222 .ie = WLAN_EID_CHANNEL_SWITCH,
223 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
226 .ie = WLAN_EID_HT_INFORMATION,
227 .rule = CONF_BCN_RULE_PASS_ON_CHANGE,
230 .synch_fail_thold = 10,
231 .bss_lose_timeout = 100,
232 .beacon_rx_timeout = 10000,
233 .broadcast_timeout = 20000,
234 .rx_broadcast_in_ps = 1,
235 .ps_poll_threshold = 10,
236 .ps_poll_recovery_period = 700,
237 .bet_enable = CONF_BET_MODE_ENABLE,
238 .bet_max_consecutive = 50,
239 .psm_entry_retries = 8,
240 .psm_exit_retries = 16,
241 .psm_entry_nullfunc_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,
261 .min_dwell_time_active = 7500,
262 .max_dwell_time_active = 30000,
263 .min_dwell_time_passive = 100000,
264 .max_dwell_time_passive = 100000,
268 /* sched_scan requires dwell times in TU instead of TU/1000 */
269 .min_dwell_time_active = 8,
270 .max_dwell_time_active = 30,
271 .dwell_time_passive = 100,
272 .dwell_time_dfs = 150,
274 .rssi_threshold = -90,
278 .tx_per_channel_power_compensation_2 = {
279 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
281 .tx_per_channel_power_compensation_5 = {
282 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
283 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
284 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
289 .tx_ba_win_size = 64,
290 .inactivity_timeout = 10000,
291 .tx_ba_tid_bitmap = CONF_TX_BA_ENABLED_TID_BITMAP,
297 .tx_min_block_num = 40,
299 .min_req_tx_blocks = 100,
300 .min_req_rx_blocks = 22,
307 .tx_min_block_num = 40,
309 .min_req_tx_blocks = 45,
310 .min_req_rx_blocks = 22,
316 .n_divider_fref_set_1 = 0xff, /* default */
317 .n_divider_fref_set_2 = 12,
318 .m_divider_fref_set_1 = 148,
319 .m_divider_fref_set_2 = 0xffff, /* default */
320 .coex_pll_stabilization_time = 0xffffffff, /* default */
321 .ldo_stabilization_time = 0xffff, /* default */
322 .fm_disturbed_band_margin = 0xff, /* default */
323 .swallow_clk_diff = 0xff, /* default */
332 .mode = WL12XX_FWLOG_ON_DEMAND,
335 .timestamp = WL12XX_FWLOG_TIMESTAMP_DISABLED,
336 .output = WL12XX_FWLOG_OUTPUT_HOST,
339 .hci_io_ds = HCI_IO_DS_6MA,
341 .rate_retry_score = 32000,
346 .inverse_curiosity_factor = 5,
348 .tx_fail_high_th = 10,
349 .per_alpha_shift = 4,
351 .per_beta1_shift = 10,
352 .per_beta2_shift = 8,
354 .rate_check_down = 12,
355 .rate_retry_policy = {
356 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00,
363 .hangover_period = 20,
365 .early_termination_mode = 1,
376 static char *fwlog_param;
377 static bool bug_on_recovery;
379 static void __wl1271_op_remove_interface(struct wl1271 *wl,
380 bool reset_tx_queues);
381 static void wl1271_free_ap_keys(struct wl1271 *wl);
384 static void wl1271_device_release(struct device *dev)
389 static struct platform_device wl1271_device = {
393 /* device model insists to have a release function */
395 .release = wl1271_device_release,
399 static DEFINE_MUTEX(wl_list_mutex);
400 static LIST_HEAD(wl_list);
402 static int wl1271_check_operstate(struct wl1271 *wl, unsigned char operstate)
405 if (operstate != IF_OPER_UP)
408 if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags))
411 ret = wl12xx_cmd_set_peer_state(wl, wl->sta_hlid);
415 wl12xx_croc(wl, wl->role_id);
417 wl1271_info("Association completed.");
420 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
423 struct net_device *dev = arg;
424 struct wireless_dev *wdev;
426 struct ieee80211_hw *hw;
428 struct wl1271 *wl_temp;
431 /* Check that this notification is for us. */
432 if (what != NETDEV_CHANGE)
435 wdev = dev->ieee80211_ptr;
443 hw = wiphy_priv(wiphy);
448 mutex_lock(&wl_list_mutex);
449 list_for_each_entry(wl, &wl_list, list) {
453 mutex_unlock(&wl_list_mutex);
457 mutex_lock(&wl->mutex);
459 if (wl->state == WL1271_STATE_OFF)
462 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
465 ret = wl1271_ps_elp_wakeup(wl);
469 wl1271_check_operstate(wl, dev->operstate);
471 wl1271_ps_elp_sleep(wl);
474 mutex_unlock(&wl->mutex);
479 static int wl1271_reg_notify(struct wiphy *wiphy,
480 struct regulatory_request *request)
482 struct ieee80211_supported_band *band;
483 struct ieee80211_channel *ch;
486 band = wiphy->bands[IEEE80211_BAND_5GHZ];
487 for (i = 0; i < band->n_channels; i++) {
488 ch = &band->channels[i];
489 if (ch->flags & IEEE80211_CHAN_DISABLED)
492 if (ch->flags & IEEE80211_CHAN_RADAR)
493 ch->flags |= IEEE80211_CHAN_NO_IBSS |
494 IEEE80211_CHAN_PASSIVE_SCAN;
501 static int wl1271_set_rx_streaming(struct wl1271 *wl, bool enable)
505 /* we should hold wl->mutex */
506 ret = wl1271_acx_ps_rx_streaming(wl, enable);
511 set_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
513 clear_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags);
519 * this function is being called when the rx_streaming interval
520 * has beed changed or rx_streaming should be disabled
522 int wl1271_recalc_rx_streaming(struct wl1271 *wl)
525 int period = wl->conf.rx_streaming.interval;
527 /* don't reconfigure if rx_streaming is disabled */
528 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
531 /* reconfigure/disable according to new streaming_period */
533 test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) &&
534 (wl->conf.rx_streaming.always ||
535 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
536 ret = wl1271_set_rx_streaming(wl, true);
538 ret = wl1271_set_rx_streaming(wl, false);
539 /* don't cancel_work_sync since we might deadlock */
540 del_timer_sync(&wl->rx_streaming_timer);
546 static void wl1271_rx_streaming_enable_work(struct work_struct *work)
550 container_of(work, struct wl1271, rx_streaming_enable_work);
552 mutex_lock(&wl->mutex);
554 if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags) ||
555 !test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
556 (!wl->conf.rx_streaming.always &&
557 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
560 if (!wl->conf.rx_streaming.interval)
563 ret = wl1271_ps_elp_wakeup(wl);
567 ret = wl1271_set_rx_streaming(wl, true);
571 /* stop it after some time of inactivity */
572 mod_timer(&wl->rx_streaming_timer,
573 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
576 wl1271_ps_elp_sleep(wl);
578 mutex_unlock(&wl->mutex);
581 static void wl1271_rx_streaming_disable_work(struct work_struct *work)
585 container_of(work, struct wl1271, rx_streaming_disable_work);
587 mutex_lock(&wl->mutex);
589 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED, &wl->flags))
592 ret = wl1271_ps_elp_wakeup(wl);
596 ret = wl1271_set_rx_streaming(wl, false);
601 wl1271_ps_elp_sleep(wl);
603 mutex_unlock(&wl->mutex);
606 static void wl1271_rx_streaming_timer(unsigned long data)
608 struct wl1271 *wl = (struct wl1271 *)data;
609 ieee80211_queue_work(wl->hw, &wl->rx_streaming_disable_work);
612 static void wl1271_conf_init(struct wl1271 *wl)
616 * This function applies the default configuration to the driver. This
617 * function is invoked upon driver load (spi probe.)
619 * The configuration is stored in a run-time structure in order to
620 * facilitate for run-time adjustment of any of the parameters. Making
621 * changes to the configuration structure will apply the new values on
622 * the next interface up (wl1271_op_start.)
625 /* apply driver default configuration */
626 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
628 /* Adjust settings according to optional module parameters */
630 if (!strcmp(fwlog_param, "continuous")) {
631 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
632 } else if (!strcmp(fwlog_param, "ondemand")) {
633 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
634 } else if (!strcmp(fwlog_param, "dbgpins")) {
635 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
636 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
637 } else if (!strcmp(fwlog_param, "disable")) {
638 wl->conf.fwlog.mem_blocks = 0;
639 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
641 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
646 static int wl1271_plt_init(struct wl1271 *wl)
648 struct conf_tx_ac_category *conf_ac;
649 struct conf_tx_tid *conf_tid;
652 if (wl->chip.id == CHIP_ID_1283_PG20)
653 ret = wl128x_cmd_general_parms(wl);
655 ret = wl1271_cmd_general_parms(wl);
659 if (wl->chip.id == CHIP_ID_1283_PG20)
660 ret = wl128x_cmd_radio_parms(wl);
662 ret = wl1271_cmd_radio_parms(wl);
666 if (wl->chip.id != CHIP_ID_1283_PG20) {
667 ret = wl1271_cmd_ext_radio_parms(wl);
674 /* Chip-specific initializations */
675 ret = wl1271_chip_specific_init(wl);
679 ret = wl1271_sta_init_templates_config(wl);
683 ret = wl1271_acx_init_mem_config(wl);
687 /* PHY layer config */
688 ret = wl1271_init_phy_config(wl);
690 goto out_free_memmap;
692 ret = wl1271_acx_dco_itrim_params(wl);
694 goto out_free_memmap;
696 /* Initialize connection monitoring thresholds */
697 ret = wl1271_acx_conn_monit_params(wl, false);
699 goto out_free_memmap;
701 /* Bluetooth WLAN coexistence */
702 ret = wl1271_init_pta(wl);
704 goto out_free_memmap;
706 /* FM WLAN coexistence */
707 ret = wl1271_acx_fm_coex(wl);
709 goto out_free_memmap;
711 /* Energy detection */
712 ret = wl1271_init_energy_detection(wl);
714 goto out_free_memmap;
716 ret = wl12xx_acx_mem_cfg(wl);
718 goto out_free_memmap;
720 /* Default fragmentation threshold */
721 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
723 goto out_free_memmap;
725 /* Default TID/AC configuration */
726 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
727 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
728 conf_ac = &wl->conf.tx.ac_conf[i];
729 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
730 conf_ac->cw_max, conf_ac->aifsn,
731 conf_ac->tx_op_limit);
733 goto out_free_memmap;
735 conf_tid = &wl->conf.tx.tid_conf[i];
736 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
737 conf_tid->channel_type,
740 conf_tid->ack_policy,
741 conf_tid->apsd_conf[0],
742 conf_tid->apsd_conf[1]);
744 goto out_free_memmap;
747 /* Enable data path */
748 ret = wl1271_cmd_data_path(wl, 1);
750 goto out_free_memmap;
752 /* Configure for CAM power saving (ie. always active) */
753 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
755 goto out_free_memmap;
758 ret = wl1271_acx_pm_config(wl);
760 goto out_free_memmap;
765 kfree(wl->target_mem_map);
766 wl->target_mem_map = NULL;
771 static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_pkts)
775 /* only regulate station links */
776 if (hlid < WL1271_AP_STA_HLID_START)
779 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
782 * Wake up from high level PS if the STA is asleep with too little
783 * packets in FW or if the STA is awake.
785 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
786 wl1271_ps_link_end(wl, hlid);
788 /* Start high-level PS if the STA is asleep with enough blocks in FW */
789 else if (fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
790 wl1271_ps_link_start(wl, hlid, true);
793 bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
797 /* global/broadcast "stations" are always active */
798 if (hlid < WL1271_AP_STA_HLID_START)
801 id = hlid - WL1271_AP_STA_HLID_START;
802 return test_bit(id, wl->ap_hlid_map);
805 static void wl12xx_irq_update_links_status(struct wl1271 *wl,
806 struct wl12xx_fw_status *status)
811 /* TODO: also use link_fast_bitmap here */
813 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
814 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
815 wl1271_debug(DEBUG_PSM,
816 "link ps prev 0x%x cur 0x%x changed 0x%x",
817 wl->ap_fw_ps_map, cur_fw_ps_map,
818 wl->ap_fw_ps_map ^ cur_fw_ps_map);
820 wl->ap_fw_ps_map = cur_fw_ps_map;
823 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
824 if (!wl1271_is_active_sta(wl, hlid))
827 cnt = status->tx_lnk_free_pkts[hlid] -
828 wl->links[hlid].prev_freed_pkts;
830 wl->links[hlid].prev_freed_pkts =
831 status->tx_lnk_free_pkts[hlid];
832 wl->links[hlid].allocated_pkts -= cnt;
834 wl12xx_irq_ps_regulate_link(wl, hlid,
835 wl->links[hlid].allocated_pkts);
839 static void wl12xx_fw_status(struct wl1271 *wl,
840 struct wl12xx_fw_status *status)
843 u32 old_tx_blk_count = wl->tx_blocks_available;
844 int avail, freed_blocks;
847 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
849 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
850 "drv_rx_counter = %d, tx_results_counter = %d)",
852 status->fw_rx_counter,
853 status->drv_rx_counter,
854 status->tx_results_counter);
856 for (i = 0; i < NUM_TX_QUEUES; i++) {
857 /* prevent wrap-around in freed-packets counter */
858 wl->tx_allocated_pkts[i] -=
859 (status->tx_released_pkts[i] -
860 wl->tx_pkts_freed[i]) & 0xff;
862 wl->tx_pkts_freed[i] = status->tx_released_pkts[i];
865 /* prevent wrap-around in total blocks counter */
866 if (likely(wl->tx_blocks_freed <=
867 le32_to_cpu(status->total_released_blks)))
868 freed_blocks = le32_to_cpu(status->total_released_blks) -
871 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
872 le32_to_cpu(status->total_released_blks);
874 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
876 wl->tx_allocated_blocks -= freed_blocks;
878 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
881 * The FW might change the total number of TX memblocks before
882 * we get a notification about blocks being released. Thus, the
883 * available blocks calculation might yield a temporary result
884 * which is lower than the actual available blocks. Keeping in
885 * mind that only blocks that were allocated can be moved from
886 * TX to RX, tx_blocks_available should never decrease here.
888 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
891 /* if more blocks are available now, tx work can be scheduled */
892 if (wl->tx_blocks_available > old_tx_blk_count)
893 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
895 /* for AP update num of allocated TX blocks per link and ps status */
896 if (wl->bss_type == BSS_TYPE_AP_BSS)
897 wl12xx_irq_update_links_status(wl, status);
899 /* update the host-chipset time offset */
901 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
902 (s64)le32_to_cpu(status->fw_localtime);
905 static void wl1271_flush_deferred_work(struct wl1271 *wl)
909 /* Pass all received frames to the network stack */
910 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
911 ieee80211_rx_ni(wl->hw, skb);
913 /* Return sent skbs to the network stack */
914 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
915 ieee80211_tx_status_ni(wl->hw, skb);
918 static void wl1271_netstack_work(struct work_struct *work)
921 container_of(work, struct wl1271, netstack_work);
924 wl1271_flush_deferred_work(wl);
925 } while (skb_queue_len(&wl->deferred_rx_queue));
928 #define WL1271_IRQ_MAX_LOOPS 256
930 irqreturn_t wl1271_irq(int irq, void *cookie)
934 int loopcount = WL1271_IRQ_MAX_LOOPS;
935 struct wl1271 *wl = (struct wl1271 *)cookie;
937 unsigned int defer_count;
940 /* TX might be handled here, avoid redundant work */
941 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
942 cancel_work_sync(&wl->tx_work);
945 * In case edge triggered interrupt must be used, we cannot iterate
946 * more than once without introducing race conditions with the hardirq.
948 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
951 mutex_lock(&wl->mutex);
953 wl1271_debug(DEBUG_IRQ, "IRQ work");
955 if (unlikely(wl->state == WL1271_STATE_OFF))
958 ret = wl1271_ps_elp_wakeup(wl);
962 while (!done && loopcount--) {
964 * In order to avoid a race with the hardirq, clear the flag
965 * before acknowledging the chip. Since the mutex is held,
966 * wl1271_ps_elp_wakeup cannot be called concurrently.
968 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
969 smp_mb__after_clear_bit();
971 wl12xx_fw_status(wl, wl->fw_status);
972 intr = le32_to_cpu(wl->fw_status->intr);
973 intr &= WL1271_INTR_MASK;
979 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
980 wl1271_error("watchdog interrupt received! "
981 "starting recovery.");
982 wl12xx_queue_recovery_work(wl);
984 /* restarting the chip. ignore any other interrupt. */
988 if (likely(intr & WL1271_ACX_INTR_DATA)) {
989 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
991 wl12xx_rx(wl, wl->fw_status);
993 /* Check if any tx blocks were freed */
994 spin_lock_irqsave(&wl->wl_lock, flags);
995 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
996 wl1271_tx_total_queue_count(wl) > 0) {
997 spin_unlock_irqrestore(&wl->wl_lock, flags);
999 * In order to avoid starvation of the TX path,
1000 * call the work function directly.
1002 wl1271_tx_work_locked(wl);
1004 spin_unlock_irqrestore(&wl->wl_lock, flags);
1007 /* check for tx results */
1008 if (wl->fw_status->tx_results_counter !=
1009 (wl->tx_results_count & 0xff))
1010 wl1271_tx_complete(wl);
1012 /* Make sure the deferred queues don't get too long */
1013 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
1014 skb_queue_len(&wl->deferred_rx_queue);
1015 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
1016 wl1271_flush_deferred_work(wl);
1019 if (intr & WL1271_ACX_INTR_EVENT_A) {
1020 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
1021 wl1271_event_handle(wl, 0);
1024 if (intr & WL1271_ACX_INTR_EVENT_B) {
1025 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
1026 wl1271_event_handle(wl, 1);
1029 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
1030 wl1271_debug(DEBUG_IRQ,
1031 "WL1271_ACX_INTR_INIT_COMPLETE");
1033 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
1034 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
1037 wl1271_ps_elp_sleep(wl);
1040 spin_lock_irqsave(&wl->wl_lock, flags);
1041 /* In case TX was not handled here, queue TX work */
1042 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
1043 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1044 wl1271_tx_total_queue_count(wl) > 0)
1045 ieee80211_queue_work(wl->hw, &wl->tx_work);
1046 spin_unlock_irqrestore(&wl->wl_lock, flags);
1048 mutex_unlock(&wl->mutex);
1052 EXPORT_SYMBOL_GPL(wl1271_irq);
1054 static int wl1271_fetch_firmware(struct wl1271 *wl)
1056 const struct firmware *fw;
1057 const char *fw_name;
1060 if (wl->chip.id == CHIP_ID_1283_PG20)
1061 fw_name = WL128X_FW_NAME;
1063 fw_name = WL127X_FW_NAME;
1065 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
1067 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
1070 wl1271_error("could not get firmware: %d", ret);
1075 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1082 wl->fw_len = fw->size;
1083 wl->fw = vmalloc(wl->fw_len);
1086 wl1271_error("could not allocate memory for the firmware");
1091 memcpy(wl->fw, fw->data, wl->fw_len);
1095 release_firmware(fw);
1100 static int wl1271_fetch_nvs(struct wl1271 *wl)
1102 const struct firmware *fw;
1105 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
1108 wl1271_error("could not get nvs file: %d", ret);
1112 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
1115 wl1271_error("could not allocate memory for the nvs file");
1120 wl->nvs_len = fw->size;
1123 release_firmware(fw);
1128 void wl12xx_queue_recovery_work(struct wl1271 *wl)
1130 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1131 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1134 size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
1138 /* The FW log is a length-value list, find where the log end */
1139 while (len < maxlen) {
1140 if (memblock[len] == 0)
1142 if (len + memblock[len] + 1 > maxlen)
1144 len += memblock[len] + 1;
1147 /* Make sure we have enough room */
1148 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
1150 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1151 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
1152 wl->fwlog_size += len;
1157 static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
1163 if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
1164 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
1165 (wl->conf.fwlog.mem_blocks == 0))
1168 wl1271_info("Reading FW panic log");
1170 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
1175 * Make sure the chip is awake and the logger isn't active.
1176 * This might fail if the firmware hanged.
1178 if (!wl1271_ps_elp_wakeup(wl))
1179 wl12xx_cmd_stop_fwlog(wl);
1181 /* Read the first memory block address */
1182 wl12xx_fw_status(wl, wl->fw_status);
1183 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
1187 /* Traverse the memory blocks linked list */
1190 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
1191 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
1195 * Memory blocks are linked to one another. The first 4 bytes
1196 * of each memory block hold the hardware address of the next
1197 * one. The last memory block points to the first one.
1199 addr = le32_to_cpup((__le32 *)block);
1200 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
1201 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
1203 } while (addr && (addr != first_addr));
1205 wake_up_interruptible(&wl->fwlog_waitq);
1211 static void wl1271_recovery_work(struct work_struct *work)
1214 container_of(work, struct wl1271, recovery_work);
1216 mutex_lock(&wl->mutex);
1218 if (wl->state != WL1271_STATE_ON)
1221 /* Avoid a recursive recovery */
1222 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1224 wl12xx_read_fwlog_panic(wl);
1226 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1227 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
1229 BUG_ON(bug_on_recovery);
1232 * Advance security sequence number to overcome potential progress
1233 * in the firmware during recovery. This doens't hurt if the network is
1236 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags) ||
1237 test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
1238 wl->tx_security_seq += WL1271_TX_SQN_POST_RECOVERY_PADDING;
1240 /* Prevent spurious TX during FW restart */
1241 ieee80211_stop_queues(wl->hw);
1243 if (wl->sched_scanning) {
1244 ieee80211_sched_scan_stopped(wl->hw);
1245 wl->sched_scanning = false;
1248 /* reboot the chipset */
1249 __wl1271_op_remove_interface(wl, false);
1251 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1253 ieee80211_restart_hw(wl->hw);
1256 * Its safe to enable TX now - the queues are stopped after a request
1257 * to restart the HW.
1259 ieee80211_wake_queues(wl->hw);
1262 mutex_unlock(&wl->mutex);
1265 static void wl1271_fw_wakeup(struct wl1271 *wl)
1269 elp_reg = ELPCTRL_WAKE_UP;
1270 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1273 static int wl1271_setup(struct wl1271 *wl)
1275 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1279 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1280 if (!wl->tx_res_if) {
1281 kfree(wl->fw_status);
1288 static int wl1271_chip_wakeup(struct wl1271 *wl)
1290 struct wl1271_partition_set partition;
1293 msleep(WL1271_PRE_POWER_ON_SLEEP);
1294 ret = wl1271_power_on(wl);
1297 msleep(WL1271_POWER_ON_SLEEP);
1298 wl1271_io_reset(wl);
1301 /* We don't need a real memory partition here, because we only want
1302 * to use the registers at this point. */
1303 memset(&partition, 0, sizeof(partition));
1304 partition.reg.start = REGISTERS_BASE;
1305 partition.reg.size = REGISTERS_DOWN_SIZE;
1306 wl1271_set_partition(wl, &partition);
1308 /* ELP module wake up */
1309 wl1271_fw_wakeup(wl);
1311 /* whal_FwCtrl_BootSm() */
1313 /* 0. read chip id from CHIP_ID */
1314 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
1316 /* 1. check if chip id is valid */
1318 switch (wl->chip.id) {
1319 case CHIP_ID_1271_PG10:
1320 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1323 ret = wl1271_setup(wl);
1327 case CHIP_ID_1271_PG20:
1328 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1332 * 'end-of-transaction flag' and 'LPD mode flag'
1333 * should be set in wl127x AP mode only
1335 if (wl->bss_type == BSS_TYPE_AP_BSS)
1336 wl->quirks |= (WL12XX_QUIRK_END_OF_TRANSACTION |
1337 WL12XX_QUIRK_LPD_MODE);
1339 ret = wl1271_setup(wl);
1343 case CHIP_ID_1283_PG20:
1344 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1347 ret = wl1271_setup(wl);
1351 if (wl1271_set_block_size(wl))
1352 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1354 case CHIP_ID_1283_PG10:
1356 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1361 if (wl->fw == NULL) {
1362 ret = wl1271_fetch_firmware(wl);
1367 /* No NVS from netlink, try to get it from the filesystem */
1368 if (wl->nvs == NULL) {
1369 ret = wl1271_fetch_nvs(wl);
1378 int wl1271_plt_start(struct wl1271 *wl)
1380 int retries = WL1271_BOOT_RETRIES;
1381 struct wiphy *wiphy = wl->hw->wiphy;
1384 mutex_lock(&wl->mutex);
1386 wl1271_notice("power up");
1388 if (wl->state != WL1271_STATE_OFF) {
1389 wl1271_error("cannot go into PLT state because not "
1390 "in off state: %d", wl->state);
1395 wl->bss_type = BSS_TYPE_STA_BSS;
1399 ret = wl1271_chip_wakeup(wl);
1403 ret = wl1271_boot(wl);
1407 ret = wl1271_plt_init(wl);
1411 wl->state = WL1271_STATE_PLT;
1412 wl1271_notice("firmware booted in PLT mode (%s)",
1413 wl->chip.fw_ver_str);
1415 /* update hw/fw version info in wiphy struct */
1416 wiphy->hw_version = wl->chip.id;
1417 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1418 sizeof(wiphy->fw_version));
1423 mutex_unlock(&wl->mutex);
1424 /* Unlocking the mutex in the middle of handling is
1425 inherently unsafe. In this case we deem it safe to do,
1426 because we need to let any possibly pending IRQ out of
1427 the system (and while we are WL1271_STATE_OFF the IRQ
1428 work function will not do anything.) Also, any other
1429 possible concurrent operations will fail due to the
1430 current state, hence the wl1271 struct should be safe. */
1431 wl1271_disable_interrupts(wl);
1432 wl1271_flush_deferred_work(wl);
1433 cancel_work_sync(&wl->netstack_work);
1434 mutex_lock(&wl->mutex);
1436 wl1271_power_off(wl);
1439 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1440 WL1271_BOOT_RETRIES);
1442 mutex_unlock(&wl->mutex);
1447 static int __wl1271_plt_stop(struct wl1271 *wl)
1451 wl1271_notice("power down");
1453 if (wl->state != WL1271_STATE_PLT) {
1454 wl1271_error("cannot power down because not in PLT "
1455 "state: %d", wl->state);
1460 wl1271_power_off(wl);
1462 wl->state = WL1271_STATE_OFF;
1465 mutex_unlock(&wl->mutex);
1466 wl1271_disable_interrupts(wl);
1467 wl1271_flush_deferred_work(wl);
1468 cancel_work_sync(&wl->netstack_work);
1469 cancel_work_sync(&wl->recovery_work);
1470 mutex_lock(&wl->mutex);
1475 int wl1271_plt_stop(struct wl1271 *wl)
1479 mutex_lock(&wl->mutex);
1480 ret = __wl1271_plt_stop(wl);
1481 mutex_unlock(&wl->mutex);
1485 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1487 struct wl1271 *wl = hw->priv;
1488 unsigned long flags;
1492 mapping = skb_get_queue_mapping(skb);
1493 q = wl1271_tx_get_queue(mapping);
1495 if (wl->bss_type == BSS_TYPE_AP_BSS)
1496 hlid = wl12xx_tx_get_hlid_ap(wl, skb);
1498 spin_lock_irqsave(&wl->wl_lock, flags);
1500 /* queue the packet */
1501 if (wl->bss_type == BSS_TYPE_AP_BSS) {
1502 if (!wl1271_is_active_sta(wl, hlid)) {
1503 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d",
1509 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1510 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1512 skb_queue_tail(&wl->tx_queue[q], skb);
1515 wl->tx_queue_count[q]++;
1518 * The workqueue is slow to process the tx_queue and we need stop
1519 * the queue here, otherwise the queue will get too long.
1521 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1522 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1523 ieee80211_stop_queue(wl->hw, mapping);
1524 set_bit(q, &wl->stopped_queues_map);
1528 * The chip specific setup must run before the first TX packet -
1529 * before that, the tx_work will not be initialized!
1532 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1533 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1534 ieee80211_queue_work(wl->hw, &wl->tx_work);
1537 spin_unlock_irqrestore(&wl->wl_lock, flags);
1540 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1542 unsigned long flags;
1543 int q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1545 spin_lock_irqsave(&wl->wl_lock, flags);
1546 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1547 wl->tx_queue_count[q]++;
1548 spin_unlock_irqrestore(&wl->wl_lock, flags);
1550 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1551 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1552 wl1271_tx_work_locked(wl);
1555 * If the FW TX is busy, TX work will be scheduled by the threaded
1556 * interrupt handler function
1562 * The size of the dummy packet should be at least 1400 bytes. However, in
1563 * order to minimize the number of bus transactions, aligning it to 512 bytes
1564 * boundaries could be beneficial, performance wise
1566 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1568 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1570 struct sk_buff *skb;
1571 struct ieee80211_hdr_3addr *hdr;
1572 unsigned int dummy_packet_size;
1574 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1575 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1577 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1579 wl1271_warning("Failed to allocate a dummy packet skb");
1583 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1585 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1586 memset(hdr, 0, sizeof(*hdr));
1587 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1588 IEEE80211_STYPE_NULLFUNC |
1589 IEEE80211_FCTL_TODS);
1591 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1593 /* Dummy packets require the TID to be management */
1594 skb->priority = WL1271_TID_MGMT;
1596 /* Initialize all fields that might be used */
1597 skb_set_queue_mapping(skb, 0);
1598 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1604 static struct notifier_block wl1271_dev_notifier = {
1605 .notifier_call = wl1271_dev_notify,
1609 static int wl1271_configure_suspend_sta(struct wl1271 *wl)
1613 mutex_lock(&wl->mutex);
1615 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1618 ret = wl1271_ps_elp_wakeup(wl);
1622 /* enter psm if needed*/
1623 if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1624 DECLARE_COMPLETION_ONSTACK(compl);
1626 wl->ps_compl = &compl;
1627 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1628 wl->basic_rate, true);
1632 /* we must unlock here so we will be able to get events */
1633 wl1271_ps_elp_sleep(wl);
1634 mutex_unlock(&wl->mutex);
1636 ret = wait_for_completion_timeout(
1637 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1639 wl1271_warning("couldn't enter ps mode!");
1644 /* take mutex again, and wakeup */
1645 mutex_lock(&wl->mutex);
1647 ret = wl1271_ps_elp_wakeup(wl);
1652 wl1271_ps_elp_sleep(wl);
1654 mutex_unlock(&wl->mutex);
1660 static int wl1271_configure_suspend_ap(struct wl1271 *wl)
1664 mutex_lock(&wl->mutex);
1666 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags))
1669 ret = wl1271_ps_elp_wakeup(wl);
1673 ret = wl1271_acx_beacon_filter_opt(wl, true);
1675 wl1271_ps_elp_sleep(wl);
1677 mutex_unlock(&wl->mutex);
1682 static int wl1271_configure_suspend(struct wl1271 *wl)
1684 if (wl->bss_type == BSS_TYPE_STA_BSS)
1685 return wl1271_configure_suspend_sta(wl);
1686 if (wl->bss_type == BSS_TYPE_AP_BSS)
1687 return wl1271_configure_suspend_ap(wl);
1691 static void wl1271_configure_resume(struct wl1271 *wl)
1694 bool is_sta = wl->bss_type == BSS_TYPE_STA_BSS;
1695 bool is_ap = wl->bss_type == BSS_TYPE_AP_BSS;
1697 if (!is_sta && !is_ap)
1700 mutex_lock(&wl->mutex);
1701 ret = wl1271_ps_elp_wakeup(wl);
1706 /* exit psm if it wasn't configured */
1707 if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1708 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1709 wl->basic_rate, true);
1711 wl1271_acx_beacon_filter_opt(wl, false);
1714 wl1271_ps_elp_sleep(wl);
1716 mutex_unlock(&wl->mutex);
1719 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1720 struct cfg80211_wowlan *wow)
1722 struct wl1271 *wl = hw->priv;
1725 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1726 WARN_ON(!wow || !wow->any);
1728 wl->wow_enabled = true;
1729 ret = wl1271_configure_suspend(wl);
1731 wl1271_warning("couldn't prepare device to suspend");
1734 /* flush any remaining work */
1735 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1738 * disable and re-enable interrupts in order to flush
1741 wl1271_disable_interrupts(wl);
1744 * set suspended flag to avoid triggering a new threaded_irq
1745 * work. no need for spinlock as interrupts are disabled.
1747 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1749 wl1271_enable_interrupts(wl);
1750 flush_work(&wl->tx_work);
1751 flush_delayed_work(&wl->pspoll_work);
1752 flush_delayed_work(&wl->elp_work);
1757 static int wl1271_op_resume(struct ieee80211_hw *hw)
1759 struct wl1271 *wl = hw->priv;
1760 unsigned long flags;
1761 bool run_irq_work = false;
1763 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1765 WARN_ON(!wl->wow_enabled);
1768 * re-enable irq_work enqueuing, and call irq_work directly if
1769 * there is a pending work.
1771 spin_lock_irqsave(&wl->wl_lock, flags);
1772 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1773 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1774 run_irq_work = true;
1775 spin_unlock_irqrestore(&wl->wl_lock, flags);
1778 wl1271_debug(DEBUG_MAC80211,
1779 "run postponed irq_work directly");
1781 wl1271_enable_interrupts(wl);
1783 wl1271_configure_resume(wl);
1784 wl->wow_enabled = false;
1790 static int wl1271_op_start(struct ieee80211_hw *hw)
1792 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1795 * We have to delay the booting of the hardware because
1796 * we need to know the local MAC address before downloading and
1797 * initializing the firmware. The MAC address cannot be changed
1798 * after boot, and without the proper MAC address, the firmware
1799 * will not function properly.
1801 * The MAC address is first known when the corresponding interface
1802 * is added. That is where we will initialize the hardware.
1808 static void wl1271_op_stop(struct ieee80211_hw *hw)
1810 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1813 static u8 wl12xx_get_role_type(struct wl1271 *wl)
1815 switch (wl->bss_type) {
1816 case BSS_TYPE_AP_BSS:
1817 return WL1271_ROLE_AP;
1819 case BSS_TYPE_STA_BSS:
1820 return WL1271_ROLE_STA;
1823 return WL1271_ROLE_IBSS;
1826 wl1271_error("invalid bss_type: %d", wl->bss_type);
1828 return WL12XX_INVALID_ROLE_TYPE;
1831 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1832 struct ieee80211_vif *vif)
1834 struct wl1271 *wl = hw->priv;
1835 struct wiphy *wiphy = hw->wiphy;
1836 int retries = WL1271_BOOT_RETRIES;
1839 bool booted = false;
1841 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1842 vif->type, vif->addr);
1844 mutex_lock(&wl->mutex);
1846 wl1271_debug(DEBUG_MAC80211,
1847 "multiple vifs are not supported yet");
1853 * in some very corner case HW recovery scenarios its possible to
1854 * get here before __wl1271_op_remove_interface is complete, so
1855 * opt out if that is the case.
1857 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1862 switch (vif->type) {
1863 case NL80211_IFTYPE_STATION:
1864 wl->bss_type = BSS_TYPE_STA_BSS;
1865 wl->set_bss_type = BSS_TYPE_STA_BSS;
1867 case NL80211_IFTYPE_ADHOC:
1868 wl->bss_type = BSS_TYPE_IBSS;
1869 wl->set_bss_type = BSS_TYPE_STA_BSS;
1871 case NL80211_IFTYPE_AP:
1872 wl->bss_type = BSS_TYPE_AP_BSS;
1879 role_type = wl12xx_get_role_type(wl);
1880 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
1884 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1886 if (wl->state != WL1271_STATE_OFF) {
1887 wl1271_error("cannot start because not in off state: %d",
1895 ret = wl1271_chip_wakeup(wl);
1899 ret = wl1271_boot(wl);
1903 if (wl->bss_type == BSS_TYPE_STA_BSS ||
1904 wl->bss_type == BSS_TYPE_IBSS) {
1906 * The device role is a special role used for
1907 * rx and tx frames prior to association (as
1908 * the STA role can get packets only from
1909 * its associated bssid)
1911 ret = wl12xx_cmd_role_enable(wl,
1918 ret = wl12xx_cmd_role_enable(wl, role_type, &wl->role_id);
1922 ret = wl1271_hw_init(wl);
1930 mutex_unlock(&wl->mutex);
1931 /* Unlocking the mutex in the middle of handling is
1932 inherently unsafe. In this case we deem it safe to do,
1933 because we need to let any possibly pending IRQ out of
1934 the system (and while we are WL1271_STATE_OFF the IRQ
1935 work function will not do anything.) Also, any other
1936 possible concurrent operations will fail due to the
1937 current state, hence the wl1271 struct should be safe. */
1938 wl1271_disable_interrupts(wl);
1939 wl1271_flush_deferred_work(wl);
1940 cancel_work_sync(&wl->netstack_work);
1941 mutex_lock(&wl->mutex);
1943 wl1271_power_off(wl);
1947 wl1271_error("firmware boot failed despite %d retries",
1948 WL1271_BOOT_RETRIES);
1953 wl->state = WL1271_STATE_ON;
1954 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1955 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1957 /* update hw/fw version info in wiphy struct */
1958 wiphy->hw_version = wl->chip.id;
1959 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1960 sizeof(wiphy->fw_version));
1963 * Now we know if 11a is supported (info from the NVS), so disable
1964 * 11a channels if not supported
1966 if (!wl->enable_11a)
1967 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1969 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1970 wl->enable_11a ? "" : "not ");
1973 mutex_unlock(&wl->mutex);
1975 mutex_lock(&wl_list_mutex);
1977 list_add(&wl->list, &wl_list);
1978 mutex_unlock(&wl_list_mutex);
1983 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1984 bool reset_tx_queues)
1988 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1990 /* because of hardware recovery, we may get here twice */
1991 if (wl->state != WL1271_STATE_ON)
1994 wl1271_info("down");
1996 mutex_lock(&wl_list_mutex);
1997 list_del(&wl->list);
1998 mutex_unlock(&wl_list_mutex);
2000 /* enable dyn ps just in case (if left on due to fw crash etc) */
2001 if (wl->bss_type == BSS_TYPE_STA_BSS)
2002 ieee80211_enable_dyn_ps(wl->vif);
2004 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
2005 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2006 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2007 wl->scan.req = NULL;
2008 ieee80211_scan_completed(wl->hw, true);
2011 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2012 /* disable active roles */
2013 ret = wl1271_ps_elp_wakeup(wl);
2017 if (wl->bss_type == BSS_TYPE_STA_BSS) {
2018 ret = wl12xx_cmd_role_disable(wl, &wl->dev_role_id);
2023 ret = wl12xx_cmd_role_disable(wl, &wl->role_id);
2027 wl1271_ps_elp_sleep(wl);
2030 /* clear all hlids (except system_hlid) */
2031 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
2032 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
2033 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
2034 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
2037 * this must be before the cancel_work calls below, so that the work
2038 * functions don't perform further work.
2040 wl->state = WL1271_STATE_OFF;
2042 mutex_unlock(&wl->mutex);
2044 wl1271_disable_interrupts(wl);
2045 wl1271_flush_deferred_work(wl);
2046 cancel_delayed_work_sync(&wl->scan_complete_work);
2047 cancel_work_sync(&wl->netstack_work);
2048 cancel_work_sync(&wl->tx_work);
2049 del_timer_sync(&wl->rx_streaming_timer);
2050 cancel_work_sync(&wl->rx_streaming_enable_work);
2051 cancel_work_sync(&wl->rx_streaming_disable_work);
2052 cancel_delayed_work_sync(&wl->pspoll_work);
2053 cancel_delayed_work_sync(&wl->elp_work);
2055 mutex_lock(&wl->mutex);
2057 /* let's notify MAC80211 about the remaining pending TX frames */
2058 wl1271_tx_reset(wl, reset_tx_queues);
2059 wl1271_power_off(wl);
2061 memset(wl->bssid, 0, ETH_ALEN);
2062 memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
2064 wl->bss_type = MAX_BSS_TYPE;
2065 wl->set_bss_type = MAX_BSS_TYPE;
2066 wl->band = IEEE80211_BAND_2GHZ;
2069 wl->psm_entry_retry = 0;
2070 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2071 wl->tx_blocks_available = 0;
2072 wl->tx_allocated_blocks = 0;
2073 wl->tx_results_count = 0;
2074 wl->tx_packets_count = 0;
2075 wl->time_offset = 0;
2076 wl->session_counter = 0;
2077 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2079 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2080 wl1271_free_ap_keys(wl);
2081 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
2082 wl->ap_fw_ps_map = 0;
2084 wl->sched_scanning = false;
2085 wl->role_id = WL12XX_INVALID_ROLE_ID;
2086 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
2087 memset(wl->roles_map, 0, sizeof(wl->roles_map));
2088 memset(wl->links_map, 0, sizeof(wl->links_map));
2089 memset(wl->roc_map, 0, sizeof(wl->roc_map));
2091 /* The system link is always allocated */
2092 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
2095 * this is performed after the cancel_work calls and the associated
2096 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2097 * get executed before all these vars have been reset.
2101 wl->tx_blocks_freed = 0;
2103 for (i = 0; i < NUM_TX_QUEUES; i++) {
2104 wl->tx_pkts_freed[i] = 0;
2105 wl->tx_allocated_pkts[i] = 0;
2108 wl1271_debugfs_reset(wl);
2110 kfree(wl->fw_status);
2111 wl->fw_status = NULL;
2112 kfree(wl->tx_res_if);
2113 wl->tx_res_if = NULL;
2114 kfree(wl->target_mem_map);
2115 wl->target_mem_map = NULL;
2118 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2119 struct ieee80211_vif *vif)
2121 struct wl1271 *wl = hw->priv;
2123 mutex_lock(&wl->mutex);
2125 * wl->vif can be null here if someone shuts down the interface
2126 * just when hardware recovery has been started.
2129 WARN_ON(wl->vif != vif);
2130 __wl1271_op_remove_interface(wl, true);
2133 mutex_unlock(&wl->mutex);
2134 cancel_work_sync(&wl->recovery_work);
2137 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
2140 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2143 * One of the side effects of the JOIN command is that is clears
2144 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2145 * to a WPA/WPA2 access point will therefore kill the data-path.
2146 * Currently the only valid scenario for JOIN during association
2147 * is on roaming, in which case we will also be given new keys.
2148 * Keep the below message for now, unless it starts bothering
2149 * users who really like to roam a lot :)
2151 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2152 wl1271_info("JOIN while associated.");
2155 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2158 ret = wl12xx_cmd_role_start_ibss(wl);
2160 ret = wl12xx_cmd_role_start_sta(wl);
2164 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2168 * The join command disable the keep-alive mode, shut down its process,
2169 * and also clear the template config, so we need to reset it all after
2170 * the join. The acx_aid starts the keep-alive process, and the order
2171 * of the commands below is relevant.
2173 ret = wl1271_acx_keep_alive_mode(wl, true);
2177 ret = wl1271_acx_aid(wl, wl->aid);
2181 ret = wl1271_cmd_build_klv_null_data(wl);
2185 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2186 ACX_KEEP_ALIVE_TPL_VALID);
2194 static int wl1271_unjoin(struct wl1271 *wl)
2198 /* to stop listening to a channel, we disconnect */
2199 ret = wl12xx_cmd_role_stop_sta(wl);
2203 memset(wl->bssid, 0, ETH_ALEN);
2205 /* reset TX security counters on a clean disconnect */
2206 wl->tx_security_last_seq_lsb = 0;
2207 wl->tx_security_seq = 0;
2213 static void wl1271_set_band_rate(struct wl1271 *wl)
2215 if (wl->band == IEEE80211_BAND_2GHZ) {
2216 wl->basic_rate_set = wl->conf.tx.basic_rate;
2217 wl->rate_set = wl->conf.tx.basic_rate;
2219 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2220 wl->rate_set = wl->conf.tx.basic_rate_5;
2225 static bool wl12xx_is_roc(struct wl1271 *wl)
2229 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2230 if (role_id >= WL12XX_MAX_ROLES)
2236 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
2241 /* no need to croc if we weren't busy (e.g. during boot) */
2242 if (wl12xx_is_roc(wl)) {
2243 ret = wl12xx_croc(wl, wl->dev_role_id);
2247 ret = wl12xx_cmd_role_stop_dev(wl);
2251 wl->rate_set = wl1271_tx_min_rate_get(wl);
2252 ret = wl1271_acx_sta_rate_policies(wl);
2255 ret = wl1271_acx_keep_alive_config(
2256 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2257 ACX_KEEP_ALIVE_TPL_INVALID);
2260 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2262 /* The current firmware only supports sched_scan in idle */
2263 if (wl->sched_scanning) {
2264 wl1271_scan_sched_scan_stop(wl);
2265 ieee80211_sched_scan_stopped(wl->hw);
2268 ret = wl12xx_cmd_role_start_dev(wl);
2272 ret = wl12xx_roc(wl, wl->dev_role_id);
2275 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2282 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2284 struct wl1271 *wl = hw->priv;
2285 struct ieee80211_conf *conf = &hw->conf;
2286 int channel, ret = 0;
2289 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2291 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2294 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2296 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2300 * mac80211 will go to idle nearly immediately after transmitting some
2301 * frames, such as the deauth. To make sure those frames reach the air,
2302 * wait here until the TX queue is fully flushed.
2304 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2305 (conf->flags & IEEE80211_CONF_IDLE))
2306 wl1271_tx_flush(wl);
2308 mutex_lock(&wl->mutex);
2310 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2311 /* we support configuring the channel and band while off */
2312 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2313 wl->band = conf->channel->band;
2314 wl->channel = channel;
2317 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2318 wl->power_level = conf->power_level;
2323 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2325 ret = wl1271_ps_elp_wakeup(wl);
2329 /* if the channel changes while joined, join again */
2330 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2331 ((wl->band != conf->channel->band) ||
2332 (wl->channel != channel))) {
2333 wl->band = conf->channel->band;
2334 wl->channel = channel;
2338 * FIXME: the mac80211 should really provide a fixed
2339 * rate to use here. for now, just use the smallest
2340 * possible rate for the band as a fixed rate for
2341 * association frames and other control messages.
2343 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2344 wl1271_set_band_rate(wl);
2346 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2347 ret = wl1271_acx_sta_rate_policies(wl);
2349 wl1271_warning("rate policy for channel "
2352 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2353 if (wl12xx_is_roc(wl)) {
2355 ret = wl12xx_croc(wl, wl->dev_role_id);
2359 ret = wl1271_join(wl, false);
2361 wl1271_warning("cmd join on channel "
2365 * change the ROC channel. do it only if we are
2366 * not idle. otherwise, CROC will be called
2369 if (wl12xx_is_roc(wl) &&
2370 !(conf->flags & IEEE80211_CONF_IDLE)) {
2371 ret = wl12xx_croc(wl, wl->dev_role_id);
2375 ret = wl12xx_roc(wl, wl->dev_role_id);
2377 wl1271_warning("roc failed %d",
2384 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2385 ret = wl1271_sta_handle_idle(wl,
2386 conf->flags & IEEE80211_CONF_IDLE);
2388 wl1271_warning("idle mode change failed %d", ret);
2392 * if mac80211 changes the PSM mode, make sure the mode is not
2393 * incorrectly changed after the pspoll failure active window.
2395 if (changed & IEEE80211_CONF_CHANGE_PS)
2396 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2398 if (conf->flags & IEEE80211_CONF_PS &&
2399 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2400 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2403 * We enter PSM only if we're already associated.
2404 * If we're not, we'll enter it when joining an SSID,
2405 * through the bss_info_changed() hook.
2407 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2408 wl1271_debug(DEBUG_PSM, "psm enabled");
2409 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2410 wl->basic_rate, true);
2412 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2413 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2414 wl1271_debug(DEBUG_PSM, "psm disabled");
2416 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2418 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2419 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2420 wl->basic_rate, true);
2423 if (conf->power_level != wl->power_level) {
2424 ret = wl1271_acx_tx_power(wl, conf->power_level);
2428 wl->power_level = conf->power_level;
2432 wl1271_ps_elp_sleep(wl);
2435 mutex_unlock(&wl->mutex);
2440 struct wl1271_filter_params {
2443 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2446 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2447 struct netdev_hw_addr_list *mc_list)
2449 struct wl1271_filter_params *fp;
2450 struct netdev_hw_addr *ha;
2451 struct wl1271 *wl = hw->priv;
2453 if (unlikely(wl->state == WL1271_STATE_OFF))
2456 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2458 wl1271_error("Out of memory setting filters.");
2462 /* update multicast filtering parameters */
2463 fp->mc_list_length = 0;
2464 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2465 fp->enabled = false;
2468 netdev_hw_addr_list_for_each(ha, mc_list) {
2469 memcpy(fp->mc_list[fp->mc_list_length],
2470 ha->addr, ETH_ALEN);
2471 fp->mc_list_length++;
2475 return (u64)(unsigned long)fp;
2478 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2481 FIF_BCN_PRBRESP_PROMISC | \
2485 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2486 unsigned int changed,
2487 unsigned int *total, u64 multicast)
2489 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2490 struct wl1271 *wl = hw->priv;
2493 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2494 " total %x", changed, *total);
2496 mutex_lock(&wl->mutex);
2498 *total &= WL1271_SUPPORTED_FILTERS;
2499 changed &= WL1271_SUPPORTED_FILTERS;
2501 if (unlikely(wl->state == WL1271_STATE_OFF))
2504 ret = wl1271_ps_elp_wakeup(wl);
2508 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2509 if (*total & FIF_ALLMULTI)
2510 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2512 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2514 fp->mc_list_length);
2520 * the fw doesn't provide an api to configure the filters. instead,
2521 * the filters configuration is based on the active roles / ROC
2526 wl1271_ps_elp_sleep(wl);
2529 mutex_unlock(&wl->mutex);
2533 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2534 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2537 struct wl1271_ap_key *ap_key;
2540 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2542 if (key_size > MAX_KEY_SIZE)
2546 * Find next free entry in ap_keys. Also check we are not replacing
2549 for (i = 0; i < MAX_NUM_KEYS; i++) {
2550 if (wl->recorded_ap_keys[i] == NULL)
2553 if (wl->recorded_ap_keys[i]->id == id) {
2554 wl1271_warning("trying to record key replacement");
2559 if (i == MAX_NUM_KEYS)
2562 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2567 ap_key->key_type = key_type;
2568 ap_key->key_size = key_size;
2569 memcpy(ap_key->key, key, key_size);
2570 ap_key->hlid = hlid;
2571 ap_key->tx_seq_32 = tx_seq_32;
2572 ap_key->tx_seq_16 = tx_seq_16;
2574 wl->recorded_ap_keys[i] = ap_key;
2578 static void wl1271_free_ap_keys(struct wl1271 *wl)
2582 for (i = 0; i < MAX_NUM_KEYS; i++) {
2583 kfree(wl->recorded_ap_keys[i]);
2584 wl->recorded_ap_keys[i] = NULL;
2588 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2591 struct wl1271_ap_key *key;
2592 bool wep_key_added = false;
2594 for (i = 0; i < MAX_NUM_KEYS; i++) {
2596 if (wl->recorded_ap_keys[i] == NULL)
2599 key = wl->recorded_ap_keys[i];
2601 if (hlid == WL12XX_INVALID_LINK_ID)
2602 hlid = wl->ap_bcast_hlid;
2604 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2605 key->id, key->key_type,
2606 key->key_size, key->key,
2607 hlid, key->tx_seq_32,
2612 if (key->key_type == KEY_WEP)
2613 wep_key_added = true;
2616 if (wep_key_added) {
2617 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
2624 wl1271_free_ap_keys(wl);
2628 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2629 u8 key_size, const u8 *key, u32 tx_seq_32,
2630 u16 tx_seq_16, struct ieee80211_sta *sta)
2633 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2636 struct wl1271_station *wl_sta;
2640 wl_sta = (struct wl1271_station *)sta->drv_priv;
2641 hlid = wl_sta->hlid;
2643 hlid = wl->ap_bcast_hlid;
2646 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2648 * We do not support removing keys after AP shutdown.
2649 * Pretend we do to make mac80211 happy.
2651 if (action != KEY_ADD_OR_REPLACE)
2654 ret = wl1271_record_ap_key(wl, id,
2656 key, hlid, tx_seq_32,
2659 ret = wl1271_cmd_set_ap_key(wl, action,
2660 id, key_type, key_size,
2661 key, hlid, tx_seq_32,
2669 static const u8 bcast_addr[ETH_ALEN] = {
2670 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2674 * A STA set to GEM cipher requires 2 tx spare blocks.
2675 * Return to default value when GEM cipher key is removed
2677 if (key_type == KEY_GEM) {
2678 if (action == KEY_ADD_OR_REPLACE)
2679 wl->tx_spare_blocks = 2;
2680 else if (action == KEY_REMOVE)
2681 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2684 addr = sta ? sta->addr : bcast_addr;
2686 if (is_zero_ether_addr(addr)) {
2687 /* We dont support TX only encryption */
2691 /* The wl1271 does not allow to remove unicast keys - they
2692 will be cleared automatically on next CMD_JOIN. Ignore the
2693 request silently, as we dont want the mac80211 to emit
2694 an error message. */
2695 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2698 /* don't remove key if hlid was already deleted */
2699 if (action == KEY_REMOVE &&
2700 wl->sta_hlid == WL12XX_INVALID_LINK_ID)
2703 ret = wl1271_cmd_set_sta_key(wl, action,
2704 id, key_type, key_size,
2705 key, addr, tx_seq_32,
2710 /* the default WEP key needs to be configured at least once */
2711 if (key_type == KEY_WEP) {
2712 ret = wl12xx_cmd_set_default_wep_key(wl,
2723 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2724 struct ieee80211_vif *vif,
2725 struct ieee80211_sta *sta,
2726 struct ieee80211_key_conf *key_conf)
2728 struct wl1271 *wl = hw->priv;
2734 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2736 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2737 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2738 key_conf->cipher, key_conf->keyidx,
2739 key_conf->keylen, key_conf->flags);
2740 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2742 mutex_lock(&wl->mutex);
2744 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2749 ret = wl1271_ps_elp_wakeup(wl);
2753 switch (key_conf->cipher) {
2754 case WLAN_CIPHER_SUITE_WEP40:
2755 case WLAN_CIPHER_SUITE_WEP104:
2758 key_conf->hw_key_idx = key_conf->keyidx;
2760 case WLAN_CIPHER_SUITE_TKIP:
2761 key_type = KEY_TKIP;
2763 key_conf->hw_key_idx = key_conf->keyidx;
2764 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2765 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2767 case WLAN_CIPHER_SUITE_CCMP:
2770 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2771 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2772 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2774 case WL1271_CIPHER_SUITE_GEM:
2776 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2777 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2780 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2788 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2789 key_conf->keyidx, key_type,
2790 key_conf->keylen, key_conf->key,
2791 tx_seq_32, tx_seq_16, sta);
2793 wl1271_error("Could not add or replace key");
2799 ret = wl1271_set_key(wl, KEY_REMOVE,
2800 key_conf->keyidx, key_type,
2801 key_conf->keylen, key_conf->key,
2804 wl1271_error("Could not remove key");
2810 wl1271_error("Unsupported key cmd 0x%x", cmd);
2816 wl1271_ps_elp_sleep(wl);
2819 mutex_unlock(&wl->mutex);
2824 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2825 struct ieee80211_vif *vif,
2826 struct cfg80211_scan_request *req)
2828 struct wl1271 *wl = hw->priv;
2833 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2836 ssid = req->ssids[0].ssid;
2837 len = req->ssids[0].ssid_len;
2840 mutex_lock(&wl->mutex);
2842 if (wl->state == WL1271_STATE_OFF) {
2844 * We cannot return -EBUSY here because cfg80211 will expect
2845 * a call to ieee80211_scan_completed if we do - in this case
2846 * there won't be any call.
2852 ret = wl1271_ps_elp_wakeup(wl);
2856 /* cancel ROC before scanning */
2857 if (wl12xx_is_roc(wl)) {
2858 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2859 /* don't allow scanning right now */
2863 wl12xx_croc(wl, wl->dev_role_id);
2864 wl12xx_cmd_role_stop_dev(wl);
2867 ret = wl1271_scan(hw->priv, ssid, len, req);
2869 wl1271_ps_elp_sleep(wl);
2871 mutex_unlock(&wl->mutex);
2876 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2877 struct ieee80211_vif *vif)
2879 struct wl1271 *wl = hw->priv;
2882 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2884 mutex_lock(&wl->mutex);
2886 if (wl->state == WL1271_STATE_OFF)
2889 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2892 ret = wl1271_ps_elp_wakeup(wl);
2896 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2897 ret = wl1271_scan_stop(wl);
2901 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2902 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2903 wl->scan.req = NULL;
2904 ieee80211_scan_completed(wl->hw, true);
2907 wl1271_ps_elp_sleep(wl);
2909 mutex_unlock(&wl->mutex);
2911 cancel_delayed_work_sync(&wl->scan_complete_work);
2914 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2915 struct ieee80211_vif *vif,
2916 struct cfg80211_sched_scan_request *req,
2917 struct ieee80211_sched_scan_ies *ies)
2919 struct wl1271 *wl = hw->priv;
2922 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2924 mutex_lock(&wl->mutex);
2926 ret = wl1271_ps_elp_wakeup(wl);
2930 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2934 ret = wl1271_scan_sched_scan_start(wl);
2938 wl->sched_scanning = true;
2941 wl1271_ps_elp_sleep(wl);
2943 mutex_unlock(&wl->mutex);
2947 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2948 struct ieee80211_vif *vif)
2950 struct wl1271 *wl = hw->priv;
2953 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2955 mutex_lock(&wl->mutex);
2957 ret = wl1271_ps_elp_wakeup(wl);
2961 wl1271_scan_sched_scan_stop(wl);
2963 wl1271_ps_elp_sleep(wl);
2965 mutex_unlock(&wl->mutex);
2968 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2970 struct wl1271 *wl = hw->priv;
2973 mutex_lock(&wl->mutex);
2975 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2980 ret = wl1271_ps_elp_wakeup(wl);
2984 ret = wl1271_acx_frag_threshold(wl, value);
2986 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2988 wl1271_ps_elp_sleep(wl);
2991 mutex_unlock(&wl->mutex);
2996 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2998 struct wl1271 *wl = hw->priv;
3001 mutex_lock(&wl->mutex);
3003 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3008 ret = wl1271_ps_elp_wakeup(wl);
3012 ret = wl1271_acx_rts_threshold(wl, value);
3014 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
3016 wl1271_ps_elp_sleep(wl);
3019 mutex_unlock(&wl->mutex);
3024 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
3028 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3032 wl1271_error("No SSID in IEs!");
3037 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3038 wl1271_error("SSID is too long!");
3042 wl->ssid_len = ssid_len;
3043 memcpy(wl->ssid, ptr+2, ssid_len);
3047 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3048 struct ieee80211_bss_conf *bss_conf,
3053 if (changed & BSS_CHANGED_ERP_SLOT) {
3054 if (bss_conf->use_short_slot)
3055 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
3057 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
3059 wl1271_warning("Set slot time failed %d", ret);
3064 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3065 if (bss_conf->use_short_preamble)
3066 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
3068 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
3071 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3072 if (bss_conf->use_cts_prot)
3073 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
3075 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
3077 wl1271_warning("Set ctsprotect failed %d", ret);
3086 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3087 struct ieee80211_vif *vif,
3088 struct ieee80211_bss_conf *bss_conf,
3091 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3094 if ((changed & BSS_CHANGED_BEACON_INT)) {
3095 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3096 bss_conf->beacon_int);
3098 wl->beacon_int = bss_conf->beacon_int;
3101 if ((changed & BSS_CHANGED_BEACON)) {
3102 struct ieee80211_hdr *hdr;
3103 int ieoffset = offsetof(struct ieee80211_mgmt,
3105 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3111 wl1271_debug(DEBUG_MASTER, "beacon updated");
3113 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3115 dev_kfree_skb(beacon);
3118 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3120 ret = wl1271_cmd_template_set(wl, tmpl_id,
3123 wl1271_tx_min_rate_get(wl));
3125 dev_kfree_skb(beacon);
3129 hdr = (struct ieee80211_hdr *) beacon->data;
3130 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3131 IEEE80211_STYPE_PROBE_RESP);
3133 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3134 CMD_TEMPL_PROBE_RESPONSE;
3135 ret = wl1271_cmd_template_set(wl,
3139 wl1271_tx_min_rate_get(wl));
3140 dev_kfree_skb(beacon);
3149 /* AP mode changes */
3150 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3151 struct ieee80211_vif *vif,
3152 struct ieee80211_bss_conf *bss_conf,
3157 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3158 u32 rates = bss_conf->basic_rates;
3160 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3161 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3163 ret = wl1271_init_ap_rates(wl);
3165 wl1271_error("AP rate policy change failed %d", ret);
3169 ret = wl1271_ap_init_templates(wl);
3174 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3178 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3179 if (bss_conf->enable_beacon) {
3180 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3181 ret = wl12xx_cmd_role_start_ap(wl);
3185 ret = wl1271_ap_init_hwenc(wl);
3189 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3190 wl1271_debug(DEBUG_AP, "started AP");
3193 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3194 ret = wl12xx_cmd_role_stop_ap(wl);
3198 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3199 wl1271_debug(DEBUG_AP, "stopped AP");
3204 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3208 /* Handle HT information change */
3209 if ((changed & BSS_CHANGED_HT) &&
3210 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3211 ret = wl1271_acx_set_ht_information(wl,
3212 bss_conf->ht_operation_mode);
3214 wl1271_warning("Set ht information failed %d", ret);
3223 /* STA/IBSS mode changes */
3224 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3225 struct ieee80211_vif *vif,
3226 struct ieee80211_bss_conf *bss_conf,
3229 bool do_join = false, set_assoc = false;
3230 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
3231 bool ibss_joined = false;
3232 u32 sta_rate_set = 0;
3234 struct ieee80211_sta *sta;
3235 bool sta_exists = false;
3236 struct ieee80211_sta_ht_cap sta_ht_cap;
3239 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3245 if (changed & BSS_CHANGED_IBSS) {
3246 if (bss_conf->ibss_joined) {
3247 set_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags);
3250 if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED,
3253 wl12xx_cmd_role_start_dev(wl);
3254 wl12xx_roc(wl, wl->dev_role_id);
3259 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3262 /* Need to update the SSID (for filtering etc) */
3263 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3266 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3267 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3268 bss_conf->enable_beacon ? "enabled" : "disabled");
3270 if (bss_conf->enable_beacon)
3271 wl->set_bss_type = BSS_TYPE_IBSS;
3273 wl->set_bss_type = BSS_TYPE_STA_BSS;
3277 if ((changed & BSS_CHANGED_CQM)) {
3278 bool enable = false;
3279 if (bss_conf->cqm_rssi_thold)
3281 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3282 bss_conf->cqm_rssi_thold,
3283 bss_conf->cqm_rssi_hyst);
3286 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3289 if ((changed & BSS_CHANGED_BSSID) &&
3291 * Now we know the correct bssid, so we send a new join command
3292 * and enable the BSSID filter
3294 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
3295 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
3297 if (!is_zero_ether_addr(wl->bssid)) {
3298 ret = wl1271_cmd_build_null_data(wl);
3302 ret = wl1271_build_qos_null_data(wl);
3306 /* Need to update the BSSID (for filtering etc) */
3311 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3313 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3317 /* save the supp_rates of the ap */
3318 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3319 if (sta->ht_cap.ht_supported)
3321 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3322 sta_ht_cap = sta->ht_cap;
3329 if ((changed & BSS_CHANGED_ASSOC)) {
3330 if (bss_conf->assoc) {
3333 wl->aid = bss_conf->aid;
3336 wl->ps_poll_failures = 0;
3339 * use basic rates from AP, and determine lowest rate
3340 * to use with control frames.
3342 rates = bss_conf->basic_rates;
3343 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3345 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3347 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3349 ret = wl1271_acx_sta_rate_policies(wl);
3354 * with wl1271, we don't need to update the
3355 * beacon_int and dtim_period, because the firmware
3356 * updates it by itself when the first beacon is
3357 * received after a join.
3359 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3364 * Get a template for hardware connection maintenance
3366 dev_kfree_skb(wl->probereq);
3367 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3368 ieoffset = offsetof(struct ieee80211_mgmt,
3369 u.probe_req.variable);
3370 wl1271_ssid_set(wl, wl->probereq, ieoffset);
3372 /* enable the connection monitoring feature */
3373 ret = wl1271_acx_conn_monit_params(wl, true);
3377 /* use defaults when not associated */
3379 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3382 !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3386 /* free probe-request template */
3387 dev_kfree_skb(wl->probereq);
3388 wl->probereq = NULL;
3390 /* re-enable dynamic ps - just in case */
3391 ieee80211_enable_dyn_ps(wl->vif);
3393 /* revert back to minimum rates for the current band */
3394 wl1271_set_band_rate(wl);
3395 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3396 ret = wl1271_acx_sta_rate_policies(wl);
3400 /* disable connection monitor features */
3401 ret = wl1271_acx_conn_monit_params(wl, false);
3403 /* Disable the keep-alive feature */
3404 ret = wl1271_acx_keep_alive_mode(wl, false);
3408 /* restore the bssid filter and go to dummy bssid */
3410 u32 conf_flags = wl->hw->conf.flags;
3412 * we might have to disable roc, if there was
3413 * no IF_OPER_UP notification.
3416 ret = wl12xx_croc(wl, wl->role_id);
3421 * (we also need to disable roc in case of
3422 * roaming on the same channel. until we will
3423 * have a better flow...)
3425 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3426 ret = wl12xx_croc(wl, wl->dev_role_id);
3432 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3433 wl12xx_cmd_role_start_dev(wl);
3434 wl12xx_roc(wl, wl->dev_role_id);
3440 if (changed & BSS_CHANGED_IBSS) {
3441 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3442 bss_conf->ibss_joined);
3444 if (bss_conf->ibss_joined) {
3445 u32 rates = bss_conf->basic_rates;
3446 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3448 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3450 /* by default, use 11b rates */
3451 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3452 ret = wl1271_acx_sta_rate_policies(wl);
3458 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3462 if (changed & BSS_CHANGED_ARP_FILTER) {
3463 __be32 addr = bss_conf->arp_addr_list[0];
3464 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3466 if (bss_conf->arp_addr_cnt == 1 &&
3467 bss_conf->arp_filter_enabled) {
3469 * The template should have been configured only upon
3470 * association. however, it seems that the correct ip
3471 * isn't being set (when sending), so we have to
3472 * reconfigure the template upon every ip change.
3474 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3476 wl1271_warning("build arp rsp failed: %d", ret);
3480 ret = wl1271_acx_arp_ip_filter(wl,
3481 ACX_ARP_FILTER_ARP_FILTERING,
3484 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3491 ret = wl1271_join(wl, set_assoc);
3493 wl1271_warning("cmd join failed %d", ret);
3497 /* ROC until connected (after EAPOL exchange) */
3499 ret = wl12xx_roc(wl, wl->role_id);
3503 wl1271_check_operstate(wl,
3504 ieee80211_get_operstate(vif));
3507 * stop device role if started (we might already be in
3508 * STA role). TODO: make it better.
3510 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3511 ret = wl12xx_croc(wl, wl->dev_role_id);
3515 ret = wl12xx_cmd_role_stop_dev(wl);
3520 /* If we want to go in PSM but we're not there yet */
3521 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3522 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3523 enum wl1271_cmd_ps_mode mode;
3525 mode = STATION_POWER_SAVE_MODE;
3526 ret = wl1271_ps_set_mode(wl, mode,
3534 /* Handle new association with HT. Do this after join. */
3536 if ((changed & BSS_CHANGED_HT) &&
3537 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3538 ret = wl1271_acx_set_ht_capabilities(wl,
3543 wl1271_warning("Set ht cap true failed %d",
3548 /* handle new association without HT and disassociation */
3549 else if (changed & BSS_CHANGED_ASSOC) {
3550 ret = wl1271_acx_set_ht_capabilities(wl,
3555 wl1271_warning("Set ht cap false failed %d",
3562 /* Handle HT information change. Done after join. */
3563 if ((changed & BSS_CHANGED_HT) &&
3564 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3565 ret = wl1271_acx_set_ht_information(wl,
3566 bss_conf->ht_operation_mode);
3568 wl1271_warning("Set ht information failed %d", ret);
3577 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3578 struct ieee80211_vif *vif,
3579 struct ieee80211_bss_conf *bss_conf,
3582 struct wl1271 *wl = hw->priv;
3583 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3586 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3589 mutex_lock(&wl->mutex);
3591 if (unlikely(wl->state == WL1271_STATE_OFF))
3594 ret = wl1271_ps_elp_wakeup(wl);
3599 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3601 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3603 wl1271_ps_elp_sleep(wl);
3606 mutex_unlock(&wl->mutex);
3609 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3610 const struct ieee80211_tx_queue_params *params)
3612 struct wl1271 *wl = hw->priv;
3616 mutex_lock(&wl->mutex);
3618 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3621 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3623 ps_scheme = CONF_PS_SCHEME_LEGACY;
3625 if (wl->state == WL1271_STATE_OFF) {
3627 * If the state is off, the parameters will be recorded and
3628 * configured on init. This happens in AP-mode.
3630 struct conf_tx_ac_category *conf_ac =
3631 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3632 struct conf_tx_tid *conf_tid =
3633 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3635 conf_ac->ac = wl1271_tx_get_queue(queue);
3636 conf_ac->cw_min = (u8)params->cw_min;
3637 conf_ac->cw_max = params->cw_max;
3638 conf_ac->aifsn = params->aifs;
3639 conf_ac->tx_op_limit = params->txop << 5;
3641 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3642 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3643 conf_tid->tsid = wl1271_tx_get_queue(queue);
3644 conf_tid->ps_scheme = ps_scheme;
3645 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3646 conf_tid->apsd_conf[0] = 0;
3647 conf_tid->apsd_conf[1] = 0;
3651 ret = wl1271_ps_elp_wakeup(wl);
3656 * the txop is confed in units of 32us by the mac80211,
3659 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3660 params->cw_min, params->cw_max,
3661 params->aifs, params->txop << 5);
3665 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3666 CONF_CHANNEL_TYPE_EDCF,
3667 wl1271_tx_get_queue(queue),
3668 ps_scheme, CONF_ACK_POLICY_LEGACY,
3672 wl1271_ps_elp_sleep(wl);
3675 mutex_unlock(&wl->mutex);
3680 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3683 struct wl1271 *wl = hw->priv;
3684 u64 mactime = ULLONG_MAX;
3687 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3689 mutex_lock(&wl->mutex);
3691 if (unlikely(wl->state == WL1271_STATE_OFF))
3694 ret = wl1271_ps_elp_wakeup(wl);
3698 ret = wl1271_acx_tsf_info(wl, &mactime);
3703 wl1271_ps_elp_sleep(wl);
3706 mutex_unlock(&wl->mutex);
3710 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3711 struct survey_info *survey)
3713 struct wl1271 *wl = hw->priv;
3714 struct ieee80211_conf *conf = &hw->conf;
3719 survey->channel = conf->channel;
3720 survey->filled = SURVEY_INFO_NOISE_DBM;
3721 survey->noise = wl->noise;
3726 static int wl1271_allocate_sta(struct wl1271 *wl,
3727 struct ieee80211_sta *sta,
3730 struct wl1271_station *wl_sta;
3733 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3734 if (id >= AP_MAX_STATIONS) {
3735 wl1271_warning("could not allocate HLID - too much stations");
3739 wl_sta = (struct wl1271_station *)sta->drv_priv;
3740 set_bit(id, wl->ap_hlid_map);
3741 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3742 *hlid = wl_sta->hlid;
3743 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3747 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3749 int id = hlid - WL1271_AP_STA_HLID_START;
3751 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3754 clear_bit(id, wl->ap_hlid_map);
3755 memset(wl->links[hlid].addr, 0, ETH_ALEN);
3756 wl->links[hlid].ba_bitmap = 0;
3757 wl1271_tx_reset_link_queues(wl, hlid);
3758 __clear_bit(hlid, &wl->ap_ps_map);
3759 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3762 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3763 struct ieee80211_vif *vif,
3764 struct ieee80211_sta *sta)
3766 struct wl1271 *wl = hw->priv;
3770 mutex_lock(&wl->mutex);
3772 if (unlikely(wl->state == WL1271_STATE_OFF))
3775 if (wl->bss_type != BSS_TYPE_AP_BSS)
3778 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3780 ret = wl1271_allocate_sta(wl, sta, &hlid);
3784 ret = wl1271_ps_elp_wakeup(wl);
3788 ret = wl12xx_cmd_add_peer(wl, sta, hlid);
3792 ret = wl12xx_cmd_set_peer_state(wl, hlid);
3796 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
3801 wl1271_ps_elp_sleep(wl);
3805 wl1271_free_sta(wl, hlid);
3808 mutex_unlock(&wl->mutex);
3812 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3813 struct ieee80211_vif *vif,
3814 struct ieee80211_sta *sta)
3816 struct wl1271 *wl = hw->priv;
3817 struct wl1271_station *wl_sta;
3820 mutex_lock(&wl->mutex);
3822 if (unlikely(wl->state == WL1271_STATE_OFF))
3825 if (wl->bss_type != BSS_TYPE_AP_BSS)
3828 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3830 wl_sta = (struct wl1271_station *)sta->drv_priv;
3831 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3832 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3835 ret = wl1271_ps_elp_wakeup(wl);
3839 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
3843 wl1271_free_sta(wl, wl_sta->hlid);
3846 wl1271_ps_elp_sleep(wl);
3849 mutex_unlock(&wl->mutex);
3853 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3854 struct ieee80211_vif *vif,
3855 enum ieee80211_ampdu_mlme_action action,
3856 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3859 struct wl1271 *wl = hw->priv;
3861 u8 hlid, *ba_bitmap;
3863 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
3866 /* sanity check - the fields in FW are only 8bits wide */
3867 if (WARN_ON(tid > 0xFF))
3870 mutex_lock(&wl->mutex);
3872 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3877 if (wl->bss_type == BSS_TYPE_STA_BSS) {
3878 hlid = wl->sta_hlid;
3879 ba_bitmap = &wl->ba_rx_bitmap;
3880 } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
3881 struct wl1271_station *wl_sta;
3883 wl_sta = (struct wl1271_station *)sta->drv_priv;
3884 hlid = wl_sta->hlid;
3885 ba_bitmap = &wl->links[hlid].ba_bitmap;
3891 ret = wl1271_ps_elp_wakeup(wl);
3895 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3899 case IEEE80211_AMPDU_RX_START:
3900 if (!wl->ba_support || !wl->ba_allowed) {
3905 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
3907 wl1271_error("exceeded max RX BA sessions");
3911 if (*ba_bitmap & BIT(tid)) {
3913 wl1271_error("cannot enable RX BA session on active "
3918 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
3921 *ba_bitmap |= BIT(tid);
3922 wl->ba_rx_session_count++;
3926 case IEEE80211_AMPDU_RX_STOP:
3927 if (!(*ba_bitmap & BIT(tid))) {
3929 wl1271_error("no active RX BA session on tid: %d",
3934 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
3937 *ba_bitmap &= ~BIT(tid);
3938 wl->ba_rx_session_count--;
3943 * The BA initiator session management in FW independently.
3944 * Falling break here on purpose for all TX APDU commands.
3946 case IEEE80211_AMPDU_TX_START:
3947 case IEEE80211_AMPDU_TX_STOP:
3948 case IEEE80211_AMPDU_TX_OPERATIONAL:
3953 wl1271_error("Incorrect ampdu action id=%x\n", action);
3957 wl1271_ps_elp_sleep(wl);
3960 mutex_unlock(&wl->mutex);
3965 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3967 struct wl1271 *wl = hw->priv;
3970 mutex_lock(&wl->mutex);
3972 if (unlikely(wl->state == WL1271_STATE_OFF))
3975 /* packets are considered pending if in the TX queue or the FW */
3976 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
3978 /* the above is appropriate for STA mode for PS purposes */
3979 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3982 mutex_unlock(&wl->mutex);
3987 /* can't be const, mac80211 writes to this */
3988 static struct ieee80211_rate wl1271_rates[] = {
3990 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3991 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3993 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3994 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3995 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3997 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3998 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3999 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4001 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4002 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
4003 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4005 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4006 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4008 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4009 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4011 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4012 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4014 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4015 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4017 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4018 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4020 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4021 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4023 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4024 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4026 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4027 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4030 /* can't be const, mac80211 writes to this */
4031 static struct ieee80211_channel wl1271_channels[] = {
4032 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4033 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4034 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4035 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4036 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4037 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4038 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4039 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4040 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4041 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4042 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4043 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4044 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4045 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
4048 /* mapping to indexes for wl1271_rates */
4049 static const u8 wl1271_rate_to_idx_2ghz[] = {
4050 /* MCS rates are used only with 11n */
4051 7, /* CONF_HW_RXTX_RATE_MCS7 */
4052 6, /* CONF_HW_RXTX_RATE_MCS6 */
4053 5, /* CONF_HW_RXTX_RATE_MCS5 */
4054 4, /* CONF_HW_RXTX_RATE_MCS4 */
4055 3, /* CONF_HW_RXTX_RATE_MCS3 */
4056 2, /* CONF_HW_RXTX_RATE_MCS2 */
4057 1, /* CONF_HW_RXTX_RATE_MCS1 */
4058 0, /* CONF_HW_RXTX_RATE_MCS0 */
4060 11, /* CONF_HW_RXTX_RATE_54 */
4061 10, /* CONF_HW_RXTX_RATE_48 */
4062 9, /* CONF_HW_RXTX_RATE_36 */
4063 8, /* CONF_HW_RXTX_RATE_24 */
4065 /* TI-specific rate */
4066 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4068 7, /* CONF_HW_RXTX_RATE_18 */
4069 6, /* CONF_HW_RXTX_RATE_12 */
4070 3, /* CONF_HW_RXTX_RATE_11 */
4071 5, /* CONF_HW_RXTX_RATE_9 */
4072 4, /* CONF_HW_RXTX_RATE_6 */
4073 2, /* CONF_HW_RXTX_RATE_5_5 */
4074 1, /* CONF_HW_RXTX_RATE_2 */
4075 0 /* CONF_HW_RXTX_RATE_1 */
4078 /* 11n STA capabilities */
4079 #define HW_RX_HIGHEST_RATE 72
4081 #ifdef CONFIG_WL12XX_HT
4082 #define WL12XX_HT_CAP { \
4083 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4084 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
4085 .ht_supported = true, \
4086 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4087 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4089 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4090 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4091 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4095 #define WL12XX_HT_CAP { \
4096 .ht_supported = false, \
4100 /* can't be const, mac80211 writes to this */
4101 static struct ieee80211_supported_band wl1271_band_2ghz = {
4102 .channels = wl1271_channels,
4103 .n_channels = ARRAY_SIZE(wl1271_channels),
4104 .bitrates = wl1271_rates,
4105 .n_bitrates = ARRAY_SIZE(wl1271_rates),
4106 .ht_cap = WL12XX_HT_CAP,
4109 /* 5 GHz data rates for WL1273 */
4110 static struct ieee80211_rate wl1271_rates_5ghz[] = {
4112 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4113 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4115 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4116 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4118 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4119 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4121 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4122 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4124 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4125 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4127 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4128 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4130 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4131 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4133 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4134 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4137 /* 5 GHz band channels for WL1273 */
4138 static struct ieee80211_channel wl1271_channels_5ghz[] = {
4139 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4140 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4141 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4142 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4143 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4144 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4145 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4146 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4147 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4148 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4149 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4150 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4151 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4152 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4153 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4154 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4155 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4156 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4157 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4158 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4159 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4160 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4161 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4162 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4163 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4164 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4165 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4166 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4167 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4168 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4169 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4170 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4171 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4172 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4175 /* mapping to indexes for wl1271_rates_5ghz */
4176 static const u8 wl1271_rate_to_idx_5ghz[] = {
4177 /* MCS rates are used only with 11n */
4178 7, /* CONF_HW_RXTX_RATE_MCS7 */
4179 6, /* CONF_HW_RXTX_RATE_MCS6 */
4180 5, /* CONF_HW_RXTX_RATE_MCS5 */
4181 4, /* CONF_HW_RXTX_RATE_MCS4 */
4182 3, /* CONF_HW_RXTX_RATE_MCS3 */
4183 2, /* CONF_HW_RXTX_RATE_MCS2 */
4184 1, /* CONF_HW_RXTX_RATE_MCS1 */
4185 0, /* CONF_HW_RXTX_RATE_MCS0 */
4187 7, /* CONF_HW_RXTX_RATE_54 */
4188 6, /* CONF_HW_RXTX_RATE_48 */
4189 5, /* CONF_HW_RXTX_RATE_36 */
4190 4, /* CONF_HW_RXTX_RATE_24 */
4192 /* TI-specific rate */
4193 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4195 3, /* CONF_HW_RXTX_RATE_18 */
4196 2, /* CONF_HW_RXTX_RATE_12 */
4197 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4198 1, /* CONF_HW_RXTX_RATE_9 */
4199 0, /* CONF_HW_RXTX_RATE_6 */
4200 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4201 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4202 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4205 static struct ieee80211_supported_band wl1271_band_5ghz = {
4206 .channels = wl1271_channels_5ghz,
4207 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4208 .bitrates = wl1271_rates_5ghz,
4209 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4210 .ht_cap = WL12XX_HT_CAP,
4213 static const u8 *wl1271_band_rate_to_idx[] = {
4214 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4215 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4218 static const struct ieee80211_ops wl1271_ops = {
4219 .start = wl1271_op_start,
4220 .stop = wl1271_op_stop,
4221 .add_interface = wl1271_op_add_interface,
4222 .remove_interface = wl1271_op_remove_interface,
4224 .suspend = wl1271_op_suspend,
4225 .resume = wl1271_op_resume,
4227 .config = wl1271_op_config,
4228 .prepare_multicast = wl1271_op_prepare_multicast,
4229 .configure_filter = wl1271_op_configure_filter,
4231 .set_key = wl1271_op_set_key,
4232 .hw_scan = wl1271_op_hw_scan,
4233 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
4234 .sched_scan_start = wl1271_op_sched_scan_start,
4235 .sched_scan_stop = wl1271_op_sched_scan_stop,
4236 .bss_info_changed = wl1271_op_bss_info_changed,
4237 .set_frag_threshold = wl1271_op_set_frag_threshold,
4238 .set_rts_threshold = wl1271_op_set_rts_threshold,
4239 .conf_tx = wl1271_op_conf_tx,
4240 .get_tsf = wl1271_op_get_tsf,
4241 .get_survey = wl1271_op_get_survey,
4242 .sta_add = wl1271_op_sta_add,
4243 .sta_remove = wl1271_op_sta_remove,
4244 .ampdu_action = wl1271_op_ampdu_action,
4245 .tx_frames_pending = wl1271_tx_frames_pending,
4246 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4250 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
4254 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
4256 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4257 wl1271_error("Illegal RX rate from HW: %d", rate);
4261 idx = wl1271_band_rate_to_idx[band][rate];
4262 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4263 wl1271_error("Unsupported RX rate from HW: %d", rate);
4270 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4271 struct device_attribute *attr,
4274 struct wl1271 *wl = dev_get_drvdata(dev);
4279 mutex_lock(&wl->mutex);
4280 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4282 mutex_unlock(&wl->mutex);
4288 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4289 struct device_attribute *attr,
4290 const char *buf, size_t count)
4292 struct wl1271 *wl = dev_get_drvdata(dev);
4296 ret = kstrtoul(buf, 10, &res);
4298 wl1271_warning("incorrect value written to bt_coex_mode");
4302 mutex_lock(&wl->mutex);
4306 if (res == wl->sg_enabled)
4309 wl->sg_enabled = res;
4311 if (wl->state == WL1271_STATE_OFF)
4314 ret = wl1271_ps_elp_wakeup(wl);
4318 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4319 wl1271_ps_elp_sleep(wl);
4322 mutex_unlock(&wl->mutex);
4326 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4327 wl1271_sysfs_show_bt_coex_state,
4328 wl1271_sysfs_store_bt_coex_state);
4330 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4331 struct device_attribute *attr,
4334 struct wl1271 *wl = dev_get_drvdata(dev);
4339 mutex_lock(&wl->mutex);
4340 if (wl->hw_pg_ver >= 0)
4341 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4343 len = snprintf(buf, len, "n/a\n");
4344 mutex_unlock(&wl->mutex);
4349 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4350 wl1271_sysfs_show_hw_pg_ver, NULL);
4352 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4353 struct bin_attribute *bin_attr,
4354 char *buffer, loff_t pos, size_t count)
4356 struct device *dev = container_of(kobj, struct device, kobj);
4357 struct wl1271 *wl = dev_get_drvdata(dev);
4361 ret = mutex_lock_interruptible(&wl->mutex);
4363 return -ERESTARTSYS;
4365 /* Let only one thread read the log at a time, blocking others */
4366 while (wl->fwlog_size == 0) {
4369 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4371 TASK_INTERRUPTIBLE);
4373 if (wl->fwlog_size != 0) {
4374 finish_wait(&wl->fwlog_waitq, &wait);
4378 mutex_unlock(&wl->mutex);
4381 finish_wait(&wl->fwlog_waitq, &wait);
4383 if (signal_pending(current))
4384 return -ERESTARTSYS;
4386 ret = mutex_lock_interruptible(&wl->mutex);
4388 return -ERESTARTSYS;
4391 /* Check if the fwlog is still valid */
4392 if (wl->fwlog_size < 0) {
4393 mutex_unlock(&wl->mutex);
4397 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4398 len = min(count, (size_t)wl->fwlog_size);
4399 wl->fwlog_size -= len;
4400 memcpy(buffer, wl->fwlog, len);
4402 /* Make room for new messages */
4403 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4405 mutex_unlock(&wl->mutex);
4410 static struct bin_attribute fwlog_attr = {
4411 .attr = {.name = "fwlog", .mode = S_IRUSR},
4412 .read = wl1271_sysfs_read_fwlog,
4415 int wl1271_register_hw(struct wl1271 *wl)
4419 if (wl->mac80211_registered)
4422 ret = wl1271_fetch_nvs(wl);
4424 /* NOTE: The wl->nvs->nvs element must be first, in
4425 * order to simplify the casting, we assume it is at
4426 * the beginning of the wl->nvs structure.
4428 u8 *nvs_ptr = (u8 *)wl->nvs;
4430 wl->mac_addr[0] = nvs_ptr[11];
4431 wl->mac_addr[1] = nvs_ptr[10];
4432 wl->mac_addr[2] = nvs_ptr[6];
4433 wl->mac_addr[3] = nvs_ptr[5];
4434 wl->mac_addr[4] = nvs_ptr[4];
4435 wl->mac_addr[5] = nvs_ptr[3];
4438 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4440 ret = ieee80211_register_hw(wl->hw);
4442 wl1271_error("unable to register mac80211 hw: %d", ret);
4446 wl->mac80211_registered = true;
4448 wl1271_debugfs_init(wl);
4450 register_netdevice_notifier(&wl1271_dev_notifier);
4452 wl1271_notice("loaded");
4456 EXPORT_SYMBOL_GPL(wl1271_register_hw);
4458 void wl1271_unregister_hw(struct wl1271 *wl)
4460 if (wl->state == WL1271_STATE_PLT)
4461 __wl1271_plt_stop(wl);
4463 unregister_netdevice_notifier(&wl1271_dev_notifier);
4464 ieee80211_unregister_hw(wl->hw);
4465 wl->mac80211_registered = false;
4468 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4470 int wl1271_init_ieee80211(struct wl1271 *wl)
4472 static const u32 cipher_suites[] = {
4473 WLAN_CIPHER_SUITE_WEP40,
4474 WLAN_CIPHER_SUITE_WEP104,
4475 WLAN_CIPHER_SUITE_TKIP,
4476 WLAN_CIPHER_SUITE_CCMP,
4477 WL1271_CIPHER_SUITE_GEM,
4480 /* The tx descriptor buffer and the TKIP space. */
4481 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4482 sizeof(struct wl1271_tx_hw_descr);
4485 /* FIXME: find a proper value */
4486 wl->hw->channel_change_time = 10000;
4487 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4489 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4490 IEEE80211_HW_BEACON_FILTER |
4491 IEEE80211_HW_SUPPORTS_PS |
4492 IEEE80211_HW_SUPPORTS_UAPSD |
4493 IEEE80211_HW_HAS_RATE_CONTROL |
4494 IEEE80211_HW_CONNECTION_MONITOR |
4495 IEEE80211_HW_SUPPORTS_CQM_RSSI |
4496 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4497 IEEE80211_HW_SPECTRUM_MGMT |
4498 IEEE80211_HW_AP_LINK_PS;
4500 wl->hw->wiphy->cipher_suites = cipher_suites;
4501 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4503 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4504 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
4505 wl->hw->wiphy->max_scan_ssids = 1;
4506 wl->hw->wiphy->max_sched_scan_ssids = 8;
4508 * Maximum length of elements in scanning probe request templates
4509 * should be the maximum length possible for a template, without
4510 * the IEEE80211 header of the template
4512 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4513 sizeof(struct ieee80211_header);
4515 /* make sure all our channels fit in the scanned_ch bitmask */
4516 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4517 ARRAY_SIZE(wl1271_channels_5ghz) >
4518 WL1271_MAX_CHANNELS);
4520 * We keep local copies of the band structs because we need to
4521 * modify them on a per-device basis.
4523 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4524 sizeof(wl1271_band_2ghz));
4525 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4526 sizeof(wl1271_band_5ghz));
4528 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4529 &wl->bands[IEEE80211_BAND_2GHZ];
4530 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4531 &wl->bands[IEEE80211_BAND_5GHZ];
4534 wl->hw->max_rates = 1;
4536 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4538 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
4540 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4542 wl->hw->max_rx_aggregation_subframes = 8;
4546 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
4548 #define WL1271_DEFAULT_CHANNEL 0
4550 struct ieee80211_hw *wl1271_alloc_hw(void)
4552 struct ieee80211_hw *hw;
4553 struct platform_device *plat_dev = NULL;
4558 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4560 wl1271_error("could not alloc ieee80211_hw");
4565 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
4567 wl1271_error("could not allocate platform_device");
4569 goto err_plat_alloc;
4573 memset(wl, 0, sizeof(*wl));
4575 INIT_LIST_HEAD(&wl->list);
4578 wl->plat_dev = plat_dev;
4580 for (i = 0; i < NUM_TX_QUEUES; i++)
4581 skb_queue_head_init(&wl->tx_queue[i]);
4583 for (i = 0; i < NUM_TX_QUEUES; i++)
4584 for (j = 0; j < AP_MAX_LINKS; j++)
4585 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4587 skb_queue_head_init(&wl->deferred_rx_queue);
4588 skb_queue_head_init(&wl->deferred_tx_queue);
4590 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
4591 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
4592 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
4593 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4594 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4595 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
4596 INIT_WORK(&wl->rx_streaming_enable_work,
4597 wl1271_rx_streaming_enable_work);
4598 INIT_WORK(&wl->rx_streaming_disable_work,
4599 wl1271_rx_streaming_disable_work);
4601 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4602 if (!wl->freezable_wq) {
4607 wl->channel = WL1271_DEFAULT_CHANNEL;
4608 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
4609 wl->default_key = 0;
4611 wl->psm_entry_retry = 0;
4612 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
4613 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
4614 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
4615 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
4616 wl->band = IEEE80211_BAND_2GHZ;
4619 wl->sg_enabled = true;
4621 wl->bss_type = MAX_BSS_TYPE;
4622 wl->set_bss_type = MAX_BSS_TYPE;
4623 wl->last_tx_hlid = 0;
4625 wl->ap_fw_ps_map = 0;
4627 wl->platform_quirks = 0;
4628 wl->sched_scanning = false;
4629 wl->tx_security_seq = 0;
4630 wl->tx_security_last_seq_lsb = 0;
4631 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
4632 wl->role_id = WL12XX_INVALID_ROLE_ID;
4633 wl->system_hlid = WL12XX_SYSTEM_HLID;
4634 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
4635 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4636 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
4637 wl->session_counter = 0;
4638 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
4639 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
4640 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4641 (unsigned long) wl);
4643 init_waitqueue_head(&wl->fwlog_waitq);
4645 /* The system link is always allocated */
4646 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4648 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
4649 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
4650 wl->tx_frames[i] = NULL;
4652 spin_lock_init(&wl->wl_lock);
4654 wl->state = WL1271_STATE_OFF;
4655 mutex_init(&wl->mutex);
4657 /* Apply default driver configuration. */
4658 wl1271_conf_init(wl);
4660 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4661 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4662 if (!wl->aggr_buf) {
4667 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4668 if (!wl->dummy_packet) {
4673 /* Allocate one page for the FW log */
4674 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4677 goto err_dummy_packet;
4680 /* Register platform device */
4681 ret = platform_device_register(wl->plat_dev);
4683 wl1271_error("couldn't register platform device");
4686 dev_set_drvdata(&wl->plat_dev->dev, wl);
4688 /* Create sysfs file to control bt coex state */
4689 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4691 wl1271_error("failed to create sysfs file bt_coex_state");
4695 /* Create sysfs file to get HW PG version */
4696 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4698 wl1271_error("failed to create sysfs file hw_pg_ver");
4699 goto err_bt_coex_state;
4702 /* Create sysfs file for the FW log */
4703 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4705 wl1271_error("failed to create sysfs file fwlog");
4712 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4715 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4718 platform_device_unregister(wl->plat_dev);
4721 free_page((unsigned long)wl->fwlog);
4724 dev_kfree_skb(wl->dummy_packet);
4727 free_pages((unsigned long)wl->aggr_buf, order);
4730 destroy_workqueue(wl->freezable_wq);
4733 wl1271_debugfs_exit(wl);
4737 ieee80211_free_hw(hw);
4741 return ERR_PTR(ret);
4743 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4745 int wl1271_free_hw(struct wl1271 *wl)
4747 /* Unblock any fwlog readers */
4748 mutex_lock(&wl->mutex);
4749 wl->fwlog_size = -1;
4750 wake_up_interruptible_all(&wl->fwlog_waitq);
4751 mutex_unlock(&wl->mutex);
4753 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4755 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4757 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4758 platform_device_unregister(wl->plat_dev);
4759 free_page((unsigned long)wl->fwlog);
4760 dev_kfree_skb(wl->dummy_packet);
4761 free_pages((unsigned long)wl->aggr_buf,
4762 get_order(WL1271_AGGR_BUFFER_SIZE));
4763 kfree(wl->plat_dev);
4765 wl1271_debugfs_exit(wl);
4772 kfree(wl->fw_status);
4773 kfree(wl->tx_res_if);
4774 destroy_workqueue(wl->freezable_wq);
4776 ieee80211_free_hw(wl->hw);
4780 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4782 u32 wl12xx_debug_level = DEBUG_NONE;
4783 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4784 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4785 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4787 module_param_named(fwlog, fwlog_param, charp, 0);
4788 MODULE_PARM_DESC(keymap,
4789 "FW logger options: continuous, ondemand, dbgpins or disable");
4791 module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
4792 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
4794 MODULE_LICENSE("GPL");
4795 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4796 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");