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>
35 #include <linux/interrupt.h>
39 #include "wl12xx_80211.h"
53 #define WL1271_BOOT_RETRIES 3
55 static struct conf_drv_settings default_conf = {
58 [CONF_SG_ACL_BT_MASTER_MIN_BR] = 10,
59 [CONF_SG_ACL_BT_MASTER_MAX_BR] = 180,
60 [CONF_SG_ACL_BT_SLAVE_MIN_BR] = 10,
61 [CONF_SG_ACL_BT_SLAVE_MAX_BR] = 180,
62 [CONF_SG_ACL_BT_MASTER_MIN_EDR] = 10,
63 [CONF_SG_ACL_BT_MASTER_MAX_EDR] = 80,
64 [CONF_SG_ACL_BT_SLAVE_MIN_EDR] = 10,
65 [CONF_SG_ACL_BT_SLAVE_MAX_EDR] = 80,
66 [CONF_SG_ACL_WLAN_PS_MASTER_BR] = 8,
67 [CONF_SG_ACL_WLAN_PS_SLAVE_BR] = 8,
68 [CONF_SG_ACL_WLAN_PS_MASTER_EDR] = 20,
69 [CONF_SG_ACL_WLAN_PS_SLAVE_EDR] = 20,
70 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_BR] = 20,
71 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_BR] = 35,
72 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_BR] = 16,
73 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_BR] = 35,
74 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_EDR] = 32,
75 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_EDR] = 50,
76 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_EDR] = 28,
77 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_EDR] = 50,
78 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_BR] = 10,
79 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_EDR] = 20,
80 [CONF_SG_ACL_PASSIVE_SCAN_BT_BR] = 75,
81 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_BR] = 15,
82 [CONF_SG_ACL_PASSIVE_SCAN_BT_EDR] = 27,
83 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_EDR] = 17,
84 /* active scan params */
85 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
86 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
87 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
88 /* passive scan params */
89 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_BR] = 800,
90 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_EDR] = 200,
91 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
92 /* passive scan in dual antenna params */
93 [CONF_SG_CONSECUTIVE_HV3_IN_PASSIVE_SCAN] = 0,
94 [CONF_SG_BCN_HV3_COLLISION_THRESH_IN_PASSIVE_SCAN] = 0,
95 [CONF_SG_TX_RX_PROTECTION_BWIDTH_IN_PASSIVE_SCAN] = 0,
97 [CONF_SG_STA_FORCE_PS_IN_BT_SCO] = 1,
98 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
99 [CONF_SG_BEACON_MISS_PERCENT] = 60,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_RXT] = 1200,
102 [CONF_SG_TXT] = 1000,
103 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
104 [CONF_SG_GENERAL_USAGE_BIT_MAP] = 3,
105 [CONF_SG_HV3_MAX_SERVED] = 6,
106 [CONF_SG_PS_POLL_TIMEOUT] = 10,
107 [CONF_SG_UPSD_TIMEOUT] = 10,
108 [CONF_SG_CONSECUTIVE_CTS_THRESHOLD] = 2,
109 [CONF_SG_STA_RX_WINDOW_AFTER_DTIM] = 5,
110 [CONF_SG_STA_CONNECTION_PROTECTION_TIME] = 30,
112 [CONF_AP_BEACON_MISS_TX] = 3,
113 [CONF_AP_RX_WINDOW_AFTER_BEACON] = 10,
114 [CONF_AP_BEACON_WINDOW_INTERVAL] = 2,
115 [CONF_AP_CONNECTION_PROTECTION_TIME] = 0,
116 [CONF_AP_BT_ACL_VAL_BT_SERVE_TIME] = 25,
117 [CONF_AP_BT_ACL_VAL_WL_SERVE_TIME] = 25,
119 .state = CONF_SG_PROTECTIVE,
122 .rx_msdu_life_time = 512000,
123 .packet_detection_threshold = 0,
124 .ps_poll_timeout = 15,
126 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
127 .rx_cca_threshold = 0,
128 .irq_blk_threshold = 0xFFFF,
129 .irq_pkt_threshold = 0,
131 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
134 .tx_energy_detection = 0,
137 .short_retry_limit = 10,
138 .long_retry_limit = 10,
161 .aifsn = CONF_TX_AIFS_PIFS,
168 .aifsn = CONF_TX_AIFS_PIFS,
172 .max_tx_retries = 100,
173 .ap_aging_period = 300,
177 .queue_id = CONF_TX_AC_BE,
178 .channel_type = CONF_CHANNEL_TYPE_EDCF,
179 .tsid = CONF_TX_AC_BE,
180 .ps_scheme = CONF_PS_SCHEME_LEGACY,
181 .ack_policy = CONF_ACK_POLICY_LEGACY,
185 .queue_id = CONF_TX_AC_BK,
186 .channel_type = CONF_CHANNEL_TYPE_EDCF,
187 .tsid = CONF_TX_AC_BK,
188 .ps_scheme = CONF_PS_SCHEME_LEGACY,
189 .ack_policy = CONF_ACK_POLICY_LEGACY,
193 .queue_id = CONF_TX_AC_VI,
194 .channel_type = CONF_CHANNEL_TYPE_EDCF,
195 .tsid = CONF_TX_AC_VI,
196 .ps_scheme = CONF_PS_SCHEME_LEGACY,
197 .ack_policy = CONF_ACK_POLICY_LEGACY,
201 .queue_id = CONF_TX_AC_VO,
202 .channel_type = CONF_CHANNEL_TYPE_EDCF,
203 .tsid = CONF_TX_AC_VO,
204 .ps_scheme = CONF_PS_SCHEME_LEGACY,
205 .ack_policy = CONF_ACK_POLICY_LEGACY,
209 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
210 .tx_compl_timeout = 700,
211 .tx_compl_threshold = 4,
212 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
213 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
214 .tmpl_short_retry_limit = 10,
215 .tmpl_long_retry_limit = 10,
218 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
219 .listen_interval = 1,
220 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
221 .bcn_filt_ie_count = 2,
224 .ie = WLAN_EID_CHANNEL_SWITCH,
225 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
228 .ie = WLAN_EID_HT_INFORMATION,
229 .rule = CONF_BCN_RULE_PASS_ON_CHANGE,
232 .synch_fail_thold = 10,
233 .bss_lose_timeout = 100,
234 .beacon_rx_timeout = 10000,
235 .broadcast_timeout = 20000,
236 .rx_broadcast_in_ps = 1,
237 .ps_poll_threshold = 10,
238 .ps_poll_recovery_period = 700,
239 .bet_enable = CONF_BET_MODE_ENABLE,
240 .bet_max_consecutive = 50,
241 .psm_entry_retries = 8,
242 .psm_exit_retries = 16,
243 .psm_entry_nullfunc_retries = 3,
244 .keep_alive_interval = 55000,
245 .max_listen_interval = 20,
252 .host_clk_settling_time = 5000,
253 .host_fast_wakeup_support = false
257 .avg_weight_rssi_beacon = 20,
258 .avg_weight_rssi_data = 10,
259 .avg_weight_snr_beacon = 20,
260 .avg_weight_snr_data = 10,
263 .min_dwell_time_active = 7500,
264 .max_dwell_time_active = 30000,
265 .min_dwell_time_passive = 100000,
266 .max_dwell_time_passive = 100000,
270 /* sched_scan requires dwell times in TU instead of TU/1000 */
271 .min_dwell_time_active = 30,
272 .max_dwell_time_active = 60,
273 .dwell_time_passive = 100,
274 .dwell_time_dfs = 150,
276 .rssi_threshold = -90,
280 .tx_per_channel_power_compensation_2 = {
281 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
283 .tx_per_channel_power_compensation_5 = {
284 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
285 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
286 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291 .tx_ba_win_size = 64,
292 .inactivity_timeout = 10000,
293 .tx_ba_tid_bitmap = CONF_TX_BA_ENABLED_TID_BITMAP,
299 .tx_min_block_num = 40,
301 .min_req_tx_blocks = 100,
302 .min_req_rx_blocks = 22,
309 .tx_min_block_num = 40,
311 .min_req_tx_blocks = 45,
312 .min_req_rx_blocks = 22,
318 .n_divider_fref_set_1 = 0xff, /* default */
319 .n_divider_fref_set_2 = 12,
320 .m_divider_fref_set_1 = 148,
321 .m_divider_fref_set_2 = 0xffff, /* default */
322 .coex_pll_stabilization_time = 0xffffffff, /* default */
323 .ldo_stabilization_time = 0xffff, /* default */
324 .fm_disturbed_band_margin = 0xff, /* default */
325 .swallow_clk_diff = 0xff, /* default */
334 .mode = WL12XX_FWLOG_ON_DEMAND,
337 .timestamp = WL12XX_FWLOG_TIMESTAMP_DISABLED,
338 .output = WL12XX_FWLOG_OUTPUT_HOST,
341 .hci_io_ds = HCI_IO_DS_6MA,
343 .rate_retry_score = 32000,
348 .inverse_curiosity_factor = 5,
350 .tx_fail_high_th = 10,
351 .per_alpha_shift = 4,
353 .per_beta1_shift = 10,
354 .per_beta2_shift = 8,
356 .rate_check_down = 12,
357 .rate_retry_policy = {
358 0x00, 0x00, 0x00, 0x00, 0x00,
359 0x00, 0x00, 0x00, 0x00, 0x00,
365 .hangover_period = 20,
367 .early_termination_mode = 1,
378 static char *fwlog_param;
379 static bool bug_on_recovery;
381 static void __wl1271_op_remove_interface(struct wl1271 *wl,
382 struct ieee80211_vif *vif,
383 bool reset_tx_queues);
384 static void wl1271_op_stop(struct ieee80211_hw *hw);
385 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
387 static DEFINE_MUTEX(wl_list_mutex);
388 static LIST_HEAD(wl_list);
390 static int wl1271_check_operstate(struct wl1271 *wl, struct wl12xx_vif *wlvif,
391 unsigned char operstate)
395 if (operstate != IF_OPER_UP)
398 if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
401 ret = wl12xx_cmd_set_peer_state(wl, wlvif->sta.hlid);
405 wl12xx_croc(wl, wlvif->role_id);
407 wl1271_info("Association completed.");
410 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
413 struct net_device *dev = arg;
414 struct wireless_dev *wdev;
416 struct ieee80211_hw *hw;
418 struct wl1271 *wl_temp;
419 struct wl12xx_vif *wlvif;
422 /* Check that this notification is for us. */
423 if (what != NETDEV_CHANGE)
426 wdev = dev->ieee80211_ptr;
434 hw = wiphy_priv(wiphy);
439 mutex_lock(&wl_list_mutex);
440 list_for_each_entry(wl, &wl_list, list) {
444 mutex_unlock(&wl_list_mutex);
448 mutex_lock(&wl->mutex);
450 if (wl->state == WL1271_STATE_OFF)
453 if (dev->operstate != IF_OPER_UP)
456 * The correct behavior should be just getting the appropriate wlvif
457 * from the given dev, but currently we don't have a mac80211
460 wl12xx_for_each_wlvif_sta(wl, wlvif) {
461 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
463 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
466 ret = wl1271_ps_elp_wakeup(wl);
470 wl1271_check_operstate(wl, wlvif,
471 ieee80211_get_operstate(vif));
473 wl1271_ps_elp_sleep(wl);
476 mutex_unlock(&wl->mutex);
481 static int wl1271_reg_notify(struct wiphy *wiphy,
482 struct regulatory_request *request)
484 struct ieee80211_supported_band *band;
485 struct ieee80211_channel *ch;
488 band = wiphy->bands[IEEE80211_BAND_5GHZ];
489 for (i = 0; i < band->n_channels; i++) {
490 ch = &band->channels[i];
491 if (ch->flags & IEEE80211_CHAN_DISABLED)
494 if (ch->flags & IEEE80211_CHAN_RADAR)
495 ch->flags |= IEEE80211_CHAN_NO_IBSS |
496 IEEE80211_CHAN_PASSIVE_SCAN;
503 static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
508 /* we should hold wl->mutex */
509 ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
514 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
516 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
522 * this function is being called when the rx_streaming interval
523 * has beed changed or rx_streaming should be disabled
525 int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
528 int period = wl->conf.rx_streaming.interval;
530 /* don't reconfigure if rx_streaming is disabled */
531 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
534 /* reconfigure/disable according to new streaming_period */
536 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
537 (wl->conf.rx_streaming.always ||
538 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
539 ret = wl1271_set_rx_streaming(wl, wlvif, true);
541 ret = wl1271_set_rx_streaming(wl, wlvif, false);
542 /* don't cancel_work_sync since we might deadlock */
543 del_timer_sync(&wlvif->rx_streaming_timer);
549 static void wl1271_rx_streaming_enable_work(struct work_struct *work)
552 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
553 rx_streaming_enable_work);
554 struct wl1271 *wl = wlvif->wl;
556 mutex_lock(&wl->mutex);
558 if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
559 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
560 (!wl->conf.rx_streaming.always &&
561 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
564 if (!wl->conf.rx_streaming.interval)
567 ret = wl1271_ps_elp_wakeup(wl);
571 ret = wl1271_set_rx_streaming(wl, wlvif, true);
575 /* stop it after some time of inactivity */
576 mod_timer(&wlvif->rx_streaming_timer,
577 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
580 wl1271_ps_elp_sleep(wl);
582 mutex_unlock(&wl->mutex);
585 static void wl1271_rx_streaming_disable_work(struct work_struct *work)
588 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
589 rx_streaming_disable_work);
590 struct wl1271 *wl = wlvif->wl;
592 mutex_lock(&wl->mutex);
594 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
597 ret = wl1271_ps_elp_wakeup(wl);
601 ret = wl1271_set_rx_streaming(wl, wlvif, false);
606 wl1271_ps_elp_sleep(wl);
608 mutex_unlock(&wl->mutex);
611 static void wl1271_rx_streaming_timer(unsigned long data)
613 struct wl12xx_vif *wlvif = (struct wl12xx_vif *)data;
614 struct wl1271 *wl = wlvif->wl;
615 ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
618 static void wl1271_conf_init(struct wl1271 *wl)
622 * This function applies the default configuration to the driver. This
623 * function is invoked upon driver load (spi probe.)
625 * The configuration is stored in a run-time structure in order to
626 * facilitate for run-time adjustment of any of the parameters. Making
627 * changes to the configuration structure will apply the new values on
628 * the next interface up (wl1271_op_start.)
631 /* apply driver default configuration */
632 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
634 /* Adjust settings according to optional module parameters */
636 if (!strcmp(fwlog_param, "continuous")) {
637 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
638 } else if (!strcmp(fwlog_param, "ondemand")) {
639 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
640 } else if (!strcmp(fwlog_param, "dbgpins")) {
641 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
642 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
643 } else if (!strcmp(fwlog_param, "disable")) {
644 wl->conf.fwlog.mem_blocks = 0;
645 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
647 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
652 static int wl1271_plt_init(struct wl1271 *wl)
656 if (wl->chip.id == CHIP_ID_1283_PG20)
657 ret = wl128x_cmd_general_parms(wl);
659 ret = wl1271_cmd_general_parms(wl);
663 if (wl->chip.id == CHIP_ID_1283_PG20)
664 ret = wl128x_cmd_radio_parms(wl);
666 ret = wl1271_cmd_radio_parms(wl);
670 if (wl->chip.id != CHIP_ID_1283_PG20) {
671 ret = wl1271_cmd_ext_radio_parms(wl);
678 /* Chip-specific initializations */
679 ret = wl1271_chip_specific_init(wl);
683 ret = wl1271_acx_init_mem_config(wl);
687 ret = wl12xx_acx_mem_cfg(wl);
689 goto out_free_memmap;
691 /* Enable data path */
692 ret = wl1271_cmd_data_path(wl, 1);
694 goto out_free_memmap;
696 /* Configure for CAM power saving (ie. always active) */
697 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
699 goto out_free_memmap;
702 ret = wl1271_acx_pm_config(wl);
704 goto out_free_memmap;
709 kfree(wl->target_mem_map);
710 wl->target_mem_map = NULL;
715 static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
716 struct wl12xx_vif *wlvif,
719 bool fw_ps, single_sta;
721 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
722 single_sta = (wl->active_sta_count == 1);
725 * Wake up from high level PS if the STA is asleep with too little
726 * packets in FW or if the STA is awake.
728 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
729 wl12xx_ps_link_end(wl, wlvif, hlid);
732 * Start high-level PS if the STA is asleep with enough blocks in FW.
733 * Make an exception if this is the only connected station. In this
734 * case FW-memory congestion is not a problem.
736 else if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
737 wl12xx_ps_link_start(wl, wlvif, hlid, true);
740 static void wl12xx_irq_update_links_status(struct wl1271 *wl,
741 struct wl12xx_vif *wlvif,
742 struct wl12xx_fw_status *status)
744 struct wl1271_link *lnk;
748 /* TODO: also use link_fast_bitmap here */
750 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
751 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
752 wl1271_debug(DEBUG_PSM,
753 "link ps prev 0x%x cur 0x%x changed 0x%x",
754 wl->ap_fw_ps_map, cur_fw_ps_map,
755 wl->ap_fw_ps_map ^ cur_fw_ps_map);
757 wl->ap_fw_ps_map = cur_fw_ps_map;
760 for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, WL12XX_MAX_LINKS) {
761 lnk = &wl->links[hlid];
762 cnt = status->tx_lnk_free_pkts[hlid] - lnk->prev_freed_pkts;
764 lnk->prev_freed_pkts = status->tx_lnk_free_pkts[hlid];
765 lnk->allocated_pkts -= cnt;
767 wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
768 lnk->allocated_pkts);
772 static void wl12xx_fw_status(struct wl1271 *wl,
773 struct wl12xx_fw_status *status)
775 struct wl12xx_vif *wlvif;
777 u32 old_tx_blk_count = wl->tx_blocks_available;
778 int avail, freed_blocks;
781 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
783 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
784 "drv_rx_counter = %d, tx_results_counter = %d)",
786 status->fw_rx_counter,
787 status->drv_rx_counter,
788 status->tx_results_counter);
790 for (i = 0; i < NUM_TX_QUEUES; i++) {
791 /* prevent wrap-around in freed-packets counter */
792 wl->tx_allocated_pkts[i] -=
793 (status->tx_released_pkts[i] -
794 wl->tx_pkts_freed[i]) & 0xff;
796 wl->tx_pkts_freed[i] = status->tx_released_pkts[i];
799 /* prevent wrap-around in total blocks counter */
800 if (likely(wl->tx_blocks_freed <=
801 le32_to_cpu(status->total_released_blks)))
802 freed_blocks = le32_to_cpu(status->total_released_blks) -
805 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
806 le32_to_cpu(status->total_released_blks);
808 wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
810 wl->tx_allocated_blocks -= freed_blocks;
812 avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
815 * The FW might change the total number of TX memblocks before
816 * we get a notification about blocks being released. Thus, the
817 * available blocks calculation might yield a temporary result
818 * which is lower than the actual available blocks. Keeping in
819 * mind that only blocks that were allocated can be moved from
820 * TX to RX, tx_blocks_available should never decrease here.
822 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
825 /* if more blocks are available now, tx work can be scheduled */
826 if (wl->tx_blocks_available > old_tx_blk_count)
827 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
829 /* for AP update num of allocated TX blocks per link and ps status */
830 wl12xx_for_each_wlvif_ap(wl, wlvif) {
831 wl12xx_irq_update_links_status(wl, wlvif, status);
834 /* update the host-chipset time offset */
836 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
837 (s64)le32_to_cpu(status->fw_localtime);
840 static void wl1271_flush_deferred_work(struct wl1271 *wl)
844 /* Pass all received frames to the network stack */
845 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
846 ieee80211_rx_ni(wl->hw, skb);
848 /* Return sent skbs to the network stack */
849 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
850 ieee80211_tx_status_ni(wl->hw, skb);
853 static void wl1271_netstack_work(struct work_struct *work)
856 container_of(work, struct wl1271, netstack_work);
859 wl1271_flush_deferred_work(wl);
860 } while (skb_queue_len(&wl->deferred_rx_queue));
863 #define WL1271_IRQ_MAX_LOOPS 256
865 static irqreturn_t wl1271_irq(int irq, void *cookie)
869 int loopcount = WL1271_IRQ_MAX_LOOPS;
870 struct wl1271 *wl = (struct wl1271 *)cookie;
872 unsigned int defer_count;
875 /* TX might be handled here, avoid redundant work */
876 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
877 cancel_work_sync(&wl->tx_work);
880 * In case edge triggered interrupt must be used, we cannot iterate
881 * more than once without introducing race conditions with the hardirq.
883 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
886 mutex_lock(&wl->mutex);
888 wl1271_debug(DEBUG_IRQ, "IRQ work");
890 if (unlikely(wl->state == WL1271_STATE_OFF))
893 ret = wl1271_ps_elp_wakeup(wl);
897 while (!done && loopcount--) {
899 * In order to avoid a race with the hardirq, clear the flag
900 * before acknowledging the chip. Since the mutex is held,
901 * wl1271_ps_elp_wakeup cannot be called concurrently.
903 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
904 smp_mb__after_clear_bit();
906 wl12xx_fw_status(wl, wl->fw_status);
907 intr = le32_to_cpu(wl->fw_status->intr);
908 intr &= WL1271_INTR_MASK;
914 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
915 wl1271_error("watchdog interrupt received! "
916 "starting recovery.");
917 wl12xx_queue_recovery_work(wl);
919 /* restarting the chip. ignore any other interrupt. */
923 if (likely(intr & WL1271_ACX_INTR_DATA)) {
924 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
926 wl12xx_rx(wl, wl->fw_status);
928 /* Check if any tx blocks were freed */
929 spin_lock_irqsave(&wl->wl_lock, flags);
930 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
931 wl1271_tx_total_queue_count(wl) > 0) {
932 spin_unlock_irqrestore(&wl->wl_lock, flags);
934 * In order to avoid starvation of the TX path,
935 * call the work function directly.
937 wl1271_tx_work_locked(wl);
939 spin_unlock_irqrestore(&wl->wl_lock, flags);
942 /* check for tx results */
943 if (wl->fw_status->tx_results_counter !=
944 (wl->tx_results_count & 0xff))
945 wl1271_tx_complete(wl);
947 /* Make sure the deferred queues don't get too long */
948 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
949 skb_queue_len(&wl->deferred_rx_queue);
950 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
951 wl1271_flush_deferred_work(wl);
954 if (intr & WL1271_ACX_INTR_EVENT_A) {
955 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
956 wl1271_event_handle(wl, 0);
959 if (intr & WL1271_ACX_INTR_EVENT_B) {
960 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
961 wl1271_event_handle(wl, 1);
964 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
965 wl1271_debug(DEBUG_IRQ,
966 "WL1271_ACX_INTR_INIT_COMPLETE");
968 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
969 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
972 wl1271_ps_elp_sleep(wl);
975 spin_lock_irqsave(&wl->wl_lock, flags);
976 /* In case TX was not handled here, queue TX work */
977 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
978 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
979 wl1271_tx_total_queue_count(wl) > 0)
980 ieee80211_queue_work(wl->hw, &wl->tx_work);
981 spin_unlock_irqrestore(&wl->wl_lock, flags);
983 mutex_unlock(&wl->mutex);
988 static int wl1271_fetch_firmware(struct wl1271 *wl)
990 const struct firmware *fw;
994 if (wl->chip.id == CHIP_ID_1283_PG20)
995 fw_name = WL128X_FW_NAME;
997 fw_name = WL127X_FW_NAME;
999 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
1001 ret = request_firmware(&fw, fw_name, wl->dev);
1004 wl1271_error("could not get firmware %s: %d", fw_name, ret);
1009 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1016 wl->fw_len = fw->size;
1017 wl->fw = vmalloc(wl->fw_len);
1020 wl1271_error("could not allocate memory for the firmware");
1025 memcpy(wl->fw, fw->data, wl->fw_len);
1029 release_firmware(fw);
1034 static int wl1271_fetch_nvs(struct wl1271 *wl)
1036 const struct firmware *fw;
1039 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev);
1042 wl1271_error("could not get nvs file %s: %d", WL12XX_NVS_NAME,
1047 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
1050 wl1271_error("could not allocate memory for the nvs file");
1055 wl->nvs_len = fw->size;
1058 release_firmware(fw);
1063 void wl12xx_queue_recovery_work(struct wl1271 *wl)
1065 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1066 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1069 size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
1073 /* The FW log is a length-value list, find where the log end */
1074 while (len < maxlen) {
1075 if (memblock[len] == 0)
1077 if (len + memblock[len] + 1 > maxlen)
1079 len += memblock[len] + 1;
1082 /* Make sure we have enough room */
1083 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
1085 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1086 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
1087 wl->fwlog_size += len;
1092 static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
1098 if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
1099 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
1100 (wl->conf.fwlog.mem_blocks == 0))
1103 wl1271_info("Reading FW panic log");
1105 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
1110 * Make sure the chip is awake and the logger isn't active.
1111 * This might fail if the firmware hanged.
1113 if (!wl1271_ps_elp_wakeup(wl))
1114 wl12xx_cmd_stop_fwlog(wl);
1116 /* Read the first memory block address */
1117 wl12xx_fw_status(wl, wl->fw_status);
1118 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
1122 /* Traverse the memory blocks linked list */
1125 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
1126 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
1130 * Memory blocks are linked to one another. The first 4 bytes
1131 * of each memory block hold the hardware address of the next
1132 * one. The last memory block points to the first one.
1134 addr = le32_to_cpup((__le32 *)block);
1135 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
1136 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
1138 } while (addr && (addr != first_addr));
1140 wake_up_interruptible(&wl->fwlog_waitq);
1146 static void wl1271_recovery_work(struct work_struct *work)
1149 container_of(work, struct wl1271, recovery_work);
1150 struct wl12xx_vif *wlvif;
1151 struct ieee80211_vif *vif;
1153 mutex_lock(&wl->mutex);
1155 if (wl->state != WL1271_STATE_ON)
1158 /* Avoid a recursive recovery */
1159 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1161 wl12xx_read_fwlog_panic(wl);
1163 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1164 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
1166 BUG_ON(bug_on_recovery);
1169 * Advance security sequence number to overcome potential progress
1170 * in the firmware during recovery. This doens't hurt if the network is
1173 wl12xx_for_each_wlvif(wl, wlvif) {
1174 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
1175 test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1176 wlvif->tx_security_seq +=
1177 WL1271_TX_SQN_POST_RECOVERY_PADDING;
1180 /* Prevent spurious TX during FW restart */
1181 ieee80211_stop_queues(wl->hw);
1183 if (wl->sched_scanning) {
1184 ieee80211_sched_scan_stopped(wl->hw);
1185 wl->sched_scanning = false;
1188 /* reboot the chipset */
1189 while (!list_empty(&wl->wlvif_list)) {
1190 wlvif = list_first_entry(&wl->wlvif_list,
1191 struct wl12xx_vif, list);
1192 vif = wl12xx_wlvif_to_vif(wlvif);
1193 __wl1271_op_remove_interface(wl, vif, false);
1195 mutex_unlock(&wl->mutex);
1196 wl1271_op_stop(wl->hw);
1198 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1200 ieee80211_restart_hw(wl->hw);
1203 * Its safe to enable TX now - the queues are stopped after a request
1204 * to restart the HW.
1206 ieee80211_wake_queues(wl->hw);
1209 mutex_unlock(&wl->mutex);
1212 static void wl1271_fw_wakeup(struct wl1271 *wl)
1216 elp_reg = ELPCTRL_WAKE_UP;
1217 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1220 static int wl1271_setup(struct wl1271 *wl)
1222 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1226 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1227 if (!wl->tx_res_if) {
1228 kfree(wl->fw_status);
1235 static int wl1271_chip_wakeup(struct wl1271 *wl)
1237 struct wl1271_partition_set partition;
1240 msleep(WL1271_PRE_POWER_ON_SLEEP);
1241 ret = wl1271_power_on(wl);
1244 msleep(WL1271_POWER_ON_SLEEP);
1245 wl1271_io_reset(wl);
1248 /* We don't need a real memory partition here, because we only want
1249 * to use the registers at this point. */
1250 memset(&partition, 0, sizeof(partition));
1251 partition.reg.start = REGISTERS_BASE;
1252 partition.reg.size = REGISTERS_DOWN_SIZE;
1253 wl1271_set_partition(wl, &partition);
1255 /* ELP module wake up */
1256 wl1271_fw_wakeup(wl);
1258 /* whal_FwCtrl_BootSm() */
1260 /* 0. read chip id from CHIP_ID */
1261 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
1264 * For wl127x based devices we could use the default block
1265 * size (512 bytes), but due to a bug in the sdio driver, we
1266 * need to set it explicitly after the chip is powered on. To
1267 * simplify the code and since the performance impact is
1268 * negligible, we use the same block size for all different
1271 if (!wl1271_set_block_size(wl))
1272 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
1274 switch (wl->chip.id) {
1275 case CHIP_ID_1271_PG10:
1276 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1279 ret = wl1271_setup(wl);
1282 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
1285 case CHIP_ID_1271_PG20:
1286 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1289 ret = wl1271_setup(wl);
1292 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
1295 case CHIP_ID_1283_PG20:
1296 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1299 ret = wl1271_setup(wl);
1303 case CHIP_ID_1283_PG10:
1305 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1310 if (wl->fw == NULL) {
1311 ret = wl1271_fetch_firmware(wl);
1316 /* No NVS from netlink, try to get it from the filesystem */
1317 if (wl->nvs == NULL) {
1318 ret = wl1271_fetch_nvs(wl);
1327 int wl1271_plt_start(struct wl1271 *wl)
1329 int retries = WL1271_BOOT_RETRIES;
1330 struct wiphy *wiphy = wl->hw->wiphy;
1333 mutex_lock(&wl->mutex);
1335 wl1271_notice("power up");
1337 if (wl->state != WL1271_STATE_OFF) {
1338 wl1271_error("cannot go into PLT state because not "
1339 "in off state: %d", wl->state);
1346 ret = wl1271_chip_wakeup(wl);
1350 ret = wl1271_boot(wl);
1354 ret = wl1271_plt_init(wl);
1358 wl->state = WL1271_STATE_PLT;
1359 wl1271_notice("firmware booted in PLT mode (%s)",
1360 wl->chip.fw_ver_str);
1362 /* update hw/fw version info in wiphy struct */
1363 wiphy->hw_version = wl->chip.id;
1364 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1365 sizeof(wiphy->fw_version));
1370 mutex_unlock(&wl->mutex);
1371 /* Unlocking the mutex in the middle of handling is
1372 inherently unsafe. In this case we deem it safe to do,
1373 because we need to let any possibly pending IRQ out of
1374 the system (and while we are WL1271_STATE_OFF the IRQ
1375 work function will not do anything.) Also, any other
1376 possible concurrent operations will fail due to the
1377 current state, hence the wl1271 struct should be safe. */
1378 wl1271_disable_interrupts(wl);
1379 wl1271_flush_deferred_work(wl);
1380 cancel_work_sync(&wl->netstack_work);
1381 mutex_lock(&wl->mutex);
1383 wl1271_power_off(wl);
1386 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1387 WL1271_BOOT_RETRIES);
1389 mutex_unlock(&wl->mutex);
1394 static int __wl1271_plt_stop(struct wl1271 *wl)
1398 wl1271_notice("power down");
1400 if (wl->state != WL1271_STATE_PLT) {
1401 wl1271_error("cannot power down because not in PLT "
1402 "state: %d", wl->state);
1407 wl1271_power_off(wl);
1409 wl->state = WL1271_STATE_OFF;
1412 mutex_unlock(&wl->mutex);
1413 wl1271_disable_interrupts(wl);
1414 wl1271_flush_deferred_work(wl);
1415 cancel_work_sync(&wl->netstack_work);
1416 cancel_work_sync(&wl->recovery_work);
1417 mutex_lock(&wl->mutex);
1422 int wl1271_plt_stop(struct wl1271 *wl)
1426 mutex_lock(&wl->mutex);
1427 ret = __wl1271_plt_stop(wl);
1428 mutex_unlock(&wl->mutex);
1432 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1434 struct wl1271 *wl = hw->priv;
1435 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1436 struct ieee80211_vif *vif = info->control.vif;
1437 struct wl12xx_vif *wlvif = NULL;
1438 unsigned long flags;
1443 wlvif = wl12xx_vif_to_data(vif);
1445 mapping = skb_get_queue_mapping(skb);
1446 q = wl1271_tx_get_queue(mapping);
1448 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
1450 spin_lock_irqsave(&wl->wl_lock, flags);
1452 /* queue the packet */
1453 if (hlid == WL12XX_INVALID_LINK_ID ||
1454 (wlvif && !test_bit(hlid, wlvif->links_map))) {
1455 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
1456 ieee80211_free_txskb(hw, skb);
1460 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1461 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1463 wl->tx_queue_count[q]++;
1466 * The workqueue is slow to process the tx_queue and we need stop
1467 * the queue here, otherwise the queue will get too long.
1469 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1470 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1471 ieee80211_stop_queue(wl->hw, mapping);
1472 set_bit(q, &wl->stopped_queues_map);
1476 * The chip specific setup must run before the first TX packet -
1477 * before that, the tx_work will not be initialized!
1480 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1481 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1482 ieee80211_queue_work(wl->hw, &wl->tx_work);
1485 spin_unlock_irqrestore(&wl->wl_lock, flags);
1488 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1490 unsigned long flags;
1493 /* no need to queue a new dummy packet if one is already pending */
1494 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1497 q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1499 spin_lock_irqsave(&wl->wl_lock, flags);
1500 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1501 wl->tx_queue_count[q]++;
1502 spin_unlock_irqrestore(&wl->wl_lock, flags);
1504 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1505 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1506 wl1271_tx_work_locked(wl);
1509 * If the FW TX is busy, TX work will be scheduled by the threaded
1510 * interrupt handler function
1516 * The size of the dummy packet should be at least 1400 bytes. However, in
1517 * order to minimize the number of bus transactions, aligning it to 512 bytes
1518 * boundaries could be beneficial, performance wise
1520 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1522 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1524 struct sk_buff *skb;
1525 struct ieee80211_hdr_3addr *hdr;
1526 unsigned int dummy_packet_size;
1528 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1529 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1531 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1533 wl1271_warning("Failed to allocate a dummy packet skb");
1537 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1539 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1540 memset(hdr, 0, sizeof(*hdr));
1541 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1542 IEEE80211_STYPE_NULLFUNC |
1543 IEEE80211_FCTL_TODS);
1545 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1547 /* Dummy packets require the TID to be management */
1548 skb->priority = WL1271_TID_MGMT;
1550 /* Initialize all fields that might be used */
1551 skb_set_queue_mapping(skb, 0);
1552 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1558 static struct notifier_block wl1271_dev_notifier = {
1559 .notifier_call = wl1271_dev_notify,
1563 static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1564 struct wl12xx_vif *wlvif)
1568 mutex_lock(&wl->mutex);
1570 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1573 ret = wl1271_ps_elp_wakeup(wl);
1577 /* enter psm if needed*/
1578 if (!test_bit(WLVIF_FLAG_PSM, &wlvif->flags)) {
1579 DECLARE_COMPLETION_ONSTACK(compl);
1581 wlvif->ps_compl = &compl;
1582 ret = wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE,
1583 wlvif->basic_rate, true);
1587 /* we must unlock here so we will be able to get events */
1588 wl1271_ps_elp_sleep(wl);
1589 mutex_unlock(&wl->mutex);
1591 ret = wait_for_completion_timeout(
1592 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1594 mutex_lock(&wl->mutex);
1596 wl1271_warning("couldn't enter ps mode!");
1601 ret = wl1271_ps_elp_wakeup(wl);
1606 wl1271_ps_elp_sleep(wl);
1608 wlvif->ps_compl = NULL;
1610 mutex_unlock(&wl->mutex);
1615 static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1616 struct wl12xx_vif *wlvif)
1620 mutex_lock(&wl->mutex);
1622 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1625 ret = wl1271_ps_elp_wakeup(wl);
1629 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
1631 wl1271_ps_elp_sleep(wl);
1633 mutex_unlock(&wl->mutex);
1638 static int wl1271_configure_suspend(struct wl1271 *wl,
1639 struct wl12xx_vif *wlvif)
1641 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1642 return wl1271_configure_suspend_sta(wl, wlvif);
1643 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
1644 return wl1271_configure_suspend_ap(wl, wlvif);
1648 static void wl1271_configure_resume(struct wl1271 *wl,
1649 struct wl12xx_vif *wlvif)
1652 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1653 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1655 if (!is_sta && !is_ap)
1658 mutex_lock(&wl->mutex);
1659 ret = wl1271_ps_elp_wakeup(wl);
1664 /* exit psm if it wasn't configured */
1665 if (!test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags))
1666 wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE,
1667 wlvif->basic_rate, true);
1669 wl1271_acx_beacon_filter_opt(wl, wlvif, false);
1672 wl1271_ps_elp_sleep(wl);
1674 mutex_unlock(&wl->mutex);
1677 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1678 struct cfg80211_wowlan *wow)
1680 struct wl1271 *wl = hw->priv;
1681 struct wl12xx_vif *wlvif;
1684 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1685 WARN_ON(!wow || !wow->any);
1687 wl->wow_enabled = true;
1688 wl12xx_for_each_wlvif(wl, wlvif) {
1689 ret = wl1271_configure_suspend(wl, wlvif);
1691 wl1271_warning("couldn't prepare device to suspend");
1695 /* flush any remaining work */
1696 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1699 * disable and re-enable interrupts in order to flush
1702 wl1271_disable_interrupts(wl);
1705 * set suspended flag to avoid triggering a new threaded_irq
1706 * work. no need for spinlock as interrupts are disabled.
1708 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1710 wl1271_enable_interrupts(wl);
1711 flush_work(&wl->tx_work);
1712 wl12xx_for_each_wlvif(wl, wlvif) {
1713 flush_delayed_work(&wlvif->pspoll_work);
1715 flush_delayed_work(&wl->elp_work);
1720 static int wl1271_op_resume(struct ieee80211_hw *hw)
1722 struct wl1271 *wl = hw->priv;
1723 struct wl12xx_vif *wlvif;
1724 unsigned long flags;
1725 bool run_irq_work = false;
1727 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1729 WARN_ON(!wl->wow_enabled);
1732 * re-enable irq_work enqueuing, and call irq_work directly if
1733 * there is a pending work.
1735 spin_lock_irqsave(&wl->wl_lock, flags);
1736 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1737 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1738 run_irq_work = true;
1739 spin_unlock_irqrestore(&wl->wl_lock, flags);
1742 wl1271_debug(DEBUG_MAC80211,
1743 "run postponed irq_work directly");
1745 wl1271_enable_interrupts(wl);
1747 wl12xx_for_each_wlvif(wl, wlvif) {
1748 wl1271_configure_resume(wl, wlvif);
1750 wl->wow_enabled = false;
1756 static int wl1271_op_start(struct ieee80211_hw *hw)
1758 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1761 * We have to delay the booting of the hardware because
1762 * we need to know the local MAC address before downloading and
1763 * initializing the firmware. The MAC address cannot be changed
1764 * after boot, and without the proper MAC address, the firmware
1765 * will not function properly.
1767 * The MAC address is first known when the corresponding interface
1768 * is added. That is where we will initialize the hardware.
1774 static void wl1271_op_stop(struct ieee80211_hw *hw)
1776 struct wl1271 *wl = hw->priv;
1779 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1781 mutex_lock(&wl->mutex);
1782 if (wl->state == WL1271_STATE_OFF) {
1783 mutex_unlock(&wl->mutex);
1787 * this must be before the cancel_work calls below, so that the work
1788 * functions don't perform further work.
1790 wl->state = WL1271_STATE_OFF;
1791 mutex_unlock(&wl->mutex);
1793 mutex_lock(&wl_list_mutex);
1794 list_del(&wl->list);
1795 mutex_unlock(&wl_list_mutex);
1797 wl1271_disable_interrupts(wl);
1798 wl1271_flush_deferred_work(wl);
1799 cancel_delayed_work_sync(&wl->scan_complete_work);
1800 cancel_work_sync(&wl->netstack_work);
1801 cancel_work_sync(&wl->tx_work);
1802 cancel_delayed_work_sync(&wl->elp_work);
1804 /* let's notify MAC80211 about the remaining pending TX frames */
1805 wl12xx_tx_reset(wl, true);
1806 mutex_lock(&wl->mutex);
1808 wl1271_power_off(wl);
1810 wl->band = IEEE80211_BAND_2GHZ;
1813 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1814 wl->tx_blocks_available = 0;
1815 wl->tx_allocated_blocks = 0;
1816 wl->tx_results_count = 0;
1817 wl->tx_packets_count = 0;
1818 wl->time_offset = 0;
1819 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
1820 wl->ap_fw_ps_map = 0;
1822 wl->sched_scanning = false;
1823 memset(wl->roles_map, 0, sizeof(wl->roles_map));
1824 memset(wl->links_map, 0, sizeof(wl->links_map));
1825 memset(wl->roc_map, 0, sizeof(wl->roc_map));
1826 wl->active_sta_count = 0;
1828 /* The system link is always allocated */
1829 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1832 * this is performed after the cancel_work calls and the associated
1833 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1834 * get executed before all these vars have been reset.
1838 wl->tx_blocks_freed = 0;
1840 for (i = 0; i < NUM_TX_QUEUES; i++) {
1841 wl->tx_pkts_freed[i] = 0;
1842 wl->tx_allocated_pkts[i] = 0;
1845 wl1271_debugfs_reset(wl);
1847 kfree(wl->fw_status);
1848 wl->fw_status = NULL;
1849 kfree(wl->tx_res_if);
1850 wl->tx_res_if = NULL;
1851 kfree(wl->target_mem_map);
1852 wl->target_mem_map = NULL;
1854 mutex_unlock(&wl->mutex);
1857 static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
1859 u8 policy = find_first_zero_bit(wl->rate_policies_map,
1860 WL12XX_MAX_RATE_POLICIES);
1861 if (policy >= WL12XX_MAX_RATE_POLICIES)
1864 __set_bit(policy, wl->rate_policies_map);
1869 static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
1871 if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
1874 __clear_bit(*idx, wl->rate_policies_map);
1875 *idx = WL12XX_MAX_RATE_POLICIES;
1878 static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1880 switch (wlvif->bss_type) {
1881 case BSS_TYPE_AP_BSS:
1883 return WL1271_ROLE_P2P_GO;
1885 return WL1271_ROLE_AP;
1887 case BSS_TYPE_STA_BSS:
1889 return WL1271_ROLE_P2P_CL;
1891 return WL1271_ROLE_STA;
1894 return WL1271_ROLE_IBSS;
1897 wl1271_error("invalid bss_type: %d", wlvif->bss_type);
1899 return WL12XX_INVALID_ROLE_TYPE;
1902 static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
1904 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
1907 /* clear everything but the persistent data */
1908 memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
1910 switch (ieee80211_vif_type_p2p(vif)) {
1911 case NL80211_IFTYPE_P2P_CLIENT:
1914 case NL80211_IFTYPE_STATION:
1915 wlvif->bss_type = BSS_TYPE_STA_BSS;
1917 case NL80211_IFTYPE_ADHOC:
1918 wlvif->bss_type = BSS_TYPE_IBSS;
1920 case NL80211_IFTYPE_P2P_GO:
1923 case NL80211_IFTYPE_AP:
1924 wlvif->bss_type = BSS_TYPE_AP_BSS;
1927 wlvif->bss_type = MAX_BSS_TYPE;
1931 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
1932 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
1933 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
1935 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
1936 wlvif->bss_type == BSS_TYPE_IBSS) {
1937 /* init sta/ibss data */
1938 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
1939 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
1940 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
1941 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
1944 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
1945 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
1946 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
1947 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
1948 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
1949 wl12xx_allocate_rate_policy(wl,
1950 &wlvif->ap.ucast_rate_idx[i]);
1953 wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
1954 wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
1955 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
1956 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
1957 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
1958 wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
1961 * mac80211 configures some values globally, while we treat them
1962 * per-interface. thus, on init, we have to copy them from wl
1964 wlvif->band = wl->band;
1965 wlvif->channel = wl->channel;
1966 wlvif->power_level = wl->power_level;
1968 INIT_WORK(&wlvif->rx_streaming_enable_work,
1969 wl1271_rx_streaming_enable_work);
1970 INIT_WORK(&wlvif->rx_streaming_disable_work,
1971 wl1271_rx_streaming_disable_work);
1972 INIT_DELAYED_WORK(&wlvif->pspoll_work, wl1271_pspoll_work);
1973 INIT_LIST_HEAD(&wlvif->list);
1975 setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
1976 (unsigned long) wlvif);
1980 static bool wl12xx_init_fw(struct wl1271 *wl)
1982 int retries = WL1271_BOOT_RETRIES;
1983 bool booted = false;
1984 struct wiphy *wiphy = wl->hw->wiphy;
1989 ret = wl1271_chip_wakeup(wl);
1993 ret = wl1271_boot(wl);
1997 ret = wl1271_hw_init(wl);
2005 mutex_unlock(&wl->mutex);
2006 /* Unlocking the mutex in the middle of handling is
2007 inherently unsafe. In this case we deem it safe to do,
2008 because we need to let any possibly pending IRQ out of
2009 the system (and while we are WL1271_STATE_OFF the IRQ
2010 work function will not do anything.) Also, any other
2011 possible concurrent operations will fail due to the
2012 current state, hence the wl1271 struct should be safe. */
2013 wl1271_disable_interrupts(wl);
2014 wl1271_flush_deferred_work(wl);
2015 cancel_work_sync(&wl->netstack_work);
2016 mutex_lock(&wl->mutex);
2018 wl1271_power_off(wl);
2022 wl1271_error("firmware boot failed despite %d retries",
2023 WL1271_BOOT_RETRIES);
2027 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
2029 /* update hw/fw version info in wiphy struct */
2030 wiphy->hw_version = wl->chip.id;
2031 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
2032 sizeof(wiphy->fw_version));
2035 * Now we know if 11a is supported (info from the NVS), so disable
2036 * 11a channels if not supported
2038 if (!wl->enable_11a)
2039 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
2041 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2042 wl->enable_11a ? "" : "not ");
2044 wl->state = WL1271_STATE_ON;
2049 static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
2051 return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
2054 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2055 struct ieee80211_vif *vif)
2057 struct wl1271 *wl = hw->priv;
2058 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2061 bool booted = false;
2063 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER;
2065 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2066 ieee80211_vif_type_p2p(vif), vif->addr);
2068 mutex_lock(&wl->mutex);
2069 ret = wl1271_ps_elp_wakeup(wl);
2074 wl1271_debug(DEBUG_MAC80211,
2075 "multiple vifs are not supported yet");
2081 * in some very corner case HW recovery scenarios its possible to
2082 * get here before __wl1271_op_remove_interface is complete, so
2083 * opt out if that is the case.
2085 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2086 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2091 ret = wl12xx_init_vif_data(wl, vif);
2096 role_type = wl12xx_get_role_type(wl, wlvif);
2097 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2103 * TODO: after the nvs issue will be solved, move this block
2104 * to start(), and make sure here the driver is ON.
2106 if (wl->state == WL1271_STATE_OFF) {
2108 * we still need this in order to configure the fw
2109 * while uploading the nvs
2111 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
2113 booted = wl12xx_init_fw(wl);
2120 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2121 wlvif->bss_type == BSS_TYPE_IBSS) {
2123 * The device role is a special role used for
2124 * rx and tx frames prior to association (as
2125 * the STA role can get packets only from
2126 * its associated bssid)
2128 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2130 &wlvif->dev_role_id);
2135 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2136 role_type, &wlvif->role_id);
2140 ret = wl1271_init_vif_specific(wl, vif);
2145 list_add(&wlvif->list, &wl->wlvif_list);
2146 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2148 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2153 wl1271_ps_elp_sleep(wl);
2155 mutex_unlock(&wl->mutex);
2157 mutex_lock(&wl_list_mutex);
2159 list_add(&wl->list, &wl_list);
2160 mutex_unlock(&wl_list_mutex);
2165 static void __wl1271_op_remove_interface(struct wl1271 *wl,
2166 struct ieee80211_vif *vif,
2167 bool reset_tx_queues)
2169 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2172 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
2174 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2179 /* because of hardware recovery, we may get here twice */
2180 if (wl->state != WL1271_STATE_ON)
2183 wl1271_info("down");
2185 /* enable dyn ps just in case (if left on due to fw crash etc) */
2186 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
2187 ieee80211_enable_dyn_ps(vif);
2189 if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2190 wl->scan_vif == vif) {
2191 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2192 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2193 wl->scan_vif = NULL;
2194 wl->scan.req = NULL;
2195 ieee80211_scan_completed(wl->hw, true);
2198 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2199 /* disable active roles */
2200 ret = wl1271_ps_elp_wakeup(wl);
2204 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2205 wlvif->bss_type == BSS_TYPE_IBSS) {
2206 if (wl12xx_dev_role_started(wlvif))
2207 wl12xx_stop_dev(wl, wlvif);
2209 ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
2214 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
2218 wl1271_ps_elp_sleep(wl);
2221 /* clear all hlids (except system_hlid) */
2222 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2224 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2225 wlvif->bss_type == BSS_TYPE_IBSS) {
2226 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2227 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2228 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2229 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2231 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2232 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2233 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2234 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2235 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2236 wl12xx_free_rate_policy(wl,
2237 &wlvif->ap.ucast_rate_idx[i]);
2240 wl12xx_tx_reset_wlvif(wl, wlvif);
2241 wl1271_free_ap_keys(wl, wlvif);
2242 if (wl->last_wlvif == wlvif)
2243 wl->last_wlvif = NULL;
2244 list_del(&wlvif->list);
2245 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
2246 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2247 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2249 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2254 mutex_unlock(&wl->mutex);
2255 del_timer_sync(&wlvif->rx_streaming_timer);
2256 cancel_work_sync(&wlvif->rx_streaming_enable_work);
2257 cancel_work_sync(&wlvif->rx_streaming_disable_work);
2258 cancel_delayed_work_sync(&wlvif->pspoll_work);
2260 mutex_lock(&wl->mutex);
2263 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2264 struct ieee80211_vif *vif)
2266 struct wl1271 *wl = hw->priv;
2267 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2268 struct wl12xx_vif *iter;
2270 mutex_lock(&wl->mutex);
2272 if (wl->state == WL1271_STATE_OFF ||
2273 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2277 * wl->vif can be null here if someone shuts down the interface
2278 * just when hardware recovery has been started.
2280 wl12xx_for_each_wlvif(wl, iter) {
2284 __wl1271_op_remove_interface(wl, vif, true);
2287 WARN_ON(iter != wlvif);
2289 mutex_unlock(&wl->mutex);
2290 cancel_work_sync(&wl->recovery_work);
2293 static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
2294 struct ieee80211_vif *vif,
2295 enum nl80211_iftype new_type, bool p2p)
2297 wl1271_op_remove_interface(hw, vif);
2299 vif->type = ieee80211_iftype_p2p(new_type, p2p);
2301 return wl1271_op_add_interface(hw, vif);
2304 static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2308 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2311 * One of the side effects of the JOIN command is that is clears
2312 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2313 * to a WPA/WPA2 access point will therefore kill the data-path.
2314 * Currently the only valid scenario for JOIN during association
2315 * is on roaming, in which case we will also be given new keys.
2316 * Keep the below message for now, unless it starts bothering
2317 * users who really like to roam a lot :)
2319 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2320 wl1271_info("JOIN while associated.");
2323 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2326 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
2328 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
2332 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2336 * The join command disable the keep-alive mode, shut down its process,
2337 * and also clear the template config, so we need to reset it all after
2338 * the join. The acx_aid starts the keep-alive process, and the order
2339 * of the commands below is relevant.
2341 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2345 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2349 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2353 ret = wl1271_acx_keep_alive_config(wl, wlvif,
2354 CMD_TEMPL_KLV_IDX_NULL_DATA,
2355 ACX_KEEP_ALIVE_TPL_VALID);
2363 static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2367 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
2368 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2370 wl12xx_cmd_stop_channel_switch(wl);
2371 ieee80211_chswitch_done(vif, false);
2374 /* to stop listening to a channel, we disconnect */
2375 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
2379 /* reset TX security counters on a clean disconnect */
2380 wlvif->tx_security_last_seq_lsb = 0;
2381 wlvif->tx_security_seq = 0;
2387 static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2389 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
2390 wlvif->rate_set = wlvif->basic_rate_set;
2393 static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2397 bool cur_idle = !test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2399 if (idle == cur_idle)
2403 /* no need to croc if we weren't busy (e.g. during boot) */
2404 if (wl12xx_dev_role_started(wlvif)) {
2405 ret = wl12xx_stop_dev(wl, wlvif);
2410 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2411 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2414 ret = wl1271_acx_keep_alive_config(
2415 wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA,
2416 ACX_KEEP_ALIVE_TPL_INVALID);
2419 clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2421 /* The current firmware only supports sched_scan in idle */
2422 if (wl->sched_scanning) {
2423 wl1271_scan_sched_scan_stop(wl);
2424 ieee80211_sched_scan_stopped(wl->hw);
2427 ret = wl12xx_start_dev(wl, wlvif);
2430 set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2437 static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2438 struct ieee80211_conf *conf, u32 changed)
2440 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2443 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2445 /* if the channel changes while joined, join again */
2446 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2447 ((wlvif->band != conf->channel->band) ||
2448 (wlvif->channel != channel))) {
2449 /* send all pending packets */
2450 wl1271_tx_work_locked(wl);
2451 wlvif->band = conf->channel->band;
2452 wlvif->channel = channel;
2456 * FIXME: the mac80211 should really provide a fixed
2457 * rate to use here. for now, just use the smallest
2458 * possible rate for the band as a fixed rate for
2459 * association frames and other control messages.
2461 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2462 wl1271_set_band_rate(wl, wlvif);
2465 wl1271_tx_min_rate_get(wl,
2466 wlvif->basic_rate_set);
2467 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2469 wl1271_warning("rate policy for channel "
2472 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED,
2474 if (wl12xx_dev_role_started(wlvif)) {
2476 ret = wl12xx_croc(wl,
2477 wlvif->dev_role_id);
2481 ret = wl1271_join(wl, wlvif, false);
2483 wl1271_warning("cmd join on channel "
2487 * change the ROC channel. do it only if we are
2488 * not idle. otherwise, CROC will be called
2491 if (wl12xx_dev_role_started(wlvif) &&
2492 !(conf->flags & IEEE80211_CONF_IDLE)) {
2493 ret = wl12xx_stop_dev(wl, wlvif);
2497 ret = wl12xx_start_dev(wl, wlvif);
2506 * if mac80211 changes the PSM mode, make sure the mode is not
2507 * incorrectly changed after the pspoll failure active window.
2509 if (changed & IEEE80211_CONF_CHANGE_PS)
2510 clear_bit(WLVIF_FLAG_PSPOLL_FAILURE, &wlvif->flags);
2512 if (conf->flags & IEEE80211_CONF_PS &&
2513 !test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags)) {
2514 set_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags);
2517 * We enter PSM only if we're already associated.
2518 * If we're not, we'll enter it when joining an SSID,
2519 * through the bss_info_changed() hook.
2521 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
2522 wl1271_debug(DEBUG_PSM, "psm enabled");
2523 ret = wl1271_ps_set_mode(wl, wlvif,
2524 STATION_POWER_SAVE_MODE,
2525 wlvif->basic_rate, true);
2527 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2528 test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags)) {
2529 wl1271_debug(DEBUG_PSM, "psm disabled");
2531 clear_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags);
2533 if (test_bit(WLVIF_FLAG_PSM, &wlvif->flags))
2534 ret = wl1271_ps_set_mode(wl, wlvif,
2535 STATION_ACTIVE_MODE,
2536 wlvif->basic_rate, true);
2539 if (conf->power_level != wlvif->power_level) {
2540 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
2544 wlvif->power_level = conf->power_level;
2550 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2552 struct wl1271 *wl = hw->priv;
2553 struct wl12xx_vif *wlvif;
2554 struct ieee80211_conf *conf = &hw->conf;
2555 int channel, ret = 0;
2557 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2559 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2562 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2564 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2568 * mac80211 will go to idle nearly immediately after transmitting some
2569 * frames, such as the deauth. To make sure those frames reach the air,
2570 * wait here until the TX queue is fully flushed.
2572 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2573 (conf->flags & IEEE80211_CONF_IDLE))
2574 wl1271_tx_flush(wl);
2576 mutex_lock(&wl->mutex);
2578 /* we support configuring the channel and band even while off */
2579 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2580 wl->band = conf->channel->band;
2581 wl->channel = channel;
2584 if (changed & IEEE80211_CONF_CHANGE_POWER)
2585 wl->power_level = conf->power_level;
2587 if (unlikely(wl->state == WL1271_STATE_OFF))
2590 ret = wl1271_ps_elp_wakeup(wl);
2594 /* configure each interface */
2595 wl12xx_for_each_wlvif(wl, wlvif) {
2596 ret = wl12xx_config_vif(wl, wlvif, conf, changed);
2602 wl1271_ps_elp_sleep(wl);
2605 mutex_unlock(&wl->mutex);
2610 struct wl1271_filter_params {
2613 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2616 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2617 struct netdev_hw_addr_list *mc_list)
2619 struct wl1271_filter_params *fp;
2620 struct netdev_hw_addr *ha;
2621 struct wl1271 *wl = hw->priv;
2623 if (unlikely(wl->state == WL1271_STATE_OFF))
2626 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2628 wl1271_error("Out of memory setting filters.");
2632 /* update multicast filtering parameters */
2633 fp->mc_list_length = 0;
2634 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2635 fp->enabled = false;
2638 netdev_hw_addr_list_for_each(ha, mc_list) {
2639 memcpy(fp->mc_list[fp->mc_list_length],
2640 ha->addr, ETH_ALEN);
2641 fp->mc_list_length++;
2645 return (u64)(unsigned long)fp;
2648 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2651 FIF_BCN_PRBRESP_PROMISC | \
2655 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2656 unsigned int changed,
2657 unsigned int *total, u64 multicast)
2659 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2660 struct wl1271 *wl = hw->priv;
2661 struct wl12xx_vif *wlvif;
2665 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2666 " total %x", changed, *total);
2668 mutex_lock(&wl->mutex);
2670 *total &= WL1271_SUPPORTED_FILTERS;
2671 changed &= WL1271_SUPPORTED_FILTERS;
2673 if (unlikely(wl->state == WL1271_STATE_OFF))
2676 ret = wl1271_ps_elp_wakeup(wl);
2680 wl12xx_for_each_wlvif(wl, wlvif) {
2681 if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
2682 if (*total & FIF_ALLMULTI)
2683 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2687 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2690 fp->mc_list_length);
2697 * the fw doesn't provide an api to configure the filters. instead,
2698 * the filters configuration is based on the active roles / ROC
2703 wl1271_ps_elp_sleep(wl);
2706 mutex_unlock(&wl->mutex);
2710 static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2711 u8 id, u8 key_type, u8 key_size,
2712 const u8 *key, u8 hlid, u32 tx_seq_32,
2715 struct wl1271_ap_key *ap_key;
2718 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2720 if (key_size > MAX_KEY_SIZE)
2724 * Find next free entry in ap_keys. Also check we are not replacing
2727 for (i = 0; i < MAX_NUM_KEYS; i++) {
2728 if (wlvif->ap.recorded_keys[i] == NULL)
2731 if (wlvif->ap.recorded_keys[i]->id == id) {
2732 wl1271_warning("trying to record key replacement");
2737 if (i == MAX_NUM_KEYS)
2740 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2745 ap_key->key_type = key_type;
2746 ap_key->key_size = key_size;
2747 memcpy(ap_key->key, key, key_size);
2748 ap_key->hlid = hlid;
2749 ap_key->tx_seq_32 = tx_seq_32;
2750 ap_key->tx_seq_16 = tx_seq_16;
2752 wlvif->ap.recorded_keys[i] = ap_key;
2756 static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2760 for (i = 0; i < MAX_NUM_KEYS; i++) {
2761 kfree(wlvif->ap.recorded_keys[i]);
2762 wlvif->ap.recorded_keys[i] = NULL;
2766 static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2769 struct wl1271_ap_key *key;
2770 bool wep_key_added = false;
2772 for (i = 0; i < MAX_NUM_KEYS; i++) {
2774 if (wlvif->ap.recorded_keys[i] == NULL)
2777 key = wlvif->ap.recorded_keys[i];
2779 if (hlid == WL12XX_INVALID_LINK_ID)
2780 hlid = wlvif->ap.bcast_hlid;
2782 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2783 key->id, key->key_type,
2784 key->key_size, key->key,
2785 hlid, key->tx_seq_32,
2790 if (key->key_type == KEY_WEP)
2791 wep_key_added = true;
2794 if (wep_key_added) {
2795 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
2796 wlvif->ap.bcast_hlid);
2802 wl1271_free_ap_keys(wl, wlvif);
2806 static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2807 u16 action, u8 id, u8 key_type,
2808 u8 key_size, const u8 *key, u32 tx_seq_32,
2809 u16 tx_seq_16, struct ieee80211_sta *sta)
2812 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2815 struct wl1271_station *wl_sta;
2819 wl_sta = (struct wl1271_station *)sta->drv_priv;
2820 hlid = wl_sta->hlid;
2822 hlid = wlvif->ap.bcast_hlid;
2825 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
2827 * We do not support removing keys after AP shutdown.
2828 * Pretend we do to make mac80211 happy.
2830 if (action != KEY_ADD_OR_REPLACE)
2833 ret = wl1271_record_ap_key(wl, wlvif, id,
2835 key, hlid, tx_seq_32,
2838 ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
2839 id, key_type, key_size,
2840 key, hlid, tx_seq_32,
2848 static const u8 bcast_addr[ETH_ALEN] = {
2849 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2853 * A STA set to GEM cipher requires 2 tx spare blocks.
2854 * Return to default value when GEM cipher key is removed
2856 if (key_type == KEY_GEM) {
2857 if (action == KEY_ADD_OR_REPLACE)
2858 wl->tx_spare_blocks = 2;
2859 else if (action == KEY_REMOVE)
2860 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2863 addr = sta ? sta->addr : bcast_addr;
2865 if (is_zero_ether_addr(addr)) {
2866 /* We dont support TX only encryption */
2870 /* The wl1271 does not allow to remove unicast keys - they
2871 will be cleared automatically on next CMD_JOIN. Ignore the
2872 request silently, as we dont want the mac80211 to emit
2873 an error message. */
2874 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2877 /* don't remove key if hlid was already deleted */
2878 if (action == KEY_REMOVE &&
2879 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
2882 ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
2883 id, key_type, key_size,
2884 key, addr, tx_seq_32,
2889 /* the default WEP key needs to be configured at least once */
2890 if (key_type == KEY_WEP) {
2891 ret = wl12xx_cmd_set_default_wep_key(wl,
2902 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2903 struct ieee80211_vif *vif,
2904 struct ieee80211_sta *sta,
2905 struct ieee80211_key_conf *key_conf)
2907 struct wl1271 *wl = hw->priv;
2908 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2914 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2916 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2917 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2918 key_conf->cipher, key_conf->keyidx,
2919 key_conf->keylen, key_conf->flags);
2920 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2922 mutex_lock(&wl->mutex);
2924 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2929 ret = wl1271_ps_elp_wakeup(wl);
2933 switch (key_conf->cipher) {
2934 case WLAN_CIPHER_SUITE_WEP40:
2935 case WLAN_CIPHER_SUITE_WEP104:
2938 key_conf->hw_key_idx = key_conf->keyidx;
2940 case WLAN_CIPHER_SUITE_TKIP:
2941 key_type = KEY_TKIP;
2943 key_conf->hw_key_idx = key_conf->keyidx;
2944 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
2945 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2947 case WLAN_CIPHER_SUITE_CCMP:
2950 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2951 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
2952 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2954 case WL1271_CIPHER_SUITE_GEM:
2956 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
2957 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2960 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2968 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2969 key_conf->keyidx, key_type,
2970 key_conf->keylen, key_conf->key,
2971 tx_seq_32, tx_seq_16, sta);
2973 wl1271_error("Could not add or replace key");
2979 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
2980 key_conf->keyidx, key_type,
2981 key_conf->keylen, key_conf->key,
2984 wl1271_error("Could not remove key");
2990 wl1271_error("Unsupported key cmd 0x%x", cmd);
2996 wl1271_ps_elp_sleep(wl);
2999 mutex_unlock(&wl->mutex);
3004 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3005 struct ieee80211_vif *vif,
3006 struct cfg80211_scan_request *req)
3008 struct wl1271 *wl = hw->priv;
3009 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3015 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3018 ssid = req->ssids[0].ssid;
3019 len = req->ssids[0].ssid_len;
3022 mutex_lock(&wl->mutex);
3024 if (wl->state == WL1271_STATE_OFF) {
3026 * We cannot return -EBUSY here because cfg80211 will expect
3027 * a call to ieee80211_scan_completed if we do - in this case
3028 * there won't be any call.
3034 ret = wl1271_ps_elp_wakeup(wl);
3038 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
3039 test_bit(wlvif->role_id, wl->roc_map)) {
3040 /* don't allow scanning right now */
3045 /* cancel ROC before scanning */
3046 if (wl12xx_dev_role_started(wlvif))
3047 wl12xx_stop_dev(wl, wlvif);
3049 ret = wl1271_scan(hw->priv, vif, ssid, len, req);
3051 wl1271_ps_elp_sleep(wl);
3053 mutex_unlock(&wl->mutex);
3058 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3059 struct ieee80211_vif *vif)
3061 struct wl1271 *wl = hw->priv;
3064 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3066 mutex_lock(&wl->mutex);
3068 if (wl->state == WL1271_STATE_OFF)
3071 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3074 ret = wl1271_ps_elp_wakeup(wl);
3078 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
3079 ret = wl1271_scan_stop(wl);
3083 wl->scan.state = WL1271_SCAN_STATE_IDLE;
3084 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3085 wl->scan_vif = NULL;
3086 wl->scan.req = NULL;
3087 ieee80211_scan_completed(wl->hw, true);
3090 wl1271_ps_elp_sleep(wl);
3092 mutex_unlock(&wl->mutex);
3094 cancel_delayed_work_sync(&wl->scan_complete_work);
3097 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3098 struct ieee80211_vif *vif,
3099 struct cfg80211_sched_scan_request *req,
3100 struct ieee80211_sched_scan_ies *ies)
3102 struct wl1271 *wl = hw->priv;
3103 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3106 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3108 mutex_lock(&wl->mutex);
3110 ret = wl1271_ps_elp_wakeup(wl);
3114 ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies);
3118 ret = wl1271_scan_sched_scan_start(wl, wlvif);
3122 wl->sched_scanning = true;
3125 wl1271_ps_elp_sleep(wl);
3127 mutex_unlock(&wl->mutex);
3131 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3132 struct ieee80211_vif *vif)
3134 struct wl1271 *wl = hw->priv;
3137 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3139 mutex_lock(&wl->mutex);
3141 ret = wl1271_ps_elp_wakeup(wl);
3145 wl1271_scan_sched_scan_stop(wl);
3147 wl1271_ps_elp_sleep(wl);
3149 mutex_unlock(&wl->mutex);
3152 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3154 struct wl1271 *wl = hw->priv;
3157 mutex_lock(&wl->mutex);
3159 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3164 ret = wl1271_ps_elp_wakeup(wl);
3168 ret = wl1271_acx_frag_threshold(wl, value);
3170 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3172 wl1271_ps_elp_sleep(wl);
3175 mutex_unlock(&wl->mutex);
3180 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3182 struct wl1271 *wl = hw->priv;
3183 struct wl12xx_vif *wlvif;
3186 mutex_lock(&wl->mutex);
3188 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3193 ret = wl1271_ps_elp_wakeup(wl);
3197 wl12xx_for_each_wlvif(wl, wlvif) {
3198 ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3200 wl1271_warning("set rts threshold failed: %d", ret);
3202 wl1271_ps_elp_sleep(wl);
3205 mutex_unlock(&wl->mutex);
3210 static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb,
3213 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3215 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3219 wl1271_error("No SSID in IEs!");
3224 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3225 wl1271_error("SSID is too long!");
3229 wlvif->ssid_len = ssid_len;
3230 memcpy(wlvif->ssid, ptr+2, ssid_len);
3234 static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3237 const u8 *next, *end = skb->data + skb->len;
3238 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3239 skb->len - ieoffset);
3244 memmove(ie, next, end - next);
3245 skb_trim(skb, skb->len - len);
3248 static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3249 unsigned int oui, u8 oui_type,
3253 const u8 *next, *end = skb->data + skb->len;
3254 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3255 skb->data + ieoffset,
3256 skb->len - ieoffset);
3261 memmove(ie, next, end - next);
3262 skb_trim(skb, skb->len - len);
3265 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
3266 struct ieee80211_vif *vif)
3268 struct sk_buff *skb;
3271 skb = ieee80211_proberesp_get(wl->hw, vif);
3275 ret = wl1271_cmd_template_set(wl,
3276 CMD_TEMPL_AP_PROBE_RESPONSE,
3285 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
3286 struct ieee80211_vif *vif,
3288 size_t probe_rsp_len,
3291 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3292 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
3293 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3294 int ssid_ie_offset, ie_offset, templ_len;
3297 /* no need to change probe response if the SSID is set correctly */
3298 if (wlvif->ssid_len > 0)
3299 return wl1271_cmd_template_set(wl,
3300 CMD_TEMPL_AP_PROBE_RESPONSE,
3305 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3306 wl1271_error("probe_rsp template too big");
3310 /* start searching from IE offset */
3311 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3313 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3314 probe_rsp_len - ie_offset);
3316 wl1271_error("No SSID in beacon!");
3320 ssid_ie_offset = ptr - probe_rsp_data;
3321 ptr += (ptr[1] + 2);
3323 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3325 /* insert SSID from bss_conf */
3326 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3327 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3328 memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3329 bss_conf->ssid, bss_conf->ssid_len);
3330 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3332 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3333 ptr, probe_rsp_len - (ptr - probe_rsp_data));
3334 templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3336 return wl1271_cmd_template_set(wl,
3337 CMD_TEMPL_AP_PROBE_RESPONSE,
3343 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3344 struct ieee80211_vif *vif,
3345 struct ieee80211_bss_conf *bss_conf,
3348 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3351 if (changed & BSS_CHANGED_ERP_SLOT) {
3352 if (bss_conf->use_short_slot)
3353 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
3355 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
3357 wl1271_warning("Set slot time failed %d", ret);
3362 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3363 if (bss_conf->use_short_preamble)
3364 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
3366 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
3369 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3370 if (bss_conf->use_cts_prot)
3371 ret = wl1271_acx_cts_protect(wl, wlvif,
3374 ret = wl1271_acx_cts_protect(wl, wlvif,
3375 CTSPROTECT_DISABLE);
3377 wl1271_warning("Set ctsprotect failed %d", ret);
3386 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3387 struct ieee80211_vif *vif,
3388 struct ieee80211_bss_conf *bss_conf,
3391 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3392 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3395 if ((changed & BSS_CHANGED_BEACON_INT)) {
3396 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3397 bss_conf->beacon_int);
3399 wlvif->beacon_int = bss_conf->beacon_int;
3402 if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
3403 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3404 if (!wl1271_ap_set_probe_resp_tmpl(wl, rate, vif)) {
3405 wl1271_debug(DEBUG_AP, "probe response updated");
3406 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
3410 if ((changed & BSS_CHANGED_BEACON)) {
3411 struct ieee80211_hdr *hdr;
3413 int ieoffset = offsetof(struct ieee80211_mgmt,
3415 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3423 wl1271_debug(DEBUG_MASTER, "beacon updated");
3425 ret = wl1271_ssid_set(vif, beacon, ieoffset);
3427 dev_kfree_skb(beacon);
3430 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3431 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3433 ret = wl1271_cmd_template_set(wl, tmpl_id,
3438 dev_kfree_skb(beacon);
3443 * In case we already have a probe-resp beacon set explicitly
3444 * by usermode, don't use the beacon data.
3446 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
3449 /* remove TIM ie from probe response */
3450 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3453 * remove p2p ie from probe response.
3454 * the fw reponds to probe requests that don't include
3455 * the p2p ie. probe requests with p2p ie will be passed,
3456 * and will be responded by the supplicant (the spec
3457 * forbids including the p2p ie when responding to probe
3458 * requests that didn't include it).
3460 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3461 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3463 hdr = (struct ieee80211_hdr *) beacon->data;
3464 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3465 IEEE80211_STYPE_PROBE_RESP);
3467 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
3472 ret = wl1271_cmd_template_set(wl,
3473 CMD_TEMPL_PROBE_RESPONSE,
3478 dev_kfree_skb(beacon);
3485 wl1271_error("beacon info change failed: %d", ret);
3489 /* AP mode changes */
3490 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3491 struct ieee80211_vif *vif,
3492 struct ieee80211_bss_conf *bss_conf,
3495 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3498 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3499 u32 rates = bss_conf->basic_rates;
3501 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
3503 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
3504 wlvif->basic_rate_set);
3506 ret = wl1271_init_ap_rates(wl, wlvif);
3508 wl1271_error("AP rate policy change failed %d", ret);
3512 ret = wl1271_ap_init_templates(wl, vif);
3517 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3521 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3522 if (bss_conf->enable_beacon) {
3523 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3524 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
3528 ret = wl1271_ap_init_hwenc(wl, wlvif);
3532 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3533 wl1271_debug(DEBUG_AP, "started AP");
3536 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3537 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
3541 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3542 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
3544 wl1271_debug(DEBUG_AP, "stopped AP");
3549 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3553 /* Handle HT information change */
3554 if ((changed & BSS_CHANGED_HT) &&
3555 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3556 ret = wl1271_acx_set_ht_information(wl, wlvif,
3557 bss_conf->ht_operation_mode);
3559 wl1271_warning("Set ht information failed %d", ret);
3568 /* STA/IBSS mode changes */
3569 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3570 struct ieee80211_vif *vif,
3571 struct ieee80211_bss_conf *bss_conf,
3574 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3575 bool do_join = false, set_assoc = false;
3576 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
3577 bool ibss_joined = false;
3578 u32 sta_rate_set = 0;
3580 struct ieee80211_sta *sta;
3581 bool sta_exists = false;
3582 struct ieee80211_sta_ht_cap sta_ht_cap;
3585 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3591 if (changed & BSS_CHANGED_IBSS) {
3592 if (bss_conf->ibss_joined) {
3593 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
3596 if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED,
3598 wl1271_unjoin(wl, wlvif);
3599 wl12xx_start_dev(wl, wlvif);
3604 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3607 /* Need to update the SSID (for filtering etc) */
3608 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3611 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3612 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3613 bss_conf->enable_beacon ? "enabled" : "disabled");
3618 if (changed & BSS_CHANGED_IDLE) {
3619 ret = wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);
3621 wl1271_warning("idle mode change failed %d", ret);
3624 if ((changed & BSS_CHANGED_CQM)) {
3625 bool enable = false;
3626 if (bss_conf->cqm_rssi_thold)
3628 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
3629 bss_conf->cqm_rssi_thold,
3630 bss_conf->cqm_rssi_hyst);
3633 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
3636 if (changed & BSS_CHANGED_BSSID)
3637 if (!is_zero_ether_addr(bss_conf->bssid)) {
3638 ret = wl12xx_cmd_build_null_data(wl, wlvif);
3642 ret = wl1271_build_qos_null_data(wl, vif);
3646 /* Need to update the BSSID (for filtering etc) */
3650 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3652 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3656 /* save the supp_rates of the ap */
3657 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3658 if (sta->ht_cap.ht_supported)
3660 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3661 sta_ht_cap = sta->ht_cap;
3668 if ((changed & BSS_CHANGED_ASSOC)) {
3669 if (bss_conf->assoc) {
3672 wlvif->aid = bss_conf->aid;
3675 wlvif->ps_poll_failures = 0;
3678 * use basic rates from AP, and determine lowest rate
3679 * to use with control frames.
3681 rates = bss_conf->basic_rates;
3682 wlvif->basic_rate_set =
3683 wl1271_tx_enabled_rates_get(wl, rates,
3686 wl1271_tx_min_rate_get(wl,
3687 wlvif->basic_rate_set);
3690 wl1271_tx_enabled_rates_get(wl,
3693 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3698 * with wl1271, we don't need to update the
3699 * beacon_int and dtim_period, because the firmware
3700 * updates it by itself when the first beacon is
3701 * received after a join.
3703 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
3708 * Get a template for hardware connection maintenance
3710 dev_kfree_skb(wlvif->probereq);
3711 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
3714 ieoffset = offsetof(struct ieee80211_mgmt,
3715 u.probe_req.variable);
3716 wl1271_ssid_set(vif, wlvif->probereq, ieoffset);
3718 /* enable the connection monitoring feature */
3719 ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
3723 /* use defaults when not associated */
3725 !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED,
3728 !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT,
3732 /* free probe-request template */
3733 dev_kfree_skb(wlvif->probereq);
3734 wlvif->probereq = NULL;
3736 /* re-enable dynamic ps - just in case */
3737 ieee80211_enable_dyn_ps(vif);
3739 /* revert back to minimum rates for the current band */
3740 wl1271_set_band_rate(wl, wlvif);
3742 wl1271_tx_min_rate_get(wl,
3743 wlvif->basic_rate_set);
3744 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3748 /* disable connection monitor features */
3749 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
3751 /* Disable the keep-alive feature */
3752 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
3756 /* restore the bssid filter and go to dummy bssid */
3758 u32 conf_flags = wl->hw->conf.flags;
3760 * we might have to disable roc, if there was
3761 * no IF_OPER_UP notification.
3764 ret = wl12xx_croc(wl, wlvif->role_id);
3769 * (we also need to disable roc in case of
3770 * roaming on the same channel. until we will
3771 * have a better flow...)
3773 if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
3774 ret = wl12xx_croc(wl,
3775 wlvif->dev_role_id);
3780 wl1271_unjoin(wl, wlvif);
3781 if (!(conf_flags & IEEE80211_CONF_IDLE))
3782 wl12xx_start_dev(wl, wlvif);
3787 if (changed & BSS_CHANGED_IBSS) {
3788 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3789 bss_conf->ibss_joined);
3791 if (bss_conf->ibss_joined) {
3792 u32 rates = bss_conf->basic_rates;
3793 wlvif->basic_rate_set =
3794 wl1271_tx_enabled_rates_get(wl, rates,
3797 wl1271_tx_min_rate_get(wl,
3798 wlvif->basic_rate_set);
3800 /* by default, use 11b + OFDM rates */
3801 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3802 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3808 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3812 if (changed & BSS_CHANGED_ARP_FILTER) {
3813 __be32 addr = bss_conf->arp_addr_list[0];
3814 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
3816 if (bss_conf->arp_addr_cnt == 1 &&
3817 bss_conf->arp_filter_enabled) {
3819 * The template should have been configured only upon
3820 * association. however, it seems that the correct ip
3821 * isn't being set (when sending), so we have to
3822 * reconfigure the template upon every ip change.
3824 ret = wl1271_cmd_build_arp_rsp(wl, wlvif, addr);
3826 wl1271_warning("build arp rsp failed: %d", ret);
3830 ret = wl1271_acx_arp_ip_filter(wl, wlvif,
3831 ACX_ARP_FILTER_ARP_FILTERING,
3834 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
3841 ret = wl1271_join(wl, wlvif, set_assoc);
3843 wl1271_warning("cmd join failed %d", ret);
3847 /* ROC until connected (after EAPOL exchange) */
3849 ret = wl12xx_roc(wl, wlvif, wlvif->role_id);
3853 wl1271_check_operstate(wl, wlvif,
3854 ieee80211_get_operstate(vif));
3857 * stop device role if started (we might already be in
3860 if (wl12xx_dev_role_started(wlvif)) {
3861 ret = wl12xx_stop_dev(wl, wlvif);
3866 /* If we want to go in PSM but we're not there yet */
3867 if (test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags) &&
3868 !test_bit(WLVIF_FLAG_PSM, &wlvif->flags)) {
3869 enum wl1271_cmd_ps_mode mode;
3871 mode = STATION_POWER_SAVE_MODE;
3872 ret = wl1271_ps_set_mode(wl, wlvif, mode,
3880 /* Handle new association with HT. Do this after join. */
3882 if ((changed & BSS_CHANGED_HT) &&
3883 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3884 ret = wl1271_acx_set_ht_capabilities(wl,
3889 wl1271_warning("Set ht cap true failed %d",
3894 /* handle new association without HT and disassociation */
3895 else if (changed & BSS_CHANGED_ASSOC) {
3896 ret = wl1271_acx_set_ht_capabilities(wl,
3901 wl1271_warning("Set ht cap false failed %d",
3908 /* Handle HT information change. Done after join. */
3909 if ((changed & BSS_CHANGED_HT) &&
3910 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3911 ret = wl1271_acx_set_ht_information(wl, wlvif,
3912 bss_conf->ht_operation_mode);
3914 wl1271_warning("Set ht information failed %d", ret);
3923 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3924 struct ieee80211_vif *vif,
3925 struct ieee80211_bss_conf *bss_conf,
3928 struct wl1271 *wl = hw->priv;
3929 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3930 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3933 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3936 mutex_lock(&wl->mutex);
3938 if (unlikely(wl->state == WL1271_STATE_OFF))
3941 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
3944 ret = wl1271_ps_elp_wakeup(wl);
3949 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3951 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3953 wl1271_ps_elp_sleep(wl);
3956 mutex_unlock(&wl->mutex);
3959 static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
3960 struct ieee80211_vif *vif, u16 queue,
3961 const struct ieee80211_tx_queue_params *params)
3963 struct wl1271 *wl = hw->priv;
3964 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3968 mutex_lock(&wl->mutex);
3970 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3973 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3975 ps_scheme = CONF_PS_SCHEME_LEGACY;
3977 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
3980 ret = wl1271_ps_elp_wakeup(wl);
3985 * the txop is confed in units of 32us by the mac80211,
3988 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
3989 params->cw_min, params->cw_max,
3990 params->aifs, params->txop << 5);
3994 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
3995 CONF_CHANNEL_TYPE_EDCF,
3996 wl1271_tx_get_queue(queue),
3997 ps_scheme, CONF_ACK_POLICY_LEGACY,
4001 wl1271_ps_elp_sleep(wl);
4004 mutex_unlock(&wl->mutex);
4009 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4010 struct ieee80211_vif *vif)
4013 struct wl1271 *wl = hw->priv;
4014 u64 mactime = ULLONG_MAX;
4017 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4019 mutex_lock(&wl->mutex);
4021 if (unlikely(wl->state == WL1271_STATE_OFF))
4024 ret = wl1271_ps_elp_wakeup(wl);
4028 ret = wl1271_acx_tsf_info(wl, &mactime);
4033 wl1271_ps_elp_sleep(wl);
4036 mutex_unlock(&wl->mutex);
4040 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4041 struct survey_info *survey)
4043 struct wl1271 *wl = hw->priv;
4044 struct ieee80211_conf *conf = &hw->conf;
4049 survey->channel = conf->channel;
4050 survey->filled = SURVEY_INFO_NOISE_DBM;
4051 survey->noise = wl->noise;
4056 static int wl1271_allocate_sta(struct wl1271 *wl,
4057 struct wl12xx_vif *wlvif,
4058 struct ieee80211_sta *sta)
4060 struct wl1271_station *wl_sta;
4064 if (wl->active_sta_count >= AP_MAX_STATIONS) {
4065 wl1271_warning("could not allocate HLID - too much stations");
4069 wl_sta = (struct wl1271_station *)sta->drv_priv;
4070 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4072 wl1271_warning("could not allocate HLID - too many links");
4076 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4077 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4078 wl->active_sta_count++;
4082 void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4084 if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4087 clear_bit(hlid, wlvif->ap.sta_hlid_map);
4088 memset(wl->links[hlid].addr, 0, ETH_ALEN);
4089 wl->links[hlid].ba_bitmap = 0;
4090 wl1271_tx_reset_link_queues(wl, hlid);
4091 __clear_bit(hlid, &wl->ap_ps_map);
4092 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
4093 wl12xx_free_link(wl, wlvif, &hlid);
4094 wl->active_sta_count--;
4097 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
4098 struct ieee80211_vif *vif,
4099 struct ieee80211_sta *sta)
4101 struct wl1271 *wl = hw->priv;
4102 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4103 struct wl1271_station *wl_sta;
4107 mutex_lock(&wl->mutex);
4109 if (unlikely(wl->state == WL1271_STATE_OFF))
4112 if (wlvif->bss_type != BSS_TYPE_AP_BSS)
4115 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4117 ret = wl1271_allocate_sta(wl, wlvif, sta);
4121 wl_sta = (struct wl1271_station *)sta->drv_priv;
4122 hlid = wl_sta->hlid;
4124 ret = wl1271_ps_elp_wakeup(wl);
4128 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
4132 ret = wl12xx_cmd_set_peer_state(wl, hlid);
4136 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
4141 wl1271_ps_elp_sleep(wl);
4145 wl1271_free_sta(wl, wlvif, hlid);
4148 mutex_unlock(&wl->mutex);
4152 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
4153 struct ieee80211_vif *vif,
4154 struct ieee80211_sta *sta)
4156 struct wl1271 *wl = hw->priv;
4157 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4158 struct wl1271_station *wl_sta;
4161 mutex_lock(&wl->mutex);
4163 if (unlikely(wl->state == WL1271_STATE_OFF))
4166 if (wlvif->bss_type != BSS_TYPE_AP_BSS)
4169 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4171 wl_sta = (struct wl1271_station *)sta->drv_priv;
4173 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
4176 ret = wl1271_ps_elp_wakeup(wl);
4180 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
4184 wl1271_free_sta(wl, wlvif, wl_sta->hlid);
4187 wl1271_ps_elp_sleep(wl);
4190 mutex_unlock(&wl->mutex);
4194 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4195 struct ieee80211_vif *vif,
4196 enum ieee80211_ampdu_mlme_action action,
4197 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4200 struct wl1271 *wl = hw->priv;
4201 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4203 u8 hlid, *ba_bitmap;
4205 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4208 /* sanity check - the fields in FW are only 8bits wide */
4209 if (WARN_ON(tid > 0xFF))
4212 mutex_lock(&wl->mutex);
4214 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4219 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
4220 hlid = wlvif->sta.hlid;
4221 ba_bitmap = &wlvif->sta.ba_rx_bitmap;
4222 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
4223 struct wl1271_station *wl_sta;
4225 wl_sta = (struct wl1271_station *)sta->drv_priv;
4226 hlid = wl_sta->hlid;
4227 ba_bitmap = &wl->links[hlid].ba_bitmap;
4233 ret = wl1271_ps_elp_wakeup(wl);
4237 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4241 case IEEE80211_AMPDU_RX_START:
4242 if (!wlvif->ba_support || !wlvif->ba_allowed) {
4247 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4249 wl1271_error("exceeded max RX BA sessions");
4253 if (*ba_bitmap & BIT(tid)) {
4255 wl1271_error("cannot enable RX BA session on active "
4260 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4263 *ba_bitmap |= BIT(tid);
4264 wl->ba_rx_session_count++;
4268 case IEEE80211_AMPDU_RX_STOP:
4269 if (!(*ba_bitmap & BIT(tid))) {
4271 wl1271_error("no active RX BA session on tid: %d",
4276 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4279 *ba_bitmap &= ~BIT(tid);
4280 wl->ba_rx_session_count--;
4285 * The BA initiator session management in FW independently.
4286 * Falling break here on purpose for all TX APDU commands.
4288 case IEEE80211_AMPDU_TX_START:
4289 case IEEE80211_AMPDU_TX_STOP:
4290 case IEEE80211_AMPDU_TX_OPERATIONAL:
4295 wl1271_error("Incorrect ampdu action id=%x\n", action);
4299 wl1271_ps_elp_sleep(wl);
4302 mutex_unlock(&wl->mutex);
4307 static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4308 struct ieee80211_vif *vif,
4309 const struct cfg80211_bitrate_mask *mask)
4311 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4312 struct wl1271 *wl = hw->priv;
4315 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4316 mask->control[NL80211_BAND_2GHZ].legacy,
4317 mask->control[NL80211_BAND_5GHZ].legacy);
4319 mutex_lock(&wl->mutex);
4321 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4322 wlvif->bitrate_masks[i] =
4323 wl1271_tx_enabled_rates_get(wl,
4324 mask->control[i].legacy,
4327 if (unlikely(wl->state == WL1271_STATE_OFF))
4330 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4331 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
4333 ret = wl1271_ps_elp_wakeup(wl);
4337 wl1271_set_band_rate(wl, wlvif);
4339 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4340 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4342 wl1271_ps_elp_sleep(wl);
4345 mutex_unlock(&wl->mutex);
4350 static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4351 struct ieee80211_channel_switch *ch_switch)
4353 struct wl1271 *wl = hw->priv;
4354 struct wl12xx_vif *wlvif;
4357 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4359 mutex_lock(&wl->mutex);
4361 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4362 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4363 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4364 ieee80211_chswitch_done(vif, false);
4369 ret = wl1271_ps_elp_wakeup(wl);
4373 /* TODO: change mac80211 to pass vif as param */
4374 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4375 ret = wl12xx_cmd_channel_switch(wl, ch_switch);
4378 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
4381 wl1271_ps_elp_sleep(wl);
4384 mutex_unlock(&wl->mutex);
4387 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
4389 struct wl1271 *wl = hw->priv;
4392 mutex_lock(&wl->mutex);
4394 if (unlikely(wl->state == WL1271_STATE_OFF))
4397 /* packets are considered pending if in the TX queue or the FW */
4398 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
4400 mutex_unlock(&wl->mutex);
4405 /* can't be const, mac80211 writes to this */
4406 static struct ieee80211_rate wl1271_rates[] = {
4408 .hw_value = CONF_HW_BIT_RATE_1MBPS,
4409 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
4411 .hw_value = CONF_HW_BIT_RATE_2MBPS,
4412 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
4413 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4415 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4416 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
4417 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4419 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4420 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
4421 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4423 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4424 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4426 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4427 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4429 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4430 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4432 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4433 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4435 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4436 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4438 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4439 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4441 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4442 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4444 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4445 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4448 /* can't be const, mac80211 writes to this */
4449 static struct ieee80211_channel wl1271_channels[] = {
4450 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4451 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4452 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4453 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4454 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4455 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4456 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4457 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4458 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4459 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4460 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4461 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4462 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4463 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
4466 /* mapping to indexes for wl1271_rates */
4467 static const u8 wl1271_rate_to_idx_2ghz[] = {
4468 /* MCS rates are used only with 11n */
4469 7, /* CONF_HW_RXTX_RATE_MCS7 */
4470 6, /* CONF_HW_RXTX_RATE_MCS6 */
4471 5, /* CONF_HW_RXTX_RATE_MCS5 */
4472 4, /* CONF_HW_RXTX_RATE_MCS4 */
4473 3, /* CONF_HW_RXTX_RATE_MCS3 */
4474 2, /* CONF_HW_RXTX_RATE_MCS2 */
4475 1, /* CONF_HW_RXTX_RATE_MCS1 */
4476 0, /* CONF_HW_RXTX_RATE_MCS0 */
4478 11, /* CONF_HW_RXTX_RATE_54 */
4479 10, /* CONF_HW_RXTX_RATE_48 */
4480 9, /* CONF_HW_RXTX_RATE_36 */
4481 8, /* CONF_HW_RXTX_RATE_24 */
4483 /* TI-specific rate */
4484 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4486 7, /* CONF_HW_RXTX_RATE_18 */
4487 6, /* CONF_HW_RXTX_RATE_12 */
4488 3, /* CONF_HW_RXTX_RATE_11 */
4489 5, /* CONF_HW_RXTX_RATE_9 */
4490 4, /* CONF_HW_RXTX_RATE_6 */
4491 2, /* CONF_HW_RXTX_RATE_5_5 */
4492 1, /* CONF_HW_RXTX_RATE_2 */
4493 0 /* CONF_HW_RXTX_RATE_1 */
4496 /* 11n STA capabilities */
4497 #define HW_RX_HIGHEST_RATE 72
4499 #define WL12XX_HT_CAP { \
4500 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4501 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
4502 .ht_supported = true, \
4503 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4504 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4506 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4507 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4508 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4512 /* can't be const, mac80211 writes to this */
4513 static struct ieee80211_supported_band wl1271_band_2ghz = {
4514 .channels = wl1271_channels,
4515 .n_channels = ARRAY_SIZE(wl1271_channels),
4516 .bitrates = wl1271_rates,
4517 .n_bitrates = ARRAY_SIZE(wl1271_rates),
4518 .ht_cap = WL12XX_HT_CAP,
4521 /* 5 GHz data rates for WL1273 */
4522 static struct ieee80211_rate wl1271_rates_5ghz[] = {
4524 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4525 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4527 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4528 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4530 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4531 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4533 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4534 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4536 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4537 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4539 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4540 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4542 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4543 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4545 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4546 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4549 /* 5 GHz band channels for WL1273 */
4550 static struct ieee80211_channel wl1271_channels_5ghz[] = {
4551 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4552 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4553 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4554 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4555 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4556 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4557 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4558 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4559 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4560 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4561 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4562 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4563 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4564 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4565 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4566 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4567 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4568 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4569 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4570 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4571 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4572 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4573 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4574 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4575 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4576 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4577 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4578 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4579 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4580 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4581 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4582 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4583 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4584 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4587 /* mapping to indexes for wl1271_rates_5ghz */
4588 static const u8 wl1271_rate_to_idx_5ghz[] = {
4589 /* MCS rates are used only with 11n */
4590 7, /* CONF_HW_RXTX_RATE_MCS7 */
4591 6, /* CONF_HW_RXTX_RATE_MCS6 */
4592 5, /* CONF_HW_RXTX_RATE_MCS5 */
4593 4, /* CONF_HW_RXTX_RATE_MCS4 */
4594 3, /* CONF_HW_RXTX_RATE_MCS3 */
4595 2, /* CONF_HW_RXTX_RATE_MCS2 */
4596 1, /* CONF_HW_RXTX_RATE_MCS1 */
4597 0, /* CONF_HW_RXTX_RATE_MCS0 */
4599 7, /* CONF_HW_RXTX_RATE_54 */
4600 6, /* CONF_HW_RXTX_RATE_48 */
4601 5, /* CONF_HW_RXTX_RATE_36 */
4602 4, /* CONF_HW_RXTX_RATE_24 */
4604 /* TI-specific rate */
4605 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4607 3, /* CONF_HW_RXTX_RATE_18 */
4608 2, /* CONF_HW_RXTX_RATE_12 */
4609 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4610 1, /* CONF_HW_RXTX_RATE_9 */
4611 0, /* CONF_HW_RXTX_RATE_6 */
4612 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4613 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4614 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4617 static struct ieee80211_supported_band wl1271_band_5ghz = {
4618 .channels = wl1271_channels_5ghz,
4619 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4620 .bitrates = wl1271_rates_5ghz,
4621 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4622 .ht_cap = WL12XX_HT_CAP,
4625 static const u8 *wl1271_band_rate_to_idx[] = {
4626 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4627 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4630 static const struct ieee80211_ops wl1271_ops = {
4631 .start = wl1271_op_start,
4632 .stop = wl1271_op_stop,
4633 .add_interface = wl1271_op_add_interface,
4634 .remove_interface = wl1271_op_remove_interface,
4635 .change_interface = wl12xx_op_change_interface,
4637 .suspend = wl1271_op_suspend,
4638 .resume = wl1271_op_resume,
4640 .config = wl1271_op_config,
4641 .prepare_multicast = wl1271_op_prepare_multicast,
4642 .configure_filter = wl1271_op_configure_filter,
4644 .set_key = wl1271_op_set_key,
4645 .hw_scan = wl1271_op_hw_scan,
4646 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
4647 .sched_scan_start = wl1271_op_sched_scan_start,
4648 .sched_scan_stop = wl1271_op_sched_scan_stop,
4649 .bss_info_changed = wl1271_op_bss_info_changed,
4650 .set_frag_threshold = wl1271_op_set_frag_threshold,
4651 .set_rts_threshold = wl1271_op_set_rts_threshold,
4652 .conf_tx = wl1271_op_conf_tx,
4653 .get_tsf = wl1271_op_get_tsf,
4654 .get_survey = wl1271_op_get_survey,
4655 .sta_add = wl1271_op_sta_add,
4656 .sta_remove = wl1271_op_sta_remove,
4657 .ampdu_action = wl1271_op_ampdu_action,
4658 .tx_frames_pending = wl1271_tx_frames_pending,
4659 .set_bitrate_mask = wl12xx_set_bitrate_mask,
4660 .channel_switch = wl12xx_op_channel_switch,
4661 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
4665 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
4669 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
4671 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4672 wl1271_error("Illegal RX rate from HW: %d", rate);
4676 idx = wl1271_band_rate_to_idx[band][rate];
4677 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4678 wl1271_error("Unsupported RX rate from HW: %d", rate);
4685 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4686 struct device_attribute *attr,
4689 struct wl1271 *wl = dev_get_drvdata(dev);
4694 mutex_lock(&wl->mutex);
4695 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4697 mutex_unlock(&wl->mutex);
4703 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4704 struct device_attribute *attr,
4705 const char *buf, size_t count)
4707 struct wl1271 *wl = dev_get_drvdata(dev);
4711 ret = kstrtoul(buf, 10, &res);
4713 wl1271_warning("incorrect value written to bt_coex_mode");
4717 mutex_lock(&wl->mutex);
4721 if (res == wl->sg_enabled)
4724 wl->sg_enabled = res;
4726 if (wl->state == WL1271_STATE_OFF)
4729 ret = wl1271_ps_elp_wakeup(wl);
4733 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4734 wl1271_ps_elp_sleep(wl);
4737 mutex_unlock(&wl->mutex);
4741 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4742 wl1271_sysfs_show_bt_coex_state,
4743 wl1271_sysfs_store_bt_coex_state);
4745 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4746 struct device_attribute *attr,
4749 struct wl1271 *wl = dev_get_drvdata(dev);
4754 mutex_lock(&wl->mutex);
4755 if (wl->hw_pg_ver >= 0)
4756 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4758 len = snprintf(buf, len, "n/a\n");
4759 mutex_unlock(&wl->mutex);
4764 static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4765 wl1271_sysfs_show_hw_pg_ver, NULL);
4767 static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4768 struct bin_attribute *bin_attr,
4769 char *buffer, loff_t pos, size_t count)
4771 struct device *dev = container_of(kobj, struct device, kobj);
4772 struct wl1271 *wl = dev_get_drvdata(dev);
4776 ret = mutex_lock_interruptible(&wl->mutex);
4778 return -ERESTARTSYS;
4780 /* Let only one thread read the log at a time, blocking others */
4781 while (wl->fwlog_size == 0) {
4784 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4786 TASK_INTERRUPTIBLE);
4788 if (wl->fwlog_size != 0) {
4789 finish_wait(&wl->fwlog_waitq, &wait);
4793 mutex_unlock(&wl->mutex);
4796 finish_wait(&wl->fwlog_waitq, &wait);
4798 if (signal_pending(current))
4799 return -ERESTARTSYS;
4801 ret = mutex_lock_interruptible(&wl->mutex);
4803 return -ERESTARTSYS;
4806 /* Check if the fwlog is still valid */
4807 if (wl->fwlog_size < 0) {
4808 mutex_unlock(&wl->mutex);
4812 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4813 len = min(count, (size_t)wl->fwlog_size);
4814 wl->fwlog_size -= len;
4815 memcpy(buffer, wl->fwlog, len);
4817 /* Make room for new messages */
4818 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4820 mutex_unlock(&wl->mutex);
4825 static struct bin_attribute fwlog_attr = {
4826 .attr = {.name = "fwlog", .mode = S_IRUSR},
4827 .read = wl1271_sysfs_read_fwlog,
4830 static int wl1271_register_hw(struct wl1271 *wl)
4834 if (wl->mac80211_registered)
4837 ret = wl1271_fetch_nvs(wl);
4839 /* NOTE: The wl->nvs->nvs element must be first, in
4840 * order to simplify the casting, we assume it is at
4841 * the beginning of the wl->nvs structure.
4843 u8 *nvs_ptr = (u8 *)wl->nvs;
4845 wl->mac_addr[0] = nvs_ptr[11];
4846 wl->mac_addr[1] = nvs_ptr[10];
4847 wl->mac_addr[2] = nvs_ptr[6];
4848 wl->mac_addr[3] = nvs_ptr[5];
4849 wl->mac_addr[4] = nvs_ptr[4];
4850 wl->mac_addr[5] = nvs_ptr[3];
4853 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4855 ret = ieee80211_register_hw(wl->hw);
4857 wl1271_error("unable to register mac80211 hw: %d", ret);
4861 wl->mac80211_registered = true;
4863 wl1271_debugfs_init(wl);
4865 register_netdevice_notifier(&wl1271_dev_notifier);
4867 wl1271_notice("loaded");
4872 static void wl1271_unregister_hw(struct wl1271 *wl)
4874 if (wl->state == WL1271_STATE_PLT)
4875 __wl1271_plt_stop(wl);
4877 unregister_netdevice_notifier(&wl1271_dev_notifier);
4878 ieee80211_unregister_hw(wl->hw);
4879 wl->mac80211_registered = false;
4883 static int wl1271_init_ieee80211(struct wl1271 *wl)
4885 static const u32 cipher_suites[] = {
4886 WLAN_CIPHER_SUITE_WEP40,
4887 WLAN_CIPHER_SUITE_WEP104,
4888 WLAN_CIPHER_SUITE_TKIP,
4889 WLAN_CIPHER_SUITE_CCMP,
4890 WL1271_CIPHER_SUITE_GEM,
4893 /* The tx descriptor buffer and the TKIP space. */
4894 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4895 sizeof(struct wl1271_tx_hw_descr);
4898 /* FIXME: find a proper value */
4899 wl->hw->channel_change_time = 10000;
4900 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
4902 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4903 IEEE80211_HW_SUPPORTS_PS |
4904 IEEE80211_HW_SUPPORTS_UAPSD |
4905 IEEE80211_HW_HAS_RATE_CONTROL |
4906 IEEE80211_HW_CONNECTION_MONITOR |
4907 IEEE80211_HW_SUPPORTS_CQM_RSSI |
4908 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4909 IEEE80211_HW_SPECTRUM_MGMT |
4910 IEEE80211_HW_AP_LINK_PS |
4911 IEEE80211_HW_AMPDU_AGGREGATION |
4912 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4914 wl->hw->wiphy->cipher_suites = cipher_suites;
4915 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4917 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4918 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
4919 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
4920 wl->hw->wiphy->max_scan_ssids = 1;
4921 wl->hw->wiphy->max_sched_scan_ssids = 16;
4922 wl->hw->wiphy->max_match_sets = 16;
4924 * Maximum length of elements in scanning probe request templates
4925 * should be the maximum length possible for a template, without
4926 * the IEEE80211 header of the template
4928 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4929 sizeof(struct ieee80211_header);
4931 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4932 sizeof(struct ieee80211_header);
4934 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4936 /* make sure all our channels fit in the scanned_ch bitmask */
4937 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4938 ARRAY_SIZE(wl1271_channels_5ghz) >
4939 WL1271_MAX_CHANNELS);
4941 * We keep local copies of the band structs because we need to
4942 * modify them on a per-device basis.
4944 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4945 sizeof(wl1271_band_2ghz));
4946 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4947 sizeof(wl1271_band_5ghz));
4949 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4950 &wl->bands[IEEE80211_BAND_2GHZ];
4951 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4952 &wl->bands[IEEE80211_BAND_5GHZ];
4955 wl->hw->max_rates = 1;
4957 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4959 /* the FW answers probe-requests in AP-mode */
4960 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
4961 wl->hw->wiphy->probe_resp_offload =
4962 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
4963 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
4964 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
4966 SET_IEEE80211_DEV(wl->hw, wl->dev);
4968 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4969 wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
4971 wl->hw->max_rx_aggregation_subframes = 8;
4976 #define WL1271_DEFAULT_CHANNEL 0
4978 static struct ieee80211_hw *wl1271_alloc_hw(void)
4980 struct ieee80211_hw *hw;
4985 BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
4987 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4989 wl1271_error("could not alloc ieee80211_hw");
4995 memset(wl, 0, sizeof(*wl));
4997 INIT_LIST_HEAD(&wl->list);
4998 INIT_LIST_HEAD(&wl->wlvif_list);
5002 for (i = 0; i < NUM_TX_QUEUES; i++)
5003 for (j = 0; j < WL12XX_MAX_LINKS; j++)
5004 skb_queue_head_init(&wl->links[j].tx_queue[i]);
5006 skb_queue_head_init(&wl->deferred_rx_queue);
5007 skb_queue_head_init(&wl->deferred_tx_queue);
5009 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
5010 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
5011 INIT_WORK(&wl->tx_work, wl1271_tx_work);
5012 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5013 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
5015 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5016 if (!wl->freezable_wq) {
5021 wl->channel = WL1271_DEFAULT_CHANNEL;
5023 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
5024 wl->band = IEEE80211_BAND_2GHZ;
5027 wl->sg_enabled = true;
5030 wl->ap_fw_ps_map = 0;
5032 wl->platform_quirks = 0;
5033 wl->sched_scanning = false;
5034 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
5035 wl->system_hlid = WL12XX_SYSTEM_HLID;
5036 wl->active_sta_count = 0;
5038 init_waitqueue_head(&wl->fwlog_waitq);
5040 /* The system link is always allocated */
5041 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5043 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
5044 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
5045 wl->tx_frames[i] = NULL;
5047 spin_lock_init(&wl->wl_lock);
5049 wl->state = WL1271_STATE_OFF;
5050 mutex_init(&wl->mutex);
5052 /* Apply default driver configuration. */
5053 wl1271_conf_init(wl);
5055 order = get_order(WL1271_AGGR_BUFFER_SIZE);
5056 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5057 if (!wl->aggr_buf) {
5062 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5063 if (!wl->dummy_packet) {
5068 /* Allocate one page for the FW log */
5069 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5072 goto err_dummy_packet;
5078 dev_kfree_skb(wl->dummy_packet);
5081 free_pages((unsigned long)wl->aggr_buf, order);
5084 destroy_workqueue(wl->freezable_wq);
5087 wl1271_debugfs_exit(wl);
5088 ieee80211_free_hw(hw);
5092 return ERR_PTR(ret);
5095 static int wl1271_free_hw(struct wl1271 *wl)
5097 /* Unblock any fwlog readers */
5098 mutex_lock(&wl->mutex);
5099 wl->fwlog_size = -1;
5100 wake_up_interruptible_all(&wl->fwlog_waitq);
5101 mutex_unlock(&wl->mutex);
5103 device_remove_bin_file(wl->dev, &fwlog_attr);
5105 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5107 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5108 free_page((unsigned long)wl->fwlog);
5109 dev_kfree_skb(wl->dummy_packet);
5110 free_pages((unsigned long)wl->aggr_buf,
5111 get_order(WL1271_AGGR_BUFFER_SIZE));
5113 wl1271_debugfs_exit(wl);
5120 kfree(wl->fw_status);
5121 kfree(wl->tx_res_if);
5122 destroy_workqueue(wl->freezable_wq);
5124 ieee80211_free_hw(wl->hw);
5129 static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
5131 struct wl1271 *wl = cookie;
5132 unsigned long flags;
5134 wl1271_debug(DEBUG_IRQ, "IRQ");
5136 /* complete the ELP completion */
5137 spin_lock_irqsave(&wl->wl_lock, flags);
5138 set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
5139 if (wl->elp_compl) {
5140 complete(wl->elp_compl);
5141 wl->elp_compl = NULL;
5144 if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
5145 /* don't enqueue a work right now. mark it as pending */
5146 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
5147 wl1271_debug(DEBUG_IRQ, "should not enqueue work");
5148 disable_irq_nosync(wl->irq);
5149 pm_wakeup_event(wl->dev, 0);
5150 spin_unlock_irqrestore(&wl->wl_lock, flags);
5153 spin_unlock_irqrestore(&wl->wl_lock, flags);
5155 return IRQ_WAKE_THREAD;
5158 static int __devinit wl12xx_probe(struct platform_device *pdev)
5160 struct wl12xx_platform_data *pdata = pdev->dev.platform_data;
5161 struct ieee80211_hw *hw;
5163 unsigned long irqflags;
5166 hw = wl1271_alloc_hw();
5168 wl1271_error("can't allocate hw");
5174 wl->irq = platform_get_irq(pdev, 0);
5175 wl->ref_clock = pdata->board_ref_clock;
5176 wl->tcxo_clock = pdata->board_tcxo_clock;
5177 wl->platform_quirks = pdata->platform_quirks;
5178 wl->set_power = pdata->set_power;
5179 wl->dev = &pdev->dev;
5180 wl->if_ops = pdata->ops;
5182 platform_set_drvdata(pdev, wl);
5184 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
5185 irqflags = IRQF_TRIGGER_RISING;
5187 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
5189 ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq,
5193 wl1271_error("request_irq() failed: %d", ret);
5197 ret = enable_irq_wake(wl->irq);
5199 wl->irq_wake_enabled = true;
5200 device_init_wakeup(wl->dev, 1);
5201 if (pdata->pwr_in_suspend)
5202 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
5205 disable_irq(wl->irq);
5207 ret = wl1271_init_ieee80211(wl);
5211 ret = wl1271_register_hw(wl);
5215 /* Create sysfs file to control bt coex state */
5216 ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
5218 wl1271_error("failed to create sysfs file bt_coex_state");
5222 /* Create sysfs file to get HW PG version */
5223 ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
5225 wl1271_error("failed to create sysfs file hw_pg_ver");
5226 goto out_bt_coex_state;
5229 /* Create sysfs file for the FW log */
5230 ret = device_create_bin_file(wl->dev, &fwlog_attr);
5232 wl1271_error("failed to create sysfs file fwlog");
5239 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5242 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5245 free_irq(wl->irq, wl);
5254 static int __devexit wl12xx_remove(struct platform_device *pdev)
5256 struct wl1271 *wl = platform_get_drvdata(pdev);
5258 if (wl->irq_wake_enabled) {
5259 device_init_wakeup(wl->dev, 0);
5260 disable_irq_wake(wl->irq);
5262 wl1271_unregister_hw(wl);
5263 free_irq(wl->irq, wl);
5269 static const struct platform_device_id wl12xx_id_table[] __devinitconst = {
5271 { } /* Terminating Entry */
5273 MODULE_DEVICE_TABLE(platform, wl12xx_id_table);
5275 static struct platform_driver wl12xx_driver = {
5276 .probe = wl12xx_probe,
5277 .remove = __devexit_p(wl12xx_remove),
5278 .id_table = wl12xx_id_table,
5280 .name = "wl12xx_driver",
5281 .owner = THIS_MODULE,
5285 static int __init wl12xx_init(void)
5287 return platform_driver_register(&wl12xx_driver);
5289 module_init(wl12xx_init);
5291 static void __exit wl12xx_exit(void)
5293 platform_driver_unregister(&wl12xx_driver);
5295 module_exit(wl12xx_exit);
5297 u32 wl12xx_debug_level = DEBUG_NONE;
5298 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
5299 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
5300 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
5302 module_param_named(fwlog, fwlog_param, charp, 0);
5303 MODULE_PARM_DESC(keymap,
5304 "FW logger options: continuous, ondemand, dbgpins or disable");
5306 module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
5307 MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
5309 MODULE_LICENSE("GPL");
5310 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
5311 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");