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
= wl12xx_acx_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
;
777 static void wl1271_irq_ps_regulate_link(struct wl1271
*wl
, u8 hlid
, u8 tx_blks
)
781 /* only regulate station links */
782 if (hlid
< WL1271_AP_STA_HLID_START
)
785 fw_ps
= test_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
788 * Wake up from high level PS if the STA is asleep with too little
789 * blocks in FW or if the STA is awake.
791 if (!fw_ps
|| tx_blks
< WL1271_PS_STA_MAX_BLOCKS
)
792 wl1271_ps_link_end(wl
, hlid
);
794 /* Start high-level PS if the STA is asleep with enough blocks in FW */
795 else if (fw_ps
&& tx_blks
>= WL1271_PS_STA_MAX_BLOCKS
)
796 wl1271_ps_link_start(wl
, hlid
, true);
799 static void wl1271_irq_update_links_status(struct wl1271
*wl
,
800 struct wl1271_fw_ap_status
*status
)
805 cur_fw_ps_map
= le32_to_cpu(status
->link_ps_bitmap
);
806 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
807 wl1271_debug(DEBUG_PSM
,
808 "link ps prev 0x%x cur 0x%x changed 0x%x",
809 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
810 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
812 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
815 for (hlid
= WL1271_AP_STA_HLID_START
; hlid
< AP_MAX_LINKS
; hlid
++) {
816 u8 cnt
= status
->tx_lnk_free_blks
[hlid
] -
817 wl
->links
[hlid
].prev_freed_blks
;
819 wl
->links
[hlid
].prev_freed_blks
=
820 status
->tx_lnk_free_blks
[hlid
];
821 wl
->links
[hlid
].allocated_blks
-= cnt
;
823 wl1271_irq_ps_regulate_link(wl
, hlid
,
824 wl
->links
[hlid
].allocated_blks
);
829 static void wl12xx_fw_status(struct wl1271
*wl
,
830 struct wl12xx_fw_status
*status
)
833 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
834 int avail
, freed_blocks
;
836 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
, sizeof(*status
), false);
838 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
839 "drv_rx_counter = %d, tx_results_counter = %d)",
841 status
->fw_rx_counter
,
842 status
->drv_rx_counter
,
843 status
->tx_results_counter
);
845 freed_blocks
= le32_to_cpu(status
->total_released_blks
) -
847 wl
->tx_blocks_freed
= le32_to_cpu(status
->total_released_blks
);
849 wl
->tx_allocated_blocks
-= freed_blocks
;
851 avail
= le32_to_cpu(status
->tx_total
) - wl
->tx_allocated_blocks
;
854 * The FW might change the total number of TX memblocks before
855 * we get a notification about blocks being released. Thus, the
856 * available blocks calculation might yield a temporary result
857 * which is lower than the actual available blocks. Keeping in
858 * mind that only blocks that were allocated can be moved from
859 * TX to RX, tx_blocks_available should never decrease here.
861 wl
->tx_blocks_available
= max((int)wl
->tx_blocks_available
,
864 /* if more blocks are available now, tx work can be scheduled */
865 if (wl
->tx_blocks_available
> old_tx_blk_count
)
866 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
868 /* for AP update num of allocated TX blocks per link and ps status */
869 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
871 wl1271_irq_update_links_status(wl
, status
);
875 /* update the host-chipset time offset */
877 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
878 (s64
)le32_to_cpu(status
->fw_localtime
);
881 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
885 /* Pass all received frames to the network stack */
886 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
887 ieee80211_rx_ni(wl
->hw
, skb
);
889 /* Return sent skbs to the network stack */
890 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
891 ieee80211_tx_status_ni(wl
->hw
, skb
);
894 static void wl1271_netstack_work(struct work_struct
*work
)
897 container_of(work
, struct wl1271
, netstack_work
);
900 wl1271_flush_deferred_work(wl
);
901 } while (skb_queue_len(&wl
->deferred_rx_queue
));
904 #define WL1271_IRQ_MAX_LOOPS 256
906 irqreturn_t
wl1271_irq(int irq
, void *cookie
)
910 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
911 struct wl1271
*wl
= (struct wl1271
*)cookie
;
913 unsigned int defer_count
;
916 /* TX might be handled here, avoid redundant work */
917 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
918 cancel_work_sync(&wl
->tx_work
);
921 * In case edge triggered interrupt must be used, we cannot iterate
922 * more than once without introducing race conditions with the hardirq.
924 if (wl
->platform_quirks
& WL12XX_PLATFORM_QUIRK_EDGE_IRQ
)
927 mutex_lock(&wl
->mutex
);
929 wl1271_debug(DEBUG_IRQ
, "IRQ work");
931 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
934 ret
= wl1271_ps_elp_wakeup(wl
);
938 while (!done
&& loopcount
--) {
940 * In order to avoid a race with the hardirq, clear the flag
941 * before acknowledging the chip. Since the mutex is held,
942 * wl1271_ps_elp_wakeup cannot be called concurrently.
944 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
945 smp_mb__after_clear_bit();
947 wl12xx_fw_status(wl
, wl
->fw_status
);
948 intr
= le32_to_cpu(wl
->fw_status
->intr
);
949 intr
&= WL1271_INTR_MASK
;
955 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
956 wl1271_error("watchdog interrupt received! "
957 "starting recovery.");
958 wl12xx_queue_recovery_work(wl
);
960 /* restarting the chip. ignore any other interrupt. */
964 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
965 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
967 wl12xx_rx(wl
, wl
->fw_status
);
969 /* Check if any tx blocks were freed */
970 spin_lock_irqsave(&wl
->wl_lock
, flags
);
971 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
972 wl1271_tx_total_queue_count(wl
) > 0) {
973 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
975 * In order to avoid starvation of the TX path,
976 * call the work function directly.
978 wl1271_tx_work_locked(wl
);
980 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
983 /* check for tx results */
984 if (wl
->fw_status
->tx_results_counter
!=
985 (wl
->tx_results_count
& 0xff))
986 wl1271_tx_complete(wl
);
988 /* Make sure the deferred queues don't get too long */
989 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
990 skb_queue_len(&wl
->deferred_rx_queue
);
991 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
992 wl1271_flush_deferred_work(wl
);
995 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
996 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
997 wl1271_event_handle(wl
, 0);
1000 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
1001 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
1002 wl1271_event_handle(wl
, 1);
1005 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
1006 wl1271_debug(DEBUG_IRQ
,
1007 "WL1271_ACX_INTR_INIT_COMPLETE");
1009 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
1010 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
1013 wl1271_ps_elp_sleep(wl
);
1016 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1017 /* In case TX was not handled here, queue TX work */
1018 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
1019 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1020 wl1271_tx_total_queue_count(wl
) > 0)
1021 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1022 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1024 mutex_unlock(&wl
->mutex
);
1028 EXPORT_SYMBOL_GPL(wl1271_irq
);
1030 static int wl1271_fetch_firmware(struct wl1271
*wl
)
1032 const struct firmware
*fw
;
1033 const char *fw_name
;
1036 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
1037 fw_name
= WL128X_FW_NAME
;
1039 fw_name
= WL127X_FW_NAME
;
1041 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
1043 ret
= request_firmware(&fw
, fw_name
, wl1271_wl_to_dev(wl
));
1046 wl1271_error("could not get firmware: %d", ret
);
1051 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1058 wl
->fw_len
= fw
->size
;
1059 wl
->fw
= vmalloc(wl
->fw_len
);
1062 wl1271_error("could not allocate memory for the firmware");
1067 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
1071 release_firmware(fw
);
1076 static int wl1271_fetch_nvs(struct wl1271
*wl
)
1078 const struct firmware
*fw
;
1081 ret
= request_firmware(&fw
, WL12XX_NVS_NAME
, wl1271_wl_to_dev(wl
));
1084 wl1271_error("could not get nvs file: %d", ret
);
1088 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
1091 wl1271_error("could not allocate memory for the nvs file");
1096 wl
->nvs_len
= fw
->size
;
1099 release_firmware(fw
);
1104 void wl12xx_queue_recovery_work(struct wl1271
*wl
)
1106 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1107 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
1110 size_t wl12xx_copy_fwlog(struct wl1271
*wl
, u8
*memblock
, size_t maxlen
)
1114 /* The FW log is a length-value list, find where the log end */
1115 while (len
< maxlen
) {
1116 if (memblock
[len
] == 0)
1118 if (len
+ memblock
[len
] + 1 > maxlen
)
1120 len
+= memblock
[len
] + 1;
1123 /* Make sure we have enough room */
1124 len
= min(len
, (size_t)(PAGE_SIZE
- wl
->fwlog_size
));
1126 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1127 memcpy(wl
->fwlog
+ wl
->fwlog_size
, memblock
, len
);
1128 wl
->fwlog_size
+= len
;
1133 static void wl12xx_read_fwlog_panic(struct wl1271
*wl
)
1139 if ((wl
->quirks
& WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED
) ||
1140 (wl
->conf
.fwlog
.mode
!= WL12XX_FWLOG_ON_DEMAND
) ||
1141 (wl
->conf
.fwlog
.mem_blocks
== 0))
1144 wl1271_info("Reading FW panic log");
1146 block
= kmalloc(WL12XX_HW_BLOCK_SIZE
, GFP_KERNEL
);
1151 * Make sure the chip is awake and the logger isn't active.
1152 * This might fail if the firmware hanged.
1154 if (!wl1271_ps_elp_wakeup(wl
))
1155 wl12xx_cmd_stop_fwlog(wl
);
1157 /* Read the first memory block address */
1158 wl12xx_fw_status(wl
, wl
->fw_status
);
1159 first_addr
= le32_to_cpu(wl
->fw_status
->log_start_addr
);
1163 /* Traverse the memory blocks linked list */
1166 memset(block
, 0, WL12XX_HW_BLOCK_SIZE
);
1167 wl1271_read_hwaddr(wl
, addr
, block
, WL12XX_HW_BLOCK_SIZE
,
1171 * Memory blocks are linked to one another. The first 4 bytes
1172 * of each memory block hold the hardware address of the next
1173 * one. The last memory block points to the first one.
1175 addr
= le32_to_cpup((__le32
*)block
);
1176 if (!wl12xx_copy_fwlog(wl
, block
+ sizeof(addr
),
1177 WL12XX_HW_BLOCK_SIZE
- sizeof(addr
)))
1179 } while (addr
&& (addr
!= first_addr
));
1181 wake_up_interruptible(&wl
->fwlog_waitq
);
1187 static void wl1271_recovery_work(struct work_struct
*work
)
1190 container_of(work
, struct wl1271
, recovery_work
);
1192 mutex_lock(&wl
->mutex
);
1194 if (wl
->state
!= WL1271_STATE_ON
)
1197 /* Avoid a recursive recovery */
1198 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
1200 wl12xx_read_fwlog_panic(wl
);
1202 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1203 wl
->chip
.fw_ver_str
, wl1271_read32(wl
, SCR_PAD4
));
1206 * Advance security sequence number to overcome potential progress
1207 * in the firmware during recovery. This doens't hurt if the network is
1210 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) ||
1211 test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
))
1212 wl
->tx_security_seq
+= WL1271_TX_SQN_POST_RECOVERY_PADDING
;
1214 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1215 ieee80211_connection_loss(wl
->vif
);
1217 /* Prevent spurious TX during FW restart */
1218 ieee80211_stop_queues(wl
->hw
);
1220 if (wl
->sched_scanning
) {
1221 ieee80211_sched_scan_stopped(wl
->hw
);
1222 wl
->sched_scanning
= false;
1225 /* reboot the chipset */
1226 __wl1271_op_remove_interface(wl
, false);
1228 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
1230 ieee80211_restart_hw(wl
->hw
);
1233 * Its safe to enable TX now - the queues are stopped after a request
1234 * to restart the HW.
1236 ieee80211_wake_queues(wl
->hw
);
1239 mutex_unlock(&wl
->mutex
);
1242 static void wl1271_fw_wakeup(struct wl1271
*wl
)
1246 elp_reg
= ELPCTRL_WAKE_UP
;
1247 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
1250 static int wl1271_setup(struct wl1271
*wl
)
1252 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
1256 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
1257 if (!wl
->tx_res_if
) {
1258 kfree(wl
->fw_status
);
1265 static int wl1271_chip_wakeup(struct wl1271
*wl
)
1267 struct wl1271_partition_set partition
;
1270 msleep(WL1271_PRE_POWER_ON_SLEEP
);
1271 ret
= wl1271_power_on(wl
);
1274 msleep(WL1271_POWER_ON_SLEEP
);
1275 wl1271_io_reset(wl
);
1278 /* We don't need a real memory partition here, because we only want
1279 * to use the registers at this point. */
1280 memset(&partition
, 0, sizeof(partition
));
1281 partition
.reg
.start
= REGISTERS_BASE
;
1282 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
1283 wl1271_set_partition(wl
, &partition
);
1285 /* ELP module wake up */
1286 wl1271_fw_wakeup(wl
);
1288 /* whal_FwCtrl_BootSm() */
1290 /* 0. read chip id from CHIP_ID */
1291 wl
->chip
.id
= wl1271_read32(wl
, CHIP_ID_B
);
1293 /* 1. check if chip id is valid */
1295 switch (wl
->chip
.id
) {
1296 case CHIP_ID_1271_PG10
:
1297 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1300 ret
= wl1271_setup(wl
);
1304 case CHIP_ID_1271_PG20
:
1305 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
1309 * 'end-of-transaction flag' and 'LPD mode flag'
1310 * should be set in wl127x AP mode only
1312 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1313 wl
->quirks
|= (WL12XX_QUIRK_END_OF_TRANSACTION
|
1314 WL12XX_QUIRK_LPD_MODE
);
1316 ret
= wl1271_setup(wl
);
1320 case CHIP_ID_1283_PG20
:
1321 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1283 PG20)",
1324 ret
= wl1271_setup(wl
);
1328 if (wl1271_set_block_size(wl
))
1329 wl
->quirks
|= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT
;
1331 case CHIP_ID_1283_PG10
:
1333 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
1338 if (wl
->fw
== NULL
) {
1339 ret
= wl1271_fetch_firmware(wl
);
1344 /* No NVS from netlink, try to get it from the filesystem */
1345 if (wl
->nvs
== NULL
) {
1346 ret
= wl1271_fetch_nvs(wl
);
1355 int wl1271_plt_start(struct wl1271
*wl
)
1357 int retries
= WL1271_BOOT_RETRIES
;
1358 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
1361 mutex_lock(&wl
->mutex
);
1363 wl1271_notice("power up");
1365 if (wl
->state
!= WL1271_STATE_OFF
) {
1366 wl1271_error("cannot go into PLT state because not "
1367 "in off state: %d", wl
->state
);
1372 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1376 ret
= wl1271_chip_wakeup(wl
);
1380 ret
= wl1271_boot(wl
);
1384 ret
= wl1271_plt_init(wl
);
1388 wl
->state
= WL1271_STATE_PLT
;
1389 wl1271_notice("firmware booted in PLT mode (%s)",
1390 wl
->chip
.fw_ver_str
);
1392 /* update hw/fw version info in wiphy struct */
1393 wiphy
->hw_version
= wl
->chip
.id
;
1394 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1395 sizeof(wiphy
->fw_version
));
1400 mutex_unlock(&wl
->mutex
);
1401 /* Unlocking the mutex in the middle of handling is
1402 inherently unsafe. In this case we deem it safe to do,
1403 because we need to let any possibly pending IRQ out of
1404 the system (and while we are WL1271_STATE_OFF the IRQ
1405 work function will not do anything.) Also, any other
1406 possible concurrent operations will fail due to the
1407 current state, hence the wl1271 struct should be safe. */
1408 wl1271_disable_interrupts(wl
);
1409 wl1271_flush_deferred_work(wl
);
1410 cancel_work_sync(&wl
->netstack_work
);
1411 mutex_lock(&wl
->mutex
);
1413 wl1271_power_off(wl
);
1416 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1417 WL1271_BOOT_RETRIES
);
1419 mutex_unlock(&wl
->mutex
);
1424 static int __wl1271_plt_stop(struct wl1271
*wl
)
1428 wl1271_notice("power down");
1430 if (wl
->state
!= WL1271_STATE_PLT
) {
1431 wl1271_error("cannot power down because not in PLT "
1432 "state: %d", wl
->state
);
1437 wl1271_power_off(wl
);
1439 wl
->state
= WL1271_STATE_OFF
;
1442 mutex_unlock(&wl
->mutex
);
1443 wl1271_disable_interrupts(wl
);
1444 wl1271_flush_deferred_work(wl
);
1445 cancel_work_sync(&wl
->netstack_work
);
1446 cancel_work_sync(&wl
->recovery_work
);
1447 mutex_lock(&wl
->mutex
);
1452 int wl1271_plt_stop(struct wl1271
*wl
)
1456 mutex_lock(&wl
->mutex
);
1457 ret
= __wl1271_plt_stop(wl
);
1458 mutex_unlock(&wl
->mutex
);
1462 static void wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
1464 struct wl1271
*wl
= hw
->priv
;
1465 unsigned long flags
;
1469 mapping
= skb_get_queue_mapping(skb
);
1470 q
= wl1271_tx_get_queue(mapping
);
1472 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1473 hlid
= wl1271_tx_get_hlid(skb
);
1475 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1477 wl
->tx_queue_count
[q
]++;
1480 * The workqueue is slow to process the tx_queue and we need stop
1481 * the queue here, otherwise the queue will get too long.
1483 if (wl
->tx_queue_count
[q
] >= WL1271_TX_QUEUE_HIGH_WATERMARK
) {
1484 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues for q %d", q
);
1485 ieee80211_stop_queue(wl
->hw
, mapping
);
1486 set_bit(q
, &wl
->stopped_queues_map
);
1489 /* queue the packet */
1490 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
1491 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d", hlid
, q
);
1492 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1494 skb_queue_tail(&wl
->tx_queue
[q
], skb
);
1498 * The chip specific setup must run before the first TX packet -
1499 * before that, the tx_work will not be initialized!
1502 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1503 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1504 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1506 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1509 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1511 unsigned long flags
;
1512 int q
= wl1271_tx_get_queue(skb_get_queue_mapping(wl
->dummy_packet
));
1514 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1515 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
);
1516 wl
->tx_queue_count
[q
]++;
1517 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1519 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1520 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1521 wl1271_tx_work_locked(wl
);
1524 * If the FW TX is busy, TX work will be scheduled by the threaded
1525 * interrupt handler function
1531 * The size of the dummy packet should be at least 1400 bytes. However, in
1532 * order to minimize the number of bus transactions, aligning it to 512 bytes
1533 * boundaries could be beneficial, performance wise
1535 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1537 static struct sk_buff
*wl12xx_alloc_dummy_packet(struct wl1271
*wl
)
1539 struct sk_buff
*skb
;
1540 struct ieee80211_hdr_3addr
*hdr
;
1541 unsigned int dummy_packet_size
;
1543 dummy_packet_size
= TOTAL_TX_DUMMY_PACKET_SIZE
-
1544 sizeof(struct wl1271_tx_hw_descr
) - sizeof(*hdr
);
1546 skb
= dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE
);
1548 wl1271_warning("Failed to allocate a dummy packet skb");
1552 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1554 hdr
= (struct ieee80211_hdr_3addr
*) skb_put(skb
, sizeof(*hdr
));
1555 memset(hdr
, 0, sizeof(*hdr
));
1556 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1557 IEEE80211_STYPE_NULLFUNC
|
1558 IEEE80211_FCTL_TODS
);
1560 memset(skb_put(skb
, dummy_packet_size
), 0, dummy_packet_size
);
1562 /* Dummy packets require the TID to be management */
1563 skb
->priority
= WL1271_TID_MGMT
;
1565 /* Initialize all fields that might be used */
1566 skb_set_queue_mapping(skb
, 0);
1567 memset(IEEE80211_SKB_CB(skb
), 0, sizeof(struct ieee80211_tx_info
));
1573 static struct notifier_block wl1271_dev_notifier
= {
1574 .notifier_call
= wl1271_dev_notify
,
1578 static int wl1271_configure_suspend_sta(struct wl1271
*wl
)
1582 mutex_lock(&wl
->mutex
);
1584 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1587 ret
= wl1271_ps_elp_wakeup(wl
);
1591 /* enter psm if needed*/
1592 if (!test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
1593 DECLARE_COMPLETION_ONSTACK(compl);
1595 wl
->ps_compl
= &compl;
1596 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
1597 wl
->basic_rate
, true);
1601 /* we must unlock here so we will be able to get events */
1602 wl1271_ps_elp_sleep(wl
);
1603 mutex_unlock(&wl
->mutex
);
1605 ret
= wait_for_completion_timeout(
1606 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT
));
1608 wl1271_warning("couldn't enter ps mode!");
1613 /* take mutex again, and wakeup */
1614 mutex_lock(&wl
->mutex
);
1616 ret
= wl1271_ps_elp_wakeup(wl
);
1621 wl1271_ps_elp_sleep(wl
);
1623 mutex_unlock(&wl
->mutex
);
1629 static int wl1271_configure_suspend_ap(struct wl1271
*wl
)
1633 mutex_lock(&wl
->mutex
);
1635 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
))
1638 ret
= wl1271_ps_elp_wakeup(wl
);
1642 ret
= wl1271_acx_set_ap_beacon_filter(wl
, true);
1644 wl1271_ps_elp_sleep(wl
);
1646 mutex_unlock(&wl
->mutex
);
1651 static int wl1271_configure_suspend(struct wl1271
*wl
)
1653 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1654 return wl1271_configure_suspend_sta(wl
);
1655 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1656 return wl1271_configure_suspend_ap(wl
);
1660 static void wl1271_configure_resume(struct wl1271
*wl
)
1663 bool is_sta
= wl
->bss_type
== BSS_TYPE_STA_BSS
;
1664 bool is_ap
= wl
->bss_type
== BSS_TYPE_AP_BSS
;
1666 if (!is_sta
&& !is_ap
)
1669 mutex_lock(&wl
->mutex
);
1670 ret
= wl1271_ps_elp_wakeup(wl
);
1675 /* exit psm if it wasn't configured */
1676 if (!test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
))
1677 wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
1678 wl
->basic_rate
, true);
1680 wl1271_acx_set_ap_beacon_filter(wl
, false);
1683 wl1271_ps_elp_sleep(wl
);
1685 mutex_unlock(&wl
->mutex
);
1688 static int wl1271_op_suspend(struct ieee80211_hw
*hw
,
1689 struct cfg80211_wowlan
*wow
)
1691 struct wl1271
*wl
= hw
->priv
;
1694 wl1271_debug(DEBUG_MAC80211
, "mac80211 suspend wow=%d", !!wow
);
1695 WARN_ON(!wow
|| !wow
->any
);
1697 wl
->wow_enabled
= true;
1698 ret
= wl1271_configure_suspend(wl
);
1700 wl1271_warning("couldn't prepare device to suspend");
1703 /* flush any remaining work */
1704 wl1271_debug(DEBUG_MAC80211
, "flushing remaining works");
1707 * disable and re-enable interrupts in order to flush
1710 wl1271_disable_interrupts(wl
);
1713 * set suspended flag to avoid triggering a new threaded_irq
1714 * work. no need for spinlock as interrupts are disabled.
1716 set_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1718 wl1271_enable_interrupts(wl
);
1719 flush_work(&wl
->tx_work
);
1720 flush_delayed_work(&wl
->pspoll_work
);
1721 flush_delayed_work(&wl
->elp_work
);
1726 static int wl1271_op_resume(struct ieee80211_hw
*hw
)
1728 struct wl1271
*wl
= hw
->priv
;
1729 unsigned long flags
;
1730 bool run_irq_work
= false;
1732 wl1271_debug(DEBUG_MAC80211
, "mac80211 resume wow=%d",
1734 WARN_ON(!wl
->wow_enabled
);
1737 * re-enable irq_work enqueuing, and call irq_work directly if
1738 * there is a pending work.
1740 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1741 clear_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1742 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
))
1743 run_irq_work
= true;
1744 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1747 wl1271_debug(DEBUG_MAC80211
,
1748 "run postponed irq_work directly");
1750 wl1271_enable_interrupts(wl
);
1752 wl1271_configure_resume(wl
);
1753 wl
->wow_enabled
= false;
1759 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1761 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1764 * We have to delay the booting of the hardware because
1765 * we need to know the local MAC address before downloading and
1766 * initializing the firmware. The MAC address cannot be changed
1767 * after boot, and without the proper MAC address, the firmware
1768 * will not function properly.
1770 * The MAC address is first known when the corresponding interface
1771 * is added. That is where we will initialize the hardware.
1777 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
1779 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1782 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1783 struct ieee80211_vif
*vif
)
1785 struct wl1271
*wl
= hw
->priv
;
1786 struct wiphy
*wiphy
= hw
->wiphy
;
1787 int retries
= WL1271_BOOT_RETRIES
;
1789 bool booted
= false;
1791 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1792 vif
->type
, vif
->addr
);
1794 mutex_lock(&wl
->mutex
);
1796 wl1271_debug(DEBUG_MAC80211
,
1797 "multiple vifs are not supported yet");
1803 * in some very corner case HW recovery scenarios its possible to
1804 * get here before __wl1271_op_remove_interface is complete, so
1805 * opt out if that is the case.
1807 if (test_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
)) {
1812 switch (vif
->type
) {
1813 case NL80211_IFTYPE_STATION
:
1814 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1815 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1817 case NL80211_IFTYPE_ADHOC
:
1818 wl
->bss_type
= BSS_TYPE_IBSS
;
1819 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1821 case NL80211_IFTYPE_AP
:
1822 wl
->bss_type
= BSS_TYPE_AP_BSS
;
1829 memcpy(wl
->mac_addr
, vif
->addr
, ETH_ALEN
);
1831 if (wl
->state
!= WL1271_STATE_OFF
) {
1832 wl1271_error("cannot start because not in off state: %d",
1840 ret
= wl1271_chip_wakeup(wl
);
1844 ret
= wl1271_boot(wl
);
1848 ret
= wl1271_hw_init(wl
);
1856 mutex_unlock(&wl
->mutex
);
1857 /* Unlocking the mutex in the middle of handling is
1858 inherently unsafe. In this case we deem it safe to do,
1859 because we need to let any possibly pending IRQ out of
1860 the system (and while we are WL1271_STATE_OFF the IRQ
1861 work function will not do anything.) Also, any other
1862 possible concurrent operations will fail due to the
1863 current state, hence the wl1271 struct should be safe. */
1864 wl1271_disable_interrupts(wl
);
1865 wl1271_flush_deferred_work(wl
);
1866 cancel_work_sync(&wl
->netstack_work
);
1867 mutex_lock(&wl
->mutex
);
1869 wl1271_power_off(wl
);
1873 wl1271_error("firmware boot failed despite %d retries",
1874 WL1271_BOOT_RETRIES
);
1879 wl
->state
= WL1271_STATE_ON
;
1880 set_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
);
1881 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
1883 /* update hw/fw version info in wiphy struct */
1884 wiphy
->hw_version
= wl
->chip
.id
;
1885 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1886 sizeof(wiphy
->fw_version
));
1889 * Now we know if 11a is supported (info from the NVS), so disable
1890 * 11a channels if not supported
1892 if (!wl
->enable_11a
)
1893 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
1895 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
1896 wl
->enable_11a
? "" : "not ");
1899 mutex_unlock(&wl
->mutex
);
1901 mutex_lock(&wl_list_mutex
);
1903 list_add(&wl
->list
, &wl_list
);
1904 mutex_unlock(&wl_list_mutex
);
1909 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
1910 bool reset_tx_queues
)
1913 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
1915 /* because of hardware recovery, we may get here twice */
1916 if (wl
->state
!= WL1271_STATE_ON
)
1919 wl1271_info("down");
1921 mutex_lock(&wl_list_mutex
);
1922 list_del(&wl
->list
);
1923 mutex_unlock(&wl_list_mutex
);
1925 /* enable dyn ps just in case (if left on due to fw crash etc) */
1926 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1927 ieee80211_enable_dyn_ps(wl
->vif
);
1929 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
1930 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
1931 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
1932 wl
->scan
.req
= NULL
;
1933 ieee80211_scan_completed(wl
->hw
, true);
1937 * this must be before the cancel_work calls below, so that the work
1938 * functions don't perform further work.
1940 wl
->state
= WL1271_STATE_OFF
;
1942 mutex_unlock(&wl
->mutex
);
1944 wl1271_disable_interrupts(wl
);
1945 wl1271_flush_deferred_work(wl
);
1946 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1947 cancel_work_sync(&wl
->netstack_work
);
1948 cancel_work_sync(&wl
->tx_work
);
1949 del_timer_sync(&wl
->rx_streaming_timer
);
1950 cancel_work_sync(&wl
->rx_streaming_enable_work
);
1951 cancel_work_sync(&wl
->rx_streaming_disable_work
);
1952 cancel_delayed_work_sync(&wl
->pspoll_work
);
1953 cancel_delayed_work_sync(&wl
->elp_work
);
1955 mutex_lock(&wl
->mutex
);
1957 /* let's notify MAC80211 about the remaining pending TX frames */
1958 wl1271_tx_reset(wl
, reset_tx_queues
);
1959 wl1271_power_off(wl
);
1961 memset(wl
->bssid
, 0, ETH_ALEN
);
1962 memset(wl
->ssid
, 0, IEEE80211_MAX_SSID_LEN
+ 1);
1964 wl
->bss_type
= MAX_BSS_TYPE
;
1965 wl
->set_bss_type
= MAX_BSS_TYPE
;
1966 wl
->band
= IEEE80211_BAND_2GHZ
;
1969 wl
->psm_entry_retry
= 0;
1970 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1971 wl
->tx_blocks_available
= 0;
1972 wl
->tx_allocated_blocks
= 0;
1973 wl
->tx_results_count
= 0;
1974 wl
->tx_packets_count
= 0;
1975 wl
->time_offset
= 0;
1976 wl
->session_counter
= 0;
1977 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1979 wl1271_free_ap_keys(wl
);
1980 memset(wl
->ap_hlid_map
, 0, sizeof(wl
->ap_hlid_map
));
1981 wl
->ap_fw_ps_map
= 0;
1983 wl
->sched_scanning
= false;
1984 wl
->role_id
= WL12XX_INVALID_ROLE_ID
;
1987 * this is performed after the cancel_work calls and the associated
1988 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1989 * get executed before all these vars have been reset.
1993 wl
->tx_blocks_freed
= 0;
1995 wl1271_debugfs_reset(wl
);
1997 kfree(wl
->fw_status
);
1998 wl
->fw_status
= NULL
;
1999 kfree(wl
->tx_res_if
);
2000 wl
->tx_res_if
= NULL
;
2001 kfree(wl
->target_mem_map
);
2002 wl
->target_mem_map
= NULL
;
2005 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
2006 struct ieee80211_vif
*vif
)
2008 struct wl1271
*wl
= hw
->priv
;
2010 mutex_lock(&wl
->mutex
);
2012 * wl->vif can be null here if someone shuts down the interface
2013 * just when hardware recovery has been started.
2016 WARN_ON(wl
->vif
!= vif
);
2017 __wl1271_op_remove_interface(wl
, true);
2020 mutex_unlock(&wl
->mutex
);
2021 cancel_work_sync(&wl
->recovery_work
);
2024 static int wl1271_dummy_join(struct wl1271
*wl
)
2027 /* we need to use a dummy BSSID for now */
2028 static const u8 dummy_bssid
[ETH_ALEN
] = { 0x0b, 0xad, 0xde,
2031 memcpy(wl
->bssid
, dummy_bssid
, ETH_ALEN
);
2033 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
2037 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
2043 static int wl1271_join(struct wl1271
*wl
, bool set_assoc
)
2048 * One of the side effects of the JOIN command is that is clears
2049 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2050 * to a WPA/WPA2 access point will therefore kill the data-path.
2051 * Currently the only valid scenario for JOIN during association
2052 * is on roaming, in which case we will also be given new keys.
2053 * Keep the below message for now, unless it starts bothering
2054 * users who really like to roam a lot :)
2056 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2057 wl1271_info("JOIN while associated.");
2060 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
2062 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
2066 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
2068 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2072 * The join command disable the keep-alive mode, shut down its process,
2073 * and also clear the template config, so we need to reset it all after
2074 * the join. The acx_aid starts the keep-alive process, and the order
2075 * of the commands below is relevant.
2077 ret
= wl1271_acx_keep_alive_mode(wl
, true);
2081 ret
= wl1271_acx_aid(wl
, wl
->aid
);
2085 ret
= wl1271_cmd_build_klv_null_data(wl
);
2089 ret
= wl1271_acx_keep_alive_config(wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
2090 ACX_KEEP_ALIVE_TPL_VALID
);
2098 static int wl1271_unjoin(struct wl1271
*wl
)
2102 /* to stop listening to a channel, we disconnect */
2103 ret
= wl1271_cmd_disconnect(wl
);
2107 clear_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
2108 memset(wl
->bssid
, 0, ETH_ALEN
);
2110 /* reset TX security counters on a clean disconnect */
2111 wl
->tx_security_last_seq_lsb
= 0;
2112 wl
->tx_security_seq
= 0;
2118 static void wl1271_set_band_rate(struct wl1271
*wl
)
2120 if (wl
->band
== IEEE80211_BAND_2GHZ
)
2121 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate
;
2123 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate_5
;
2126 static int wl1271_sta_handle_idle(struct wl1271
*wl
, bool idle
)
2131 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
2132 ret
= wl1271_unjoin(wl
);
2136 wl
->rate_set
= wl1271_tx_min_rate_get(wl
);
2137 ret
= wl1271_acx_sta_rate_policies(wl
);
2140 ret
= wl1271_acx_keep_alive_config(
2141 wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
2142 ACX_KEEP_ALIVE_TPL_INVALID
);
2145 set_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
2147 /* increment the session counter */
2148 wl
->session_counter
++;
2149 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
2150 wl
->session_counter
= 0;
2152 /* The current firmware only supports sched_scan in idle */
2153 if (wl
->sched_scanning
) {
2154 wl1271_scan_sched_scan_stop(wl
);
2155 ieee80211_sched_scan_stopped(wl
->hw
);
2158 ret
= wl1271_dummy_join(wl
);
2161 clear_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
2168 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
2170 struct wl1271
*wl
= hw
->priv
;
2171 struct ieee80211_conf
*conf
= &hw
->conf
;
2172 int channel
, ret
= 0;
2175 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
2177 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s"
2180 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
2182 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
2186 * mac80211 will go to idle nearly immediately after transmitting some
2187 * frames, such as the deauth. To make sure those frames reach the air,
2188 * wait here until the TX queue is fully flushed.
2190 if ((changed
& IEEE80211_CONF_CHANGE_IDLE
) &&
2191 (conf
->flags
& IEEE80211_CONF_IDLE
))
2192 wl1271_tx_flush(wl
);
2194 mutex_lock(&wl
->mutex
);
2196 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2197 /* we support configuring the channel and band while off */
2198 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
)) {
2199 wl
->band
= conf
->channel
->band
;
2200 wl
->channel
= channel
;
2203 if ((changed
& IEEE80211_CONF_CHANGE_POWER
))
2204 wl
->power_level
= conf
->power_level
;
2209 is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2211 ret
= wl1271_ps_elp_wakeup(wl
);
2215 /* if the channel changes while joined, join again */
2216 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
&&
2217 ((wl
->band
!= conf
->channel
->band
) ||
2218 (wl
->channel
!= channel
))) {
2219 wl
->band
= conf
->channel
->band
;
2220 wl
->channel
= channel
;
2224 * FIXME: the mac80211 should really provide a fixed
2225 * rate to use here. for now, just use the smallest
2226 * possible rate for the band as a fixed rate for
2227 * association frames and other control messages.
2229 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2230 wl1271_set_band_rate(wl
);
2232 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2233 ret
= wl1271_acx_sta_rate_policies(wl
);
2235 wl1271_warning("rate policy for channel "
2238 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
2239 ret
= wl1271_join(wl
, false);
2241 wl1271_warning("cmd join on channel "
2247 if (changed
& IEEE80211_CONF_CHANGE_IDLE
&& !is_ap
) {
2248 ret
= wl1271_sta_handle_idle(wl
,
2249 conf
->flags
& IEEE80211_CONF_IDLE
);
2251 wl1271_warning("idle mode change failed %d", ret
);
2255 * if mac80211 changes the PSM mode, make sure the mode is not
2256 * incorrectly changed after the pspoll failure active window.
2258 if (changed
& IEEE80211_CONF_CHANGE_PS
)
2259 clear_bit(WL1271_FLAG_PSPOLL_FAILURE
, &wl
->flags
);
2261 if (conf
->flags
& IEEE80211_CONF_PS
&&
2262 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
2263 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
2266 * We enter PSM only if we're already associated.
2267 * If we're not, we'll enter it when joining an SSID,
2268 * through the bss_info_changed() hook.
2270 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
2271 wl1271_debug(DEBUG_PSM
, "psm enabled");
2272 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
2273 wl
->basic_rate
, true);
2275 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
2276 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
2277 wl1271_debug(DEBUG_PSM
, "psm disabled");
2279 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
2281 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
2282 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
2283 wl
->basic_rate
, true);
2286 if (conf
->power_level
!= wl
->power_level
) {
2287 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
2291 wl
->power_level
= conf
->power_level
;
2295 wl1271_ps_elp_sleep(wl
);
2298 mutex_unlock(&wl
->mutex
);
2303 struct wl1271_filter_params
{
2306 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
2309 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
2310 struct netdev_hw_addr_list
*mc_list
)
2312 struct wl1271_filter_params
*fp
;
2313 struct netdev_hw_addr
*ha
;
2314 struct wl1271
*wl
= hw
->priv
;
2316 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2319 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
2321 wl1271_error("Out of memory setting filters.");
2325 /* update multicast filtering parameters */
2326 fp
->mc_list_length
= 0;
2327 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
2328 fp
->enabled
= false;
2331 netdev_hw_addr_list_for_each(ha
, mc_list
) {
2332 memcpy(fp
->mc_list
[fp
->mc_list_length
],
2333 ha
->addr
, ETH_ALEN
);
2334 fp
->mc_list_length
++;
2338 return (u64
)(unsigned long)fp
;
2341 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2344 FIF_BCN_PRBRESP_PROMISC | \
2348 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
2349 unsigned int changed
,
2350 unsigned int *total
, u64 multicast
)
2352 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
2353 struct wl1271
*wl
= hw
->priv
;
2356 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
2357 " total %x", changed
, *total
);
2359 mutex_lock(&wl
->mutex
);
2361 *total
&= WL1271_SUPPORTED_FILTERS
;
2362 changed
&= WL1271_SUPPORTED_FILTERS
;
2364 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2367 ret
= wl1271_ps_elp_wakeup(wl
);
2371 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
) {
2372 if (*total
& FIF_ALLMULTI
)
2373 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
2375 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
2377 fp
->mc_list_length
);
2383 * the fw doesn't provide an api to configure the filters. instead,
2384 * the filters configuration is based on the active roles / ROC
2389 wl1271_ps_elp_sleep(wl
);
2392 mutex_unlock(&wl
->mutex
);
2396 static int wl1271_record_ap_key(struct wl1271
*wl
, u8 id
, u8 key_type
,
2397 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
2400 struct wl1271_ap_key
*ap_key
;
2403 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
2405 if (key_size
> MAX_KEY_SIZE
)
2409 * Find next free entry in ap_keys. Also check we are not replacing
2412 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2413 if (wl
->recorded_ap_keys
[i
] == NULL
)
2416 if (wl
->recorded_ap_keys
[i
]->id
== id
) {
2417 wl1271_warning("trying to record key replacement");
2422 if (i
== MAX_NUM_KEYS
)
2425 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
2430 ap_key
->key_type
= key_type
;
2431 ap_key
->key_size
= key_size
;
2432 memcpy(ap_key
->key
, key
, key_size
);
2433 ap_key
->hlid
= hlid
;
2434 ap_key
->tx_seq_32
= tx_seq_32
;
2435 ap_key
->tx_seq_16
= tx_seq_16
;
2437 wl
->recorded_ap_keys
[i
] = ap_key
;
2441 static void wl1271_free_ap_keys(struct wl1271
*wl
)
2445 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2446 kfree(wl
->recorded_ap_keys
[i
]);
2447 wl
->recorded_ap_keys
[i
] = NULL
;
2451 static int wl1271_ap_init_hwenc(struct wl1271
*wl
)
2454 struct wl1271_ap_key
*key
;
2455 bool wep_key_added
= false;
2457 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2458 if (wl
->recorded_ap_keys
[i
] == NULL
)
2461 key
= wl
->recorded_ap_keys
[i
];
2462 ret
= wl1271_cmd_set_ap_key(wl
, KEY_ADD_OR_REPLACE
,
2463 key
->id
, key
->key_type
,
2464 key
->key_size
, key
->key
,
2465 key
->hlid
, key
->tx_seq_32
,
2470 if (key
->key_type
== KEY_WEP
)
2471 wep_key_added
= true;
2474 if (wep_key_added
) {
2475 ret
= wl1271_cmd_set_ap_default_wep_key(wl
, wl
->default_key
);
2481 wl1271_free_ap_keys(wl
);
2485 static int wl1271_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
2486 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
2487 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
2490 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2493 struct wl1271_station
*wl_sta
;
2497 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2498 hlid
= wl_sta
->hlid
;
2500 hlid
= WL1271_AP_BROADCAST_HLID
;
2503 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2505 * We do not support removing keys after AP shutdown.
2506 * Pretend we do to make mac80211 happy.
2508 if (action
!= KEY_ADD_OR_REPLACE
)
2511 ret
= wl1271_record_ap_key(wl
, id
,
2513 key
, hlid
, tx_seq_32
,
2516 ret
= wl1271_cmd_set_ap_key(wl
, action
,
2517 id
, key_type
, key_size
,
2518 key
, hlid
, tx_seq_32
,
2526 static const u8 bcast_addr
[ETH_ALEN
] = {
2527 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2530 addr
= sta
? sta
->addr
: bcast_addr
;
2532 if (is_zero_ether_addr(addr
)) {
2533 /* We dont support TX only encryption */
2537 /* The wl1271 does not allow to remove unicast keys - they
2538 will be cleared automatically on next CMD_JOIN. Ignore the
2539 request silently, as we dont want the mac80211 to emit
2540 an error message. */
2541 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
2544 ret
= wl1271_cmd_set_sta_key(wl
, action
,
2545 id
, key_type
, key_size
,
2546 key
, addr
, tx_seq_32
,
2551 /* the default WEP key needs to be configured at least once */
2552 if (key_type
== KEY_WEP
) {
2553 ret
= wl1271_cmd_set_sta_default_wep_key(wl
,
2563 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
2564 struct ieee80211_vif
*vif
,
2565 struct ieee80211_sta
*sta
,
2566 struct ieee80211_key_conf
*key_conf
)
2568 struct wl1271
*wl
= hw
->priv
;
2574 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
2576 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
2577 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2578 key_conf
->cipher
, key_conf
->keyidx
,
2579 key_conf
->keylen
, key_conf
->flags
);
2580 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
2582 mutex_lock(&wl
->mutex
);
2584 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2589 ret
= wl1271_ps_elp_wakeup(wl
);
2593 switch (key_conf
->cipher
) {
2594 case WLAN_CIPHER_SUITE_WEP40
:
2595 case WLAN_CIPHER_SUITE_WEP104
:
2598 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2600 case WLAN_CIPHER_SUITE_TKIP
:
2601 key_type
= KEY_TKIP
;
2603 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2604 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2605 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2607 case WLAN_CIPHER_SUITE_CCMP
:
2610 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2611 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2612 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2614 case WL1271_CIPHER_SUITE_GEM
:
2616 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2617 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2620 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
2628 ret
= wl1271_set_key(wl
, KEY_ADD_OR_REPLACE
,
2629 key_conf
->keyidx
, key_type
,
2630 key_conf
->keylen
, key_conf
->key
,
2631 tx_seq_32
, tx_seq_16
, sta
);
2633 wl1271_error("Could not add or replace key");
2639 ret
= wl1271_set_key(wl
, KEY_REMOVE
,
2640 key_conf
->keyidx
, key_type
,
2641 key_conf
->keylen
, key_conf
->key
,
2644 wl1271_error("Could not remove key");
2650 wl1271_error("Unsupported key cmd 0x%x", cmd
);
2656 wl1271_ps_elp_sleep(wl
);
2659 mutex_unlock(&wl
->mutex
);
2664 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
2665 struct ieee80211_vif
*vif
,
2666 struct cfg80211_scan_request
*req
)
2668 struct wl1271
*wl
= hw
->priv
;
2673 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
2676 ssid
= req
->ssids
[0].ssid
;
2677 len
= req
->ssids
[0].ssid_len
;
2680 mutex_lock(&wl
->mutex
);
2682 if (wl
->state
== WL1271_STATE_OFF
) {
2684 * We cannot return -EBUSY here because cfg80211 will expect
2685 * a call to ieee80211_scan_completed if we do - in this case
2686 * there won't be any call.
2692 ret
= wl1271_ps_elp_wakeup(wl
);
2696 ret
= wl1271_scan(hw
->priv
, ssid
, len
, req
);
2698 wl1271_ps_elp_sleep(wl
);
2701 mutex_unlock(&wl
->mutex
);
2706 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw
*hw
,
2707 struct ieee80211_vif
*vif
)
2709 struct wl1271
*wl
= hw
->priv
;
2712 wl1271_debug(DEBUG_MAC80211
, "mac80211 cancel hw scan");
2714 mutex_lock(&wl
->mutex
);
2716 if (wl
->state
== WL1271_STATE_OFF
)
2719 if (wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
)
2722 ret
= wl1271_ps_elp_wakeup(wl
);
2726 if (wl
->scan
.state
!= WL1271_SCAN_STATE_DONE
) {
2727 ret
= wl1271_scan_stop(wl
);
2731 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
2732 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
2733 wl
->scan
.req
= NULL
;
2734 ieee80211_scan_completed(wl
->hw
, true);
2737 wl1271_ps_elp_sleep(wl
);
2739 mutex_unlock(&wl
->mutex
);
2741 cancel_delayed_work_sync(&wl
->scan_complete_work
);
2744 static int wl1271_op_sched_scan_start(struct ieee80211_hw
*hw
,
2745 struct ieee80211_vif
*vif
,
2746 struct cfg80211_sched_scan_request
*req
,
2747 struct ieee80211_sched_scan_ies
*ies
)
2749 struct wl1271
*wl
= hw
->priv
;
2752 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_start");
2754 mutex_lock(&wl
->mutex
);
2756 ret
= wl1271_ps_elp_wakeup(wl
);
2760 ret
= wl1271_scan_sched_scan_config(wl
, req
, ies
);
2764 ret
= wl1271_scan_sched_scan_start(wl
);
2768 wl
->sched_scanning
= true;
2771 wl1271_ps_elp_sleep(wl
);
2773 mutex_unlock(&wl
->mutex
);
2777 static void wl1271_op_sched_scan_stop(struct ieee80211_hw
*hw
,
2778 struct ieee80211_vif
*vif
)
2780 struct wl1271
*wl
= hw
->priv
;
2783 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_stop");
2785 mutex_lock(&wl
->mutex
);
2787 ret
= wl1271_ps_elp_wakeup(wl
);
2791 wl1271_scan_sched_scan_stop(wl
);
2793 wl1271_ps_elp_sleep(wl
);
2795 mutex_unlock(&wl
->mutex
);
2798 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
2800 struct wl1271
*wl
= hw
->priv
;
2803 mutex_lock(&wl
->mutex
);
2805 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2810 ret
= wl1271_ps_elp_wakeup(wl
);
2814 ret
= wl1271_acx_frag_threshold(wl
, value
);
2816 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
2818 wl1271_ps_elp_sleep(wl
);
2821 mutex_unlock(&wl
->mutex
);
2826 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
2828 struct wl1271
*wl
= hw
->priv
;
2831 mutex_lock(&wl
->mutex
);
2833 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2838 ret
= wl1271_ps_elp_wakeup(wl
);
2842 ret
= wl1271_acx_rts_threshold(wl
, value
);
2844 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
2846 wl1271_ps_elp_sleep(wl
);
2849 mutex_unlock(&wl
->mutex
);
2854 static int wl1271_ssid_set(struct wl1271
*wl
, struct sk_buff
*skb
,
2858 const u8
*ptr
= cfg80211_find_ie(WLAN_EID_SSID
, skb
->data
+ offset
,
2862 wl1271_error("No SSID in IEs!");
2867 if (ssid_len
> IEEE80211_MAX_SSID_LEN
) {
2868 wl1271_error("SSID is too long!");
2872 wl
->ssid_len
= ssid_len
;
2873 memcpy(wl
->ssid
, ptr
+2, ssid_len
);
2877 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
2878 struct ieee80211_bss_conf
*bss_conf
,
2883 if (changed
& BSS_CHANGED_ERP_SLOT
) {
2884 if (bss_conf
->use_short_slot
)
2885 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
2887 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
2889 wl1271_warning("Set slot time failed %d", ret
);
2894 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
2895 if (bss_conf
->use_short_preamble
)
2896 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
2898 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
2901 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
2902 if (bss_conf
->use_cts_prot
)
2903 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
2905 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
2907 wl1271_warning("Set ctsprotect failed %d", ret
);
2916 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
2917 struct ieee80211_vif
*vif
,
2918 struct ieee80211_bss_conf
*bss_conf
,
2921 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2924 if ((changed
& BSS_CHANGED_BEACON_INT
)) {
2925 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
2926 bss_conf
->beacon_int
);
2928 wl
->beacon_int
= bss_conf
->beacon_int
;
2931 if ((changed
& BSS_CHANGED_BEACON
)) {
2932 struct ieee80211_hdr
*hdr
;
2933 int ieoffset
= offsetof(struct ieee80211_mgmt
,
2935 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
2941 wl1271_debug(DEBUG_MASTER
, "beacon updated");
2943 ret
= wl1271_ssid_set(wl
, beacon
, ieoffset
);
2945 dev_kfree_skb(beacon
);
2948 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
2950 ret
= wl1271_cmd_template_set(wl
, tmpl_id
,
2953 wl1271_tx_min_rate_get(wl
));
2955 dev_kfree_skb(beacon
);
2959 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
2960 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
2961 IEEE80211_STYPE_PROBE_RESP
);
2963 tmpl_id
= is_ap
? CMD_TEMPL_AP_PROBE_RESPONSE
:
2964 CMD_TEMPL_PROBE_RESPONSE
;
2965 ret
= wl1271_cmd_template_set(wl
,
2969 wl1271_tx_min_rate_get(wl
));
2970 dev_kfree_skb(beacon
);
2979 /* AP mode changes */
2980 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
2981 struct ieee80211_vif
*vif
,
2982 struct ieee80211_bss_conf
*bss_conf
,
2987 if ((changed
& BSS_CHANGED_BASIC_RATES
)) {
2988 u32 rates
= bss_conf
->basic_rates
;
2990 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
);
2991 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2993 ret
= wl1271_init_ap_rates(wl
);
2995 wl1271_error("AP rate policy change failed %d", ret
);
2999 ret
= wl1271_ap_init_templates(wl
);
3004 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
3008 if ((changed
& BSS_CHANGED_BEACON_ENABLED
)) {
3009 if (bss_conf
->enable_beacon
) {
3010 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
3011 ret
= wl1271_cmd_start_bss(wl
);
3015 set_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
3016 wl1271_debug(DEBUG_AP
, "started AP");
3018 ret
= wl1271_ap_init_hwenc(wl
);
3023 if (test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
3024 ret
= wl1271_cmd_stop_bss(wl
);
3028 clear_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
3029 wl1271_debug(DEBUG_AP
, "stopped AP");
3034 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
3041 /* STA/IBSS mode changes */
3042 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
3043 struct ieee80211_vif
*vif
,
3044 struct ieee80211_bss_conf
*bss_conf
,
3047 bool do_join
= false, set_assoc
= false;
3048 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
3049 u32 sta_rate_set
= 0;
3051 struct ieee80211_sta
*sta
;
3052 bool sta_exists
= false;
3053 struct ieee80211_sta_ht_cap sta_ht_cap
;
3056 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
3062 if ((changed
& BSS_CHANGED_BEACON_INT
) && is_ibss
)
3065 /* Need to update the SSID (for filtering etc) */
3066 if ((changed
& BSS_CHANGED_BEACON
) && is_ibss
)
3069 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && is_ibss
) {
3070 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
3071 bss_conf
->enable_beacon
? "enabled" : "disabled");
3073 if (bss_conf
->enable_beacon
)
3074 wl
->set_bss_type
= BSS_TYPE_IBSS
;
3076 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
3080 if ((changed
& BSS_CHANGED_CQM
)) {
3081 bool enable
= false;
3082 if (bss_conf
->cqm_rssi_thold
)
3084 ret
= wl1271_acx_rssi_snr_trigger(wl
, enable
,
3085 bss_conf
->cqm_rssi_thold
,
3086 bss_conf
->cqm_rssi_hyst
);
3089 wl
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
3092 if ((changed
& BSS_CHANGED_BSSID
) &&
3094 * Now we know the correct bssid, so we send a new join command
3095 * and enable the BSSID filter
3097 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
3098 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
3100 if (!is_zero_ether_addr(wl
->bssid
)) {
3101 ret
= wl1271_cmd_build_null_data(wl
);
3105 ret
= wl1271_build_qos_null_data(wl
);
3109 /* Need to update the BSSID (for filtering etc) */
3115 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
3117 /* save the supp_rates of the ap */
3118 sta_rate_set
= sta
->supp_rates
[wl
->hw
->conf
.channel
->band
];
3119 if (sta
->ht_cap
.ht_supported
)
3121 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
);
3122 sta_ht_cap
= sta
->ht_cap
;
3128 /* handle new association with HT and HT information change */
3129 if ((changed
& BSS_CHANGED_HT
) &&
3130 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
3131 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
3134 wl1271_warning("Set ht cap true failed %d",
3138 ret
= wl1271_acx_set_ht_information(wl
,
3139 bss_conf
->ht_operation_mode
);
3141 wl1271_warning("Set ht information failed %d",
3146 /* handle new association without HT and disassociation */
3147 else if (changed
& BSS_CHANGED_ASSOC
) {
3148 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
3151 wl1271_warning("Set ht cap false failed %d",
3158 if ((changed
& BSS_CHANGED_ASSOC
)) {
3159 if (bss_conf
->assoc
) {
3162 wl
->aid
= bss_conf
->aid
;
3165 wl
->ps_poll_failures
= 0;
3168 * use basic rates from AP, and determine lowest rate
3169 * to use with control frames.
3171 rates
= bss_conf
->basic_rates
;
3172 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
3174 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3176 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
,
3178 ret
= wl1271_acx_sta_rate_policies(wl
);
3183 * with wl1271, we don't need to update the
3184 * beacon_int and dtim_period, because the firmware
3185 * updates it by itself when the first beacon is
3186 * received after a join.
3188 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
3193 * Get a template for hardware connection maintenance
3195 dev_kfree_skb(wl
->probereq
);
3196 wl
->probereq
= wl1271_cmd_build_ap_probe_req(wl
, NULL
);
3197 ieoffset
= offsetof(struct ieee80211_mgmt
,
3198 u
.probe_req
.variable
);
3199 wl1271_ssid_set(wl
, wl
->probereq
, ieoffset
);
3201 /* enable the connection monitoring feature */
3202 ret
= wl1271_acx_conn_monit_params(wl
, true);
3206 /* If we want to go in PSM but we're not there yet */
3207 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
3208 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
3209 enum wl1271_cmd_ps_mode mode
;
3211 mode
= STATION_POWER_SAVE_MODE
;
3212 ret
= wl1271_ps_set_mode(wl
, mode
,
3219 /* use defaults when not associated */
3221 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED
,
3223 clear_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
);
3226 /* free probe-request template */
3227 dev_kfree_skb(wl
->probereq
);
3228 wl
->probereq
= NULL
;
3230 /* re-enable dynamic ps - just in case */
3231 ieee80211_enable_dyn_ps(wl
->vif
);
3233 /* revert back to minimum rates for the current band */
3234 wl1271_set_band_rate(wl
);
3235 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3236 ret
= wl1271_acx_sta_rate_policies(wl
);
3240 /* disable connection monitor features */
3241 ret
= wl1271_acx_conn_monit_params(wl
, false);
3243 /* Disable the keep-alive feature */
3244 ret
= wl1271_acx_keep_alive_mode(wl
, false);
3248 /* restore the bssid filter and go to dummy bssid */
3251 wl1271_dummy_join(wl
);
3256 if (changed
& BSS_CHANGED_IBSS
) {
3257 wl1271_debug(DEBUG_ADHOC
, "ibss_joined: %d",
3258 bss_conf
->ibss_joined
);
3260 if (bss_conf
->ibss_joined
) {
3261 u32 rates
= bss_conf
->basic_rates
;
3262 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
3264 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
3266 /* by default, use 11b rates */
3267 wl
->rate_set
= CONF_TX_IBSS_DEFAULT_RATES
;
3268 ret
= wl1271_acx_sta_rate_policies(wl
);
3274 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
3278 if (changed
& BSS_CHANGED_ARP_FILTER
) {
3279 __be32 addr
= bss_conf
->arp_addr_list
[0];
3280 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
3282 if (bss_conf
->arp_addr_cnt
== 1 &&
3283 bss_conf
->arp_filter_enabled
) {
3285 * The template should have been configured only upon
3286 * association. however, it seems that the correct ip
3287 * isn't being set (when sending), so we have to
3288 * reconfigure the template upon every ip change.
3290 ret
= wl1271_cmd_build_arp_rsp(wl
, addr
);
3292 wl1271_warning("build arp rsp failed: %d", ret
);
3296 ret
= wl1271_acx_arp_ip_filter(wl
,
3297 ACX_ARP_FILTER_ARP_FILTERING
,
3300 ret
= wl1271_acx_arp_ip_filter(wl
, 0, addr
);
3307 ret
= wl1271_join(wl
, set_assoc
);
3309 wl1271_warning("cmd join failed %d", ret
);
3312 wl1271_check_operstate(wl
, ieee80211_get_operstate(vif
));
3319 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
3320 struct ieee80211_vif
*vif
,
3321 struct ieee80211_bss_conf
*bss_conf
,
3324 struct wl1271
*wl
= hw
->priv
;
3325 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
3328 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed 0x%x",
3331 mutex_lock(&wl
->mutex
);
3333 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3336 ret
= wl1271_ps_elp_wakeup(wl
);
3341 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
3343 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
3345 wl1271_ps_elp_sleep(wl
);
3348 mutex_unlock(&wl
->mutex
);
3351 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
, u16 queue
,
3352 const struct ieee80211_tx_queue_params
*params
)
3354 struct wl1271
*wl
= hw
->priv
;
3358 mutex_lock(&wl
->mutex
);
3360 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
3363 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
3365 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
3367 if (wl
->state
== WL1271_STATE_OFF
) {
3369 * If the state is off, the parameters will be recorded and
3370 * configured on init. This happens in AP-mode.
3372 struct conf_tx_ac_category
*conf_ac
=
3373 &wl
->conf
.tx
.ac_conf
[wl1271_tx_get_queue(queue
)];
3374 struct conf_tx_tid
*conf_tid
=
3375 &wl
->conf
.tx
.tid_conf
[wl1271_tx_get_queue(queue
)];
3377 conf_ac
->ac
= wl1271_tx_get_queue(queue
);
3378 conf_ac
->cw_min
= (u8
)params
->cw_min
;
3379 conf_ac
->cw_max
= params
->cw_max
;
3380 conf_ac
->aifsn
= params
->aifs
;
3381 conf_ac
->tx_op_limit
= params
->txop
<< 5;
3383 conf_tid
->queue_id
= wl1271_tx_get_queue(queue
);
3384 conf_tid
->channel_type
= CONF_CHANNEL_TYPE_EDCF
;
3385 conf_tid
->tsid
= wl1271_tx_get_queue(queue
);
3386 conf_tid
->ps_scheme
= ps_scheme
;
3387 conf_tid
->ack_policy
= CONF_ACK_POLICY_LEGACY
;
3388 conf_tid
->apsd_conf
[0] = 0;
3389 conf_tid
->apsd_conf
[1] = 0;
3393 ret
= wl1271_ps_elp_wakeup(wl
);
3398 * the txop is confed in units of 32us by the mac80211,
3401 ret
= wl1271_acx_ac_cfg(wl
, wl1271_tx_get_queue(queue
),
3402 params
->cw_min
, params
->cw_max
,
3403 params
->aifs
, params
->txop
<< 5);
3407 ret
= wl1271_acx_tid_cfg(wl
, wl1271_tx_get_queue(queue
),
3408 CONF_CHANNEL_TYPE_EDCF
,
3409 wl1271_tx_get_queue(queue
),
3410 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
3414 wl1271_ps_elp_sleep(wl
);
3417 mutex_unlock(&wl
->mutex
);
3422 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
)
3425 struct wl1271
*wl
= hw
->priv
;
3426 u64 mactime
= ULLONG_MAX
;
3429 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
3431 mutex_lock(&wl
->mutex
);
3433 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3436 ret
= wl1271_ps_elp_wakeup(wl
);
3440 ret
= wl1271_acx_tsf_info(wl
, &mactime
);
3445 wl1271_ps_elp_sleep(wl
);
3448 mutex_unlock(&wl
->mutex
);
3452 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
3453 struct survey_info
*survey
)
3455 struct wl1271
*wl
= hw
->priv
;
3456 struct ieee80211_conf
*conf
= &hw
->conf
;
3461 survey
->channel
= conf
->channel
;
3462 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
3463 survey
->noise
= wl
->noise
;
3468 static int wl1271_allocate_sta(struct wl1271
*wl
,
3469 struct ieee80211_sta
*sta
,
3472 struct wl1271_station
*wl_sta
;
3475 id
= find_first_zero_bit(wl
->ap_hlid_map
, AP_MAX_STATIONS
);
3476 if (id
>= AP_MAX_STATIONS
) {
3477 wl1271_warning("could not allocate HLID - too much stations");
3481 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3482 __set_bit(id
, wl
->ap_hlid_map
);
3483 wl_sta
->hlid
= WL1271_AP_STA_HLID_START
+ id
;
3484 *hlid
= wl_sta
->hlid
;
3485 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
3489 static void wl1271_free_sta(struct wl1271
*wl
, u8 hlid
)
3491 int id
= hlid
- WL1271_AP_STA_HLID_START
;
3493 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3496 __clear_bit(id
, wl
->ap_hlid_map
);
3497 memset(wl
->links
[hlid
].addr
, 0, ETH_ALEN
);
3498 wl1271_tx_reset_link_queues(wl
, hlid
);
3499 __clear_bit(hlid
, &wl
->ap_ps_map
);
3500 __clear_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
3503 bool wl1271_is_active_sta(struct wl1271
*wl
, u8 hlid
)
3505 int id
= hlid
- WL1271_AP_STA_HLID_START
;
3506 return test_bit(id
, wl
->ap_hlid_map
);
3509 static int wl1271_op_sta_add(struct ieee80211_hw
*hw
,
3510 struct ieee80211_vif
*vif
,
3511 struct ieee80211_sta
*sta
)
3513 struct wl1271
*wl
= hw
->priv
;
3517 mutex_lock(&wl
->mutex
);
3519 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3522 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3525 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
3527 ret
= wl1271_allocate_sta(wl
, sta
, &hlid
);
3531 ret
= wl1271_ps_elp_wakeup(wl
);
3535 ret
= wl1271_cmd_add_sta(wl
, sta
, hlid
);
3540 wl1271_ps_elp_sleep(wl
);
3544 wl1271_free_sta(wl
, hlid
);
3547 mutex_unlock(&wl
->mutex
);
3551 static int wl1271_op_sta_remove(struct ieee80211_hw
*hw
,
3552 struct ieee80211_vif
*vif
,
3553 struct ieee80211_sta
*sta
)
3555 struct wl1271
*wl
= hw
->priv
;
3556 struct wl1271_station
*wl_sta
;
3559 mutex_lock(&wl
->mutex
);
3561 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3564 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3567 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
3569 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3570 id
= wl_sta
->hlid
- WL1271_AP_STA_HLID_START
;
3571 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3574 ret
= wl1271_ps_elp_wakeup(wl
);
3578 ret
= wl1271_cmd_remove_sta(wl
, wl_sta
->hlid
);
3582 wl1271_free_sta(wl
, wl_sta
->hlid
);
3585 wl1271_ps_elp_sleep(wl
);
3588 mutex_unlock(&wl
->mutex
);
3592 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
3593 struct ieee80211_vif
*vif
,
3594 enum ieee80211_ampdu_mlme_action action
,
3595 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
3598 struct wl1271
*wl
= hw
->priv
;
3601 mutex_lock(&wl
->mutex
);
3603 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
3608 ret
= wl1271_ps_elp_wakeup(wl
);
3612 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu: Rx tid %d action %d",
3616 case IEEE80211_AMPDU_RX_START
:
3617 if ((wl
->ba_support
) && (wl
->ba_allowed
)) {
3618 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, *ssn
,
3621 wl
->ba_rx_bitmap
|= BIT(tid
);
3627 case IEEE80211_AMPDU_RX_STOP
:
3628 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, 0, false);
3630 wl
->ba_rx_bitmap
&= ~BIT(tid
);
3634 * The BA initiator session management in FW independently.
3635 * Falling break here on purpose for all TX APDU commands.
3637 case IEEE80211_AMPDU_TX_START
:
3638 case IEEE80211_AMPDU_TX_STOP
:
3639 case IEEE80211_AMPDU_TX_OPERATIONAL
:
3644 wl1271_error("Incorrect ampdu action id=%x\n", action
);
3648 wl1271_ps_elp_sleep(wl
);
3651 mutex_unlock(&wl
->mutex
);
3656 static bool wl1271_tx_frames_pending(struct ieee80211_hw
*hw
)
3658 struct wl1271
*wl
= hw
->priv
;
3661 mutex_lock(&wl
->mutex
);
3663 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3666 /* packets are considered pending if in the TX queue or the FW */
3667 ret
= (wl1271_tx_total_queue_count(wl
) > 0) || (wl
->tx_frames_cnt
> 0);
3669 /* the above is appropriate for STA mode for PS purposes */
3670 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
3673 mutex_unlock(&wl
->mutex
);
3678 /* can't be const, mac80211 writes to this */
3679 static struct ieee80211_rate wl1271_rates
[] = {
3681 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
3682 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
3684 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
3685 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
3686 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3688 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
3689 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
3690 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3692 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
3693 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
3694 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3696 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3697 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3699 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3700 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3702 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3703 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3705 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3706 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3708 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3709 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3711 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3712 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3714 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3715 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3717 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3718 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3721 /* can't be const, mac80211 writes to this */
3722 static struct ieee80211_channel wl1271_channels
[] = {
3723 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
3724 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
3725 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
3726 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
3727 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
3728 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
3729 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
3730 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
3731 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
3732 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
3733 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
3734 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
3735 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
3736 { .hw_value
= 14, .center_freq
= 2484, .max_power
= 25 },
3739 /* mapping to indexes for wl1271_rates */
3740 static const u8 wl1271_rate_to_idx_2ghz
[] = {
3741 /* MCS rates are used only with 11n */
3742 7, /* CONF_HW_RXTX_RATE_MCS7 */
3743 6, /* CONF_HW_RXTX_RATE_MCS6 */
3744 5, /* CONF_HW_RXTX_RATE_MCS5 */
3745 4, /* CONF_HW_RXTX_RATE_MCS4 */
3746 3, /* CONF_HW_RXTX_RATE_MCS3 */
3747 2, /* CONF_HW_RXTX_RATE_MCS2 */
3748 1, /* CONF_HW_RXTX_RATE_MCS1 */
3749 0, /* CONF_HW_RXTX_RATE_MCS0 */
3751 11, /* CONF_HW_RXTX_RATE_54 */
3752 10, /* CONF_HW_RXTX_RATE_48 */
3753 9, /* CONF_HW_RXTX_RATE_36 */
3754 8, /* CONF_HW_RXTX_RATE_24 */
3756 /* TI-specific rate */
3757 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3759 7, /* CONF_HW_RXTX_RATE_18 */
3760 6, /* CONF_HW_RXTX_RATE_12 */
3761 3, /* CONF_HW_RXTX_RATE_11 */
3762 5, /* CONF_HW_RXTX_RATE_9 */
3763 4, /* CONF_HW_RXTX_RATE_6 */
3764 2, /* CONF_HW_RXTX_RATE_5_5 */
3765 1, /* CONF_HW_RXTX_RATE_2 */
3766 0 /* CONF_HW_RXTX_RATE_1 */
3769 /* 11n STA capabilities */
3770 #define HW_RX_HIGHEST_RATE 72
3772 #ifdef CONFIG_WL12XX_HT
3773 #define WL12XX_HT_CAP { \
3774 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3775 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3776 .ht_supported = true, \
3777 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3778 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3780 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3781 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3782 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3786 #define WL12XX_HT_CAP { \
3787 .ht_supported = false, \
3791 /* can't be const, mac80211 writes to this */
3792 static struct ieee80211_supported_band wl1271_band_2ghz
= {
3793 .channels
= wl1271_channels
,
3794 .n_channels
= ARRAY_SIZE(wl1271_channels
),
3795 .bitrates
= wl1271_rates
,
3796 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
3797 .ht_cap
= WL12XX_HT_CAP
,
3800 /* 5 GHz data rates for WL1273 */
3801 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
3803 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3804 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3806 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3807 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3809 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3810 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3812 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3813 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3815 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3816 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3818 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3819 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3821 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3822 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3824 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3825 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3828 /* 5 GHz band channels for WL1273 */
3829 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
3830 { .hw_value
= 7, .center_freq
= 5035, .max_power
= 25 },
3831 { .hw_value
= 8, .center_freq
= 5040, .max_power
= 25 },
3832 { .hw_value
= 9, .center_freq
= 5045, .max_power
= 25 },
3833 { .hw_value
= 11, .center_freq
= 5055, .max_power
= 25 },
3834 { .hw_value
= 12, .center_freq
= 5060, .max_power
= 25 },
3835 { .hw_value
= 16, .center_freq
= 5080, .max_power
= 25 },
3836 { .hw_value
= 34, .center_freq
= 5170, .max_power
= 25 },
3837 { .hw_value
= 36, .center_freq
= 5180, .max_power
= 25 },
3838 { .hw_value
= 38, .center_freq
= 5190, .max_power
= 25 },
3839 { .hw_value
= 40, .center_freq
= 5200, .max_power
= 25 },
3840 { .hw_value
= 42, .center_freq
= 5210, .max_power
= 25 },
3841 { .hw_value
= 44, .center_freq
= 5220, .max_power
= 25 },
3842 { .hw_value
= 46, .center_freq
= 5230, .max_power
= 25 },
3843 { .hw_value
= 48, .center_freq
= 5240, .max_power
= 25 },
3844 { .hw_value
= 52, .center_freq
= 5260, .max_power
= 25 },
3845 { .hw_value
= 56, .center_freq
= 5280, .max_power
= 25 },
3846 { .hw_value
= 60, .center_freq
= 5300, .max_power
= 25 },
3847 { .hw_value
= 64, .center_freq
= 5320, .max_power
= 25 },
3848 { .hw_value
= 100, .center_freq
= 5500, .max_power
= 25 },
3849 { .hw_value
= 104, .center_freq
= 5520, .max_power
= 25 },
3850 { .hw_value
= 108, .center_freq
= 5540, .max_power
= 25 },
3851 { .hw_value
= 112, .center_freq
= 5560, .max_power
= 25 },
3852 { .hw_value
= 116, .center_freq
= 5580, .max_power
= 25 },
3853 { .hw_value
= 120, .center_freq
= 5600, .max_power
= 25 },
3854 { .hw_value
= 124, .center_freq
= 5620, .max_power
= 25 },
3855 { .hw_value
= 128, .center_freq
= 5640, .max_power
= 25 },
3856 { .hw_value
= 132, .center_freq
= 5660, .max_power
= 25 },
3857 { .hw_value
= 136, .center_freq
= 5680, .max_power
= 25 },
3858 { .hw_value
= 140, .center_freq
= 5700, .max_power
= 25 },
3859 { .hw_value
= 149, .center_freq
= 5745, .max_power
= 25 },
3860 { .hw_value
= 153, .center_freq
= 5765, .max_power
= 25 },
3861 { .hw_value
= 157, .center_freq
= 5785, .max_power
= 25 },
3862 { .hw_value
= 161, .center_freq
= 5805, .max_power
= 25 },
3863 { .hw_value
= 165, .center_freq
= 5825, .max_power
= 25 },
3866 /* mapping to indexes for wl1271_rates_5ghz */
3867 static const u8 wl1271_rate_to_idx_5ghz
[] = {
3868 /* MCS rates are used only with 11n */
3869 7, /* CONF_HW_RXTX_RATE_MCS7 */
3870 6, /* CONF_HW_RXTX_RATE_MCS6 */
3871 5, /* CONF_HW_RXTX_RATE_MCS5 */
3872 4, /* CONF_HW_RXTX_RATE_MCS4 */
3873 3, /* CONF_HW_RXTX_RATE_MCS3 */
3874 2, /* CONF_HW_RXTX_RATE_MCS2 */
3875 1, /* CONF_HW_RXTX_RATE_MCS1 */
3876 0, /* CONF_HW_RXTX_RATE_MCS0 */
3878 7, /* CONF_HW_RXTX_RATE_54 */
3879 6, /* CONF_HW_RXTX_RATE_48 */
3880 5, /* CONF_HW_RXTX_RATE_36 */
3881 4, /* CONF_HW_RXTX_RATE_24 */
3883 /* TI-specific rate */
3884 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3886 3, /* CONF_HW_RXTX_RATE_18 */
3887 2, /* CONF_HW_RXTX_RATE_12 */
3888 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_11 */
3889 1, /* CONF_HW_RXTX_RATE_9 */
3890 0, /* CONF_HW_RXTX_RATE_6 */
3891 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_5_5 */
3892 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_2 */
3893 CONF_HW_RXTX_RATE_UNSUPPORTED
/* CONF_HW_RXTX_RATE_1 */
3896 static struct ieee80211_supported_band wl1271_band_5ghz
= {
3897 .channels
= wl1271_channels_5ghz
,
3898 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
3899 .bitrates
= wl1271_rates_5ghz
,
3900 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
3901 .ht_cap
= WL12XX_HT_CAP
,
3904 static const u8
*wl1271_band_rate_to_idx
[] = {
3905 [IEEE80211_BAND_2GHZ
] = wl1271_rate_to_idx_2ghz
,
3906 [IEEE80211_BAND_5GHZ
] = wl1271_rate_to_idx_5ghz
3909 static const struct ieee80211_ops wl1271_ops
= {
3910 .start
= wl1271_op_start
,
3911 .stop
= wl1271_op_stop
,
3912 .add_interface
= wl1271_op_add_interface
,
3913 .remove_interface
= wl1271_op_remove_interface
,
3915 .suspend
= wl1271_op_suspend
,
3916 .resume
= wl1271_op_resume
,
3918 .config
= wl1271_op_config
,
3919 .prepare_multicast
= wl1271_op_prepare_multicast
,
3920 .configure_filter
= wl1271_op_configure_filter
,
3922 .set_key
= wl1271_op_set_key
,
3923 .hw_scan
= wl1271_op_hw_scan
,
3924 .cancel_hw_scan
= wl1271_op_cancel_hw_scan
,
3925 .sched_scan_start
= wl1271_op_sched_scan_start
,
3926 .sched_scan_stop
= wl1271_op_sched_scan_stop
,
3927 .bss_info_changed
= wl1271_op_bss_info_changed
,
3928 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
3929 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
3930 .conf_tx
= wl1271_op_conf_tx
,
3931 .get_tsf
= wl1271_op_get_tsf
,
3932 .get_survey
= wl1271_op_get_survey
,
3933 .sta_add
= wl1271_op_sta_add
,
3934 .sta_remove
= wl1271_op_sta_remove
,
3935 .ampdu_action
= wl1271_op_ampdu_action
,
3936 .tx_frames_pending
= wl1271_tx_frames_pending
,
3937 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
3941 u8
wl1271_rate_to_idx(int rate
, enum ieee80211_band band
)
3945 BUG_ON(band
>= sizeof(wl1271_band_rate_to_idx
)/sizeof(u8
*));
3947 if (unlikely(rate
>= CONF_HW_RXTX_RATE_MAX
)) {
3948 wl1271_error("Illegal RX rate from HW: %d", rate
);
3952 idx
= wl1271_band_rate_to_idx
[band
][rate
];
3953 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
3954 wl1271_error("Unsupported RX rate from HW: %d", rate
);
3961 static ssize_t
wl1271_sysfs_show_bt_coex_state(struct device
*dev
,
3962 struct device_attribute
*attr
,
3965 struct wl1271
*wl
= dev_get_drvdata(dev
);
3970 mutex_lock(&wl
->mutex
);
3971 len
= snprintf(buf
, len
, "%d\n\n0 - off\n1 - on\n",
3973 mutex_unlock(&wl
->mutex
);
3979 static ssize_t
wl1271_sysfs_store_bt_coex_state(struct device
*dev
,
3980 struct device_attribute
*attr
,
3981 const char *buf
, size_t count
)
3983 struct wl1271
*wl
= dev_get_drvdata(dev
);
3987 ret
= kstrtoul(buf
, 10, &res
);
3989 wl1271_warning("incorrect value written to bt_coex_mode");
3993 mutex_lock(&wl
->mutex
);
3997 if (res
== wl
->sg_enabled
)
4000 wl
->sg_enabled
= res
;
4002 if (wl
->state
== WL1271_STATE_OFF
)
4005 ret
= wl1271_ps_elp_wakeup(wl
);
4009 wl1271_acx_sg_enable(wl
, wl
->sg_enabled
);
4010 wl1271_ps_elp_sleep(wl
);
4013 mutex_unlock(&wl
->mutex
);
4017 static DEVICE_ATTR(bt_coex_state
, S_IRUGO
| S_IWUSR
,
4018 wl1271_sysfs_show_bt_coex_state
,
4019 wl1271_sysfs_store_bt_coex_state
);
4021 static ssize_t
wl1271_sysfs_show_hw_pg_ver(struct device
*dev
,
4022 struct device_attribute
*attr
,
4025 struct wl1271
*wl
= dev_get_drvdata(dev
);
4030 mutex_lock(&wl
->mutex
);
4031 if (wl
->hw_pg_ver
>= 0)
4032 len
= snprintf(buf
, len
, "%d\n", wl
->hw_pg_ver
);
4034 len
= snprintf(buf
, len
, "n/a\n");
4035 mutex_unlock(&wl
->mutex
);
4040 static DEVICE_ATTR(hw_pg_ver
, S_IRUGO
,
4041 wl1271_sysfs_show_hw_pg_ver
, NULL
);
4043 static ssize_t
wl1271_sysfs_read_fwlog(struct file
*filp
, struct kobject
*kobj
,
4044 struct bin_attribute
*bin_attr
,
4045 char *buffer
, loff_t pos
, size_t count
)
4047 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
4048 struct wl1271
*wl
= dev_get_drvdata(dev
);
4052 ret
= mutex_lock_interruptible(&wl
->mutex
);
4054 return -ERESTARTSYS
;
4056 /* Let only one thread read the log at a time, blocking others */
4057 while (wl
->fwlog_size
== 0) {
4060 prepare_to_wait_exclusive(&wl
->fwlog_waitq
,
4062 TASK_INTERRUPTIBLE
);
4064 if (wl
->fwlog_size
!= 0) {
4065 finish_wait(&wl
->fwlog_waitq
, &wait
);
4069 mutex_unlock(&wl
->mutex
);
4072 finish_wait(&wl
->fwlog_waitq
, &wait
);
4074 if (signal_pending(current
))
4075 return -ERESTARTSYS
;
4077 ret
= mutex_lock_interruptible(&wl
->mutex
);
4079 return -ERESTARTSYS
;
4082 /* Check if the fwlog is still valid */
4083 if (wl
->fwlog_size
< 0) {
4084 mutex_unlock(&wl
->mutex
);
4088 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4089 len
= min(count
, (size_t)wl
->fwlog_size
);
4090 wl
->fwlog_size
-= len
;
4091 memcpy(buffer
, wl
->fwlog
, len
);
4093 /* Make room for new messages */
4094 memmove(wl
->fwlog
, wl
->fwlog
+ len
, wl
->fwlog_size
);
4096 mutex_unlock(&wl
->mutex
);
4101 static struct bin_attribute fwlog_attr
= {
4102 .attr
= {.name
= "fwlog", .mode
= S_IRUSR
},
4103 .read
= wl1271_sysfs_read_fwlog
,
4106 int wl1271_register_hw(struct wl1271
*wl
)
4110 if (wl
->mac80211_registered
)
4113 ret
= wl1271_fetch_nvs(wl
);
4115 /* NOTE: The wl->nvs->nvs element must be first, in
4116 * order to simplify the casting, we assume it is at
4117 * the beginning of the wl->nvs structure.
4119 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
4121 wl
->mac_addr
[0] = nvs_ptr
[11];
4122 wl
->mac_addr
[1] = nvs_ptr
[10];
4123 wl
->mac_addr
[2] = nvs_ptr
[6];
4124 wl
->mac_addr
[3] = nvs_ptr
[5];
4125 wl
->mac_addr
[4] = nvs_ptr
[4];
4126 wl
->mac_addr
[5] = nvs_ptr
[3];
4129 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
4131 ret
= ieee80211_register_hw(wl
->hw
);
4133 wl1271_error("unable to register mac80211 hw: %d", ret
);
4137 wl
->mac80211_registered
= true;
4139 wl1271_debugfs_init(wl
);
4141 register_netdevice_notifier(&wl1271_dev_notifier
);
4143 wl1271_notice("loaded");
4147 EXPORT_SYMBOL_GPL(wl1271_register_hw
);
4149 void wl1271_unregister_hw(struct wl1271
*wl
)
4151 if (wl
->state
== WL1271_STATE_PLT
)
4152 __wl1271_plt_stop(wl
);
4154 unregister_netdevice_notifier(&wl1271_dev_notifier
);
4155 ieee80211_unregister_hw(wl
->hw
);
4156 wl
->mac80211_registered
= false;
4159 EXPORT_SYMBOL_GPL(wl1271_unregister_hw
);
4161 int wl1271_init_ieee80211(struct wl1271
*wl
)
4163 static const u32 cipher_suites
[] = {
4164 WLAN_CIPHER_SUITE_WEP40
,
4165 WLAN_CIPHER_SUITE_WEP104
,
4166 WLAN_CIPHER_SUITE_TKIP
,
4167 WLAN_CIPHER_SUITE_CCMP
,
4168 WL1271_CIPHER_SUITE_GEM
,
4171 /* The tx descriptor buffer and the TKIP space. */
4172 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
4173 sizeof(struct wl1271_tx_hw_descr
);
4176 /* FIXME: find a proper value */
4177 wl
->hw
->channel_change_time
= 10000;
4178 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
4180 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
4181 IEEE80211_HW_BEACON_FILTER
|
4182 IEEE80211_HW_SUPPORTS_PS
|
4183 IEEE80211_HW_SUPPORTS_UAPSD
|
4184 IEEE80211_HW_HAS_RATE_CONTROL
|
4185 IEEE80211_HW_CONNECTION_MONITOR
|
4186 IEEE80211_HW_SUPPORTS_CQM_RSSI
|
4187 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
4188 IEEE80211_HW_SPECTRUM_MGMT
|
4189 IEEE80211_HW_AP_LINK_PS
;
4191 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
4192 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
4194 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
4195 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
4196 wl
->hw
->wiphy
->max_scan_ssids
= 1;
4198 * Maximum length of elements in scanning probe request templates
4199 * should be the maximum length possible for a template, without
4200 * the IEEE80211 header of the template
4202 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
4203 sizeof(struct ieee80211_header
);
4205 /* make sure all our channels fit in the scanned_ch bitmask */
4206 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
4207 ARRAY_SIZE(wl1271_channels_5ghz
) >
4208 WL1271_MAX_CHANNELS
);
4210 * We keep local copies of the band structs because we need to
4211 * modify them on a per-device basis.
4213 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
4214 sizeof(wl1271_band_2ghz
));
4215 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
4216 sizeof(wl1271_band_5ghz
));
4218 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
4219 &wl
->bands
[IEEE80211_BAND_2GHZ
];
4220 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
4221 &wl
->bands
[IEEE80211_BAND_5GHZ
];
4224 wl
->hw
->max_rates
= 1;
4226 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
4228 SET_IEEE80211_DEV(wl
->hw
, wl1271_wl_to_dev(wl
));
4230 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
4232 wl
->hw
->max_rx_aggregation_subframes
= 8;
4236 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211
);
4238 #define WL1271_DEFAULT_CHANNEL 0
4240 struct ieee80211_hw
*wl1271_alloc_hw(void)
4242 struct ieee80211_hw
*hw
;
4243 struct platform_device
*plat_dev
= NULL
;
4248 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
4250 wl1271_error("could not alloc ieee80211_hw");
4255 plat_dev
= kmemdup(&wl1271_device
, sizeof(wl1271_device
), GFP_KERNEL
);
4257 wl1271_error("could not allocate platform_device");
4259 goto err_plat_alloc
;
4263 memset(wl
, 0, sizeof(*wl
));
4265 INIT_LIST_HEAD(&wl
->list
);
4268 wl
->plat_dev
= plat_dev
;
4270 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
4271 skb_queue_head_init(&wl
->tx_queue
[i
]);
4273 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
4274 for (j
= 0; j
< AP_MAX_LINKS
; j
++)
4275 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
4277 skb_queue_head_init(&wl
->deferred_rx_queue
);
4278 skb_queue_head_init(&wl
->deferred_tx_queue
);
4280 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
4281 INIT_DELAYED_WORK(&wl
->pspoll_work
, wl1271_pspoll_work
);
4282 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
4283 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
4284 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
4285 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
4286 INIT_WORK(&wl
->rx_streaming_enable_work
,
4287 wl1271_rx_streaming_enable_work
);
4288 INIT_WORK(&wl
->rx_streaming_disable_work
,
4289 wl1271_rx_streaming_disable_work
);
4291 wl
->freezable_wq
= create_freezable_workqueue("wl12xx_wq");
4292 if (!wl
->freezable_wq
) {
4297 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
4298 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
4299 wl
->default_key
= 0;
4301 wl
->psm_entry_retry
= 0;
4302 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
4303 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
4304 wl
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
4305 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
4306 wl
->band
= IEEE80211_BAND_2GHZ
;
4309 wl
->sg_enabled
= true;
4311 wl
->bss_type
= MAX_BSS_TYPE
;
4312 wl
->set_bss_type
= MAX_BSS_TYPE
;
4313 wl
->last_tx_hlid
= 0;
4315 wl
->ap_fw_ps_map
= 0;
4317 wl
->platform_quirks
= 0;
4318 wl
->sched_scanning
= false;
4319 wl
->tx_security_seq
= 0;
4320 wl
->tx_security_last_seq_lsb
= 0;
4321 wl
->role_id
= WL12XX_INVALID_ROLE_ID
;
4322 wl
->sta_hlid
= WL12XX_INVALID_LINK_ID
;
4324 setup_timer(&wl
->rx_streaming_timer
, wl1271_rx_streaming_timer
,
4325 (unsigned long) wl
);
4327 init_waitqueue_head(&wl
->fwlog_waitq
);
4329 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
4330 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
4331 wl
->tx_frames
[i
] = NULL
;
4333 spin_lock_init(&wl
->wl_lock
);
4335 wl
->state
= WL1271_STATE_OFF
;
4336 mutex_init(&wl
->mutex
);
4338 /* Apply default driver configuration. */
4339 wl1271_conf_init(wl
);
4341 order
= get_order(WL1271_AGGR_BUFFER_SIZE
);
4342 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
4343 if (!wl
->aggr_buf
) {
4348 wl
->dummy_packet
= wl12xx_alloc_dummy_packet(wl
);
4349 if (!wl
->dummy_packet
) {
4354 /* Allocate one page for the FW log */
4355 wl
->fwlog
= (u8
*)get_zeroed_page(GFP_KERNEL
);
4358 goto err_dummy_packet
;
4361 /* Register platform device */
4362 ret
= platform_device_register(wl
->plat_dev
);
4364 wl1271_error("couldn't register platform device");
4367 dev_set_drvdata(&wl
->plat_dev
->dev
, wl
);
4369 /* Create sysfs file to control bt coex state */
4370 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4372 wl1271_error("failed to create sysfs file bt_coex_state");
4376 /* Create sysfs file to get HW PG version */
4377 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4379 wl1271_error("failed to create sysfs file hw_pg_ver");
4380 goto err_bt_coex_state
;
4383 /* Create sysfs file for the FW log */
4384 ret
= device_create_bin_file(&wl
->plat_dev
->dev
, &fwlog_attr
);
4386 wl1271_error("failed to create sysfs file fwlog");
4393 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4396 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4399 platform_device_unregister(wl
->plat_dev
);
4402 free_page((unsigned long)wl
->fwlog
);
4405 dev_kfree_skb(wl
->dummy_packet
);
4408 free_pages((unsigned long)wl
->aggr_buf
, order
);
4411 destroy_workqueue(wl
->freezable_wq
);
4414 wl1271_debugfs_exit(wl
);
4418 ieee80211_free_hw(hw
);
4422 return ERR_PTR(ret
);
4424 EXPORT_SYMBOL_GPL(wl1271_alloc_hw
);
4426 int wl1271_free_hw(struct wl1271
*wl
)
4428 /* Unblock any fwlog readers */
4429 mutex_lock(&wl
->mutex
);
4430 wl
->fwlog_size
= -1;
4431 wake_up_interruptible_all(&wl
->fwlog_waitq
);
4432 mutex_unlock(&wl
->mutex
);
4434 device_remove_bin_file(&wl
->plat_dev
->dev
, &fwlog_attr
);
4436 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4438 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4439 platform_device_unregister(wl
->plat_dev
);
4440 free_page((unsigned long)wl
->fwlog
);
4441 dev_kfree_skb(wl
->dummy_packet
);
4442 free_pages((unsigned long)wl
->aggr_buf
,
4443 get_order(WL1271_AGGR_BUFFER_SIZE
));
4444 kfree(wl
->plat_dev
);
4446 wl1271_debugfs_exit(wl
);
4453 kfree(wl
->fw_status
);
4454 kfree(wl
->tx_res_if
);
4455 destroy_workqueue(wl
->freezable_wq
);
4457 ieee80211_free_hw(wl
->hw
);
4461 EXPORT_SYMBOL_GPL(wl1271_free_hw
);
4463 u32 wl12xx_debug_level
= DEBUG_NONE
;
4464 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
4465 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
4466 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
4468 module_param_named(fwlog
, fwlog_param
, charp
, 0);
4469 MODULE_PARM_DESC(keymap
,
4470 "FW logger options: continuous, ondemand, dbgpins or disable");
4472 MODULE_LICENSE("GPL");
4473 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4474 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");