2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
33 #include <linux/wl12xx.h>
34 #include <linux/sched.h>
37 #include "wl12xx_80211.h"
51 #define WL1271_BOOT_RETRIES 3
53 static struct conf_drv_settings default_conf
= {
56 [CONF_SG_BT_PER_THRESHOLD
] = 7500,
57 [CONF_SG_HV3_MAX_OVERRIDE
] = 0,
58 [CONF_SG_BT_NFS_SAMPLE_INTERVAL
] = 400,
59 [CONF_SG_BT_LOAD_RATIO
] = 200,
60 [CONF_SG_AUTO_PS_MODE
] = 1,
61 [CONF_SG_AUTO_SCAN_PROBE_REQ
] = 170,
62 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3
] = 50,
63 [CONF_SG_ANTENNA_CONFIGURATION
] = 0,
64 [CONF_SG_BEACON_MISS_PERCENT
] = 60,
65 [CONF_SG_RATE_ADAPT_THRESH
] = 12,
66 [CONF_SG_RATE_ADAPT_SNR
] = 0,
67 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR
] = 10,
68 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR
] = 30,
69 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR
] = 8,
70 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR
] = 20,
71 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR
] = 50,
72 /* Note: with UPSD, this should be 4 */
73 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR
] = 8,
74 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR
] = 7,
75 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR
] = 25,
76 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR
] = 20,
77 /* Note: with UPDS, this should be 15 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR
] = 8,
79 /* Note: with UPDS, this should be 50 */
80 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR
] = 40,
81 /* Note: with UPDS, this should be 10 */
82 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR
] = 20,
85 [CONF_SG_ADAPTIVE_RXT_TXT
] = 1,
86 [CONF_SG_PS_POLL_TIMEOUT
] = 10,
87 [CONF_SG_UPSD_TIMEOUT
] = 10,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR
] = 7,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR
] = 15,
90 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR
] = 15,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR
] = 8,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR
] = 20,
93 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR
] = 15,
94 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR
] = 20,
95 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR
] = 50,
96 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR
] = 10,
97 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3
] = 200,
98 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP
] = 800,
99 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME
] = 75,
100 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME
] = 15,
101 [CONF_SG_HV3_MAX_SERVED
] = 6,
102 [CONF_SG_DHCP_TIME
] = 5000,
103 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP
] = 100,
106 [CONF_SG_BT_PER_THRESHOLD
] = 7500,
107 [CONF_SG_HV3_MAX_OVERRIDE
] = 0,
108 [CONF_SG_BT_NFS_SAMPLE_INTERVAL
] = 400,
109 [CONF_SG_BT_LOAD_RATIO
] = 50,
110 [CONF_SG_AUTO_PS_MODE
] = 1,
111 [CONF_SG_AUTO_SCAN_PROBE_REQ
] = 170,
112 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3
] = 50,
113 [CONF_SG_ANTENNA_CONFIGURATION
] = 0,
114 [CONF_SG_BEACON_MISS_PERCENT
] = 60,
115 [CONF_SG_RATE_ADAPT_THRESH
] = 64,
116 [CONF_SG_RATE_ADAPT_SNR
] = 1,
117 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR
] = 10,
118 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR
] = 25,
119 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR
] = 25,
120 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR
] = 20,
121 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR
] = 25,
122 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR
] = 25,
123 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR
] = 7,
124 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR
] = 25,
125 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR
] = 25,
126 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR
] = 8,
127 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR
] = 25,
128 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR
] = 25,
129 [CONF_SG_RXT
] = 1200,
130 [CONF_SG_TXT
] = 1000,
131 [CONF_SG_ADAPTIVE_RXT_TXT
] = 1,
132 [CONF_SG_PS_POLL_TIMEOUT
] = 10,
133 [CONF_SG_UPSD_TIMEOUT
] = 10,
134 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR
] = 7,
135 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR
] = 15,
136 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR
] = 15,
137 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR
] = 8,
138 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR
] = 20,
139 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR
] = 15,
140 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR
] = 20,
141 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR
] = 50,
142 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR
] = 10,
143 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3
] = 200,
144 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP
] = 800,
145 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME
] = 75,
146 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME
] = 15,
147 [CONF_SG_HV3_MAX_SERVED
] = 6,
148 [CONF_SG_DHCP_TIME
] = 5000,
149 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP
] = 100,
150 [CONF_SG_TEMP_PARAM_1
] = 0,
151 [CONF_SG_TEMP_PARAM_2
] = 0,
152 [CONF_SG_TEMP_PARAM_3
] = 0,
153 [CONF_SG_TEMP_PARAM_4
] = 0,
154 [CONF_SG_TEMP_PARAM_5
] = 0,
155 [CONF_SG_AP_BEACON_MISS_TX
] = 3,
156 [CONF_SG_RX_WINDOW_LENGTH
] = 6,
157 [CONF_SG_AP_CONNECTION_PROTECTION_TIME
] = 50,
158 [CONF_SG_TEMP_PARAM_6
] = 1,
160 .state
= CONF_SG_PROTECTIVE
,
163 .rx_msdu_life_time
= 512000,
164 .packet_detection_threshold
= 0,
165 .ps_poll_timeout
= 15,
167 .rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
,
168 .rx_cca_threshold
= 0,
169 .irq_blk_threshold
= 0xFFFF,
170 .irq_pkt_threshold
= 0,
172 .queue_type
= CONF_RX_QUEUE_TYPE_LOW_PRIORITY
,
175 .tx_energy_detection
= 0,
178 .short_retry_limit
= 10,
179 .long_retry_limit
= 10,
202 .aifsn
= CONF_TX_AIFS_PIFS
,
209 .aifsn
= CONF_TX_AIFS_PIFS
,
213 .max_tx_retries
= 100,
214 .ap_aging_period
= 300,
218 .queue_id
= CONF_TX_AC_BE
,
219 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
220 .tsid
= CONF_TX_AC_BE
,
221 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
222 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
226 .queue_id
= CONF_TX_AC_BK
,
227 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
228 .tsid
= CONF_TX_AC_BK
,
229 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
230 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
234 .queue_id
= CONF_TX_AC_VI
,
235 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
236 .tsid
= CONF_TX_AC_VI
,
237 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
238 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
242 .queue_id
= CONF_TX_AC_VO
,
243 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
244 .tsid
= CONF_TX_AC_VO
,
245 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
246 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
250 .frag_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
,
251 .tx_compl_timeout
= 700,
252 .tx_compl_threshold
= 4,
253 .basic_rate
= CONF_HW_BIT_RATE_1MBPS
,
254 .basic_rate_5
= CONF_HW_BIT_RATE_6MBPS
,
255 .tmpl_short_retry_limit
= 10,
256 .tmpl_long_retry_limit
= 10,
259 .wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
,
260 .listen_interval
= 1,
261 .bcn_filt_mode
= CONF_BCN_FILT_MODE_ENABLED
,
262 .bcn_filt_ie_count
= 2,
265 .ie
= WLAN_EID_CHANNEL_SWITCH
,
266 .rule
= CONF_BCN_RULE_PASS_ON_APPEARANCE
,
269 .ie
= WLAN_EID_HT_INFORMATION
,
270 .rule
= CONF_BCN_RULE_PASS_ON_CHANGE
,
273 .synch_fail_thold
= 10,
274 .bss_lose_timeout
= 100,
275 .beacon_rx_timeout
= 10000,
276 .broadcast_timeout
= 20000,
277 .rx_broadcast_in_ps
= 1,
278 .ps_poll_threshold
= 10,
279 .ps_poll_recovery_period
= 700,
280 .bet_enable
= CONF_BET_MODE_ENABLE
,
281 .bet_max_consecutive
= 50,
282 .psm_entry_retries
= 5,
283 .psm_exit_retries
= 16,
284 .psm_entry_nullfunc_retries
= 3,
285 .psm_entry_hangover_period
= 1,
286 .keep_alive_interval
= 55000,
287 .max_listen_interval
= 20,
294 .host_clk_settling_time
= 5000,
295 .host_fast_wakeup_support
= false
299 .avg_weight_rssi_beacon
= 20,
300 .avg_weight_rssi_data
= 10,
301 .avg_weight_snr_beacon
= 20,
302 .avg_weight_snr_data
= 10,
305 .min_dwell_time_active
= 7500,
306 .max_dwell_time_active
= 30000,
307 .min_dwell_time_passive
= 100000,
308 .max_dwell_time_passive
= 100000,
312 /* sched_scan requires dwell times in TU instead of TU/1000 */
313 .min_dwell_time_active
= 8,
314 .max_dwell_time_active
= 30,
315 .dwell_time_passive
= 100,
316 .dwell_time_dfs
= 150,
318 .rssi_threshold
= -90,
322 .tx_per_channel_power_compensation_2
= {
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
325 .tx_per_channel_power_compensation_5
= {
326 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
327 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
328 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
332 .tx_ba_win_size
= 64,
333 .inactivity_timeout
= 10000,
339 .tx_min_block_num
= 40,
341 .min_req_tx_blocks
= 100,
342 .min_req_rx_blocks
= 22,
349 .tx_min_block_num
= 40,
351 .min_req_tx_blocks
= 45,
352 .min_req_rx_blocks
= 22,
358 .n_divider_fref_set_1
= 0xff, /* default */
359 .n_divider_fref_set_2
= 12,
360 .m_divider_fref_set_1
= 148,
361 .m_divider_fref_set_2
= 0xffff, /* default */
362 .coex_pll_stabilization_time
= 0xffffffff, /* default */
363 .ldo_stabilization_time
= 0xffff, /* default */
364 .fm_disturbed_band_margin
= 0xff, /* default */
365 .swallow_clk_diff
= 0xff, /* default */
374 .mode
= WL12XX_FWLOG_ON_DEMAND
,
377 .timestamp
= WL12XX_FWLOG_TIMESTAMP_DISABLED
,
378 .output
= WL12XX_FWLOG_OUTPUT_HOST
,
381 .hci_io_ds
= HCI_IO_DS_6MA
,
384 static char *fwlog_param
;
386 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
387 bool reset_tx_queues
);
388 static void wl1271_free_ap_keys(struct wl1271
*wl
);
391 static void wl1271_device_release(struct device
*dev
)
396 static struct platform_device wl1271_device
= {
400 /* device model insists to have a release function */
402 .release
= wl1271_device_release
,
406 static DEFINE_MUTEX(wl_list_mutex
);
407 static LIST_HEAD(wl_list
);
409 static int wl1271_check_operstate(struct wl1271
*wl
, unsigned char operstate
)
412 if (operstate
!= IF_OPER_UP
)
415 if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
))
418 ret
= wl1271_cmd_set_sta_state(wl
);
422 wl1271_info("Association completed.");
425 static int wl1271_dev_notify(struct notifier_block
*me
, unsigned long what
,
428 struct net_device
*dev
= arg
;
429 struct wireless_dev
*wdev
;
431 struct ieee80211_hw
*hw
;
433 struct wl1271
*wl_temp
;
436 /* Check that this notification is for us. */
437 if (what
!= NETDEV_CHANGE
)
440 wdev
= dev
->ieee80211_ptr
;
448 hw
= wiphy_priv(wiphy
);
453 mutex_lock(&wl_list_mutex
);
454 list_for_each_entry(wl
, &wl_list
, list
) {
458 mutex_unlock(&wl_list_mutex
);
462 mutex_lock(&wl
->mutex
);
464 if (wl
->state
== WL1271_STATE_OFF
)
467 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
470 ret
= wl1271_ps_elp_wakeup(wl
);
474 wl1271_check_operstate(wl
, dev
->operstate
);
476 wl1271_ps_elp_sleep(wl
);
479 mutex_unlock(&wl
->mutex
);
484 static int wl1271_reg_notify(struct wiphy
*wiphy
,
485 struct regulatory_request
*request
)
487 struct ieee80211_supported_band
*band
;
488 struct ieee80211_channel
*ch
;
491 band
= wiphy
->bands
[IEEE80211_BAND_5GHZ
];
492 for (i
= 0; i
< band
->n_channels
; i
++) {
493 ch
= &band
->channels
[i
];
494 if (ch
->flags
& IEEE80211_CHAN_DISABLED
)
497 if (ch
->flags
& IEEE80211_CHAN_RADAR
)
498 ch
->flags
|= IEEE80211_CHAN_NO_IBSS
|
499 IEEE80211_CHAN_PASSIVE_SCAN
;
506 static int wl1271_set_rx_streaming(struct wl1271
*wl
, bool enable
)
510 /* we should hold wl->mutex */
511 ret
= wl1271_acx_ps_rx_streaming(wl
, enable
);
516 set_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
);
518 clear_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
);
524 * this function is being called when the rx_streaming interval
525 * has beed changed or rx_streaming should be disabled
527 int wl1271_recalc_rx_streaming(struct wl1271
*wl
)
530 int period
= wl
->conf
.rx_streaming
.interval
;
532 /* don't reconfigure if rx_streaming is disabled */
533 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
))
536 /* reconfigure/disable according to new streaming_period */
538 test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) &&
539 (wl
->conf
.rx_streaming
.always
||
540 test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
541 ret
= wl1271_set_rx_streaming(wl
, true);
543 ret
= wl1271_set_rx_streaming(wl
, false);
544 /* don't cancel_work_sync since we might deadlock */
545 del_timer_sync(&wl
->rx_streaming_timer
);
551 static void wl1271_rx_streaming_enable_work(struct work_struct
*work
)
555 container_of(work
, struct wl1271
, rx_streaming_enable_work
);
557 mutex_lock(&wl
->mutex
);
559 if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
) ||
560 !test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) ||
561 (!wl
->conf
.rx_streaming
.always
&&
562 !test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
565 if (!wl
->conf
.rx_streaming
.interval
)
568 ret
= wl1271_ps_elp_wakeup(wl
);
572 ret
= wl1271_set_rx_streaming(wl
, true);
576 /* stop it after some time of inactivity */
577 mod_timer(&wl
->rx_streaming_timer
,
578 jiffies
+ msecs_to_jiffies(wl
->conf
.rx_streaming
.duration
));
581 wl1271_ps_elp_sleep(wl
);
583 mutex_unlock(&wl
->mutex
);
586 static void wl1271_rx_streaming_disable_work(struct work_struct
*work
)
590 container_of(work
, struct wl1271
, rx_streaming_disable_work
);
592 mutex_lock(&wl
->mutex
);
594 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
))
597 ret
= wl1271_ps_elp_wakeup(wl
);
601 ret
= wl1271_set_rx_streaming(wl
, false);
606 wl1271_ps_elp_sleep(wl
);
608 mutex_unlock(&wl
->mutex
);
611 static void wl1271_rx_streaming_timer(unsigned long data
)
613 struct wl1271
*wl
= (struct wl1271
*)data
;
614 ieee80211_queue_work(wl
->hw
, &wl
->rx_streaming_disable_work
);
617 static void wl1271_conf_init(struct wl1271
*wl
)
621 * This function applies the default configuration to the driver. This
622 * function is invoked upon driver load (spi probe.)
624 * The configuration is stored in a run-time structure in order to
625 * facilitate for run-time adjustment of any of the parameters. Making
626 * changes to the configuration structure will apply the new values on
627 * the next interface up (wl1271_op_start.)
630 /* apply driver default configuration */
631 memcpy(&wl
->conf
, &default_conf
, sizeof(default_conf
));
633 /* Adjust settings according to optional module parameters */
635 if (!strcmp(fwlog_param
, "continuous")) {
636 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
637 } else if (!strcmp(fwlog_param
, "ondemand")) {
638 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_ON_DEMAND
;
639 } else if (!strcmp(fwlog_param
, "dbgpins")) {
640 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
641 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_DBG_PINS
;
642 } else if (!strcmp(fwlog_param
, "disable")) {
643 wl
->conf
.fwlog
.mem_blocks
= 0;
644 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_NONE
;
646 wl1271_error("Unknown fwlog parameter %s", fwlog_param
);
651 static int wl1271_plt_init(struct wl1271
*wl
)
653 struct conf_tx_ac_category
*conf_ac
;
654 struct conf_tx_tid
*conf_tid
;
657 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
658 ret
= wl128x_cmd_general_parms(wl
);
660 ret
= wl1271_cmd_general_parms(wl
);
664 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
665 ret
= wl128x_cmd_radio_parms(wl
);
667 ret
= wl1271_cmd_radio_parms(wl
);
671 if (wl
->chip
.id
!= CHIP_ID_1283_PG20
) {
672 ret
= wl1271_cmd_ext_radio_parms(wl
);
679 /* Chip-specific initializations */
680 ret
= wl1271_chip_specific_init(wl
);
684 ret
= wl1271_sta_init_templates_config(wl
);
688 ret
= wl1271_acx_init_mem_config(wl
);
692 /* PHY layer config */
693 ret
= wl1271_init_phy_config(wl
);
695 goto out_free_memmap
;
697 ret
= wl1271_acx_dco_itrim_params(wl
);
699 goto out_free_memmap
;
701 /* Initialize connection monitoring thresholds */
702 ret
= wl1271_acx_conn_monit_params(wl
, false);
704 goto out_free_memmap
;
706 /* Bluetooth WLAN coexistence */
707 ret
= wl1271_init_pta(wl
);
709 goto out_free_memmap
;
711 /* FM WLAN coexistence */
712 ret
= wl1271_acx_fm_coex(wl
);
714 goto out_free_memmap
;
716 /* Energy detection */
717 ret
= wl1271_init_energy_detection(wl
);
719 goto out_free_memmap
;
721 ret
= wl1271_acx_sta_mem_cfg(wl
);
723 goto out_free_memmap
;
725 /* Default fragmentation threshold */
726 ret
= wl1271_acx_frag_threshold(wl
, wl
->conf
.tx
.frag_threshold
);
728 goto out_free_memmap
;
730 /* Default TID/AC configuration */
731 BUG_ON(wl
->conf
.tx
.tid_conf_count
!= wl
->conf
.tx
.ac_conf_count
);
732 for (i
= 0; i
< wl
->conf
.tx
.tid_conf_count
; i
++) {
733 conf_ac
= &wl
->conf
.tx
.ac_conf
[i
];
734 ret
= wl1271_acx_ac_cfg(wl
, conf_ac
->ac
, conf_ac
->cw_min
,
735 conf_ac
->cw_max
, conf_ac
->aifsn
,
736 conf_ac
->tx_op_limit
);
738 goto out_free_memmap
;
740 conf_tid
= &wl
->conf
.tx
.tid_conf
[i
];
741 ret
= wl1271_acx_tid_cfg(wl
, conf_tid
->queue_id
,
742 conf_tid
->channel_type
,
745 conf_tid
->ack_policy
,
746 conf_tid
->apsd_conf
[0],
747 conf_tid
->apsd_conf
[1]);
749 goto out_free_memmap
;
752 /* Enable data path */
753 ret
= wl1271_cmd_data_path(wl
, 1);
755 goto out_free_memmap
;
757 /* Configure for CAM power saving (ie. always active) */
758 ret
= wl1271_acx_sleep_auth(wl
, WL1271_PSM_CAM
);
760 goto out_free_memmap
;
763 ret
= wl1271_acx_pm_config(wl
);
765 goto out_free_memmap
;
770 kfree(wl
->target_mem_map
);
771 wl
->target_mem_map
= NULL
;
776 static void wl1271_irq_ps_regulate_link(struct wl1271
*wl
, u8 hlid
, u8 tx_blks
)
780 /* only regulate station links */
781 if (hlid
< WL1271_AP_STA_HLID_START
)
784 fw_ps
= test_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
787 * Wake up from high level PS if the STA is asleep with too little
788 * blocks in FW or if the STA is awake.
790 if (!fw_ps
|| tx_blks
< WL1271_PS_STA_MAX_BLOCKS
)
791 wl1271_ps_link_end(wl
, hlid
);
793 /* Start high-level PS if the STA is asleep with enough blocks in FW */
794 else if (fw_ps
&& tx_blks
>= WL1271_PS_STA_MAX_BLOCKS
)
795 wl1271_ps_link_start(wl
, hlid
, true);
798 static void wl1271_irq_update_links_status(struct wl1271
*wl
,
799 struct wl1271_fw_ap_status
*status
)
804 cur_fw_ps_map
= le32_to_cpu(status
->link_ps_bitmap
);
805 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
806 wl1271_debug(DEBUG_PSM
,
807 "link ps prev 0x%x cur 0x%x changed 0x%x",
808 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
809 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
811 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
814 for (hlid
= WL1271_AP_STA_HLID_START
; hlid
< AP_MAX_LINKS
; hlid
++) {
815 u8 cnt
= status
->tx_lnk_free_blks
[hlid
] -
816 wl
->links
[hlid
].prev_freed_blks
;
818 wl
->links
[hlid
].prev_freed_blks
=
819 status
->tx_lnk_free_blks
[hlid
];
820 wl
->links
[hlid
].allocated_blks
-= cnt
;
822 wl1271_irq_ps_regulate_link(wl
, hlid
,
823 wl
->links
[hlid
].allocated_blks
);
827 static u32
wl1271_tx_allocated_blocks(struct wl1271
*wl
)
830 u32 total_alloc_blocks
= 0;
832 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
833 total_alloc_blocks
+= wl
->tx_allocated_blocks
[i
];
835 return total_alloc_blocks
;
838 static void wl1271_fw_status(struct wl1271
*wl
,
839 struct wl1271_fw_full_status
*full_status
)
841 struct wl1271_fw_common_status
*status
= &full_status
->common
;
843 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
844 u32 freed_blocks
= 0, ac_freed_blocks
;
847 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
848 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
849 sizeof(struct wl1271_fw_ap_status
), false);
851 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
852 sizeof(struct wl1271_fw_sta_status
), false);
855 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
856 "drv_rx_counter = %d, tx_results_counter = %d)",
858 status
->fw_rx_counter
,
859 status
->drv_rx_counter
,
860 status
->tx_results_counter
);
862 /* update number of available TX blocks */
863 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
864 ac_freed_blocks
= le32_to_cpu(status
->tx_released_blks
[i
]) -
865 wl
->tx_blocks_freed
[i
];
866 freed_blocks
+= ac_freed_blocks
;
868 wl
->tx_allocated_blocks
[i
] -= ac_freed_blocks
;
870 wl
->tx_blocks_freed
[i
] =
871 le32_to_cpu(status
->tx_released_blks
[i
]);
874 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
875 /* Update num of allocated TX blocks per link and ps status */
876 wl1271_irq_update_links_status(wl
, &full_status
->ap
);
877 wl
->tx_blocks_available
+= freed_blocks
;
879 int avail
= full_status
->sta
.tx_total
-
880 wl1271_tx_allocated_blocks(wl
);
883 * The FW might change the total number of TX memblocks before
884 * we get a notification about blocks being released. Thus, the
885 * available blocks calculation might yield a temporary result
886 * which is lower than the actual available blocks. Keeping in
887 * mind that only blocks that were allocated can be moved from
888 * TX to RX, tx_blocks_available should never decrease here.
890 wl
->tx_blocks_available
= max((int)wl
->tx_blocks_available
,
894 /* if more blocks are available now, tx work can be scheduled */
895 if (wl
->tx_blocks_available
> old_tx_blk_count
)
896 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
898 /* update the host-chipset time offset */
900 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
901 (s64
)le32_to_cpu(status
->fw_localtime
);
904 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
908 /* Pass all received frames to the network stack */
909 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
910 ieee80211_rx_ni(wl
->hw
, skb
);
912 /* Return sent skbs to the network stack */
913 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
914 ieee80211_tx_status_ni(wl
->hw
, skb
);
917 static void wl1271_netstack_work(struct work_struct
*work
)
920 container_of(work
, struct wl1271
, netstack_work
);
923 wl1271_flush_deferred_work(wl
);
924 } while (skb_queue_len(&wl
->deferred_rx_queue
));
927 #define WL1271_IRQ_MAX_LOOPS 256
929 irqreturn_t
wl1271_irq(int irq
, void *cookie
)
933 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
934 struct wl1271
*wl
= (struct wl1271
*)cookie
;
936 unsigned int defer_count
;
939 /* TX might be handled here, avoid redundant work */
940 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
941 cancel_work_sync(&wl
->tx_work
);
944 * In case edge triggered interrupt must be used, we cannot iterate
945 * more than once without introducing race conditions with the hardirq.
947 if (wl
->platform_quirks
& WL12XX_PLATFORM_QUIRK_EDGE_IRQ
)
950 mutex_lock(&wl
->mutex
);
952 wl1271_debug(DEBUG_IRQ
, "IRQ work");
954 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
957 ret
= wl1271_ps_elp_wakeup(wl
);
961 while (!done
&& loopcount
--) {
963 * In order to avoid a race with the hardirq, clear the flag
964 * before acknowledging the chip. Since the mutex is held,
965 * wl1271_ps_elp_wakeup cannot be called concurrently.
967 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
968 smp_mb__after_clear_bit();
970 wl1271_fw_status(wl
, wl
->fw_status
);
971 intr
= le32_to_cpu(wl
->fw_status
->common
.intr
);
972 intr
&= WL1271_INTR_MASK
;
978 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
979 wl1271_error("watchdog interrupt received! "
980 "starting recovery.");
981 wl12xx_queue_recovery_work(wl
);
983 /* restarting the chip. ignore any other interrupt. */
987 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
988 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
990 wl1271_rx(wl
, &wl
->fw_status
->common
);
992 /* Check if any tx blocks were freed */
993 spin_lock_irqsave(&wl
->wl_lock
, flags
);
994 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
995 wl
->tx_queue_count
) {
996 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
998 * In order to avoid starvation of the TX path,
999 * call the work function directly.
1001 wl1271_tx_work_locked(wl
);
1003 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1006 /* check for tx results */
1007 if (wl
->fw_status
->common
.tx_results_counter
!=
1008 (wl
->tx_results_count
& 0xff))
1009 wl1271_tx_complete(wl
);
1011 /* Make sure the deferred queues don't get too long */
1012 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
1013 skb_queue_len(&wl
->deferred_rx_queue
);
1014 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
1015 wl1271_flush_deferred_work(wl
);
1018 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
1019 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
1020 wl1271_event_handle(wl
, 0);
1023 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
1024 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
1025 wl1271_event_handle(wl
, 1);
1028 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
1029 wl1271_debug(DEBUG_IRQ
,
1030 "WL1271_ACX_INTR_INIT_COMPLETE");
1032 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
1033 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
1036 wl1271_ps_elp_sleep(wl
);
1039 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1040 /* In case TX was not handled here, queue TX work */
1041 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
1042 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1044 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1045 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1047 mutex_unlock(&wl
->mutex
);
1051 EXPORT_SYMBOL_GPL(wl1271_irq
);
1053 static int wl1271_fetch_firmware(struct wl1271
*wl
)
1055 const struct firmware
*fw
;
1056 const char *fw_name
;
1059 switch (wl
->bss_type
) {
1060 case BSS_TYPE_AP_BSS
:
1061 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
1062 fw_name
= WL128X_AP_FW_NAME
;
1064 fw_name
= WL127X_AP_FW_NAME
;
1067 case BSS_TYPE_STA_BSS
:
1068 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
1069 fw_name
= WL128X_FW_NAME
;
1071 fw_name
= WL1271_FW_NAME
;
1074 wl1271_error("no compatible firmware for bss_type %d",
1079 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
1081 ret
= request_firmware(&fw
, fw_name
, wl1271_wl_to_dev(wl
));
1084 wl1271_error("could not get firmware: %d", ret
);
1089 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1096 wl
->fw_len
= fw
->size
;
1097 wl
->fw
= vmalloc(wl
->fw_len
);
1100 wl1271_error("could not allocate memory for the firmware");
1105 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
1106 wl
->fw_bss_type
= wl
->bss_type
;
1110 release_firmware(fw
);
1115 static int wl1271_fetch_nvs(struct wl1271
*wl
)
1117 const struct firmware
*fw
;
1120 ret
= request_firmware(&fw
, WL12XX_NVS_NAME
, wl1271_wl_to_dev(wl
));
1123 wl1271_error("could not get nvs file: %d", ret
);
1127 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
1130 wl1271_error("could not allocate memory for the nvs file");
1135 wl
->nvs_len
= fw
->size
;
1138 release_firmware(fw
);
1143 void wl12xx_queue_recovery_work(struct wl1271
*wl
)
1145 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1146 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
1149 size_t wl12xx_copy_fwlog(struct wl1271
*wl
, u8
*memblock
, size_t maxlen
)
1153 /* The FW log is a length-value list, find where the log end */
1154 while (len
< maxlen
) {
1155 if (memblock
[len
] == 0)
1157 if (len
+ memblock
[len
] + 1 > maxlen
)
1159 len
+= memblock
[len
] + 1;
1162 /* Make sure we have enough room */
1163 len
= min(len
, (size_t)(PAGE_SIZE
- wl
->fwlog_size
));
1165 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1166 memcpy(wl
->fwlog
+ wl
->fwlog_size
, memblock
, len
);
1167 wl
->fwlog_size
+= len
;
1172 static void wl12xx_read_fwlog_panic(struct wl1271
*wl
)
1178 if ((wl
->quirks
& WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED
) ||
1179 (wl
->conf
.fwlog
.mode
!= WL12XX_FWLOG_ON_DEMAND
) ||
1180 (wl
->conf
.fwlog
.mem_blocks
== 0))
1183 wl1271_info("Reading FW panic log");
1185 block
= kmalloc(WL12XX_HW_BLOCK_SIZE
, GFP_KERNEL
);
1190 * Make sure the chip is awake and the logger isn't active.
1191 * This might fail if the firmware hanged.
1193 if (!wl1271_ps_elp_wakeup(wl
))
1194 wl12xx_cmd_stop_fwlog(wl
);
1196 /* Read the first memory block address */
1197 wl1271_fw_status(wl
, wl
->fw_status
);
1198 first_addr
= __le32_to_cpu(wl
->fw_status
->sta
.log_start_addr
);
1202 /* Traverse the memory blocks linked list */
1205 memset(block
, 0, WL12XX_HW_BLOCK_SIZE
);
1206 wl1271_read_hwaddr(wl
, addr
, block
, WL12XX_HW_BLOCK_SIZE
,
1210 * Memory blocks are linked to one another. The first 4 bytes
1211 * of each memory block hold the hardware address of the next
1212 * one. The last memory block points to the first one.
1214 addr
= __le32_to_cpup((__le32
*)block
);
1215 if (!wl12xx_copy_fwlog(wl
, block
+ sizeof(addr
),
1216 WL12XX_HW_BLOCK_SIZE
- sizeof(addr
)))
1218 } while (addr
&& (addr
!= first_addr
));
1220 wake_up_interruptible(&wl
->fwlog_waitq
);
1226 static void wl1271_recovery_work(struct work_struct
*work
)
1229 container_of(work
, struct wl1271
, recovery_work
);
1231 mutex_lock(&wl
->mutex
);
1233 if (wl
->state
!= WL1271_STATE_ON
)
1236 /* Avoid a recursive recovery */
1237 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
1239 wl12xx_read_fwlog_panic(wl
);
1241 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1242 wl
->chip
.fw_ver_str
, wl1271_read32(wl
, SCR_PAD4
));
1245 * Advance security sequence number to overcome potential progress
1246 * in the firmware during recovery. This doens't hurt if the network is
1249 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) ||
1250 test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
))
1251 wl
->tx_security_seq
+= WL1271_TX_SQN_POST_RECOVERY_PADDING
;
1253 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1254 ieee80211_connection_loss(wl
->vif
);
1256 /* Prevent spurious TX during FW restart */
1257 ieee80211_stop_queues(wl
->hw
);
1259 if (wl
->sched_scanning
) {
1260 ieee80211_sched_scan_stopped(wl
->hw
);
1261 wl
->sched_scanning
= false;
1264 /* reboot the chipset */
1265 __wl1271_op_remove_interface(wl
, false);
1267 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
1269 ieee80211_restart_hw(wl
->hw
);
1272 * Its safe to enable TX now - the queues are stopped after a request
1273 * to restart the HW.
1275 ieee80211_wake_queues(wl
->hw
);
1278 mutex_unlock(&wl
->mutex
);
1281 static void wl1271_fw_wakeup(struct wl1271
*wl
)
1285 elp_reg
= ELPCTRL_WAKE_UP
;
1286 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
1289 static int wl1271_setup(struct wl1271
*wl
)
1291 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
1295 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
1296 if (!wl
->tx_res_if
) {
1297 kfree(wl
->fw_status
);
1304 static int wl1271_chip_wakeup(struct wl1271
*wl
)
1306 struct wl1271_partition_set partition
;
1309 msleep(WL1271_PRE_POWER_ON_SLEEP
);
1310 ret
= wl1271_power_on(wl
);
1313 msleep(WL1271_POWER_ON_SLEEP
);
1314 wl1271_io_reset(wl
);
1317 /* We don't need a real memory partition here, because we only want
1318 * to use the registers at this point. */
1319 memset(&partition
, 0, sizeof(partition
));
1320 partition
.reg
.start
= REGISTERS_BASE
;
1321 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
1322 wl1271_set_partition(wl
, &partition
);
1324 /* ELP module wake up */
1325 wl1271_fw_wakeup(wl
);
1327 /* whal_FwCtrl_BootSm() */
1329 /* 0. read chip id from CHIP_ID */
1330 wl
->chip
.id
= wl1271_read32(wl
, CHIP_ID_B
);
1332 /* 1. check if chip id is valid */
1334 switch (wl
->chip
.id
) {
1335 case CHIP_ID_1271_PG10
:
1336 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1339 ret
= wl1271_setup(wl
);
1343 case CHIP_ID_1271_PG20
:
1344 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
1348 * 'end-of-transaction flag' and 'LPD mode flag'
1349 * should be set in wl127x AP mode only
1351 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1352 wl
->quirks
|= (WL12XX_QUIRK_END_OF_TRANSACTION
|
1353 WL12XX_QUIRK_LPD_MODE
);
1355 ret
= wl1271_setup(wl
);
1359 case CHIP_ID_1283_PG20
:
1360 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1283 PG20)",
1363 ret
= wl1271_setup(wl
);
1367 if (wl1271_set_block_size(wl
))
1368 wl
->quirks
|= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT
;
1370 case CHIP_ID_1283_PG10
:
1372 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
1377 /* Make sure the firmware type matches the BSS type */
1378 if (wl
->fw
== NULL
|| wl
->fw_bss_type
!= wl
->bss_type
) {
1379 ret
= wl1271_fetch_firmware(wl
);
1384 /* No NVS from netlink, try to get it from the filesystem */
1385 if (wl
->nvs
== NULL
) {
1386 ret
= wl1271_fetch_nvs(wl
);
1395 int wl1271_plt_start(struct wl1271
*wl
)
1397 int retries
= WL1271_BOOT_RETRIES
;
1400 mutex_lock(&wl
->mutex
);
1402 wl1271_notice("power up");
1404 if (wl
->state
!= WL1271_STATE_OFF
) {
1405 wl1271_error("cannot go into PLT state because not "
1406 "in off state: %d", wl
->state
);
1411 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1415 ret
= wl1271_chip_wakeup(wl
);
1419 ret
= wl1271_boot(wl
);
1423 ret
= wl1271_plt_init(wl
);
1427 wl
->state
= WL1271_STATE_PLT
;
1428 wl1271_notice("firmware booted in PLT mode (%s)",
1429 wl
->chip
.fw_ver_str
);
1434 mutex_unlock(&wl
->mutex
);
1435 /* Unlocking the mutex in the middle of handling is
1436 inherently unsafe. In this case we deem it safe to do,
1437 because we need to let any possibly pending IRQ out of
1438 the system (and while we are WL1271_STATE_OFF the IRQ
1439 work function will not do anything.) Also, any other
1440 possible concurrent operations will fail due to the
1441 current state, hence the wl1271 struct should be safe. */
1442 wl1271_disable_interrupts(wl
);
1443 wl1271_flush_deferred_work(wl
);
1444 cancel_work_sync(&wl
->netstack_work
);
1445 mutex_lock(&wl
->mutex
);
1447 wl1271_power_off(wl
);
1450 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1451 WL1271_BOOT_RETRIES
);
1453 mutex_unlock(&wl
->mutex
);
1458 static int __wl1271_plt_stop(struct wl1271
*wl
)
1462 wl1271_notice("power down");
1464 if (wl
->state
!= WL1271_STATE_PLT
) {
1465 wl1271_error("cannot power down because not in PLT "
1466 "state: %d", wl
->state
);
1471 wl1271_power_off(wl
);
1473 wl
->state
= WL1271_STATE_OFF
;
1476 mutex_unlock(&wl
->mutex
);
1477 wl1271_disable_interrupts(wl
);
1478 wl1271_flush_deferred_work(wl
);
1479 cancel_work_sync(&wl
->netstack_work
);
1480 cancel_work_sync(&wl
->recovery_work
);
1481 mutex_lock(&wl
->mutex
);
1486 int wl1271_plt_stop(struct wl1271
*wl
)
1490 mutex_lock(&wl
->mutex
);
1491 ret
= __wl1271_plt_stop(wl
);
1492 mutex_unlock(&wl
->mutex
);
1496 static void wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
1498 struct wl1271
*wl
= hw
->priv
;
1499 unsigned long flags
;
1503 mapping
= skb_get_queue_mapping(skb
);
1504 q
= wl1271_tx_get_queue(mapping
);
1506 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1507 hlid
= wl1271_tx_get_hlid(skb
);
1509 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1511 wl
->tx_queue_count
++;
1514 * The workqueue is slow to process the tx_queue and we need stop
1515 * the queue here, otherwise the queue will get too long.
1517 if (skb_queue_len(&wl
->tx_queue
[q
]) >= WL1271_TX_QUEUE_HIGH_WATERMARK
) {
1518 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues for q %d", q
);
1519 ieee80211_stop_queue(wl
->hw
, mapping
);
1520 set_bit(q
, &wl
->stopped_queues_map
);
1523 /* queue the packet */
1524 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
1525 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d", hlid
, q
);
1526 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1528 skb_queue_tail(&wl
->tx_queue
[q
], skb
);
1532 * The chip specific setup must run before the first TX packet -
1533 * before that, the tx_work will not be initialized!
1536 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1537 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1538 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1540 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1543 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1545 unsigned long flags
;
1547 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1548 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
);
1549 wl
->tx_queue_count
++;
1550 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1552 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1553 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1554 wl1271_tx_work_locked(wl
);
1557 * If the FW TX is busy, TX work will be scheduled by the threaded
1558 * interrupt handler function
1564 * The size of the dummy packet should be at least 1400 bytes. However, in
1565 * order to minimize the number of bus transactions, aligning it to 512 bytes
1566 * boundaries could be beneficial, performance wise
1568 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1570 static struct sk_buff
*wl12xx_alloc_dummy_packet(struct wl1271
*wl
)
1572 struct sk_buff
*skb
;
1573 struct ieee80211_hdr_3addr
*hdr
;
1574 unsigned int dummy_packet_size
;
1576 dummy_packet_size
= TOTAL_TX_DUMMY_PACKET_SIZE
-
1577 sizeof(struct wl1271_tx_hw_descr
) - sizeof(*hdr
);
1579 skb
= dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE
);
1581 wl1271_warning("Failed to allocate a dummy packet skb");
1585 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1587 hdr
= (struct ieee80211_hdr_3addr
*) skb_put(skb
, sizeof(*hdr
));
1588 memset(hdr
, 0, sizeof(*hdr
));
1589 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1590 IEEE80211_STYPE_NULLFUNC
|
1591 IEEE80211_FCTL_TODS
);
1593 memset(skb_put(skb
, dummy_packet_size
), 0, dummy_packet_size
);
1595 /* Dummy packets require the TID to be management */
1596 skb
->priority
= WL1271_TID_MGMT
;
1598 /* Initialize all fields that might be used */
1599 skb_set_queue_mapping(skb
, 0);
1600 memset(IEEE80211_SKB_CB(skb
), 0, sizeof(struct ieee80211_tx_info
));
1606 static struct notifier_block wl1271_dev_notifier
= {
1607 .notifier_call
= wl1271_dev_notify
,
1611 static int wl1271_configure_suspend_sta(struct wl1271
*wl
)
1615 mutex_lock(&wl
->mutex
);
1617 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1620 ret
= wl1271_ps_elp_wakeup(wl
);
1624 /* enter psm if needed*/
1625 if (!test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
1626 DECLARE_COMPLETION_ONSTACK(compl);
1628 wl
->ps_compl
= &compl;
1629 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
1630 wl
->basic_rate
, true);
1634 /* we must unlock here so we will be able to get events */
1635 wl1271_ps_elp_sleep(wl
);
1636 mutex_unlock(&wl
->mutex
);
1638 ret
= wait_for_completion_timeout(
1639 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT
));
1641 wl1271_warning("couldn't enter ps mode!");
1646 /* take mutex again, and wakeup */
1647 mutex_lock(&wl
->mutex
);
1649 ret
= wl1271_ps_elp_wakeup(wl
);
1654 wl1271_ps_elp_sleep(wl
);
1656 mutex_unlock(&wl
->mutex
);
1662 static int wl1271_configure_suspend_ap(struct wl1271
*wl
)
1666 mutex_lock(&wl
->mutex
);
1668 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
))
1671 ret
= wl1271_ps_elp_wakeup(wl
);
1675 ret
= wl1271_acx_set_ap_beacon_filter(wl
, true);
1677 wl1271_ps_elp_sleep(wl
);
1679 mutex_unlock(&wl
->mutex
);
1684 static int wl1271_configure_suspend(struct wl1271
*wl
)
1686 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1687 return wl1271_configure_suspend_sta(wl
);
1688 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1689 return wl1271_configure_suspend_ap(wl
);
1693 static void wl1271_configure_resume(struct wl1271
*wl
)
1696 bool is_sta
= wl
->bss_type
== BSS_TYPE_STA_BSS
;
1697 bool is_ap
= wl
->bss_type
== BSS_TYPE_AP_BSS
;
1699 if (!is_sta
&& !is_ap
)
1702 mutex_lock(&wl
->mutex
);
1703 ret
= wl1271_ps_elp_wakeup(wl
);
1708 /* exit psm if it wasn't configured */
1709 if (!test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
))
1710 wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
1711 wl
->basic_rate
, true);
1713 wl1271_acx_set_ap_beacon_filter(wl
, false);
1716 wl1271_ps_elp_sleep(wl
);
1718 mutex_unlock(&wl
->mutex
);
1721 static int wl1271_op_suspend(struct ieee80211_hw
*hw
,
1722 struct cfg80211_wowlan
*wow
)
1724 struct wl1271
*wl
= hw
->priv
;
1727 wl1271_debug(DEBUG_MAC80211
, "mac80211 suspend wow=%d", !!wow
);
1728 WARN_ON(!wow
|| !wow
->any
);
1730 wl
->wow_enabled
= true;
1731 ret
= wl1271_configure_suspend(wl
);
1733 wl1271_warning("couldn't prepare device to suspend");
1736 /* flush any remaining work */
1737 wl1271_debug(DEBUG_MAC80211
, "flushing remaining works");
1740 * disable and re-enable interrupts in order to flush
1743 wl1271_disable_interrupts(wl
);
1746 * set suspended flag to avoid triggering a new threaded_irq
1747 * work. no need for spinlock as interrupts are disabled.
1749 set_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1751 wl1271_enable_interrupts(wl
);
1752 flush_work(&wl
->tx_work
);
1753 flush_delayed_work(&wl
->pspoll_work
);
1754 flush_delayed_work(&wl
->elp_work
);
1759 static int wl1271_op_resume(struct ieee80211_hw
*hw
)
1761 struct wl1271
*wl
= hw
->priv
;
1762 unsigned long flags
;
1763 bool run_irq_work
= false;
1765 wl1271_debug(DEBUG_MAC80211
, "mac80211 resume wow=%d",
1767 WARN_ON(!wl
->wow_enabled
);
1770 * re-enable irq_work enqueuing, and call irq_work directly if
1771 * there is a pending work.
1773 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1774 clear_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1775 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
))
1776 run_irq_work
= true;
1777 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1780 wl1271_debug(DEBUG_MAC80211
,
1781 "run postponed irq_work directly");
1783 wl1271_enable_interrupts(wl
);
1785 wl1271_configure_resume(wl
);
1786 wl
->wow_enabled
= false;
1792 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1794 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1797 * We have to delay the booting of the hardware because
1798 * we need to know the local MAC address before downloading and
1799 * initializing the firmware. The MAC address cannot be changed
1800 * after boot, and without the proper MAC address, the firmware
1801 * will not function properly.
1803 * The MAC address is first known when the corresponding interface
1804 * is added. That is where we will initialize the hardware.
1806 * In addition, we currently have different firmwares for AP and managed
1807 * operation. We will know which to boot according to interface type.
1813 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
1815 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1818 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1819 struct ieee80211_vif
*vif
)
1821 struct wl1271
*wl
= hw
->priv
;
1822 struct wiphy
*wiphy
= hw
->wiphy
;
1823 int retries
= WL1271_BOOT_RETRIES
;
1825 bool booted
= false;
1827 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1828 vif
->type
, vif
->addr
);
1830 mutex_lock(&wl
->mutex
);
1832 wl1271_debug(DEBUG_MAC80211
,
1833 "multiple vifs are not supported yet");
1839 * in some very corner case HW recovery scenarios its possible to
1840 * get here before __wl1271_op_remove_interface is complete, so
1841 * opt out if that is the case.
1843 if (test_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
)) {
1848 switch (vif
->type
) {
1849 case NL80211_IFTYPE_STATION
:
1850 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1851 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1853 case NL80211_IFTYPE_ADHOC
:
1854 wl
->bss_type
= BSS_TYPE_IBSS
;
1855 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1857 case NL80211_IFTYPE_AP
:
1858 wl
->bss_type
= BSS_TYPE_AP_BSS
;
1865 memcpy(wl
->mac_addr
, vif
->addr
, ETH_ALEN
);
1867 if (wl
->state
!= WL1271_STATE_OFF
) {
1868 wl1271_error("cannot start because not in off state: %d",
1876 ret
= wl1271_chip_wakeup(wl
);
1880 ret
= wl1271_boot(wl
);
1884 ret
= wl1271_hw_init(wl
);
1892 mutex_unlock(&wl
->mutex
);
1893 /* Unlocking the mutex in the middle of handling is
1894 inherently unsafe. In this case we deem it safe to do,
1895 because we need to let any possibly pending IRQ out of
1896 the system (and while we are WL1271_STATE_OFF the IRQ
1897 work function will not do anything.) Also, any other
1898 possible concurrent operations will fail due to the
1899 current state, hence the wl1271 struct should be safe. */
1900 wl1271_disable_interrupts(wl
);
1901 wl1271_flush_deferred_work(wl
);
1902 cancel_work_sync(&wl
->netstack_work
);
1903 mutex_lock(&wl
->mutex
);
1905 wl1271_power_off(wl
);
1909 wl1271_error("firmware boot failed despite %d retries",
1910 WL1271_BOOT_RETRIES
);
1915 wl
->state
= WL1271_STATE_ON
;
1916 set_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
);
1917 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
1919 /* update hw/fw version info in wiphy struct */
1920 wiphy
->hw_version
= wl
->chip
.id
;
1921 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1922 sizeof(wiphy
->fw_version
));
1925 * Now we know if 11a is supported (info from the NVS), so disable
1926 * 11a channels if not supported
1928 if (!wl
->enable_11a
)
1929 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
1931 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
1932 wl
->enable_11a
? "" : "not ");
1935 mutex_unlock(&wl
->mutex
);
1937 mutex_lock(&wl_list_mutex
);
1939 list_add(&wl
->list
, &wl_list
);
1940 mutex_unlock(&wl_list_mutex
);
1945 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
1946 bool reset_tx_queues
)
1950 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
1952 /* because of hardware recovery, we may get here twice */
1953 if (wl
->state
!= WL1271_STATE_ON
)
1956 wl1271_info("down");
1958 mutex_lock(&wl_list_mutex
);
1959 list_del(&wl
->list
);
1960 mutex_unlock(&wl_list_mutex
);
1962 /* enable dyn ps just in case (if left on due to fw crash etc) */
1963 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1964 ieee80211_enable_dyn_ps(wl
->vif
);
1966 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
1967 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
1968 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
1969 wl
->scan
.req
= NULL
;
1970 ieee80211_scan_completed(wl
->hw
, true);
1974 * this must be before the cancel_work calls below, so that the work
1975 * functions don't perform further work.
1977 wl
->state
= WL1271_STATE_OFF
;
1979 mutex_unlock(&wl
->mutex
);
1981 wl1271_disable_interrupts(wl
);
1982 wl1271_flush_deferred_work(wl
);
1983 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1984 cancel_work_sync(&wl
->netstack_work
);
1985 cancel_work_sync(&wl
->tx_work
);
1986 del_timer_sync(&wl
->rx_streaming_timer
);
1987 cancel_work_sync(&wl
->rx_streaming_enable_work
);
1988 cancel_work_sync(&wl
->rx_streaming_disable_work
);
1989 cancel_delayed_work_sync(&wl
->pspoll_work
);
1990 cancel_delayed_work_sync(&wl
->elp_work
);
1992 mutex_lock(&wl
->mutex
);
1994 /* let's notify MAC80211 about the remaining pending TX frames */
1995 wl1271_tx_reset(wl
, reset_tx_queues
);
1996 wl1271_power_off(wl
);
1998 memset(wl
->bssid
, 0, ETH_ALEN
);
1999 memset(wl
->ssid
, 0, IW_ESSID_MAX_SIZE
+ 1);
2001 wl
->bss_type
= MAX_BSS_TYPE
;
2002 wl
->set_bss_type
= MAX_BSS_TYPE
;
2003 wl
->band
= IEEE80211_BAND_2GHZ
;
2006 wl
->psm_entry_retry
= 0;
2007 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
2008 wl
->tx_blocks_available
= 0;
2009 wl
->tx_results_count
= 0;
2010 wl
->tx_packets_count
= 0;
2011 wl
->time_offset
= 0;
2012 wl
->session_counter
= 0;
2013 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
2016 wl1271_free_ap_keys(wl
);
2017 memset(wl
->ap_hlid_map
, 0, sizeof(wl
->ap_hlid_map
));
2018 wl
->ap_fw_ps_map
= 0;
2020 wl
->sched_scanning
= false;
2023 * this is performed after the cancel_work calls and the associated
2024 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2025 * get executed before all these vars have been reset.
2029 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
2030 wl
->tx_blocks_freed
[i
] = 0;
2031 wl
->tx_allocated_blocks
[i
] = 0;
2034 wl1271_debugfs_reset(wl
);
2036 kfree(wl
->fw_status
);
2037 wl
->fw_status
= NULL
;
2038 kfree(wl
->tx_res_if
);
2039 wl
->tx_res_if
= NULL
;
2040 kfree(wl
->target_mem_map
);
2041 wl
->target_mem_map
= NULL
;
2044 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
2045 struct ieee80211_vif
*vif
)
2047 struct wl1271
*wl
= hw
->priv
;
2049 mutex_lock(&wl
->mutex
);
2051 * wl->vif can be null here if someone shuts down the interface
2052 * just when hardware recovery has been started.
2055 WARN_ON(wl
->vif
!= vif
);
2056 __wl1271_op_remove_interface(wl
, true);
2059 mutex_unlock(&wl
->mutex
);
2060 cancel_work_sync(&wl
->recovery_work
);
2063 void wl1271_configure_filters(struct wl1271
*wl
, unsigned int filters
)
2065 wl1271_set_default_filters(wl
);
2067 /* combine requested filters with current filter config */
2068 filters
= wl
->filters
| filters
;
2070 wl1271_debug(DEBUG_FILTERS
, "RX filters set: ");
2072 if (filters
& FIF_PROMISC_IN_BSS
) {
2073 wl1271_debug(DEBUG_FILTERS
, " - FIF_PROMISC_IN_BSS");
2074 wl
->rx_config
&= ~CFG_UNI_FILTER_EN
;
2075 wl
->rx_config
|= CFG_BSSID_FILTER_EN
;
2077 if (filters
& FIF_BCN_PRBRESP_PROMISC
) {
2078 wl1271_debug(DEBUG_FILTERS
, " - FIF_BCN_PRBRESP_PROMISC");
2079 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
2080 wl
->rx_config
&= ~CFG_SSID_FILTER_EN
;
2082 if (filters
& FIF_OTHER_BSS
) {
2083 wl1271_debug(DEBUG_FILTERS
, " - FIF_OTHER_BSS");
2084 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
2086 if (filters
& FIF_CONTROL
) {
2087 wl1271_debug(DEBUG_FILTERS
, " - FIF_CONTROL");
2088 wl
->rx_filter
|= CFG_RX_CTL_EN
;
2090 if (filters
& FIF_FCSFAIL
) {
2091 wl1271_debug(DEBUG_FILTERS
, " - FIF_FCSFAIL");
2092 wl
->rx_filter
|= CFG_RX_FCS_ERROR
;
2096 static int wl1271_dummy_join(struct wl1271
*wl
)
2099 /* we need to use a dummy BSSID for now */
2100 static const u8 dummy_bssid
[ETH_ALEN
] = { 0x0b, 0xad, 0xde,
2103 memcpy(wl
->bssid
, dummy_bssid
, ETH_ALEN
);
2105 /* pass through frames from all BSS */
2106 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
2108 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
2112 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
2118 static int wl1271_join(struct wl1271
*wl
, bool set_assoc
)
2123 * One of the side effects of the JOIN command is that is clears
2124 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2125 * to a WPA/WPA2 access point will therefore kill the data-path.
2126 * Currently the only valid scenario for JOIN during association
2127 * is on roaming, in which case we will also be given new keys.
2128 * Keep the below message for now, unless it starts bothering
2129 * users who really like to roam a lot :)
2131 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2132 wl1271_info("JOIN while associated.");
2135 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
2137 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
2141 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
2143 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2147 * The join command disable the keep-alive mode, shut down its process,
2148 * and also clear the template config, so we need to reset it all after
2149 * the join. The acx_aid starts the keep-alive process, and the order
2150 * of the commands below is relevant.
2152 ret
= wl1271_acx_keep_alive_mode(wl
, true);
2156 ret
= wl1271_acx_aid(wl
, wl
->aid
);
2160 ret
= wl1271_cmd_build_klv_null_data(wl
);
2164 ret
= wl1271_acx_keep_alive_config(wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
2165 ACX_KEEP_ALIVE_TPL_VALID
);
2173 static int wl1271_unjoin(struct wl1271
*wl
)
2177 /* to stop listening to a channel, we disconnect */
2178 ret
= wl1271_cmd_disconnect(wl
);
2182 clear_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
2183 memset(wl
->bssid
, 0, ETH_ALEN
);
2185 /* reset TX security counters on a clean disconnect */
2186 wl
->tx_security_last_seq_lsb
= 0;
2187 wl
->tx_security_seq
= 0;
2189 /* stop filtering packets based on bssid */
2190 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
2196 static void wl1271_set_band_rate(struct wl1271
*wl
)
2198 if (wl
->band
== IEEE80211_BAND_2GHZ
)
2199 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate
;
2201 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate_5
;
2204 static int wl1271_sta_handle_idle(struct wl1271
*wl
, bool idle
)
2209 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
2210 ret
= wl1271_unjoin(wl
);
2214 wl
->rate_set
= wl1271_tx_min_rate_get(wl
);
2215 ret
= wl1271_acx_sta_rate_policies(wl
);
2218 ret
= wl1271_acx_keep_alive_config(
2219 wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
2220 ACX_KEEP_ALIVE_TPL_INVALID
);
2223 set_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
2225 /* increment the session counter */
2226 wl
->session_counter
++;
2227 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
2228 wl
->session_counter
= 0;
2230 /* The current firmware only supports sched_scan in idle */
2231 if (wl
->sched_scanning
) {
2232 wl1271_scan_sched_scan_stop(wl
);
2233 ieee80211_sched_scan_stopped(wl
->hw
);
2236 ret
= wl1271_dummy_join(wl
);
2239 clear_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
2246 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
2248 struct wl1271
*wl
= hw
->priv
;
2249 struct ieee80211_conf
*conf
= &hw
->conf
;
2250 int channel
, ret
= 0;
2253 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
2255 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s"
2258 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
2260 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
2264 * mac80211 will go to idle nearly immediately after transmitting some
2265 * frames, such as the deauth. To make sure those frames reach the air,
2266 * wait here until the TX queue is fully flushed.
2268 if ((changed
& IEEE80211_CONF_CHANGE_IDLE
) &&
2269 (conf
->flags
& IEEE80211_CONF_IDLE
))
2270 wl1271_tx_flush(wl
);
2272 mutex_lock(&wl
->mutex
);
2274 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2275 /* we support configuring the channel and band while off */
2276 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
)) {
2277 wl
->band
= conf
->channel
->band
;
2278 wl
->channel
= channel
;
2284 is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2286 ret
= wl1271_ps_elp_wakeup(wl
);
2290 /* if the channel changes while joined, join again */
2291 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
&&
2292 ((wl
->band
!= conf
->channel
->band
) ||
2293 (wl
->channel
!= channel
))) {
2294 wl
->band
= conf
->channel
->band
;
2295 wl
->channel
= channel
;
2299 * FIXME: the mac80211 should really provide a fixed
2300 * rate to use here. for now, just use the smallest
2301 * possible rate for the band as a fixed rate for
2302 * association frames and other control messages.
2304 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2305 wl1271_set_band_rate(wl
);
2307 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2308 ret
= wl1271_acx_sta_rate_policies(wl
);
2310 wl1271_warning("rate policy for channel "
2313 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
2314 ret
= wl1271_join(wl
, false);
2316 wl1271_warning("cmd join on channel "
2322 if (changed
& IEEE80211_CONF_CHANGE_IDLE
&& !is_ap
) {
2323 ret
= wl1271_sta_handle_idle(wl
,
2324 conf
->flags
& IEEE80211_CONF_IDLE
);
2326 wl1271_warning("idle mode change failed %d", ret
);
2330 * if mac80211 changes the PSM mode, make sure the mode is not
2331 * incorrectly changed after the pspoll failure active window.
2333 if (changed
& IEEE80211_CONF_CHANGE_PS
)
2334 clear_bit(WL1271_FLAG_PSPOLL_FAILURE
, &wl
->flags
);
2336 if (conf
->flags
& IEEE80211_CONF_PS
&&
2337 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
2338 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
2341 * We enter PSM only if we're already associated.
2342 * If we're not, we'll enter it when joining an SSID,
2343 * through the bss_info_changed() hook.
2345 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
2346 wl1271_debug(DEBUG_PSM
, "psm enabled");
2347 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
2348 wl
->basic_rate
, true);
2350 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
2351 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
2352 wl1271_debug(DEBUG_PSM
, "psm disabled");
2354 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
2356 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
2357 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
2358 wl
->basic_rate
, true);
2361 if (conf
->power_level
!= wl
->power_level
) {
2362 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
2366 wl
->power_level
= conf
->power_level
;
2370 wl1271_ps_elp_sleep(wl
);
2373 mutex_unlock(&wl
->mutex
);
2378 struct wl1271_filter_params
{
2381 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
2384 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
2385 struct netdev_hw_addr_list
*mc_list
)
2387 struct wl1271_filter_params
*fp
;
2388 struct netdev_hw_addr
*ha
;
2389 struct wl1271
*wl
= hw
->priv
;
2391 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2394 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
2396 wl1271_error("Out of memory setting filters.");
2400 /* update multicast filtering parameters */
2401 fp
->mc_list_length
= 0;
2402 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
2403 fp
->enabled
= false;
2406 netdev_hw_addr_list_for_each(ha
, mc_list
) {
2407 memcpy(fp
->mc_list
[fp
->mc_list_length
],
2408 ha
->addr
, ETH_ALEN
);
2409 fp
->mc_list_length
++;
2413 return (u64
)(unsigned long)fp
;
2416 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2419 FIF_BCN_PRBRESP_PROMISC | \
2423 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
2424 unsigned int changed
,
2425 unsigned int *total
, u64 multicast
)
2427 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
2428 struct wl1271
*wl
= hw
->priv
;
2431 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
2432 " total %x", changed
, *total
);
2434 mutex_lock(&wl
->mutex
);
2436 *total
&= WL1271_SUPPORTED_FILTERS
;
2437 changed
&= WL1271_SUPPORTED_FILTERS
;
2439 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2442 ret
= wl1271_ps_elp_wakeup(wl
);
2446 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
) {
2447 if (*total
& FIF_ALLMULTI
)
2448 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
2450 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
2452 fp
->mc_list_length
);
2457 /* determine, whether supported filter values have changed */
2461 /* configure filters */
2462 wl
->filters
= *total
;
2463 wl1271_configure_filters(wl
, 0);
2465 /* apply configured filters */
2466 ret
= wl1271_acx_rx_config(wl
, wl
->rx_config
, wl
->rx_filter
);
2471 wl1271_ps_elp_sleep(wl
);
2474 mutex_unlock(&wl
->mutex
);
2478 static int wl1271_record_ap_key(struct wl1271
*wl
, u8 id
, u8 key_type
,
2479 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
2482 struct wl1271_ap_key
*ap_key
;
2485 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
2487 if (key_size
> MAX_KEY_SIZE
)
2491 * Find next free entry in ap_keys. Also check we are not replacing
2494 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2495 if (wl
->recorded_ap_keys
[i
] == NULL
)
2498 if (wl
->recorded_ap_keys
[i
]->id
== id
) {
2499 wl1271_warning("trying to record key replacement");
2504 if (i
== MAX_NUM_KEYS
)
2507 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
2512 ap_key
->key_type
= key_type
;
2513 ap_key
->key_size
= key_size
;
2514 memcpy(ap_key
->key
, key
, key_size
);
2515 ap_key
->hlid
= hlid
;
2516 ap_key
->tx_seq_32
= tx_seq_32
;
2517 ap_key
->tx_seq_16
= tx_seq_16
;
2519 wl
->recorded_ap_keys
[i
] = ap_key
;
2523 static void wl1271_free_ap_keys(struct wl1271
*wl
)
2527 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2528 kfree(wl
->recorded_ap_keys
[i
]);
2529 wl
->recorded_ap_keys
[i
] = NULL
;
2533 static int wl1271_ap_init_hwenc(struct wl1271
*wl
)
2536 struct wl1271_ap_key
*key
;
2537 bool wep_key_added
= false;
2539 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2540 if (wl
->recorded_ap_keys
[i
] == NULL
)
2543 key
= wl
->recorded_ap_keys
[i
];
2544 ret
= wl1271_cmd_set_ap_key(wl
, KEY_ADD_OR_REPLACE
,
2545 key
->id
, key
->key_type
,
2546 key
->key_size
, key
->key
,
2547 key
->hlid
, key
->tx_seq_32
,
2552 if (key
->key_type
== KEY_WEP
)
2553 wep_key_added
= true;
2556 if (wep_key_added
) {
2557 ret
= wl1271_cmd_set_ap_default_wep_key(wl
, wl
->default_key
);
2563 wl1271_free_ap_keys(wl
);
2567 static int wl1271_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
2568 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
2569 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
2572 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2575 struct wl1271_station
*wl_sta
;
2579 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2580 hlid
= wl_sta
->hlid
;
2582 hlid
= WL1271_AP_BROADCAST_HLID
;
2585 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2587 * We do not support removing keys after AP shutdown.
2588 * Pretend we do to make mac80211 happy.
2590 if (action
!= KEY_ADD_OR_REPLACE
)
2593 ret
= wl1271_record_ap_key(wl
, id
,
2595 key
, hlid
, tx_seq_32
,
2598 ret
= wl1271_cmd_set_ap_key(wl
, action
,
2599 id
, key_type
, key_size
,
2600 key
, hlid
, tx_seq_32
,
2608 static const u8 bcast_addr
[ETH_ALEN
] = {
2609 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2612 addr
= sta
? sta
->addr
: bcast_addr
;
2614 if (is_zero_ether_addr(addr
)) {
2615 /* We dont support TX only encryption */
2619 /* The wl1271 does not allow to remove unicast keys - they
2620 will be cleared automatically on next CMD_JOIN. Ignore the
2621 request silently, as we dont want the mac80211 to emit
2622 an error message. */
2623 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
2626 ret
= wl1271_cmd_set_sta_key(wl
, action
,
2627 id
, key_type
, key_size
,
2628 key
, addr
, tx_seq_32
,
2633 /* the default WEP key needs to be configured at least once */
2634 if (key_type
== KEY_WEP
) {
2635 ret
= wl1271_cmd_set_sta_default_wep_key(wl
,
2645 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
2646 struct ieee80211_vif
*vif
,
2647 struct ieee80211_sta
*sta
,
2648 struct ieee80211_key_conf
*key_conf
)
2650 struct wl1271
*wl
= hw
->priv
;
2656 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
2658 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
2659 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2660 key_conf
->cipher
, key_conf
->keyidx
,
2661 key_conf
->keylen
, key_conf
->flags
);
2662 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
2664 mutex_lock(&wl
->mutex
);
2666 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2671 ret
= wl1271_ps_elp_wakeup(wl
);
2675 switch (key_conf
->cipher
) {
2676 case WLAN_CIPHER_SUITE_WEP40
:
2677 case WLAN_CIPHER_SUITE_WEP104
:
2680 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2682 case WLAN_CIPHER_SUITE_TKIP
:
2683 key_type
= KEY_TKIP
;
2685 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2686 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2687 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2689 case WLAN_CIPHER_SUITE_CCMP
:
2692 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2693 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2694 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2696 case WL1271_CIPHER_SUITE_GEM
:
2698 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2699 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2702 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
2710 ret
= wl1271_set_key(wl
, KEY_ADD_OR_REPLACE
,
2711 key_conf
->keyidx
, key_type
,
2712 key_conf
->keylen
, key_conf
->key
,
2713 tx_seq_32
, tx_seq_16
, sta
);
2715 wl1271_error("Could not add or replace key");
2721 ret
= wl1271_set_key(wl
, KEY_REMOVE
,
2722 key_conf
->keyidx
, key_type
,
2723 key_conf
->keylen
, key_conf
->key
,
2726 wl1271_error("Could not remove key");
2732 wl1271_error("Unsupported key cmd 0x%x", cmd
);
2738 wl1271_ps_elp_sleep(wl
);
2741 mutex_unlock(&wl
->mutex
);
2746 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
2747 struct ieee80211_vif
*vif
,
2748 struct cfg80211_scan_request
*req
)
2750 struct wl1271
*wl
= hw
->priv
;
2755 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
2758 ssid
= req
->ssids
[0].ssid
;
2759 len
= req
->ssids
[0].ssid_len
;
2762 mutex_lock(&wl
->mutex
);
2764 if (wl
->state
== WL1271_STATE_OFF
) {
2766 * We cannot return -EBUSY here because cfg80211 will expect
2767 * a call to ieee80211_scan_completed if we do - in this case
2768 * there won't be any call.
2774 ret
= wl1271_ps_elp_wakeup(wl
);
2778 ret
= wl1271_scan(hw
->priv
, ssid
, len
, req
);
2780 wl1271_ps_elp_sleep(wl
);
2783 mutex_unlock(&wl
->mutex
);
2788 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw
*hw
,
2789 struct ieee80211_vif
*vif
)
2791 struct wl1271
*wl
= hw
->priv
;
2794 wl1271_debug(DEBUG_MAC80211
, "mac80211 cancel hw scan");
2796 mutex_lock(&wl
->mutex
);
2798 if (wl
->state
== WL1271_STATE_OFF
)
2801 if (wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
)
2804 ret
= wl1271_ps_elp_wakeup(wl
);
2808 if (wl
->scan
.state
!= WL1271_SCAN_STATE_DONE
) {
2809 ret
= wl1271_scan_stop(wl
);
2813 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
2814 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
2815 wl
->scan
.req
= NULL
;
2816 ieee80211_scan_completed(wl
->hw
, true);
2819 wl1271_ps_elp_sleep(wl
);
2821 mutex_unlock(&wl
->mutex
);
2823 cancel_delayed_work_sync(&wl
->scan_complete_work
);
2826 static int wl1271_op_sched_scan_start(struct ieee80211_hw
*hw
,
2827 struct ieee80211_vif
*vif
,
2828 struct cfg80211_sched_scan_request
*req
,
2829 struct ieee80211_sched_scan_ies
*ies
)
2831 struct wl1271
*wl
= hw
->priv
;
2834 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_start");
2836 mutex_lock(&wl
->mutex
);
2838 ret
= wl1271_ps_elp_wakeup(wl
);
2842 ret
= wl1271_scan_sched_scan_config(wl
, req
, ies
);
2846 ret
= wl1271_scan_sched_scan_start(wl
);
2850 wl
->sched_scanning
= true;
2853 wl1271_ps_elp_sleep(wl
);
2855 mutex_unlock(&wl
->mutex
);
2859 static void wl1271_op_sched_scan_stop(struct ieee80211_hw
*hw
,
2860 struct ieee80211_vif
*vif
)
2862 struct wl1271
*wl
= hw
->priv
;
2865 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_stop");
2867 mutex_lock(&wl
->mutex
);
2869 ret
= wl1271_ps_elp_wakeup(wl
);
2873 wl1271_scan_sched_scan_stop(wl
);
2875 wl1271_ps_elp_sleep(wl
);
2877 mutex_unlock(&wl
->mutex
);
2880 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
2882 struct wl1271
*wl
= hw
->priv
;
2885 mutex_lock(&wl
->mutex
);
2887 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2892 ret
= wl1271_ps_elp_wakeup(wl
);
2896 ret
= wl1271_acx_frag_threshold(wl
, value
);
2898 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
2900 wl1271_ps_elp_sleep(wl
);
2903 mutex_unlock(&wl
->mutex
);
2908 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
2910 struct wl1271
*wl
= hw
->priv
;
2913 mutex_lock(&wl
->mutex
);
2915 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2920 ret
= wl1271_ps_elp_wakeup(wl
);
2924 ret
= wl1271_acx_rts_threshold(wl
, value
);
2926 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
2928 wl1271_ps_elp_sleep(wl
);
2931 mutex_unlock(&wl
->mutex
);
2936 static int wl1271_ssid_set(struct wl1271
*wl
, struct sk_buff
*skb
,
2940 const u8
*ptr
= cfg80211_find_ie(WLAN_EID_SSID
, skb
->data
+ offset
,
2944 wl1271_error("No SSID in IEs!");
2949 if (ssid_len
> IEEE80211_MAX_SSID_LEN
) {
2950 wl1271_error("SSID is too long!");
2954 wl
->ssid_len
= ssid_len
;
2955 memcpy(wl
->ssid
, ptr
+2, ssid_len
);
2959 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
2960 struct ieee80211_bss_conf
*bss_conf
,
2965 if (changed
& BSS_CHANGED_ERP_SLOT
) {
2966 if (bss_conf
->use_short_slot
)
2967 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
2969 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
2971 wl1271_warning("Set slot time failed %d", ret
);
2976 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
2977 if (bss_conf
->use_short_preamble
)
2978 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
2980 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
2983 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
2984 if (bss_conf
->use_cts_prot
)
2985 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
2987 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
2989 wl1271_warning("Set ctsprotect failed %d", ret
);
2998 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
2999 struct ieee80211_vif
*vif
,
3000 struct ieee80211_bss_conf
*bss_conf
,
3003 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
3006 if ((changed
& BSS_CHANGED_BEACON_INT
)) {
3007 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
3008 bss_conf
->beacon_int
);
3010 wl
->beacon_int
= bss_conf
->beacon_int
;
3013 if ((changed
& BSS_CHANGED_BEACON
)) {
3014 struct ieee80211_hdr
*hdr
;
3015 int ieoffset
= offsetof(struct ieee80211_mgmt
,
3017 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
3023 wl1271_debug(DEBUG_MASTER
, "beacon updated");
3025 ret
= wl1271_ssid_set(wl
, beacon
, ieoffset
);
3027 dev_kfree_skb(beacon
);
3030 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
3032 ret
= wl1271_cmd_template_set(wl
, tmpl_id
,
3035 wl1271_tx_min_rate_get(wl
));
3037 dev_kfree_skb(beacon
);
3041 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
3042 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
3043 IEEE80211_STYPE_PROBE_RESP
);
3045 tmpl_id
= is_ap
? CMD_TEMPL_AP_PROBE_RESPONSE
:
3046 CMD_TEMPL_PROBE_RESPONSE
;
3047 ret
= wl1271_cmd_template_set(wl
,
3051 wl1271_tx_min_rate_get(wl
));
3052 dev_kfree_skb(beacon
);
3061 /* AP mode changes */
3062 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
3063 struct ieee80211_vif
*vif
,
3064 struct ieee80211_bss_conf
*bss_conf
,
3069 if ((changed
& BSS_CHANGED_BASIC_RATES
)) {
3070 u32 rates
= bss_conf
->basic_rates
;
3072 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
);
3073 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3075 ret
= wl1271_init_ap_rates(wl
);
3077 wl1271_error("AP rate policy change failed %d", ret
);
3081 ret
= wl1271_ap_init_templates(wl
);
3086 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
3090 if ((changed
& BSS_CHANGED_BEACON_ENABLED
)) {
3091 if (bss_conf
->enable_beacon
) {
3092 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
3093 ret
= wl1271_cmd_start_bss(wl
);
3097 set_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
3098 wl1271_debug(DEBUG_AP
, "started AP");
3100 ret
= wl1271_ap_init_hwenc(wl
);
3105 if (test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
3106 ret
= wl1271_cmd_stop_bss(wl
);
3110 clear_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
3111 wl1271_debug(DEBUG_AP
, "stopped AP");
3116 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
3123 /* STA/IBSS mode changes */
3124 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
3125 struct ieee80211_vif
*vif
,
3126 struct ieee80211_bss_conf
*bss_conf
,
3129 bool do_join
= false, set_assoc
= false;
3130 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
3131 u32 sta_rate_set
= 0;
3133 struct ieee80211_sta
*sta
;
3134 bool sta_exists
= false;
3135 struct ieee80211_sta_ht_cap sta_ht_cap
;
3138 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
3144 if ((changed
& BSS_CHANGED_BEACON_INT
) && is_ibss
)
3147 /* Need to update the SSID (for filtering etc) */
3148 if ((changed
& BSS_CHANGED_BEACON
) && is_ibss
)
3151 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && is_ibss
) {
3152 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
3153 bss_conf
->enable_beacon
? "enabled" : "disabled");
3155 if (bss_conf
->enable_beacon
)
3156 wl
->set_bss_type
= BSS_TYPE_IBSS
;
3158 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
3162 if ((changed
& BSS_CHANGED_CQM
)) {
3163 bool enable
= false;
3164 if (bss_conf
->cqm_rssi_thold
)
3166 ret
= wl1271_acx_rssi_snr_trigger(wl
, enable
,
3167 bss_conf
->cqm_rssi_thold
,
3168 bss_conf
->cqm_rssi_hyst
);
3171 wl
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
3174 if ((changed
& BSS_CHANGED_BSSID
) &&
3176 * Now we know the correct bssid, so we send a new join command
3177 * and enable the BSSID filter
3179 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
3180 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
3182 if (!is_zero_ether_addr(wl
->bssid
)) {
3183 ret
= wl1271_cmd_build_null_data(wl
);
3187 ret
= wl1271_build_qos_null_data(wl
);
3191 /* filter out all packets not from this BSSID */
3192 wl1271_configure_filters(wl
, 0);
3194 /* Need to update the BSSID (for filtering etc) */
3200 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
3202 /* save the supp_rates of the ap */
3203 sta_rate_set
= sta
->supp_rates
[wl
->hw
->conf
.channel
->band
];
3204 if (sta
->ht_cap
.ht_supported
)
3206 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
);
3207 sta_ht_cap
= sta
->ht_cap
;
3213 /* handle new association with HT and HT information change */
3214 if ((changed
& BSS_CHANGED_HT
) &&
3215 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
3216 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
3219 wl1271_warning("Set ht cap true failed %d",
3223 ret
= wl1271_acx_set_ht_information(wl
,
3224 bss_conf
->ht_operation_mode
);
3226 wl1271_warning("Set ht information failed %d",
3231 /* handle new association without HT and disassociation */
3232 else if (changed
& BSS_CHANGED_ASSOC
) {
3233 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
3236 wl1271_warning("Set ht cap false failed %d",
3243 if ((changed
& BSS_CHANGED_ASSOC
)) {
3244 if (bss_conf
->assoc
) {
3247 wl
->aid
= bss_conf
->aid
;
3250 wl
->ps_poll_failures
= 0;
3253 * use basic rates from AP, and determine lowest rate
3254 * to use with control frames.
3256 rates
= bss_conf
->basic_rates
;
3257 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
3259 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3261 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
,
3263 ret
= wl1271_acx_sta_rate_policies(wl
);
3268 * with wl1271, we don't need to update the
3269 * beacon_int and dtim_period, because the firmware
3270 * updates it by itself when the first beacon is
3271 * received after a join.
3273 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
3278 * Get a template for hardware connection maintenance
3280 dev_kfree_skb(wl
->probereq
);
3281 wl
->probereq
= wl1271_cmd_build_ap_probe_req(wl
, NULL
);
3282 ieoffset
= offsetof(struct ieee80211_mgmt
,
3283 u
.probe_req
.variable
);
3284 wl1271_ssid_set(wl
, wl
->probereq
, ieoffset
);
3286 /* enable the connection monitoring feature */
3287 ret
= wl1271_acx_conn_monit_params(wl
, true);
3291 /* If we want to go in PSM but we're not there yet */
3292 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
3293 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
3294 enum wl1271_cmd_ps_mode mode
;
3296 mode
= STATION_POWER_SAVE_MODE
;
3297 ret
= wl1271_ps_set_mode(wl
, mode
,
3304 /* use defaults when not associated */
3306 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED
,
3308 clear_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
);
3311 /* free probe-request template */
3312 dev_kfree_skb(wl
->probereq
);
3313 wl
->probereq
= NULL
;
3315 /* re-enable dynamic ps - just in case */
3316 ieee80211_enable_dyn_ps(wl
->vif
);
3318 /* revert back to minimum rates for the current band */
3319 wl1271_set_band_rate(wl
);
3320 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3321 ret
= wl1271_acx_sta_rate_policies(wl
);
3325 /* disable connection monitor features */
3326 ret
= wl1271_acx_conn_monit_params(wl
, false);
3328 /* Disable the keep-alive feature */
3329 ret
= wl1271_acx_keep_alive_mode(wl
, false);
3333 /* restore the bssid filter and go to dummy bssid */
3336 wl1271_dummy_join(wl
);
3341 if (changed
& BSS_CHANGED_IBSS
) {
3342 wl1271_debug(DEBUG_ADHOC
, "ibss_joined: %d",
3343 bss_conf
->ibss_joined
);
3345 if (bss_conf
->ibss_joined
) {
3346 u32 rates
= bss_conf
->basic_rates
;
3347 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
3349 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3351 /* by default, use 11b rates */
3352 wl
->rate_set
= CONF_TX_IBSS_DEFAULT_RATES
;
3353 ret
= wl1271_acx_sta_rate_policies(wl
);
3359 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
3363 if (changed
& BSS_CHANGED_ARP_FILTER
) {
3364 __be32 addr
= bss_conf
->arp_addr_list
[0];
3365 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
3367 if (bss_conf
->arp_addr_cnt
== 1 &&
3368 bss_conf
->arp_filter_enabled
) {
3370 * The template should have been configured only upon
3371 * association. however, it seems that the correct ip
3372 * isn't being set (when sending), so we have to
3373 * reconfigure the template upon every ip change.
3375 ret
= wl1271_cmd_build_arp_rsp(wl
, addr
);
3377 wl1271_warning("build arp rsp failed: %d", ret
);
3381 ret
= wl1271_acx_arp_ip_filter(wl
,
3382 ACX_ARP_FILTER_ARP_FILTERING
,
3385 ret
= wl1271_acx_arp_ip_filter(wl
, 0, addr
);
3392 ret
= wl1271_join(wl
, set_assoc
);
3394 wl1271_warning("cmd join failed %d", ret
);
3397 wl1271_check_operstate(wl
, ieee80211_get_operstate(vif
));
3404 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
3405 struct ieee80211_vif
*vif
,
3406 struct ieee80211_bss_conf
*bss_conf
,
3409 struct wl1271
*wl
= hw
->priv
;
3410 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
3413 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed 0x%x",
3416 mutex_lock(&wl
->mutex
);
3418 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3421 ret
= wl1271_ps_elp_wakeup(wl
);
3426 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
3428 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
3430 wl1271_ps_elp_sleep(wl
);
3433 mutex_unlock(&wl
->mutex
);
3436 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
, u16 queue
,
3437 const struct ieee80211_tx_queue_params
*params
)
3439 struct wl1271
*wl
= hw
->priv
;
3443 mutex_lock(&wl
->mutex
);
3445 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
3448 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
3450 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
3452 if (wl
->state
== WL1271_STATE_OFF
) {
3454 * If the state is off, the parameters will be recorded and
3455 * configured on init. This happens in AP-mode.
3457 struct conf_tx_ac_category
*conf_ac
=
3458 &wl
->conf
.tx
.ac_conf
[wl1271_tx_get_queue(queue
)];
3459 struct conf_tx_tid
*conf_tid
=
3460 &wl
->conf
.tx
.tid_conf
[wl1271_tx_get_queue(queue
)];
3462 conf_ac
->ac
= wl1271_tx_get_queue(queue
);
3463 conf_ac
->cw_min
= (u8
)params
->cw_min
;
3464 conf_ac
->cw_max
= params
->cw_max
;
3465 conf_ac
->aifsn
= params
->aifs
;
3466 conf_ac
->tx_op_limit
= params
->txop
<< 5;
3468 conf_tid
->queue_id
= wl1271_tx_get_queue(queue
);
3469 conf_tid
->channel_type
= CONF_CHANNEL_TYPE_EDCF
;
3470 conf_tid
->tsid
= wl1271_tx_get_queue(queue
);
3471 conf_tid
->ps_scheme
= ps_scheme
;
3472 conf_tid
->ack_policy
= CONF_ACK_POLICY_LEGACY
;
3473 conf_tid
->apsd_conf
[0] = 0;
3474 conf_tid
->apsd_conf
[1] = 0;
3478 ret
= wl1271_ps_elp_wakeup(wl
);
3483 * the txop is confed in units of 32us by the mac80211,
3486 ret
= wl1271_acx_ac_cfg(wl
, wl1271_tx_get_queue(queue
),
3487 params
->cw_min
, params
->cw_max
,
3488 params
->aifs
, params
->txop
<< 5);
3492 ret
= wl1271_acx_tid_cfg(wl
, wl1271_tx_get_queue(queue
),
3493 CONF_CHANNEL_TYPE_EDCF
,
3494 wl1271_tx_get_queue(queue
),
3495 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
3499 wl1271_ps_elp_sleep(wl
);
3502 mutex_unlock(&wl
->mutex
);
3507 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
)
3510 struct wl1271
*wl
= hw
->priv
;
3511 u64 mactime
= ULLONG_MAX
;
3514 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
3516 mutex_lock(&wl
->mutex
);
3518 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3521 ret
= wl1271_ps_elp_wakeup(wl
);
3525 ret
= wl1271_acx_tsf_info(wl
, &mactime
);
3530 wl1271_ps_elp_sleep(wl
);
3533 mutex_unlock(&wl
->mutex
);
3537 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
3538 struct survey_info
*survey
)
3540 struct wl1271
*wl
= hw
->priv
;
3541 struct ieee80211_conf
*conf
= &hw
->conf
;
3546 survey
->channel
= conf
->channel
;
3547 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
3548 survey
->noise
= wl
->noise
;
3553 static int wl1271_allocate_sta(struct wl1271
*wl
,
3554 struct ieee80211_sta
*sta
,
3557 struct wl1271_station
*wl_sta
;
3560 id
= find_first_zero_bit(wl
->ap_hlid_map
, AP_MAX_STATIONS
);
3561 if (id
>= AP_MAX_STATIONS
) {
3562 wl1271_warning("could not allocate HLID - too much stations");
3566 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3567 __set_bit(id
, wl
->ap_hlid_map
);
3568 wl_sta
->hlid
= WL1271_AP_STA_HLID_START
+ id
;
3569 *hlid
= wl_sta
->hlid
;
3570 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
3574 static void wl1271_free_sta(struct wl1271
*wl
, u8 hlid
)
3576 int id
= hlid
- WL1271_AP_STA_HLID_START
;
3578 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3581 __clear_bit(id
, wl
->ap_hlid_map
);
3582 memset(wl
->links
[hlid
].addr
, 0, ETH_ALEN
);
3583 wl1271_tx_reset_link_queues(wl
, hlid
);
3584 __clear_bit(hlid
, &wl
->ap_ps_map
);
3585 __clear_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
3588 bool wl1271_is_active_sta(struct wl1271
*wl
, u8 hlid
)
3590 int id
= hlid
- WL1271_AP_STA_HLID_START
;
3591 return test_bit(id
, wl
->ap_hlid_map
);
3594 static int wl1271_op_sta_add(struct ieee80211_hw
*hw
,
3595 struct ieee80211_vif
*vif
,
3596 struct ieee80211_sta
*sta
)
3598 struct wl1271
*wl
= hw
->priv
;
3602 mutex_lock(&wl
->mutex
);
3604 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3607 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3610 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
3612 ret
= wl1271_allocate_sta(wl
, sta
, &hlid
);
3616 ret
= wl1271_ps_elp_wakeup(wl
);
3620 ret
= wl1271_cmd_add_sta(wl
, sta
, hlid
);
3625 wl1271_ps_elp_sleep(wl
);
3629 wl1271_free_sta(wl
, hlid
);
3632 mutex_unlock(&wl
->mutex
);
3636 static int wl1271_op_sta_remove(struct ieee80211_hw
*hw
,
3637 struct ieee80211_vif
*vif
,
3638 struct ieee80211_sta
*sta
)
3640 struct wl1271
*wl
= hw
->priv
;
3641 struct wl1271_station
*wl_sta
;
3644 mutex_lock(&wl
->mutex
);
3646 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3649 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3652 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
3654 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3655 id
= wl_sta
->hlid
- WL1271_AP_STA_HLID_START
;
3656 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3659 ret
= wl1271_ps_elp_wakeup(wl
);
3663 ret
= wl1271_cmd_remove_sta(wl
, wl_sta
->hlid
);
3667 wl1271_free_sta(wl
, wl_sta
->hlid
);
3670 wl1271_ps_elp_sleep(wl
);
3673 mutex_unlock(&wl
->mutex
);
3677 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
3678 struct ieee80211_vif
*vif
,
3679 enum ieee80211_ampdu_mlme_action action
,
3680 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
3683 struct wl1271
*wl
= hw
->priv
;
3686 mutex_lock(&wl
->mutex
);
3688 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
3693 ret
= wl1271_ps_elp_wakeup(wl
);
3697 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu: Rx tid %d action %d",
3701 case IEEE80211_AMPDU_RX_START
:
3702 if ((wl
->ba_support
) && (wl
->ba_allowed
)) {
3703 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, *ssn
,
3706 wl
->ba_rx_bitmap
|= BIT(tid
);
3712 case IEEE80211_AMPDU_RX_STOP
:
3713 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, 0, false);
3715 wl
->ba_rx_bitmap
&= ~BIT(tid
);
3719 * The BA initiator session management in FW independently.
3720 * Falling break here on purpose for all TX APDU commands.
3722 case IEEE80211_AMPDU_TX_START
:
3723 case IEEE80211_AMPDU_TX_STOP
:
3724 case IEEE80211_AMPDU_TX_OPERATIONAL
:
3729 wl1271_error("Incorrect ampdu action id=%x\n", action
);
3733 wl1271_ps_elp_sleep(wl
);
3736 mutex_unlock(&wl
->mutex
);
3741 static bool wl1271_tx_frames_pending(struct ieee80211_hw
*hw
)
3743 struct wl1271
*wl
= hw
->priv
;
3746 mutex_lock(&wl
->mutex
);
3748 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3751 /* packets are considered pending if in the TX queue or the FW */
3752 ret
= (wl
->tx_queue_count
> 0) || (wl
->tx_frames_cnt
> 0);
3754 /* the above is appropriate for STA mode for PS purposes */
3755 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
3758 mutex_unlock(&wl
->mutex
);
3763 /* can't be const, mac80211 writes to this */
3764 static struct ieee80211_rate wl1271_rates
[] = {
3766 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
3767 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
3769 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
3770 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
3771 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3773 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
3774 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
3775 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3777 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
3778 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
3779 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3781 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3782 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3784 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3785 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3787 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3788 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3790 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3791 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3793 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3794 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3796 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3797 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3799 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3800 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3802 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3803 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3806 /* can't be const, mac80211 writes to this */
3807 static struct ieee80211_channel wl1271_channels
[] = {
3808 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
3809 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
3810 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
3811 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
3812 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
3813 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
3814 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
3815 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
3816 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
3817 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
3818 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
3819 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
3820 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
3821 { .hw_value
= 14, .center_freq
= 2484, .max_power
= 25 },
3824 /* mapping to indexes for wl1271_rates */
3825 static const u8 wl1271_rate_to_idx_2ghz
[] = {
3826 /* MCS rates are used only with 11n */
3827 7, /* CONF_HW_RXTX_RATE_MCS7 */
3828 6, /* CONF_HW_RXTX_RATE_MCS6 */
3829 5, /* CONF_HW_RXTX_RATE_MCS5 */
3830 4, /* CONF_HW_RXTX_RATE_MCS4 */
3831 3, /* CONF_HW_RXTX_RATE_MCS3 */
3832 2, /* CONF_HW_RXTX_RATE_MCS2 */
3833 1, /* CONF_HW_RXTX_RATE_MCS1 */
3834 0, /* CONF_HW_RXTX_RATE_MCS0 */
3836 11, /* CONF_HW_RXTX_RATE_54 */
3837 10, /* CONF_HW_RXTX_RATE_48 */
3838 9, /* CONF_HW_RXTX_RATE_36 */
3839 8, /* CONF_HW_RXTX_RATE_24 */
3841 /* TI-specific rate */
3842 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3844 7, /* CONF_HW_RXTX_RATE_18 */
3845 6, /* CONF_HW_RXTX_RATE_12 */
3846 3, /* CONF_HW_RXTX_RATE_11 */
3847 5, /* CONF_HW_RXTX_RATE_9 */
3848 4, /* CONF_HW_RXTX_RATE_6 */
3849 2, /* CONF_HW_RXTX_RATE_5_5 */
3850 1, /* CONF_HW_RXTX_RATE_2 */
3851 0 /* CONF_HW_RXTX_RATE_1 */
3854 /* 11n STA capabilities */
3855 #define HW_RX_HIGHEST_RATE 72
3857 #ifdef CONFIG_WL12XX_HT
3858 #define WL12XX_HT_CAP { \
3859 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3860 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3861 .ht_supported = true, \
3862 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3863 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3865 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3866 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3867 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3871 #define WL12XX_HT_CAP { \
3872 .ht_supported = false, \
3876 /* can't be const, mac80211 writes to this */
3877 static struct ieee80211_supported_band wl1271_band_2ghz
= {
3878 .channels
= wl1271_channels
,
3879 .n_channels
= ARRAY_SIZE(wl1271_channels
),
3880 .bitrates
= wl1271_rates
,
3881 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
3882 .ht_cap
= WL12XX_HT_CAP
,
3885 /* 5 GHz data rates for WL1273 */
3886 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
3888 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3889 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3891 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3892 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3894 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3895 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3897 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3898 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3900 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3901 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3903 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3904 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3906 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3907 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3909 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3910 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3913 /* 5 GHz band channels for WL1273 */
3914 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
3915 { .hw_value
= 7, .center_freq
= 5035},
3916 { .hw_value
= 8, .center_freq
= 5040},
3917 { .hw_value
= 9, .center_freq
= 5045},
3918 { .hw_value
= 11, .center_freq
= 5055},
3919 { .hw_value
= 12, .center_freq
= 5060},
3920 { .hw_value
= 16, .center_freq
= 5080},
3921 { .hw_value
= 34, .center_freq
= 5170},
3922 { .hw_value
= 36, .center_freq
= 5180},
3923 { .hw_value
= 38, .center_freq
= 5190},
3924 { .hw_value
= 40, .center_freq
= 5200},
3925 { .hw_value
= 42, .center_freq
= 5210},
3926 { .hw_value
= 44, .center_freq
= 5220},
3927 { .hw_value
= 46, .center_freq
= 5230},
3928 { .hw_value
= 48, .center_freq
= 5240},
3929 { .hw_value
= 52, .center_freq
= 5260},
3930 { .hw_value
= 56, .center_freq
= 5280},
3931 { .hw_value
= 60, .center_freq
= 5300},
3932 { .hw_value
= 64, .center_freq
= 5320},
3933 { .hw_value
= 100, .center_freq
= 5500},
3934 { .hw_value
= 104, .center_freq
= 5520},
3935 { .hw_value
= 108, .center_freq
= 5540},
3936 { .hw_value
= 112, .center_freq
= 5560},
3937 { .hw_value
= 116, .center_freq
= 5580},
3938 { .hw_value
= 120, .center_freq
= 5600},
3939 { .hw_value
= 124, .center_freq
= 5620},
3940 { .hw_value
= 128, .center_freq
= 5640},
3941 { .hw_value
= 132, .center_freq
= 5660},
3942 { .hw_value
= 136, .center_freq
= 5680},
3943 { .hw_value
= 140, .center_freq
= 5700},
3944 { .hw_value
= 149, .center_freq
= 5745},
3945 { .hw_value
= 153, .center_freq
= 5765},
3946 { .hw_value
= 157, .center_freq
= 5785},
3947 { .hw_value
= 161, .center_freq
= 5805},
3948 { .hw_value
= 165, .center_freq
= 5825},
3951 /* mapping to indexes for wl1271_rates_5ghz */
3952 static const u8 wl1271_rate_to_idx_5ghz
[] = {
3953 /* MCS rates are used only with 11n */
3954 7, /* CONF_HW_RXTX_RATE_MCS7 */
3955 6, /* CONF_HW_RXTX_RATE_MCS6 */
3956 5, /* CONF_HW_RXTX_RATE_MCS5 */
3957 4, /* CONF_HW_RXTX_RATE_MCS4 */
3958 3, /* CONF_HW_RXTX_RATE_MCS3 */
3959 2, /* CONF_HW_RXTX_RATE_MCS2 */
3960 1, /* CONF_HW_RXTX_RATE_MCS1 */
3961 0, /* CONF_HW_RXTX_RATE_MCS0 */
3963 7, /* CONF_HW_RXTX_RATE_54 */
3964 6, /* CONF_HW_RXTX_RATE_48 */
3965 5, /* CONF_HW_RXTX_RATE_36 */
3966 4, /* CONF_HW_RXTX_RATE_24 */
3968 /* TI-specific rate */
3969 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3971 3, /* CONF_HW_RXTX_RATE_18 */
3972 2, /* CONF_HW_RXTX_RATE_12 */
3973 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_11 */
3974 1, /* CONF_HW_RXTX_RATE_9 */
3975 0, /* CONF_HW_RXTX_RATE_6 */
3976 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_5_5 */
3977 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_2 */
3978 CONF_HW_RXTX_RATE_UNSUPPORTED
/* CONF_HW_RXTX_RATE_1 */
3981 static struct ieee80211_supported_band wl1271_band_5ghz
= {
3982 .channels
= wl1271_channels_5ghz
,
3983 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
3984 .bitrates
= wl1271_rates_5ghz
,
3985 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
3986 .ht_cap
= WL12XX_HT_CAP
,
3989 static const u8
*wl1271_band_rate_to_idx
[] = {
3990 [IEEE80211_BAND_2GHZ
] = wl1271_rate_to_idx_2ghz
,
3991 [IEEE80211_BAND_5GHZ
] = wl1271_rate_to_idx_5ghz
3994 static const struct ieee80211_ops wl1271_ops
= {
3995 .start
= wl1271_op_start
,
3996 .stop
= wl1271_op_stop
,
3997 .add_interface
= wl1271_op_add_interface
,
3998 .remove_interface
= wl1271_op_remove_interface
,
4000 .suspend
= wl1271_op_suspend
,
4001 .resume
= wl1271_op_resume
,
4003 .config
= wl1271_op_config
,
4004 .prepare_multicast
= wl1271_op_prepare_multicast
,
4005 .configure_filter
= wl1271_op_configure_filter
,
4007 .set_key
= wl1271_op_set_key
,
4008 .hw_scan
= wl1271_op_hw_scan
,
4009 .cancel_hw_scan
= wl1271_op_cancel_hw_scan
,
4010 .sched_scan_start
= wl1271_op_sched_scan_start
,
4011 .sched_scan_stop
= wl1271_op_sched_scan_stop
,
4012 .bss_info_changed
= wl1271_op_bss_info_changed
,
4013 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
4014 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
4015 .conf_tx
= wl1271_op_conf_tx
,
4016 .get_tsf
= wl1271_op_get_tsf
,
4017 .get_survey
= wl1271_op_get_survey
,
4018 .sta_add
= wl1271_op_sta_add
,
4019 .sta_remove
= wl1271_op_sta_remove
,
4020 .ampdu_action
= wl1271_op_ampdu_action
,
4021 .tx_frames_pending
= wl1271_tx_frames_pending
,
4022 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
4026 u8
wl1271_rate_to_idx(int rate
, enum ieee80211_band band
)
4030 BUG_ON(band
>= sizeof(wl1271_band_rate_to_idx
)/sizeof(u8
*));
4032 if (unlikely(rate
>= CONF_HW_RXTX_RATE_MAX
)) {
4033 wl1271_error("Illegal RX rate from HW: %d", rate
);
4037 idx
= wl1271_band_rate_to_idx
[band
][rate
];
4038 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
4039 wl1271_error("Unsupported RX rate from HW: %d", rate
);
4046 static ssize_t
wl1271_sysfs_show_bt_coex_state(struct device
*dev
,
4047 struct device_attribute
*attr
,
4050 struct wl1271
*wl
= dev_get_drvdata(dev
);
4055 mutex_lock(&wl
->mutex
);
4056 len
= snprintf(buf
, len
, "%d\n\n0 - off\n1 - on\n",
4058 mutex_unlock(&wl
->mutex
);
4064 static ssize_t
wl1271_sysfs_store_bt_coex_state(struct device
*dev
,
4065 struct device_attribute
*attr
,
4066 const char *buf
, size_t count
)
4068 struct wl1271
*wl
= dev_get_drvdata(dev
);
4072 ret
= kstrtoul(buf
, 10, &res
);
4074 wl1271_warning("incorrect value written to bt_coex_mode");
4078 mutex_lock(&wl
->mutex
);
4082 if (res
== wl
->sg_enabled
)
4085 wl
->sg_enabled
= res
;
4087 if (wl
->state
== WL1271_STATE_OFF
)
4090 ret
= wl1271_ps_elp_wakeup(wl
);
4094 wl1271_acx_sg_enable(wl
, wl
->sg_enabled
);
4095 wl1271_ps_elp_sleep(wl
);
4098 mutex_unlock(&wl
->mutex
);
4102 static DEVICE_ATTR(bt_coex_state
, S_IRUGO
| S_IWUSR
,
4103 wl1271_sysfs_show_bt_coex_state
,
4104 wl1271_sysfs_store_bt_coex_state
);
4106 static ssize_t
wl1271_sysfs_show_hw_pg_ver(struct device
*dev
,
4107 struct device_attribute
*attr
,
4110 struct wl1271
*wl
= dev_get_drvdata(dev
);
4115 mutex_lock(&wl
->mutex
);
4116 if (wl
->hw_pg_ver
>= 0)
4117 len
= snprintf(buf
, len
, "%d\n", wl
->hw_pg_ver
);
4119 len
= snprintf(buf
, len
, "n/a\n");
4120 mutex_unlock(&wl
->mutex
);
4125 static DEVICE_ATTR(hw_pg_ver
, S_IRUGO
| S_IWUSR
,
4126 wl1271_sysfs_show_hw_pg_ver
, NULL
);
4128 static ssize_t
wl1271_sysfs_read_fwlog(struct file
*filp
, struct kobject
*kobj
,
4129 struct bin_attribute
*bin_attr
,
4130 char *buffer
, loff_t pos
, size_t count
)
4132 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
4133 struct wl1271
*wl
= dev_get_drvdata(dev
);
4137 ret
= mutex_lock_interruptible(&wl
->mutex
);
4139 return -ERESTARTSYS
;
4141 /* Let only one thread read the log at a time, blocking others */
4142 while (wl
->fwlog_size
== 0) {
4145 prepare_to_wait_exclusive(&wl
->fwlog_waitq
,
4147 TASK_INTERRUPTIBLE
);
4149 if (wl
->fwlog_size
!= 0) {
4150 finish_wait(&wl
->fwlog_waitq
, &wait
);
4154 mutex_unlock(&wl
->mutex
);
4157 finish_wait(&wl
->fwlog_waitq
, &wait
);
4159 if (signal_pending(current
))
4160 return -ERESTARTSYS
;
4162 ret
= mutex_lock_interruptible(&wl
->mutex
);
4164 return -ERESTARTSYS
;
4167 /* Check if the fwlog is still valid */
4168 if (wl
->fwlog_size
< 0) {
4169 mutex_unlock(&wl
->mutex
);
4173 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4174 len
= min(count
, (size_t)wl
->fwlog_size
);
4175 wl
->fwlog_size
-= len
;
4176 memcpy(buffer
, wl
->fwlog
, len
);
4178 /* Make room for new messages */
4179 memmove(wl
->fwlog
, wl
->fwlog
+ len
, wl
->fwlog_size
);
4181 mutex_unlock(&wl
->mutex
);
4186 static struct bin_attribute fwlog_attr
= {
4187 .attr
= {.name
= "fwlog", .mode
= S_IRUSR
},
4188 .read
= wl1271_sysfs_read_fwlog
,
4191 int wl1271_register_hw(struct wl1271
*wl
)
4195 if (wl
->mac80211_registered
)
4198 ret
= wl1271_fetch_nvs(wl
);
4200 /* NOTE: The wl->nvs->nvs element must be first, in
4201 * order to simplify the casting, we assume it is at
4202 * the beginning of the wl->nvs structure.
4204 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
4206 wl
->mac_addr
[0] = nvs_ptr
[11];
4207 wl
->mac_addr
[1] = nvs_ptr
[10];
4208 wl
->mac_addr
[2] = nvs_ptr
[6];
4209 wl
->mac_addr
[3] = nvs_ptr
[5];
4210 wl
->mac_addr
[4] = nvs_ptr
[4];
4211 wl
->mac_addr
[5] = nvs_ptr
[3];
4214 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
4216 ret
= ieee80211_register_hw(wl
->hw
);
4218 wl1271_error("unable to register mac80211 hw: %d", ret
);
4222 wl
->mac80211_registered
= true;
4224 wl1271_debugfs_init(wl
);
4226 register_netdevice_notifier(&wl1271_dev_notifier
);
4228 wl1271_notice("loaded");
4232 EXPORT_SYMBOL_GPL(wl1271_register_hw
);
4234 void wl1271_unregister_hw(struct wl1271
*wl
)
4236 if (wl
->state
== WL1271_STATE_PLT
)
4237 __wl1271_plt_stop(wl
);
4239 unregister_netdevice_notifier(&wl1271_dev_notifier
);
4240 ieee80211_unregister_hw(wl
->hw
);
4241 wl
->mac80211_registered
= false;
4244 EXPORT_SYMBOL_GPL(wl1271_unregister_hw
);
4246 int wl1271_init_ieee80211(struct wl1271
*wl
)
4248 static const u32 cipher_suites
[] = {
4249 WLAN_CIPHER_SUITE_WEP40
,
4250 WLAN_CIPHER_SUITE_WEP104
,
4251 WLAN_CIPHER_SUITE_TKIP
,
4252 WLAN_CIPHER_SUITE_CCMP
,
4253 WL1271_CIPHER_SUITE_GEM
,
4256 /* The tx descriptor buffer and the TKIP space. */
4257 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
4258 sizeof(struct wl1271_tx_hw_descr
);
4261 /* FIXME: find a proper value */
4262 wl
->hw
->channel_change_time
= 10000;
4263 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
4265 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
4266 IEEE80211_HW_BEACON_FILTER
|
4267 IEEE80211_HW_SUPPORTS_PS
|
4268 IEEE80211_HW_SUPPORTS_UAPSD
|
4269 IEEE80211_HW_HAS_RATE_CONTROL
|
4270 IEEE80211_HW_CONNECTION_MONITOR
|
4271 IEEE80211_HW_SUPPORTS_CQM_RSSI
|
4272 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
4273 IEEE80211_HW_SPECTRUM_MGMT
|
4274 IEEE80211_HW_AP_LINK_PS
;
4276 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
4277 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
4279 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
4280 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
4281 wl
->hw
->wiphy
->max_scan_ssids
= 1;
4283 * Maximum length of elements in scanning probe request templates
4284 * should be the maximum length possible for a template, without
4285 * the IEEE80211 header of the template
4287 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
4288 sizeof(struct ieee80211_header
);
4290 /* make sure all our channels fit in the scanned_ch bitmask */
4291 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
4292 ARRAY_SIZE(wl1271_channels_5ghz
) >
4293 WL1271_MAX_CHANNELS
);
4295 * We keep local copies of the band structs because we need to
4296 * modify them on a per-device basis.
4298 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
4299 sizeof(wl1271_band_2ghz
));
4300 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
4301 sizeof(wl1271_band_5ghz
));
4303 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
4304 &wl
->bands
[IEEE80211_BAND_2GHZ
];
4305 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
4306 &wl
->bands
[IEEE80211_BAND_5GHZ
];
4309 wl
->hw
->max_rates
= 1;
4311 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
4313 SET_IEEE80211_DEV(wl
->hw
, wl1271_wl_to_dev(wl
));
4315 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
4317 wl
->hw
->max_rx_aggregation_subframes
= 8;
4321 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211
);
4323 #define WL1271_DEFAULT_CHANNEL 0
4325 struct ieee80211_hw
*wl1271_alloc_hw(void)
4327 struct ieee80211_hw
*hw
;
4328 struct platform_device
*plat_dev
= NULL
;
4333 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
4335 wl1271_error("could not alloc ieee80211_hw");
4340 plat_dev
= kmemdup(&wl1271_device
, sizeof(wl1271_device
), GFP_KERNEL
);
4342 wl1271_error("could not allocate platform_device");
4344 goto err_plat_alloc
;
4348 memset(wl
, 0, sizeof(*wl
));
4350 INIT_LIST_HEAD(&wl
->list
);
4353 wl
->plat_dev
= plat_dev
;
4355 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
4356 skb_queue_head_init(&wl
->tx_queue
[i
]);
4358 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
4359 for (j
= 0; j
< AP_MAX_LINKS
; j
++)
4360 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
4362 skb_queue_head_init(&wl
->deferred_rx_queue
);
4363 skb_queue_head_init(&wl
->deferred_tx_queue
);
4365 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
4366 INIT_DELAYED_WORK(&wl
->pspoll_work
, wl1271_pspoll_work
);
4367 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
4368 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
4369 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
4370 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
4371 INIT_WORK(&wl
->rx_streaming_enable_work
,
4372 wl1271_rx_streaming_enable_work
);
4373 INIT_WORK(&wl
->rx_streaming_disable_work
,
4374 wl1271_rx_streaming_disable_work
);
4376 wl
->freezable_wq
= create_freezable_workqueue("wl12xx_wq");
4377 if (!wl
->freezable_wq
) {
4382 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
4383 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
4384 wl
->default_key
= 0;
4386 wl
->rx_config
= WL1271_DEFAULT_STA_RX_CONFIG
;
4387 wl
->rx_filter
= WL1271_DEFAULT_STA_RX_FILTER
;
4388 wl
->psm_entry_retry
= 0;
4389 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
4390 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
4391 wl
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
4392 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
4393 wl
->band
= IEEE80211_BAND_2GHZ
;
4396 wl
->sg_enabled
= true;
4398 wl
->bss_type
= MAX_BSS_TYPE
;
4399 wl
->set_bss_type
= MAX_BSS_TYPE
;
4400 wl
->fw_bss_type
= MAX_BSS_TYPE
;
4401 wl
->last_tx_hlid
= 0;
4403 wl
->ap_fw_ps_map
= 0;
4405 wl
->platform_quirks
= 0;
4406 wl
->sched_scanning
= false;
4407 wl
->tx_security_seq
= 0;
4408 wl
->tx_security_last_seq_lsb
= 0;
4410 setup_timer(&wl
->rx_streaming_timer
, wl1271_rx_streaming_timer
,
4411 (unsigned long) wl
);
4413 init_waitqueue_head(&wl
->fwlog_waitq
);
4415 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
4416 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
4417 wl
->tx_frames
[i
] = NULL
;
4419 spin_lock_init(&wl
->wl_lock
);
4421 wl
->state
= WL1271_STATE_OFF
;
4422 mutex_init(&wl
->mutex
);
4424 /* Apply default driver configuration. */
4425 wl1271_conf_init(wl
);
4427 order
= get_order(WL1271_AGGR_BUFFER_SIZE
);
4428 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
4429 if (!wl
->aggr_buf
) {
4434 wl
->dummy_packet
= wl12xx_alloc_dummy_packet(wl
);
4435 if (!wl
->dummy_packet
) {
4440 /* Allocate one page for the FW log */
4441 wl
->fwlog
= (u8
*)get_zeroed_page(GFP_KERNEL
);
4444 goto err_dummy_packet
;
4447 /* Register platform device */
4448 ret
= platform_device_register(wl
->plat_dev
);
4450 wl1271_error("couldn't register platform device");
4453 dev_set_drvdata(&wl
->plat_dev
->dev
, wl
);
4455 /* Create sysfs file to control bt coex state */
4456 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4458 wl1271_error("failed to create sysfs file bt_coex_state");
4462 /* Create sysfs file to get HW PG version */
4463 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4465 wl1271_error("failed to create sysfs file hw_pg_ver");
4466 goto err_bt_coex_state
;
4469 /* Create sysfs file for the FW log */
4470 ret
= device_create_bin_file(&wl
->plat_dev
->dev
, &fwlog_attr
);
4472 wl1271_error("failed to create sysfs file fwlog");
4479 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4482 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4485 platform_device_unregister(wl
->plat_dev
);
4488 free_page((unsigned long)wl
->fwlog
);
4491 dev_kfree_skb(wl
->dummy_packet
);
4494 free_pages((unsigned long)wl
->aggr_buf
, order
);
4497 destroy_workqueue(wl
->freezable_wq
);
4500 wl1271_debugfs_exit(wl
);
4504 ieee80211_free_hw(hw
);
4508 return ERR_PTR(ret
);
4510 EXPORT_SYMBOL_GPL(wl1271_alloc_hw
);
4512 int wl1271_free_hw(struct wl1271
*wl
)
4514 /* Unblock any fwlog readers */
4515 mutex_lock(&wl
->mutex
);
4516 wl
->fwlog_size
= -1;
4517 wake_up_interruptible_all(&wl
->fwlog_waitq
);
4518 mutex_unlock(&wl
->mutex
);
4520 device_remove_bin_file(&wl
->plat_dev
->dev
, &fwlog_attr
);
4521 platform_device_unregister(wl
->plat_dev
);
4522 free_page((unsigned long)wl
->fwlog
);
4523 dev_kfree_skb(wl
->dummy_packet
);
4524 free_pages((unsigned long)wl
->aggr_buf
,
4525 get_order(WL1271_AGGR_BUFFER_SIZE
));
4526 kfree(wl
->plat_dev
);
4528 wl1271_debugfs_exit(wl
);
4535 kfree(wl
->fw_status
);
4536 kfree(wl
->tx_res_if
);
4537 destroy_workqueue(wl
->freezable_wq
);
4539 ieee80211_free_hw(wl
->hw
);
4543 EXPORT_SYMBOL_GPL(wl1271_free_hw
);
4545 u32 wl12xx_debug_level
= DEBUG_NONE
;
4546 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
4547 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
4548 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
4550 module_param_named(fwlog
, fwlog_param
, charp
, 0);
4551 MODULE_PARM_DESC(keymap
,
4552 "FW logger options: continuous, ondemand, dbgpins or disable");
4554 MODULE_LICENSE("GPL");
4555 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4556 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");