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>
36 #include "wl12xx_80211.h"
50 #define WL1271_BOOT_RETRIES 3
52 static struct conf_drv_settings default_conf
= {
55 [CONF_SG_BT_PER_THRESHOLD
] = 7500,
56 [CONF_SG_HV3_MAX_OVERRIDE
] = 0,
57 [CONF_SG_BT_NFS_SAMPLE_INTERVAL
] = 400,
58 [CONF_SG_BT_LOAD_RATIO
] = 200,
59 [CONF_SG_AUTO_PS_MODE
] = 1,
60 [CONF_SG_AUTO_SCAN_PROBE_REQ
] = 170,
61 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3
] = 50,
62 [CONF_SG_ANTENNA_CONFIGURATION
] = 0,
63 [CONF_SG_BEACON_MISS_PERCENT
] = 60,
64 [CONF_SG_RATE_ADAPT_THRESH
] = 12,
65 [CONF_SG_RATE_ADAPT_SNR
] = 0,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR
] = 10,
67 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR
] = 30,
68 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR
] = 8,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR
] = 20,
70 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR
] = 50,
71 /* Note: with UPSD, this should be 4 */
72 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR
] = 8,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR
] = 7,
74 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR
] = 25,
75 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR
] = 20,
76 /* Note: with UPDS, this should be 15 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR
] = 8,
78 /* Note: with UPDS, this should be 50 */
79 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR
] = 40,
80 /* Note: with UPDS, this should be 10 */
81 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR
] = 20,
84 [CONF_SG_ADAPTIVE_RXT_TXT
] = 1,
85 [CONF_SG_PS_POLL_TIMEOUT
] = 10,
86 [CONF_SG_UPSD_TIMEOUT
] = 10,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR
] = 7,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR
] = 15,
89 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR
] = 15,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR
] = 8,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR
] = 20,
92 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR
] = 15,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR
] = 20,
94 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR
] = 50,
95 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR
] = 10,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3
] = 200,
97 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP
] = 800,
98 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME
] = 75,
99 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME
] = 15,
100 [CONF_SG_HV3_MAX_SERVED
] = 6,
101 [CONF_SG_DHCP_TIME
] = 5000,
102 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP
] = 100,
105 [CONF_SG_BT_PER_THRESHOLD
] = 7500,
106 [CONF_SG_HV3_MAX_OVERRIDE
] = 0,
107 [CONF_SG_BT_NFS_SAMPLE_INTERVAL
] = 400,
108 [CONF_SG_BT_LOAD_RATIO
] = 50,
109 [CONF_SG_AUTO_PS_MODE
] = 1,
110 [CONF_SG_AUTO_SCAN_PROBE_REQ
] = 170,
111 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3
] = 50,
112 [CONF_SG_ANTENNA_CONFIGURATION
] = 0,
113 [CONF_SG_BEACON_MISS_PERCENT
] = 60,
114 [CONF_SG_RATE_ADAPT_THRESH
] = 64,
115 [CONF_SG_RATE_ADAPT_SNR
] = 1,
116 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR
] = 10,
117 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR
] = 25,
118 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR
] = 25,
119 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR
] = 20,
120 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR
] = 25,
121 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR
] = 25,
122 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR
] = 7,
123 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR
] = 25,
124 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR
] = 25,
125 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR
] = 8,
126 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR
] = 25,
127 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR
] = 25,
128 [CONF_SG_RXT
] = 1200,
129 [CONF_SG_TXT
] = 1000,
130 [CONF_SG_ADAPTIVE_RXT_TXT
] = 1,
131 [CONF_SG_PS_POLL_TIMEOUT
] = 10,
132 [CONF_SG_UPSD_TIMEOUT
] = 10,
133 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR
] = 7,
134 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR
] = 15,
135 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR
] = 15,
136 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR
] = 8,
137 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR
] = 20,
138 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR
] = 15,
139 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR
] = 20,
140 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR
] = 50,
141 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR
] = 10,
142 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3
] = 200,
143 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP
] = 800,
144 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME
] = 75,
145 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME
] = 15,
146 [CONF_SG_HV3_MAX_SERVED
] = 6,
147 [CONF_SG_DHCP_TIME
] = 5000,
148 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP
] = 100,
149 [CONF_SG_TEMP_PARAM_1
] = 0,
150 [CONF_SG_TEMP_PARAM_2
] = 0,
151 [CONF_SG_TEMP_PARAM_3
] = 0,
152 [CONF_SG_TEMP_PARAM_4
] = 0,
153 [CONF_SG_TEMP_PARAM_5
] = 0,
154 [CONF_SG_AP_BEACON_MISS_TX
] = 3,
155 [CONF_SG_RX_WINDOW_LENGTH
] = 6,
156 [CONF_SG_AP_CONNECTION_PROTECTION_TIME
] = 50,
157 [CONF_SG_TEMP_PARAM_6
] = 1,
159 .state
= CONF_SG_PROTECTIVE
,
162 .rx_msdu_life_time
= 512000,
163 .packet_detection_threshold
= 0,
164 .ps_poll_timeout
= 15,
166 .rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
,
167 .rx_cca_threshold
= 0,
168 .irq_blk_threshold
= 0xFFFF,
169 .irq_pkt_threshold
= 0,
171 .queue_type
= CONF_RX_QUEUE_TYPE_LOW_PRIORITY
,
174 .tx_energy_detection
= 0,
177 .short_retry_limit
= 10,
178 .long_retry_limit
= 10,
201 .aifsn
= CONF_TX_AIFS_PIFS
,
208 .aifsn
= CONF_TX_AIFS_PIFS
,
212 .ap_max_tx_retries
= 100,
216 .queue_id
= CONF_TX_AC_BE
,
217 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
218 .tsid
= CONF_TX_AC_BE
,
219 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
220 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
224 .queue_id
= CONF_TX_AC_BK
,
225 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
226 .tsid
= CONF_TX_AC_BK
,
227 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
228 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
232 .queue_id
= CONF_TX_AC_VI
,
233 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
234 .tsid
= CONF_TX_AC_VI
,
235 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
236 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
240 .queue_id
= CONF_TX_AC_VO
,
241 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
242 .tsid
= CONF_TX_AC_VO
,
243 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
244 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
248 .frag_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
,
249 .tx_compl_timeout
= 700,
250 .tx_compl_threshold
= 4,
251 .basic_rate
= CONF_HW_BIT_RATE_1MBPS
,
252 .basic_rate_5
= CONF_HW_BIT_RATE_6MBPS
,
253 .tmpl_short_retry_limit
= 10,
254 .tmpl_long_retry_limit
= 10,
257 .wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
,
258 .listen_interval
= 1,
259 .bcn_filt_mode
= CONF_BCN_FILT_MODE_ENABLED
,
260 .bcn_filt_ie_count
= 2,
263 .ie
= WLAN_EID_CHANNEL_SWITCH
,
264 .rule
= CONF_BCN_RULE_PASS_ON_APPEARANCE
,
267 .ie
= WLAN_EID_HT_INFORMATION
,
268 .rule
= CONF_BCN_RULE_PASS_ON_CHANGE
,
271 .synch_fail_thold
= 10,
272 .bss_lose_timeout
= 100,
273 .beacon_rx_timeout
= 10000,
274 .broadcast_timeout
= 20000,
275 .rx_broadcast_in_ps
= 1,
276 .ps_poll_threshold
= 10,
277 .ps_poll_recovery_period
= 700,
278 .bet_enable
= CONF_BET_MODE_ENABLE
,
279 .bet_max_consecutive
= 50,
280 .psm_entry_retries
= 5,
281 .psm_exit_retries
= 16,
282 .psm_entry_nullfunc_retries
= 3,
283 .psm_entry_hangover_period
= 1,
284 .keep_alive_interval
= 55000,
285 .max_listen_interval
= 20,
292 .host_clk_settling_time
= 5000,
293 .host_fast_wakeup_support
= false
297 .avg_weight_rssi_beacon
= 20,
298 .avg_weight_rssi_data
= 10,
299 .avg_weight_snr_beacon
= 20,
300 .avg_weight_snr_data
= 10,
303 .min_dwell_time_active
= 7500,
304 .max_dwell_time_active
= 30000,
305 .min_dwell_time_passive
= 100000,
306 .max_dwell_time_passive
= 100000,
310 /* sched_scan requires dwell times in TU instead of TU/1000 */
311 .min_dwell_time_active
= 8,
312 .max_dwell_time_active
= 30,
313 .dwell_time_passive
= 100,
315 .rssi_threshold
= -90,
319 .tx_per_channel_power_compensation_2
= {
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
322 .tx_per_channel_power_compensation_5
= {
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
325 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
329 .tx_ba_win_size
= 64,
330 .inactivity_timeout
= 10000,
336 .tx_min_block_num
= 40,
338 .min_req_tx_blocks
= 100,
339 .min_req_rx_blocks
= 22,
346 .tx_min_block_num
= 40,
348 .min_req_tx_blocks
= 45,
349 .min_req_rx_blocks
= 22,
355 .n_divider_fref_set_1
= 0xff, /* default */
356 .n_divider_fref_set_2
= 12,
357 .m_divider_fref_set_1
= 148,
358 .m_divider_fref_set_2
= 0xffff, /* default */
359 .coex_pll_stabilization_time
= 0xffffffff, /* default */
360 .ldo_stabilization_time
= 0xffff, /* default */
361 .fm_disturbed_band_margin
= 0xff, /* default */
362 .swallow_clk_diff
= 0xff, /* default */
364 .hci_io_ds
= HCI_IO_DS_6MA
,
367 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
368 bool reset_tx_queues
);
369 static void wl1271_free_ap_keys(struct wl1271
*wl
);
372 static void wl1271_device_release(struct device
*dev
)
377 static struct platform_device wl1271_device
= {
381 /* device model insists to have a release function */
383 .release
= wl1271_device_release
,
387 static DEFINE_MUTEX(wl_list_mutex
);
388 static LIST_HEAD(wl_list
);
390 static int wl1271_dev_notify(struct notifier_block
*me
, unsigned long what
,
393 struct net_device
*dev
= arg
;
394 struct wireless_dev
*wdev
;
396 struct ieee80211_hw
*hw
;
398 struct wl1271
*wl_temp
;
401 /* Check that this notification is for us. */
402 if (what
!= NETDEV_CHANGE
)
405 wdev
= dev
->ieee80211_ptr
;
413 hw
= wiphy_priv(wiphy
);
418 mutex_lock(&wl_list_mutex
);
419 list_for_each_entry(wl
, &wl_list
, list
) {
423 mutex_unlock(&wl_list_mutex
);
427 mutex_lock(&wl
->mutex
);
429 if (wl
->state
== WL1271_STATE_OFF
)
432 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
435 ret
= wl1271_ps_elp_wakeup(wl
);
439 if ((dev
->operstate
== IF_OPER_UP
) &&
440 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
)) {
441 wl1271_cmd_set_sta_state(wl
);
442 wl1271_info("Association completed.");
445 wl1271_ps_elp_sleep(wl
);
448 mutex_unlock(&wl
->mutex
);
453 static int wl1271_reg_notify(struct wiphy
*wiphy
,
454 struct regulatory_request
*request
)
456 struct ieee80211_supported_band
*band
;
457 struct ieee80211_channel
*ch
;
460 band
= wiphy
->bands
[IEEE80211_BAND_5GHZ
];
461 for (i
= 0; i
< band
->n_channels
; i
++) {
462 ch
= &band
->channels
[i
];
463 if (ch
->flags
& IEEE80211_CHAN_DISABLED
)
466 if (ch
->flags
& IEEE80211_CHAN_RADAR
)
467 ch
->flags
|= IEEE80211_CHAN_NO_IBSS
|
468 IEEE80211_CHAN_PASSIVE_SCAN
;
475 static void wl1271_conf_init(struct wl1271
*wl
)
479 * This function applies the default configuration to the driver. This
480 * function is invoked upon driver load (spi probe.)
482 * The configuration is stored in a run-time structure in order to
483 * facilitate for run-time adjustment of any of the parameters. Making
484 * changes to the configuration structure will apply the new values on
485 * the next interface up (wl1271_op_start.)
488 /* apply driver default configuration */
489 memcpy(&wl
->conf
, &default_conf
, sizeof(default_conf
));
493 static int wl1271_plt_init(struct wl1271
*wl
)
495 struct conf_tx_ac_category
*conf_ac
;
496 struct conf_tx_tid
*conf_tid
;
499 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
500 ret
= wl128x_cmd_general_parms(wl
);
502 ret
= wl1271_cmd_general_parms(wl
);
506 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
507 ret
= wl128x_cmd_radio_parms(wl
);
509 ret
= wl1271_cmd_radio_parms(wl
);
513 if (wl
->chip
.id
!= CHIP_ID_1283_PG20
) {
514 ret
= wl1271_cmd_ext_radio_parms(wl
);
521 /* Chip-specific initializations */
522 ret
= wl1271_chip_specific_init(wl
);
526 ret
= wl1271_sta_init_templates_config(wl
);
530 ret
= wl1271_acx_init_mem_config(wl
);
534 /* PHY layer config */
535 ret
= wl1271_init_phy_config(wl
);
537 goto out_free_memmap
;
539 ret
= wl1271_acx_dco_itrim_params(wl
);
541 goto out_free_memmap
;
543 /* Initialize connection monitoring thresholds */
544 ret
= wl1271_acx_conn_monit_params(wl
, false);
546 goto out_free_memmap
;
548 /* Bluetooth WLAN coexistence */
549 ret
= wl1271_init_pta(wl
);
551 goto out_free_memmap
;
553 /* FM WLAN coexistence */
554 ret
= wl1271_acx_fm_coex(wl
);
556 goto out_free_memmap
;
558 /* Energy detection */
559 ret
= wl1271_init_energy_detection(wl
);
561 goto out_free_memmap
;
563 ret
= wl1271_acx_sta_mem_cfg(wl
);
565 goto out_free_memmap
;
567 /* Default fragmentation threshold */
568 ret
= wl1271_acx_frag_threshold(wl
, wl
->conf
.tx
.frag_threshold
);
570 goto out_free_memmap
;
572 /* Default TID/AC configuration */
573 BUG_ON(wl
->conf
.tx
.tid_conf_count
!= wl
->conf
.tx
.ac_conf_count
);
574 for (i
= 0; i
< wl
->conf
.tx
.tid_conf_count
; i
++) {
575 conf_ac
= &wl
->conf
.tx
.ac_conf
[i
];
576 ret
= wl1271_acx_ac_cfg(wl
, conf_ac
->ac
, conf_ac
->cw_min
,
577 conf_ac
->cw_max
, conf_ac
->aifsn
,
578 conf_ac
->tx_op_limit
);
580 goto out_free_memmap
;
582 conf_tid
= &wl
->conf
.tx
.tid_conf
[i
];
583 ret
= wl1271_acx_tid_cfg(wl
, conf_tid
->queue_id
,
584 conf_tid
->channel_type
,
587 conf_tid
->ack_policy
,
588 conf_tid
->apsd_conf
[0],
589 conf_tid
->apsd_conf
[1]);
591 goto out_free_memmap
;
594 /* Enable data path */
595 ret
= wl1271_cmd_data_path(wl
, 1);
597 goto out_free_memmap
;
599 /* Configure for CAM power saving (ie. always active) */
600 ret
= wl1271_acx_sleep_auth(wl
, WL1271_PSM_CAM
);
602 goto out_free_memmap
;
605 ret
= wl1271_acx_pm_config(wl
);
607 goto out_free_memmap
;
612 kfree(wl
->target_mem_map
);
613 wl
->target_mem_map
= NULL
;
618 static void wl1271_irq_ps_regulate_link(struct wl1271
*wl
, u8 hlid
, u8 tx_blks
)
622 /* only regulate station links */
623 if (hlid
< WL1271_AP_STA_HLID_START
)
626 fw_ps
= test_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
629 * Wake up from high level PS if the STA is asleep with too little
630 * blocks in FW or if the STA is awake.
632 if (!fw_ps
|| tx_blks
< WL1271_PS_STA_MAX_BLOCKS
)
633 wl1271_ps_link_end(wl
, hlid
);
635 /* Start high-level PS if the STA is asleep with enough blocks in FW */
636 else if (fw_ps
&& tx_blks
>= WL1271_PS_STA_MAX_BLOCKS
)
637 wl1271_ps_link_start(wl
, hlid
, true);
640 static void wl1271_irq_update_links_status(struct wl1271
*wl
,
641 struct wl1271_fw_ap_status
*status
)
646 cur_fw_ps_map
= le32_to_cpu(status
->link_ps_bitmap
);
647 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
648 wl1271_debug(DEBUG_PSM
,
649 "link ps prev 0x%x cur 0x%x changed 0x%x",
650 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
651 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
653 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
656 for (hlid
= WL1271_AP_STA_HLID_START
; hlid
< AP_MAX_LINKS
; hlid
++) {
657 u8 cnt
= status
->tx_lnk_free_blks
[hlid
] -
658 wl
->links
[hlid
].prev_freed_blks
;
660 wl
->links
[hlid
].prev_freed_blks
=
661 status
->tx_lnk_free_blks
[hlid
];
662 wl
->links
[hlid
].allocated_blks
-= cnt
;
664 wl1271_irq_ps_regulate_link(wl
, hlid
,
665 wl
->links
[hlid
].allocated_blks
);
669 static void wl1271_fw_status(struct wl1271
*wl
,
670 struct wl1271_fw_full_status
*full_status
)
672 struct wl1271_fw_common_status
*status
= &full_status
->common
;
674 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
675 u32 freed_blocks
= 0;
678 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
679 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
680 sizeof(struct wl1271_fw_ap_status
), false);
682 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
683 sizeof(struct wl1271_fw_sta_status
), false);
686 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
687 "drv_rx_counter = %d, tx_results_counter = %d)",
689 status
->fw_rx_counter
,
690 status
->drv_rx_counter
,
691 status
->tx_results_counter
);
693 /* update number of available TX blocks */
694 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
695 freed_blocks
+= le32_to_cpu(status
->tx_released_blks
[i
]) -
696 wl
->tx_blocks_freed
[i
];
698 wl
->tx_blocks_freed
[i
] =
699 le32_to_cpu(status
->tx_released_blks
[i
]);
702 wl
->tx_allocated_blocks
-= freed_blocks
;
704 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
705 /* Update num of allocated TX blocks per link and ps status */
706 wl1271_irq_update_links_status(wl
, &full_status
->ap
);
707 wl
->tx_blocks_available
+= freed_blocks
;
709 int avail
= full_status
->sta
.tx_total
- wl
->tx_allocated_blocks
;
712 * The FW might change the total number of TX memblocks before
713 * we get a notification about blocks being released. Thus, the
714 * available blocks calculation might yield a temporary result
715 * which is lower than the actual available blocks. Keeping in
716 * mind that only blocks that were allocated can be moved from
717 * TX to RX, tx_blocks_available should never decrease here.
719 wl
->tx_blocks_available
= max((int)wl
->tx_blocks_available
,
723 /* if more blocks are available now, tx work can be scheduled */
724 if (wl
->tx_blocks_available
> old_tx_blk_count
)
725 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
727 /* update the host-chipset time offset */
729 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
730 (s64
)le32_to_cpu(status
->fw_localtime
);
733 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
737 /* Pass all received frames to the network stack */
738 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
739 ieee80211_rx_ni(wl
->hw
, skb
);
741 /* Return sent skbs to the network stack */
742 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
743 ieee80211_tx_status(wl
->hw
, skb
);
746 static void wl1271_netstack_work(struct work_struct
*work
)
749 container_of(work
, struct wl1271
, netstack_work
);
752 wl1271_flush_deferred_work(wl
);
753 } while (skb_queue_len(&wl
->deferred_rx_queue
));
756 #define WL1271_IRQ_MAX_LOOPS 256
758 irqreturn_t
wl1271_irq(int irq
, void *cookie
)
762 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
763 struct wl1271
*wl
= (struct wl1271
*)cookie
;
765 unsigned int defer_count
;
768 /* TX might be handled here, avoid redundant work */
769 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
770 cancel_work_sync(&wl
->tx_work
);
773 * In case edge triggered interrupt must be used, we cannot iterate
774 * more than once without introducing race conditions with the hardirq.
776 if (wl
->platform_quirks
& WL12XX_PLATFORM_QUIRK_EDGE_IRQ
)
779 mutex_lock(&wl
->mutex
);
781 wl1271_debug(DEBUG_IRQ
, "IRQ work");
783 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
786 ret
= wl1271_ps_elp_wakeup(wl
);
790 while (!done
&& loopcount
--) {
792 * In order to avoid a race with the hardirq, clear the flag
793 * before acknowledging the chip. Since the mutex is held,
794 * wl1271_ps_elp_wakeup cannot be called concurrently.
796 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
797 smp_mb__after_clear_bit();
799 wl1271_fw_status(wl
, wl
->fw_status
);
800 intr
= le32_to_cpu(wl
->fw_status
->common
.intr
);
801 intr
&= WL1271_INTR_MASK
;
807 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
808 wl1271_error("watchdog interrupt received! "
809 "starting recovery.");
810 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
812 /* restarting the chip. ignore any other interrupt. */
816 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
817 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
819 wl1271_rx(wl
, &wl
->fw_status
->common
);
821 /* Check if any tx blocks were freed */
822 spin_lock_irqsave(&wl
->wl_lock
, flags
);
823 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
824 wl
->tx_queue_count
) {
825 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
827 * In order to avoid starvation of the TX path,
828 * call the work function directly.
830 wl1271_tx_work_locked(wl
);
832 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
835 /* check for tx results */
836 if (wl
->fw_status
->common
.tx_results_counter
!=
837 (wl
->tx_results_count
& 0xff))
838 wl1271_tx_complete(wl
);
840 /* Make sure the deferred queues don't get too long */
841 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
842 skb_queue_len(&wl
->deferred_rx_queue
);
843 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
844 wl1271_flush_deferred_work(wl
);
847 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
848 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
849 wl1271_event_handle(wl
, 0);
852 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
853 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
854 wl1271_event_handle(wl
, 1);
857 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
858 wl1271_debug(DEBUG_IRQ
,
859 "WL1271_ACX_INTR_INIT_COMPLETE");
861 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
862 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
865 wl1271_ps_elp_sleep(wl
);
868 spin_lock_irqsave(&wl
->wl_lock
, flags
);
869 /* In case TX was not handled here, queue TX work */
870 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
871 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
873 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
874 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
876 mutex_unlock(&wl
->mutex
);
880 EXPORT_SYMBOL_GPL(wl1271_irq
);
882 static int wl1271_fetch_firmware(struct wl1271
*wl
)
884 const struct firmware
*fw
;
888 switch (wl
->bss_type
) {
889 case BSS_TYPE_AP_BSS
:
890 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
891 fw_name
= WL128X_AP_FW_NAME
;
893 fw_name
= WL127X_AP_FW_NAME
;
896 case BSS_TYPE_STA_BSS
:
897 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
898 fw_name
= WL128X_FW_NAME
;
900 fw_name
= WL1271_FW_NAME
;
903 wl1271_error("no compatible firmware for bss_type %d",
908 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
910 ret
= request_firmware(&fw
, fw_name
, wl1271_wl_to_dev(wl
));
913 wl1271_error("could not get firmware: %d", ret
);
918 wl1271_error("firmware size is not multiple of 32 bits: %zu",
925 wl
->fw_len
= fw
->size
;
926 wl
->fw
= vmalloc(wl
->fw_len
);
929 wl1271_error("could not allocate memory for the firmware");
934 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
935 wl
->fw_bss_type
= wl
->bss_type
;
939 release_firmware(fw
);
944 static int wl1271_fetch_nvs(struct wl1271
*wl
)
946 const struct firmware
*fw
;
949 ret
= request_firmware(&fw
, WL12XX_NVS_NAME
, wl1271_wl_to_dev(wl
));
952 wl1271_error("could not get nvs file: %d", ret
);
956 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
959 wl1271_error("could not allocate memory for the nvs file");
964 wl
->nvs_len
= fw
->size
;
967 release_firmware(fw
);
972 static void wl1271_recovery_work(struct work_struct
*work
)
975 container_of(work
, struct wl1271
, recovery_work
);
977 mutex_lock(&wl
->mutex
);
979 if (wl
->state
!= WL1271_STATE_ON
)
982 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
983 wl
->chip
.fw_ver_str
, wl1271_read32(wl
, SCR_PAD4
));
985 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
986 ieee80211_connection_loss(wl
->vif
);
988 /* Prevent spurious TX during FW restart */
989 ieee80211_stop_queues(wl
->hw
);
991 if (wl
->sched_scanning
) {
992 ieee80211_sched_scan_stopped(wl
->hw
);
993 wl
->sched_scanning
= false;
996 /* reboot the chipset */
997 __wl1271_op_remove_interface(wl
, false);
998 ieee80211_restart_hw(wl
->hw
);
1001 * Its safe to enable TX now - the queues are stopped after a request
1002 * to restart the HW.
1004 ieee80211_wake_queues(wl
->hw
);
1007 mutex_unlock(&wl
->mutex
);
1010 static void wl1271_fw_wakeup(struct wl1271
*wl
)
1014 elp_reg
= ELPCTRL_WAKE_UP
;
1015 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
1018 static int wl1271_setup(struct wl1271
*wl
)
1020 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
1024 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
1025 if (!wl
->tx_res_if
) {
1026 kfree(wl
->fw_status
);
1033 static int wl1271_chip_wakeup(struct wl1271
*wl
)
1035 struct wl1271_partition_set partition
;
1038 msleep(WL1271_PRE_POWER_ON_SLEEP
);
1039 ret
= wl1271_power_on(wl
);
1042 msleep(WL1271_POWER_ON_SLEEP
);
1043 wl1271_io_reset(wl
);
1046 /* We don't need a real memory partition here, because we only want
1047 * to use the registers at this point. */
1048 memset(&partition
, 0, sizeof(partition
));
1049 partition
.reg
.start
= REGISTERS_BASE
;
1050 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
1051 wl1271_set_partition(wl
, &partition
);
1053 /* ELP module wake up */
1054 wl1271_fw_wakeup(wl
);
1056 /* whal_FwCtrl_BootSm() */
1058 /* 0. read chip id from CHIP_ID */
1059 wl
->chip
.id
= wl1271_read32(wl
, CHIP_ID_B
);
1061 /* 1. check if chip id is valid */
1063 switch (wl
->chip
.id
) {
1064 case CHIP_ID_1271_PG10
:
1065 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1068 ret
= wl1271_setup(wl
);
1072 case CHIP_ID_1271_PG20
:
1073 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
1076 /* end-of-transaction flag should be set in wl127x AP mode */
1077 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1078 wl
->quirks
|= WL12XX_QUIRK_END_OF_TRANSACTION
;
1080 ret
= wl1271_setup(wl
);
1084 case CHIP_ID_1283_PG20
:
1085 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1283 PG20)",
1088 ret
= wl1271_setup(wl
);
1091 if (wl1271_set_block_size(wl
))
1092 wl
->quirks
|= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT
;
1094 case CHIP_ID_1283_PG10
:
1096 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
1101 /* Make sure the firmware type matches the BSS type */
1102 if (wl
->fw
== NULL
|| wl
->fw_bss_type
!= wl
->bss_type
) {
1103 ret
= wl1271_fetch_firmware(wl
);
1108 /* No NVS from netlink, try to get it from the filesystem */
1109 if (wl
->nvs
== NULL
) {
1110 ret
= wl1271_fetch_nvs(wl
);
1119 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271
*wl
)
1121 unsigned int quirks
= 0;
1122 unsigned int *fw_ver
= wl
->chip
.fw_ver
;
1124 /* Only for wl127x */
1125 if ((fw_ver
[FW_VER_CHIP
] == FW_VER_CHIP_WL127X
) &&
1126 /* Check STA version */
1127 (((fw_ver
[FW_VER_IF_TYPE
] == FW_VER_IF_TYPE_STA
) &&
1128 (fw_ver
[FW_VER_MINOR
] < FW_VER_MINOR_1_SPARE_STA_MIN
)) ||
1129 /* Check AP version */
1130 ((fw_ver
[FW_VER_IF_TYPE
] == FW_VER_IF_TYPE_AP
) &&
1131 (fw_ver
[FW_VER_MINOR
] < FW_VER_MINOR_1_SPARE_AP_MIN
))))
1132 quirks
|= WL12XX_QUIRK_USE_2_SPARE_BLOCKS
;
1137 int wl1271_plt_start(struct wl1271
*wl
)
1139 int retries
= WL1271_BOOT_RETRIES
;
1142 mutex_lock(&wl
->mutex
);
1144 wl1271_notice("power up");
1146 if (wl
->state
!= WL1271_STATE_OFF
) {
1147 wl1271_error("cannot go into PLT state because not "
1148 "in off state: %d", wl
->state
);
1153 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1157 ret
= wl1271_chip_wakeup(wl
);
1161 ret
= wl1271_boot(wl
);
1165 ret
= wl1271_plt_init(wl
);
1169 wl
->state
= WL1271_STATE_PLT
;
1170 wl1271_notice("firmware booted in PLT mode (%s)",
1171 wl
->chip
.fw_ver_str
);
1173 /* Check if any quirks are needed with older fw versions */
1174 wl
->quirks
|= wl1271_get_fw_ver_quirks(wl
);
1178 mutex_unlock(&wl
->mutex
);
1179 /* Unlocking the mutex in the middle of handling is
1180 inherently unsafe. In this case we deem it safe to do,
1181 because we need to let any possibly pending IRQ out of
1182 the system (and while we are WL1271_STATE_OFF the IRQ
1183 work function will not do anything.) Also, any other
1184 possible concurrent operations will fail due to the
1185 current state, hence the wl1271 struct should be safe. */
1186 wl1271_disable_interrupts(wl
);
1187 wl1271_flush_deferred_work(wl
);
1188 cancel_work_sync(&wl
->netstack_work
);
1189 mutex_lock(&wl
->mutex
);
1191 wl1271_power_off(wl
);
1194 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1195 WL1271_BOOT_RETRIES
);
1197 mutex_unlock(&wl
->mutex
);
1202 static int __wl1271_plt_stop(struct wl1271
*wl
)
1206 wl1271_notice("power down");
1208 if (wl
->state
!= WL1271_STATE_PLT
) {
1209 wl1271_error("cannot power down because not in PLT "
1210 "state: %d", wl
->state
);
1215 wl1271_power_off(wl
);
1217 wl
->state
= WL1271_STATE_OFF
;
1220 mutex_unlock(&wl
->mutex
);
1221 wl1271_disable_interrupts(wl
);
1222 wl1271_flush_deferred_work(wl
);
1223 cancel_work_sync(&wl
->netstack_work
);
1224 cancel_work_sync(&wl
->recovery_work
);
1225 mutex_lock(&wl
->mutex
);
1230 int wl1271_plt_stop(struct wl1271
*wl
)
1234 mutex_lock(&wl
->mutex
);
1235 ret
= __wl1271_plt_stop(wl
);
1236 mutex_unlock(&wl
->mutex
);
1240 static void wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
1242 struct wl1271
*wl
= hw
->priv
;
1243 unsigned long flags
;
1247 q
= wl1271_tx_get_queue(skb_get_queue_mapping(skb
));
1249 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1250 hlid
= wl1271_tx_get_hlid(skb
);
1252 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1254 wl
->tx_queue_count
++;
1257 * The workqueue is slow to process the tx_queue and we need stop
1258 * the queue here, otherwise the queue will get too long.
1260 if (wl
->tx_queue_count
>= WL1271_TX_QUEUE_HIGH_WATERMARK
) {
1261 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues");
1262 ieee80211_stop_queues(wl
->hw
);
1263 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED
, &wl
->flags
);
1266 /* queue the packet */
1267 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
1268 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d", hlid
, q
);
1269 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1271 skb_queue_tail(&wl
->tx_queue
[q
], skb
);
1275 * The chip specific setup must run before the first TX packet -
1276 * before that, the tx_work will not be initialized!
1279 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1280 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1281 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1283 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1286 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1288 unsigned long flags
;
1290 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1291 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
);
1292 wl
->tx_queue_count
++;
1293 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1295 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1296 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1297 wl1271_tx_work_locked(wl
);
1300 * If the FW TX is busy, TX work will be scheduled by the threaded
1301 * interrupt handler function
1307 * The size of the dummy packet should be at least 1400 bytes. However, in
1308 * order to minimize the number of bus transactions, aligning it to 512 bytes
1309 * boundaries could be beneficial, performance wise
1311 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1313 static struct sk_buff
*wl12xx_alloc_dummy_packet(struct wl1271
*wl
)
1315 struct sk_buff
*skb
;
1316 struct ieee80211_hdr_3addr
*hdr
;
1317 unsigned int dummy_packet_size
;
1319 dummy_packet_size
= TOTAL_TX_DUMMY_PACKET_SIZE
-
1320 sizeof(struct wl1271_tx_hw_descr
) - sizeof(*hdr
);
1322 skb
= dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE
);
1324 wl1271_warning("Failed to allocate a dummy packet skb");
1328 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1330 hdr
= (struct ieee80211_hdr_3addr
*) skb_put(skb
, sizeof(*hdr
));
1331 memset(hdr
, 0, sizeof(*hdr
));
1332 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1333 IEEE80211_STYPE_NULLFUNC
|
1334 IEEE80211_FCTL_TODS
);
1336 memset(skb_put(skb
, dummy_packet_size
), 0, dummy_packet_size
);
1338 /* Dummy packets require the TID to be management */
1339 skb
->priority
= WL1271_TID_MGMT
;
1341 /* Initialize all fields that might be used */
1342 skb_set_queue_mapping(skb
, 0);
1343 memset(IEEE80211_SKB_CB(skb
), 0, sizeof(struct ieee80211_tx_info
));
1349 static struct notifier_block wl1271_dev_notifier
= {
1350 .notifier_call
= wl1271_dev_notify
,
1353 static int wl1271_op_suspend(struct ieee80211_hw
*hw
,
1354 struct cfg80211_wowlan
*wow
)
1356 struct wl1271
*wl
= hw
->priv
;
1357 wl1271_debug(DEBUG_MAC80211
, "mac80211 suspend wow=%d", !!wow
);
1358 wl
->wow_enabled
= !!wow
;
1359 if (wl
->wow_enabled
) {
1360 /* flush any remaining work */
1361 wl1271_debug(DEBUG_MAC80211
, "flushing remaining works");
1362 flush_delayed_work(&wl
->scan_complete_work
);
1365 * disable and re-enable interrupts in order to flush
1368 wl1271_disable_interrupts(wl
);
1371 * set suspended flag to avoid triggering a new threaded_irq
1372 * work. no need for spinlock as interrupts are disabled.
1374 set_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1376 wl1271_enable_interrupts(wl
);
1377 flush_work(&wl
->tx_work
);
1378 flush_delayed_work(&wl
->pspoll_work
);
1379 flush_delayed_work(&wl
->elp_work
);
1384 static int wl1271_op_resume(struct ieee80211_hw
*hw
)
1386 struct wl1271
*wl
= hw
->priv
;
1387 wl1271_debug(DEBUG_MAC80211
, "mac80211 resume wow=%d",
1391 * re-enable irq_work enqueuing, and call irq_work directly if
1392 * there is a pending work.
1394 if (wl
->wow_enabled
) {
1395 struct wl1271
*wl
= hw
->priv
;
1396 unsigned long flags
;
1397 bool run_irq_work
= false;
1399 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1400 clear_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1401 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
))
1402 run_irq_work
= true;
1403 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1406 wl1271_debug(DEBUG_MAC80211
,
1407 "run postponed irq_work directly");
1409 wl1271_enable_interrupts(wl
);
1416 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1418 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1421 * We have to delay the booting of the hardware because
1422 * we need to know the local MAC address before downloading and
1423 * initializing the firmware. The MAC address cannot be changed
1424 * after boot, and without the proper MAC address, the firmware
1425 * will not function properly.
1427 * The MAC address is first known when the corresponding interface
1428 * is added. That is where we will initialize the hardware.
1430 * In addition, we currently have different firmwares for AP and managed
1431 * operation. We will know which to boot according to interface type.
1437 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
1439 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1442 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1443 struct ieee80211_vif
*vif
)
1445 struct wl1271
*wl
= hw
->priv
;
1446 struct wiphy
*wiphy
= hw
->wiphy
;
1447 int retries
= WL1271_BOOT_RETRIES
;
1449 bool booted
= false;
1451 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1452 vif
->type
, vif
->addr
);
1454 mutex_lock(&wl
->mutex
);
1456 wl1271_debug(DEBUG_MAC80211
,
1457 "multiple vifs are not supported yet");
1463 * in some very corner case HW recovery scenarios its possible to
1464 * get here before __wl1271_op_remove_interface is complete, so
1465 * opt out if that is the case.
1467 if (test_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
)) {
1472 switch (vif
->type
) {
1473 case NL80211_IFTYPE_STATION
:
1474 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1475 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1477 case NL80211_IFTYPE_ADHOC
:
1478 wl
->bss_type
= BSS_TYPE_IBSS
;
1479 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1481 case NL80211_IFTYPE_AP
:
1482 wl
->bss_type
= BSS_TYPE_AP_BSS
;
1489 memcpy(wl
->mac_addr
, vif
->addr
, ETH_ALEN
);
1491 if (wl
->state
!= WL1271_STATE_OFF
) {
1492 wl1271_error("cannot start because not in off state: %d",
1500 ret
= wl1271_chip_wakeup(wl
);
1504 ret
= wl1271_boot(wl
);
1508 ret
= wl1271_hw_init(wl
);
1516 mutex_unlock(&wl
->mutex
);
1517 /* Unlocking the mutex in the middle of handling is
1518 inherently unsafe. In this case we deem it safe to do,
1519 because we need to let any possibly pending IRQ out of
1520 the system (and while we are WL1271_STATE_OFF the IRQ
1521 work function will not do anything.) Also, any other
1522 possible concurrent operations will fail due to the
1523 current state, hence the wl1271 struct should be safe. */
1524 wl1271_disable_interrupts(wl
);
1525 wl1271_flush_deferred_work(wl
);
1526 cancel_work_sync(&wl
->netstack_work
);
1527 mutex_lock(&wl
->mutex
);
1529 wl1271_power_off(wl
);
1533 wl1271_error("firmware boot failed despite %d retries",
1534 WL1271_BOOT_RETRIES
);
1539 wl
->state
= WL1271_STATE_ON
;
1540 set_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
);
1541 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
1543 /* update hw/fw version info in wiphy struct */
1544 wiphy
->hw_version
= wl
->chip
.id
;
1545 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1546 sizeof(wiphy
->fw_version
));
1548 /* Check if any quirks are needed with older fw versions */
1549 wl
->quirks
|= wl1271_get_fw_ver_quirks(wl
);
1552 * Now we know if 11a is supported (info from the NVS), so disable
1553 * 11a channels if not supported
1555 if (!wl
->enable_11a
)
1556 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
1558 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
1559 wl
->enable_11a
? "" : "not ");
1562 mutex_unlock(&wl
->mutex
);
1564 mutex_lock(&wl_list_mutex
);
1566 list_add(&wl
->list
, &wl_list
);
1567 mutex_unlock(&wl_list_mutex
);
1572 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
1573 bool reset_tx_queues
)
1577 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
1579 /* because of hardware recovery, we may get here twice */
1580 if (wl
->state
!= WL1271_STATE_ON
)
1583 wl1271_info("down");
1585 mutex_lock(&wl_list_mutex
);
1586 list_del(&wl
->list
);
1587 mutex_unlock(&wl_list_mutex
);
1589 /* enable dyn ps just in case (if left on due to fw crash etc) */
1590 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1591 ieee80211_enable_dyn_ps(wl
->vif
);
1593 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
1594 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
1595 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
1596 wl
->scan
.req
= NULL
;
1597 ieee80211_scan_completed(wl
->hw
, true);
1601 * this must be before the cancel_work calls below, so that the work
1602 * functions don't perform further work.
1604 wl
->state
= WL1271_STATE_OFF
;
1606 mutex_unlock(&wl
->mutex
);
1608 wl1271_disable_interrupts(wl
);
1609 wl1271_flush_deferred_work(wl
);
1610 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1611 cancel_work_sync(&wl
->netstack_work
);
1612 cancel_work_sync(&wl
->tx_work
);
1613 cancel_delayed_work_sync(&wl
->pspoll_work
);
1614 cancel_delayed_work_sync(&wl
->elp_work
);
1616 mutex_lock(&wl
->mutex
);
1618 /* let's notify MAC80211 about the remaining pending TX frames */
1619 wl1271_tx_reset(wl
, reset_tx_queues
);
1620 wl1271_power_off(wl
);
1622 memset(wl
->bssid
, 0, ETH_ALEN
);
1623 memset(wl
->ssid
, 0, IW_ESSID_MAX_SIZE
+ 1);
1625 wl
->bss_type
= MAX_BSS_TYPE
;
1626 wl
->set_bss_type
= MAX_BSS_TYPE
;
1627 wl
->band
= IEEE80211_BAND_2GHZ
;
1630 wl
->psm_entry_retry
= 0;
1631 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1632 wl
->tx_blocks_available
= 0;
1633 wl
->tx_allocated_blocks
= 0;
1634 wl
->tx_results_count
= 0;
1635 wl
->tx_packets_count
= 0;
1636 wl
->tx_security_last_seq
= 0;
1637 wl
->tx_security_seq
= 0;
1638 wl
->time_offset
= 0;
1639 wl
->session_counter
= 0;
1640 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1643 wl1271_free_ap_keys(wl
);
1644 memset(wl
->ap_hlid_map
, 0, sizeof(wl
->ap_hlid_map
));
1645 wl
->ap_fw_ps_map
= 0;
1647 wl
->sched_scanning
= false;
1650 * this is performed after the cancel_work calls and the associated
1651 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1652 * get executed before all these vars have been reset.
1656 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
1657 wl
->tx_blocks_freed
[i
] = 0;
1659 wl1271_debugfs_reset(wl
);
1661 kfree(wl
->fw_status
);
1662 wl
->fw_status
= NULL
;
1663 kfree(wl
->tx_res_if
);
1664 wl
->tx_res_if
= NULL
;
1665 kfree(wl
->target_mem_map
);
1666 wl
->target_mem_map
= NULL
;
1669 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
1670 struct ieee80211_vif
*vif
)
1672 struct wl1271
*wl
= hw
->priv
;
1674 mutex_lock(&wl
->mutex
);
1676 * wl->vif can be null here if someone shuts down the interface
1677 * just when hardware recovery has been started.
1680 WARN_ON(wl
->vif
!= vif
);
1681 __wl1271_op_remove_interface(wl
, true);
1684 mutex_unlock(&wl
->mutex
);
1685 cancel_work_sync(&wl
->recovery_work
);
1688 void wl1271_configure_filters(struct wl1271
*wl
, unsigned int filters
)
1690 wl1271_set_default_filters(wl
);
1692 /* combine requested filters with current filter config */
1693 filters
= wl
->filters
| filters
;
1695 wl1271_debug(DEBUG_FILTERS
, "RX filters set: ");
1697 if (filters
& FIF_PROMISC_IN_BSS
) {
1698 wl1271_debug(DEBUG_FILTERS
, " - FIF_PROMISC_IN_BSS");
1699 wl
->rx_config
&= ~CFG_UNI_FILTER_EN
;
1700 wl
->rx_config
|= CFG_BSSID_FILTER_EN
;
1702 if (filters
& FIF_BCN_PRBRESP_PROMISC
) {
1703 wl1271_debug(DEBUG_FILTERS
, " - FIF_BCN_PRBRESP_PROMISC");
1704 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1705 wl
->rx_config
&= ~CFG_SSID_FILTER_EN
;
1707 if (filters
& FIF_OTHER_BSS
) {
1708 wl1271_debug(DEBUG_FILTERS
, " - FIF_OTHER_BSS");
1709 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1711 if (filters
& FIF_CONTROL
) {
1712 wl1271_debug(DEBUG_FILTERS
, " - FIF_CONTROL");
1713 wl
->rx_filter
|= CFG_RX_CTL_EN
;
1715 if (filters
& FIF_FCSFAIL
) {
1716 wl1271_debug(DEBUG_FILTERS
, " - FIF_FCSFAIL");
1717 wl
->rx_filter
|= CFG_RX_FCS_ERROR
;
1721 static int wl1271_dummy_join(struct wl1271
*wl
)
1724 /* we need to use a dummy BSSID for now */
1725 static const u8 dummy_bssid
[ETH_ALEN
] = { 0x0b, 0xad, 0xde,
1728 memcpy(wl
->bssid
, dummy_bssid
, ETH_ALEN
);
1730 /* pass through frames from all BSS */
1731 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
1733 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
1737 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1743 static int wl1271_join(struct wl1271
*wl
, bool set_assoc
)
1748 * One of the side effects of the JOIN command is that is clears
1749 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1750 * to a WPA/WPA2 access point will therefore kill the data-path.
1751 * Currently the only valid scenario for JOIN during association
1752 * is on roaming, in which case we will also be given new keys.
1753 * Keep the below message for now, unless it starts bothering
1754 * users who really like to roam a lot :)
1756 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1757 wl1271_info("JOIN while associated.");
1760 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
1762 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
1766 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1768 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1772 * The join command disable the keep-alive mode, shut down its process,
1773 * and also clear the template config, so we need to reset it all after
1774 * the join. The acx_aid starts the keep-alive process, and the order
1775 * of the commands below is relevant.
1777 ret
= wl1271_acx_keep_alive_mode(wl
, true);
1781 ret
= wl1271_acx_aid(wl
, wl
->aid
);
1785 ret
= wl1271_cmd_build_klv_null_data(wl
);
1789 ret
= wl1271_acx_keep_alive_config(wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
1790 ACX_KEEP_ALIVE_TPL_VALID
);
1798 static int wl1271_unjoin(struct wl1271
*wl
)
1802 /* to stop listening to a channel, we disconnect */
1803 ret
= wl1271_cmd_disconnect(wl
);
1807 clear_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1808 memset(wl
->bssid
, 0, ETH_ALEN
);
1810 /* stop filtering packets based on bssid */
1811 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
1817 static void wl1271_set_band_rate(struct wl1271
*wl
)
1819 if (wl
->band
== IEEE80211_BAND_2GHZ
)
1820 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate
;
1822 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate_5
;
1825 static int wl1271_sta_handle_idle(struct wl1271
*wl
, bool idle
)
1830 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
1831 ret
= wl1271_unjoin(wl
);
1835 wl
->rate_set
= wl1271_tx_min_rate_get(wl
);
1836 ret
= wl1271_acx_sta_rate_policies(wl
);
1839 ret
= wl1271_acx_keep_alive_config(
1840 wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
1841 ACX_KEEP_ALIVE_TPL_INVALID
);
1844 set_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
1846 /* increment the session counter */
1847 wl
->session_counter
++;
1848 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
1849 wl
->session_counter
= 0;
1851 /* The current firmware only supports sched_scan in idle */
1852 if (wl
->sched_scanning
) {
1853 wl1271_scan_sched_scan_stop(wl
);
1854 ieee80211_sched_scan_stopped(wl
->hw
);
1857 ret
= wl1271_dummy_join(wl
);
1860 clear_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
1867 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
1869 struct wl1271
*wl
= hw
->priv
;
1870 struct ieee80211_conf
*conf
= &hw
->conf
;
1871 int channel
, ret
= 0;
1874 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
1876 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s"
1879 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
1881 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
1885 * mac80211 will go to idle nearly immediately after transmitting some
1886 * frames, such as the deauth. To make sure those frames reach the air,
1887 * wait here until the TX queue is fully flushed.
1889 if ((changed
& IEEE80211_CONF_CHANGE_IDLE
) &&
1890 (conf
->flags
& IEEE80211_CONF_IDLE
))
1891 wl1271_tx_flush(wl
);
1893 mutex_lock(&wl
->mutex
);
1895 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
1896 /* we support configuring the channel and band while off */
1897 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
)) {
1898 wl
->band
= conf
->channel
->band
;
1899 wl
->channel
= channel
;
1905 is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
1907 ret
= wl1271_ps_elp_wakeup(wl
);
1911 /* if the channel changes while joined, join again */
1912 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
&&
1913 ((wl
->band
!= conf
->channel
->band
) ||
1914 (wl
->channel
!= channel
))) {
1915 wl
->band
= conf
->channel
->band
;
1916 wl
->channel
= channel
;
1920 * FIXME: the mac80211 should really provide a fixed
1921 * rate to use here. for now, just use the smallest
1922 * possible rate for the band as a fixed rate for
1923 * association frames and other control messages.
1925 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1926 wl1271_set_band_rate(wl
);
1928 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
1929 ret
= wl1271_acx_sta_rate_policies(wl
);
1931 wl1271_warning("rate policy for channel "
1934 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
1935 ret
= wl1271_join(wl
, false);
1937 wl1271_warning("cmd join on channel "
1943 if (changed
& IEEE80211_CONF_CHANGE_IDLE
&& !is_ap
) {
1944 ret
= wl1271_sta_handle_idle(wl
,
1945 conf
->flags
& IEEE80211_CONF_IDLE
);
1947 wl1271_warning("idle mode change failed %d", ret
);
1951 * if mac80211 changes the PSM mode, make sure the mode is not
1952 * incorrectly changed after the pspoll failure active window.
1954 if (changed
& IEEE80211_CONF_CHANGE_PS
)
1955 clear_bit(WL1271_FLAG_PSPOLL_FAILURE
, &wl
->flags
);
1957 if (conf
->flags
& IEEE80211_CONF_PS
&&
1958 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1959 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1962 * We enter PSM only if we're already associated.
1963 * If we're not, we'll enter it when joining an SSID,
1964 * through the bss_info_changed() hook.
1966 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
1967 wl1271_debug(DEBUG_PSM
, "psm enabled");
1968 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
1969 wl
->basic_rate
, true);
1971 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
1972 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1973 wl1271_debug(DEBUG_PSM
, "psm disabled");
1975 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1977 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
1978 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
1979 wl
->basic_rate
, true);
1982 if (conf
->power_level
!= wl
->power_level
) {
1983 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
1987 wl
->power_level
= conf
->power_level
;
1991 wl1271_ps_elp_sleep(wl
);
1994 mutex_unlock(&wl
->mutex
);
1999 struct wl1271_filter_params
{
2002 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
2005 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
2006 struct netdev_hw_addr_list
*mc_list
)
2008 struct wl1271_filter_params
*fp
;
2009 struct netdev_hw_addr
*ha
;
2010 struct wl1271
*wl
= hw
->priv
;
2012 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2015 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
2017 wl1271_error("Out of memory setting filters.");
2021 /* update multicast filtering parameters */
2022 fp
->mc_list_length
= 0;
2023 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
2024 fp
->enabled
= false;
2027 netdev_hw_addr_list_for_each(ha
, mc_list
) {
2028 memcpy(fp
->mc_list
[fp
->mc_list_length
],
2029 ha
->addr
, ETH_ALEN
);
2030 fp
->mc_list_length
++;
2034 return (u64
)(unsigned long)fp
;
2037 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2040 FIF_BCN_PRBRESP_PROMISC | \
2044 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
2045 unsigned int changed
,
2046 unsigned int *total
, u64 multicast
)
2048 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
2049 struct wl1271
*wl
= hw
->priv
;
2052 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
2053 " total %x", changed
, *total
);
2055 mutex_lock(&wl
->mutex
);
2057 *total
&= WL1271_SUPPORTED_FILTERS
;
2058 changed
&= WL1271_SUPPORTED_FILTERS
;
2060 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2063 ret
= wl1271_ps_elp_wakeup(wl
);
2067 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
) {
2068 if (*total
& FIF_ALLMULTI
)
2069 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
2071 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
2073 fp
->mc_list_length
);
2078 /* determine, whether supported filter values have changed */
2082 /* configure filters */
2083 wl
->filters
= *total
;
2084 wl1271_configure_filters(wl
, 0);
2086 /* apply configured filters */
2087 ret
= wl1271_acx_rx_config(wl
, wl
->rx_config
, wl
->rx_filter
);
2092 wl1271_ps_elp_sleep(wl
);
2095 mutex_unlock(&wl
->mutex
);
2099 static int wl1271_record_ap_key(struct wl1271
*wl
, u8 id
, u8 key_type
,
2100 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
2103 struct wl1271_ap_key
*ap_key
;
2106 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
2108 if (key_size
> MAX_KEY_SIZE
)
2112 * Find next free entry in ap_keys. Also check we are not replacing
2115 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2116 if (wl
->recorded_ap_keys
[i
] == NULL
)
2119 if (wl
->recorded_ap_keys
[i
]->id
== id
) {
2120 wl1271_warning("trying to record key replacement");
2125 if (i
== MAX_NUM_KEYS
)
2128 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
2133 ap_key
->key_type
= key_type
;
2134 ap_key
->key_size
= key_size
;
2135 memcpy(ap_key
->key
, key
, key_size
);
2136 ap_key
->hlid
= hlid
;
2137 ap_key
->tx_seq_32
= tx_seq_32
;
2138 ap_key
->tx_seq_16
= tx_seq_16
;
2140 wl
->recorded_ap_keys
[i
] = ap_key
;
2144 static void wl1271_free_ap_keys(struct wl1271
*wl
)
2148 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2149 kfree(wl
->recorded_ap_keys
[i
]);
2150 wl
->recorded_ap_keys
[i
] = NULL
;
2154 static int wl1271_ap_init_hwenc(struct wl1271
*wl
)
2157 struct wl1271_ap_key
*key
;
2158 bool wep_key_added
= false;
2160 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2161 if (wl
->recorded_ap_keys
[i
] == NULL
)
2164 key
= wl
->recorded_ap_keys
[i
];
2165 ret
= wl1271_cmd_set_ap_key(wl
, KEY_ADD_OR_REPLACE
,
2166 key
->id
, key
->key_type
,
2167 key
->key_size
, key
->key
,
2168 key
->hlid
, key
->tx_seq_32
,
2173 if (key
->key_type
== KEY_WEP
)
2174 wep_key_added
= true;
2177 if (wep_key_added
) {
2178 ret
= wl1271_cmd_set_ap_default_wep_key(wl
, wl
->default_key
);
2184 wl1271_free_ap_keys(wl
);
2188 static int wl1271_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
2189 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
2190 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
2193 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2196 struct wl1271_station
*wl_sta
;
2200 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2201 hlid
= wl_sta
->hlid
;
2203 hlid
= WL1271_AP_BROADCAST_HLID
;
2206 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2208 * We do not support removing keys after AP shutdown.
2209 * Pretend we do to make mac80211 happy.
2211 if (action
!= KEY_ADD_OR_REPLACE
)
2214 ret
= wl1271_record_ap_key(wl
, id
,
2216 key
, hlid
, tx_seq_32
,
2219 ret
= wl1271_cmd_set_ap_key(wl
, action
,
2220 id
, key_type
, key_size
,
2221 key
, hlid
, tx_seq_32
,
2229 static const u8 bcast_addr
[ETH_ALEN
] = {
2230 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2233 addr
= sta
? sta
->addr
: bcast_addr
;
2235 if (is_zero_ether_addr(addr
)) {
2236 /* We dont support TX only encryption */
2240 /* The wl1271 does not allow to remove unicast keys - they
2241 will be cleared automatically on next CMD_JOIN. Ignore the
2242 request silently, as we dont want the mac80211 to emit
2243 an error message. */
2244 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
2247 ret
= wl1271_cmd_set_sta_key(wl
, action
,
2248 id
, key_type
, key_size
,
2249 key
, addr
, tx_seq_32
,
2254 /* the default WEP key needs to be configured at least once */
2255 if (key_type
== KEY_WEP
) {
2256 ret
= wl1271_cmd_set_sta_default_wep_key(wl
,
2266 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
2267 struct ieee80211_vif
*vif
,
2268 struct ieee80211_sta
*sta
,
2269 struct ieee80211_key_conf
*key_conf
)
2271 struct wl1271
*wl
= hw
->priv
;
2277 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
2279 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
2280 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2281 key_conf
->cipher
, key_conf
->keyidx
,
2282 key_conf
->keylen
, key_conf
->flags
);
2283 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
2285 mutex_lock(&wl
->mutex
);
2287 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2292 ret
= wl1271_ps_elp_wakeup(wl
);
2296 switch (key_conf
->cipher
) {
2297 case WLAN_CIPHER_SUITE_WEP40
:
2298 case WLAN_CIPHER_SUITE_WEP104
:
2301 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2303 case WLAN_CIPHER_SUITE_TKIP
:
2304 key_type
= KEY_TKIP
;
2306 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2307 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2308 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2310 case WLAN_CIPHER_SUITE_CCMP
:
2313 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2314 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2315 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2317 case WL1271_CIPHER_SUITE_GEM
:
2319 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2320 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2323 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
2331 ret
= wl1271_set_key(wl
, KEY_ADD_OR_REPLACE
,
2332 key_conf
->keyidx
, key_type
,
2333 key_conf
->keylen
, key_conf
->key
,
2334 tx_seq_32
, tx_seq_16
, sta
);
2336 wl1271_error("Could not add or replace key");
2342 ret
= wl1271_set_key(wl
, KEY_REMOVE
,
2343 key_conf
->keyidx
, key_type
,
2344 key_conf
->keylen
, key_conf
->key
,
2347 wl1271_error("Could not remove key");
2353 wl1271_error("Unsupported key cmd 0x%x", cmd
);
2359 wl1271_ps_elp_sleep(wl
);
2362 mutex_unlock(&wl
->mutex
);
2367 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
2368 struct ieee80211_vif
*vif
,
2369 struct cfg80211_scan_request
*req
)
2371 struct wl1271
*wl
= hw
->priv
;
2376 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
2379 ssid
= req
->ssids
[0].ssid
;
2380 len
= req
->ssids
[0].ssid_len
;
2383 mutex_lock(&wl
->mutex
);
2385 if (wl
->state
== WL1271_STATE_OFF
) {
2387 * We cannot return -EBUSY here because cfg80211 will expect
2388 * a call to ieee80211_scan_completed if we do - in this case
2389 * there won't be any call.
2395 ret
= wl1271_ps_elp_wakeup(wl
);
2399 ret
= wl1271_scan(hw
->priv
, ssid
, len
, req
);
2401 wl1271_ps_elp_sleep(wl
);
2404 mutex_unlock(&wl
->mutex
);
2409 static int wl1271_op_sched_scan_start(struct ieee80211_hw
*hw
,
2410 struct ieee80211_vif
*vif
,
2411 struct cfg80211_sched_scan_request
*req
,
2412 struct ieee80211_sched_scan_ies
*ies
)
2414 struct wl1271
*wl
= hw
->priv
;
2417 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_start");
2419 mutex_lock(&wl
->mutex
);
2421 ret
= wl1271_ps_elp_wakeup(wl
);
2425 ret
= wl1271_scan_sched_scan_config(wl
, req
, ies
);
2429 ret
= wl1271_scan_sched_scan_start(wl
);
2433 wl
->sched_scanning
= true;
2436 wl1271_ps_elp_sleep(wl
);
2438 mutex_unlock(&wl
->mutex
);
2442 static void wl1271_op_sched_scan_stop(struct ieee80211_hw
*hw
,
2443 struct ieee80211_vif
*vif
)
2445 struct wl1271
*wl
= hw
->priv
;
2448 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_stop");
2450 mutex_lock(&wl
->mutex
);
2452 ret
= wl1271_ps_elp_wakeup(wl
);
2456 wl1271_scan_sched_scan_stop(wl
);
2458 wl1271_ps_elp_sleep(wl
);
2460 mutex_unlock(&wl
->mutex
);
2463 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
2465 struct wl1271
*wl
= hw
->priv
;
2468 mutex_lock(&wl
->mutex
);
2470 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2475 ret
= wl1271_ps_elp_wakeup(wl
);
2479 ret
= wl1271_acx_frag_threshold(wl
, value
);
2481 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
2483 wl1271_ps_elp_sleep(wl
);
2486 mutex_unlock(&wl
->mutex
);
2491 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
2493 struct wl1271
*wl
= hw
->priv
;
2496 mutex_lock(&wl
->mutex
);
2498 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2503 ret
= wl1271_ps_elp_wakeup(wl
);
2507 ret
= wl1271_acx_rts_threshold(wl
, value
);
2509 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
2511 wl1271_ps_elp_sleep(wl
);
2514 mutex_unlock(&wl
->mutex
);
2519 static int wl1271_ssid_set(struct wl1271
*wl
, struct sk_buff
*skb
,
2523 const u8
*ptr
= cfg80211_find_ie(WLAN_EID_SSID
, skb
->data
+ offset
,
2527 wl1271_error("No SSID in IEs!");
2532 if (ssid_len
> IEEE80211_MAX_SSID_LEN
) {
2533 wl1271_error("SSID is too long!");
2537 wl
->ssid_len
= ssid_len
;
2538 memcpy(wl
->ssid
, ptr
+2, ssid_len
);
2542 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
2543 struct ieee80211_bss_conf
*bss_conf
,
2548 if (changed
& BSS_CHANGED_ERP_SLOT
) {
2549 if (bss_conf
->use_short_slot
)
2550 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
2552 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
2554 wl1271_warning("Set slot time failed %d", ret
);
2559 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
2560 if (bss_conf
->use_short_preamble
)
2561 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
2563 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
2566 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
2567 if (bss_conf
->use_cts_prot
)
2568 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
2570 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
2572 wl1271_warning("Set ctsprotect failed %d", ret
);
2581 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
2582 struct ieee80211_vif
*vif
,
2583 struct ieee80211_bss_conf
*bss_conf
,
2586 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2589 if ((changed
& BSS_CHANGED_BEACON_INT
)) {
2590 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
2591 bss_conf
->beacon_int
);
2593 wl
->beacon_int
= bss_conf
->beacon_int
;
2596 if ((changed
& BSS_CHANGED_BEACON
)) {
2597 struct ieee80211_hdr
*hdr
;
2598 int ieoffset
= offsetof(struct ieee80211_mgmt
,
2600 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
2606 wl1271_debug(DEBUG_MASTER
, "beacon updated");
2608 ret
= wl1271_ssid_set(wl
, beacon
, ieoffset
);
2610 dev_kfree_skb(beacon
);
2613 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
2615 ret
= wl1271_cmd_template_set(wl
, tmpl_id
,
2618 wl1271_tx_min_rate_get(wl
));
2620 dev_kfree_skb(beacon
);
2624 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
2625 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
2626 IEEE80211_STYPE_PROBE_RESP
);
2628 tmpl_id
= is_ap
? CMD_TEMPL_AP_PROBE_RESPONSE
:
2629 CMD_TEMPL_PROBE_RESPONSE
;
2630 ret
= wl1271_cmd_template_set(wl
,
2634 wl1271_tx_min_rate_get(wl
));
2635 dev_kfree_skb(beacon
);
2644 /* AP mode changes */
2645 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
2646 struct ieee80211_vif
*vif
,
2647 struct ieee80211_bss_conf
*bss_conf
,
2652 if ((changed
& BSS_CHANGED_BASIC_RATES
)) {
2653 u32 rates
= bss_conf
->basic_rates
;
2655 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
);
2656 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2658 ret
= wl1271_init_ap_rates(wl
);
2660 wl1271_error("AP rate policy change failed %d", ret
);
2664 ret
= wl1271_ap_init_templates(wl
);
2669 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
2673 if ((changed
& BSS_CHANGED_BEACON_ENABLED
)) {
2674 if (bss_conf
->enable_beacon
) {
2675 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2676 ret
= wl1271_cmd_start_bss(wl
);
2680 set_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
2681 wl1271_debug(DEBUG_AP
, "started AP");
2683 ret
= wl1271_ap_init_hwenc(wl
);
2688 if (test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2689 ret
= wl1271_cmd_stop_bss(wl
);
2693 clear_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
2694 wl1271_debug(DEBUG_AP
, "stopped AP");
2699 if (changed
& BSS_CHANGED_IBSS
) {
2700 wl1271_debug(DEBUG_ADHOC
, "ibss_joined: %d",
2701 bss_conf
->ibss_joined
);
2703 if (bss_conf
->ibss_joined
) {
2704 u32 rates
= bss_conf
->basic_rates
;
2705 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
2707 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2709 /* by default, use 11b rates */
2710 wl
->rate_set
= CONF_TX_IBSS_DEFAULT_RATES
;
2711 ret
= wl1271_acx_sta_rate_policies(wl
);
2717 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
2724 /* STA/IBSS mode changes */
2725 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
2726 struct ieee80211_vif
*vif
,
2727 struct ieee80211_bss_conf
*bss_conf
,
2730 bool do_join
= false, set_assoc
= false;
2731 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
2732 u32 sta_rate_set
= 0;
2734 struct ieee80211_sta
*sta
;
2735 bool sta_exists
= false;
2736 struct ieee80211_sta_ht_cap sta_ht_cap
;
2739 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
2745 if ((changed
& BSS_CHANGED_BEACON_INT
) && is_ibss
)
2748 /* Need to update the SSID (for filtering etc) */
2749 if ((changed
& BSS_CHANGED_BEACON
) && is_ibss
)
2752 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && is_ibss
) {
2753 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
2754 bss_conf
->enable_beacon
? "enabled" : "disabled");
2756 if (bss_conf
->enable_beacon
)
2757 wl
->set_bss_type
= BSS_TYPE_IBSS
;
2759 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
2763 if ((changed
& BSS_CHANGED_CQM
)) {
2764 bool enable
= false;
2765 if (bss_conf
->cqm_rssi_thold
)
2767 ret
= wl1271_acx_rssi_snr_trigger(wl
, enable
,
2768 bss_conf
->cqm_rssi_thold
,
2769 bss_conf
->cqm_rssi_hyst
);
2772 wl
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
2775 if ((changed
& BSS_CHANGED_BSSID
) &&
2777 * Now we know the correct bssid, so we send a new join command
2778 * and enable the BSSID filter
2780 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
2781 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
2783 if (!is_zero_ether_addr(wl
->bssid
)) {
2784 ret
= wl1271_cmd_build_null_data(wl
);
2788 ret
= wl1271_build_qos_null_data(wl
);
2792 /* filter out all packets not from this BSSID */
2793 wl1271_configure_filters(wl
, 0);
2795 /* Need to update the BSSID (for filtering etc) */
2801 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
2803 /* save the supp_rates of the ap */
2804 sta_rate_set
= sta
->supp_rates
[wl
->hw
->conf
.channel
->band
];
2805 if (sta
->ht_cap
.ht_supported
)
2807 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
);
2808 sta_ht_cap
= sta
->ht_cap
;
2814 /* handle new association with HT and HT information change */
2815 if ((changed
& BSS_CHANGED_HT
) &&
2816 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
2817 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
2820 wl1271_warning("Set ht cap true failed %d",
2824 ret
= wl1271_acx_set_ht_information(wl
,
2825 bss_conf
->ht_operation_mode
);
2827 wl1271_warning("Set ht information failed %d",
2832 /* handle new association without HT and disassociation */
2833 else if (changed
& BSS_CHANGED_ASSOC
) {
2834 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
2837 wl1271_warning("Set ht cap false failed %d",
2844 if ((changed
& BSS_CHANGED_ASSOC
)) {
2845 if (bss_conf
->assoc
) {
2848 wl
->aid
= bss_conf
->aid
;
2851 wl
->ps_poll_failures
= 0;
2854 * use basic rates from AP, and determine lowest rate
2855 * to use with control frames.
2857 rates
= bss_conf
->basic_rates
;
2858 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
2860 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2862 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
,
2864 ret
= wl1271_acx_sta_rate_policies(wl
);
2869 * with wl1271, we don't need to update the
2870 * beacon_int and dtim_period, because the firmware
2871 * updates it by itself when the first beacon is
2872 * received after a join.
2874 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
2879 * Get a template for hardware connection maintenance
2881 dev_kfree_skb(wl
->probereq
);
2882 wl
->probereq
= wl1271_cmd_build_ap_probe_req(wl
, NULL
);
2883 ieoffset
= offsetof(struct ieee80211_mgmt
,
2884 u
.probe_req
.variable
);
2885 wl1271_ssid_set(wl
, wl
->probereq
, ieoffset
);
2887 /* enable the connection monitoring feature */
2888 ret
= wl1271_acx_conn_monit_params(wl
, true);
2892 /* If we want to go in PSM but we're not there yet */
2893 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
2894 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
2895 enum wl1271_cmd_ps_mode mode
;
2897 mode
= STATION_POWER_SAVE_MODE
;
2898 ret
= wl1271_ps_set_mode(wl
, mode
,
2905 /* use defaults when not associated */
2907 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED
,
2909 clear_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
);
2912 /* free probe-request template */
2913 dev_kfree_skb(wl
->probereq
);
2914 wl
->probereq
= NULL
;
2916 /* re-enable dynamic ps - just in case */
2917 ieee80211_enable_dyn_ps(wl
->vif
);
2919 /* revert back to minimum rates for the current band */
2920 wl1271_set_band_rate(wl
);
2921 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2922 ret
= wl1271_acx_sta_rate_policies(wl
);
2926 /* disable connection monitor features */
2927 ret
= wl1271_acx_conn_monit_params(wl
, false);
2929 /* Disable the keep-alive feature */
2930 ret
= wl1271_acx_keep_alive_mode(wl
, false);
2934 /* restore the bssid filter and go to dummy bssid */
2937 wl1271_dummy_join(wl
);
2942 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
2946 if (changed
& BSS_CHANGED_ARP_FILTER
) {
2947 __be32 addr
= bss_conf
->arp_addr_list
[0];
2948 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
2950 if (bss_conf
->arp_addr_cnt
== 1 &&
2951 bss_conf
->arp_filter_enabled
) {
2953 * The template should have been configured only upon
2954 * association. however, it seems that the correct ip
2955 * isn't being set (when sending), so we have to
2956 * reconfigure the template upon every ip change.
2958 ret
= wl1271_cmd_build_arp_rsp(wl
, addr
);
2960 wl1271_warning("build arp rsp failed: %d", ret
);
2964 ret
= wl1271_acx_arp_ip_filter(wl
,
2965 ACX_ARP_FILTER_ARP_FILTERING
,
2968 ret
= wl1271_acx_arp_ip_filter(wl
, 0, addr
);
2975 ret
= wl1271_join(wl
, set_assoc
);
2977 wl1271_warning("cmd join failed %d", ret
);
2986 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
2987 struct ieee80211_vif
*vif
,
2988 struct ieee80211_bss_conf
*bss_conf
,
2991 struct wl1271
*wl
= hw
->priv
;
2992 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2995 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed 0x%x",
2998 mutex_lock(&wl
->mutex
);
3000 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3003 ret
= wl1271_ps_elp_wakeup(wl
);
3008 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
3010 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
3012 wl1271_ps_elp_sleep(wl
);
3015 mutex_unlock(&wl
->mutex
);
3018 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
, u16 queue
,
3019 const struct ieee80211_tx_queue_params
*params
)
3021 struct wl1271
*wl
= hw
->priv
;
3025 mutex_lock(&wl
->mutex
);
3027 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
3030 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
3032 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
3034 if (wl
->state
== WL1271_STATE_OFF
) {
3036 * If the state is off, the parameters will be recorded and
3037 * configured on init. This happens in AP-mode.
3039 struct conf_tx_ac_category
*conf_ac
=
3040 &wl
->conf
.tx
.ac_conf
[wl1271_tx_get_queue(queue
)];
3041 struct conf_tx_tid
*conf_tid
=
3042 &wl
->conf
.tx
.tid_conf
[wl1271_tx_get_queue(queue
)];
3044 conf_ac
->ac
= wl1271_tx_get_queue(queue
);
3045 conf_ac
->cw_min
= (u8
)params
->cw_min
;
3046 conf_ac
->cw_max
= params
->cw_max
;
3047 conf_ac
->aifsn
= params
->aifs
;
3048 conf_ac
->tx_op_limit
= params
->txop
<< 5;
3050 conf_tid
->queue_id
= wl1271_tx_get_queue(queue
);
3051 conf_tid
->channel_type
= CONF_CHANNEL_TYPE_EDCF
;
3052 conf_tid
->tsid
= wl1271_tx_get_queue(queue
);
3053 conf_tid
->ps_scheme
= ps_scheme
;
3054 conf_tid
->ack_policy
= CONF_ACK_POLICY_LEGACY
;
3055 conf_tid
->apsd_conf
[0] = 0;
3056 conf_tid
->apsd_conf
[1] = 0;
3060 ret
= wl1271_ps_elp_wakeup(wl
);
3065 * the txop is confed in units of 32us by the mac80211,
3068 ret
= wl1271_acx_ac_cfg(wl
, wl1271_tx_get_queue(queue
),
3069 params
->cw_min
, params
->cw_max
,
3070 params
->aifs
, params
->txop
<< 5);
3074 ret
= wl1271_acx_tid_cfg(wl
, wl1271_tx_get_queue(queue
),
3075 CONF_CHANNEL_TYPE_EDCF
,
3076 wl1271_tx_get_queue(queue
),
3077 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
3081 wl1271_ps_elp_sleep(wl
);
3084 mutex_unlock(&wl
->mutex
);
3089 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
)
3092 struct wl1271
*wl
= hw
->priv
;
3093 u64 mactime
= ULLONG_MAX
;
3096 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
3098 mutex_lock(&wl
->mutex
);
3100 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3103 ret
= wl1271_ps_elp_wakeup(wl
);
3107 ret
= wl1271_acx_tsf_info(wl
, &mactime
);
3112 wl1271_ps_elp_sleep(wl
);
3115 mutex_unlock(&wl
->mutex
);
3119 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
3120 struct survey_info
*survey
)
3122 struct wl1271
*wl
= hw
->priv
;
3123 struct ieee80211_conf
*conf
= &hw
->conf
;
3128 survey
->channel
= conf
->channel
;
3129 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
3130 survey
->noise
= wl
->noise
;
3135 static int wl1271_allocate_sta(struct wl1271
*wl
,
3136 struct ieee80211_sta
*sta
,
3139 struct wl1271_station
*wl_sta
;
3142 id
= find_first_zero_bit(wl
->ap_hlid_map
, AP_MAX_STATIONS
);
3143 if (id
>= AP_MAX_STATIONS
) {
3144 wl1271_warning("could not allocate HLID - too much stations");
3148 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3149 __set_bit(id
, wl
->ap_hlid_map
);
3150 wl_sta
->hlid
= WL1271_AP_STA_HLID_START
+ id
;
3151 *hlid
= wl_sta
->hlid
;
3152 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
3156 static void wl1271_free_sta(struct wl1271
*wl
, u8 hlid
)
3158 int id
= hlid
- WL1271_AP_STA_HLID_START
;
3160 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3163 __clear_bit(id
, wl
->ap_hlid_map
);
3164 memset(wl
->links
[hlid
].addr
, 0, ETH_ALEN
);
3165 wl1271_tx_reset_link_queues(wl
, hlid
);
3166 __clear_bit(hlid
, &wl
->ap_ps_map
);
3167 __clear_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
3170 static int wl1271_op_sta_add(struct ieee80211_hw
*hw
,
3171 struct ieee80211_vif
*vif
,
3172 struct ieee80211_sta
*sta
)
3174 struct wl1271
*wl
= hw
->priv
;
3178 mutex_lock(&wl
->mutex
);
3180 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3183 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3186 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
3188 ret
= wl1271_allocate_sta(wl
, sta
, &hlid
);
3192 ret
= wl1271_ps_elp_wakeup(wl
);
3196 ret
= wl1271_cmd_add_sta(wl
, sta
, hlid
);
3201 wl1271_ps_elp_sleep(wl
);
3205 wl1271_free_sta(wl
, hlid
);
3208 mutex_unlock(&wl
->mutex
);
3212 static int wl1271_op_sta_remove(struct ieee80211_hw
*hw
,
3213 struct ieee80211_vif
*vif
,
3214 struct ieee80211_sta
*sta
)
3216 struct wl1271
*wl
= hw
->priv
;
3217 struct wl1271_station
*wl_sta
;
3220 mutex_lock(&wl
->mutex
);
3222 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3225 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3228 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
3230 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3231 id
= wl_sta
->hlid
- WL1271_AP_STA_HLID_START
;
3232 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3235 ret
= wl1271_ps_elp_wakeup(wl
);
3239 ret
= wl1271_cmd_remove_sta(wl
, wl_sta
->hlid
);
3243 wl1271_free_sta(wl
, wl_sta
->hlid
);
3246 wl1271_ps_elp_sleep(wl
);
3249 mutex_unlock(&wl
->mutex
);
3253 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
3254 struct ieee80211_vif
*vif
,
3255 enum ieee80211_ampdu_mlme_action action
,
3256 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
3259 struct wl1271
*wl
= hw
->priv
;
3262 mutex_lock(&wl
->mutex
);
3264 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
3269 ret
= wl1271_ps_elp_wakeup(wl
);
3274 case IEEE80211_AMPDU_RX_START
:
3275 if (wl
->ba_support
) {
3276 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, *ssn
,
3279 wl
->ba_rx_bitmap
|= BIT(tid
);
3285 case IEEE80211_AMPDU_RX_STOP
:
3286 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, 0, false);
3288 wl
->ba_rx_bitmap
&= ~BIT(tid
);
3292 * The BA initiator session management in FW independently.
3293 * Falling break here on purpose for all TX APDU commands.
3295 case IEEE80211_AMPDU_TX_START
:
3296 case IEEE80211_AMPDU_TX_STOP
:
3297 case IEEE80211_AMPDU_TX_OPERATIONAL
:
3302 wl1271_error("Incorrect ampdu action id=%x\n", action
);
3306 wl1271_ps_elp_sleep(wl
);
3309 mutex_unlock(&wl
->mutex
);
3314 static bool wl1271_tx_frames_pending(struct ieee80211_hw
*hw
)
3316 struct wl1271
*wl
= hw
->priv
;
3319 mutex_lock(&wl
->mutex
);
3321 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3324 /* packets are considered pending if in the TX queue or the FW */
3325 ret
= (wl
->tx_queue_count
> 0) || (wl
->tx_frames_cnt
> 0);
3327 /* the above is appropriate for STA mode for PS purposes */
3328 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
3331 mutex_unlock(&wl
->mutex
);
3336 /* can't be const, mac80211 writes to this */
3337 static struct ieee80211_rate wl1271_rates
[] = {
3339 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
3340 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
3342 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
3343 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
3344 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3346 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
3347 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
3348 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3350 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
3351 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
3352 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3354 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3355 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3357 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3358 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3360 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3361 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3363 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3364 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3366 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3367 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3369 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3370 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3372 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3373 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3375 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3376 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3379 /* can't be const, mac80211 writes to this */
3380 static struct ieee80211_channel wl1271_channels
[] = {
3381 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
3382 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
3383 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
3384 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
3385 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
3386 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
3387 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
3388 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
3389 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
3390 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
3391 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
3392 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
3393 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
3394 { .hw_value
= 14, .center_freq
= 2484, .max_power
= 25 },
3397 /* mapping to indexes for wl1271_rates */
3398 static const u8 wl1271_rate_to_idx_2ghz
[] = {
3399 /* MCS rates are used only with 11n */
3400 7, /* CONF_HW_RXTX_RATE_MCS7 */
3401 6, /* CONF_HW_RXTX_RATE_MCS6 */
3402 5, /* CONF_HW_RXTX_RATE_MCS5 */
3403 4, /* CONF_HW_RXTX_RATE_MCS4 */
3404 3, /* CONF_HW_RXTX_RATE_MCS3 */
3405 2, /* CONF_HW_RXTX_RATE_MCS2 */
3406 1, /* CONF_HW_RXTX_RATE_MCS1 */
3407 0, /* CONF_HW_RXTX_RATE_MCS0 */
3409 11, /* CONF_HW_RXTX_RATE_54 */
3410 10, /* CONF_HW_RXTX_RATE_48 */
3411 9, /* CONF_HW_RXTX_RATE_36 */
3412 8, /* CONF_HW_RXTX_RATE_24 */
3414 /* TI-specific rate */
3415 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3417 7, /* CONF_HW_RXTX_RATE_18 */
3418 6, /* CONF_HW_RXTX_RATE_12 */
3419 3, /* CONF_HW_RXTX_RATE_11 */
3420 5, /* CONF_HW_RXTX_RATE_9 */
3421 4, /* CONF_HW_RXTX_RATE_6 */
3422 2, /* CONF_HW_RXTX_RATE_5_5 */
3423 1, /* CONF_HW_RXTX_RATE_2 */
3424 0 /* CONF_HW_RXTX_RATE_1 */
3427 /* 11n STA capabilities */
3428 #define HW_RX_HIGHEST_RATE 72
3430 #ifdef CONFIG_WL12XX_HT
3431 #define WL12XX_HT_CAP { \
3432 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3433 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3434 .ht_supported = true, \
3435 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3436 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3438 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3439 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3440 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3444 #define WL12XX_HT_CAP { \
3445 .ht_supported = false, \
3449 /* can't be const, mac80211 writes to this */
3450 static struct ieee80211_supported_band wl1271_band_2ghz
= {
3451 .channels
= wl1271_channels
,
3452 .n_channels
= ARRAY_SIZE(wl1271_channels
),
3453 .bitrates
= wl1271_rates
,
3454 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
3455 .ht_cap
= WL12XX_HT_CAP
,
3458 /* 5 GHz data rates for WL1273 */
3459 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
3461 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3462 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3464 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3465 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3467 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3468 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3470 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3471 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3473 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3474 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3476 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3477 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3479 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3480 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3482 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3483 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3486 /* 5 GHz band channels for WL1273 */
3487 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
3488 { .hw_value
= 7, .center_freq
= 5035},
3489 { .hw_value
= 8, .center_freq
= 5040},
3490 { .hw_value
= 9, .center_freq
= 5045},
3491 { .hw_value
= 11, .center_freq
= 5055},
3492 { .hw_value
= 12, .center_freq
= 5060},
3493 { .hw_value
= 16, .center_freq
= 5080},
3494 { .hw_value
= 34, .center_freq
= 5170},
3495 { .hw_value
= 36, .center_freq
= 5180},
3496 { .hw_value
= 38, .center_freq
= 5190},
3497 { .hw_value
= 40, .center_freq
= 5200},
3498 { .hw_value
= 42, .center_freq
= 5210},
3499 { .hw_value
= 44, .center_freq
= 5220},
3500 { .hw_value
= 46, .center_freq
= 5230},
3501 { .hw_value
= 48, .center_freq
= 5240},
3502 { .hw_value
= 52, .center_freq
= 5260},
3503 { .hw_value
= 56, .center_freq
= 5280},
3504 { .hw_value
= 60, .center_freq
= 5300},
3505 { .hw_value
= 64, .center_freq
= 5320},
3506 { .hw_value
= 100, .center_freq
= 5500},
3507 { .hw_value
= 104, .center_freq
= 5520},
3508 { .hw_value
= 108, .center_freq
= 5540},
3509 { .hw_value
= 112, .center_freq
= 5560},
3510 { .hw_value
= 116, .center_freq
= 5580},
3511 { .hw_value
= 120, .center_freq
= 5600},
3512 { .hw_value
= 124, .center_freq
= 5620},
3513 { .hw_value
= 128, .center_freq
= 5640},
3514 { .hw_value
= 132, .center_freq
= 5660},
3515 { .hw_value
= 136, .center_freq
= 5680},
3516 { .hw_value
= 140, .center_freq
= 5700},
3517 { .hw_value
= 149, .center_freq
= 5745},
3518 { .hw_value
= 153, .center_freq
= 5765},
3519 { .hw_value
= 157, .center_freq
= 5785},
3520 { .hw_value
= 161, .center_freq
= 5805},
3521 { .hw_value
= 165, .center_freq
= 5825},
3524 /* mapping to indexes for wl1271_rates_5ghz */
3525 static const u8 wl1271_rate_to_idx_5ghz
[] = {
3526 /* MCS rates are used only with 11n */
3527 7, /* CONF_HW_RXTX_RATE_MCS7 */
3528 6, /* CONF_HW_RXTX_RATE_MCS6 */
3529 5, /* CONF_HW_RXTX_RATE_MCS5 */
3530 4, /* CONF_HW_RXTX_RATE_MCS4 */
3531 3, /* CONF_HW_RXTX_RATE_MCS3 */
3532 2, /* CONF_HW_RXTX_RATE_MCS2 */
3533 1, /* CONF_HW_RXTX_RATE_MCS1 */
3534 0, /* CONF_HW_RXTX_RATE_MCS0 */
3536 7, /* CONF_HW_RXTX_RATE_54 */
3537 6, /* CONF_HW_RXTX_RATE_48 */
3538 5, /* CONF_HW_RXTX_RATE_36 */
3539 4, /* CONF_HW_RXTX_RATE_24 */
3541 /* TI-specific rate */
3542 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3544 3, /* CONF_HW_RXTX_RATE_18 */
3545 2, /* CONF_HW_RXTX_RATE_12 */
3546 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_11 */
3547 1, /* CONF_HW_RXTX_RATE_9 */
3548 0, /* CONF_HW_RXTX_RATE_6 */
3549 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_5_5 */
3550 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_2 */
3551 CONF_HW_RXTX_RATE_UNSUPPORTED
/* CONF_HW_RXTX_RATE_1 */
3554 static struct ieee80211_supported_band wl1271_band_5ghz
= {
3555 .channels
= wl1271_channels_5ghz
,
3556 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
3557 .bitrates
= wl1271_rates_5ghz
,
3558 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
3559 .ht_cap
= WL12XX_HT_CAP
,
3562 static const u8
*wl1271_band_rate_to_idx
[] = {
3563 [IEEE80211_BAND_2GHZ
] = wl1271_rate_to_idx_2ghz
,
3564 [IEEE80211_BAND_5GHZ
] = wl1271_rate_to_idx_5ghz
3567 static const struct ieee80211_ops wl1271_ops
= {
3568 .start
= wl1271_op_start
,
3569 .stop
= wl1271_op_stop
,
3570 .add_interface
= wl1271_op_add_interface
,
3571 .remove_interface
= wl1271_op_remove_interface
,
3572 .suspend
= wl1271_op_suspend
,
3573 .resume
= wl1271_op_resume
,
3574 .config
= wl1271_op_config
,
3575 .prepare_multicast
= wl1271_op_prepare_multicast
,
3576 .configure_filter
= wl1271_op_configure_filter
,
3578 .set_key
= wl1271_op_set_key
,
3579 .hw_scan
= wl1271_op_hw_scan
,
3580 .sched_scan_start
= wl1271_op_sched_scan_start
,
3581 .sched_scan_stop
= wl1271_op_sched_scan_stop
,
3582 .bss_info_changed
= wl1271_op_bss_info_changed
,
3583 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
3584 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
3585 .conf_tx
= wl1271_op_conf_tx
,
3586 .get_tsf
= wl1271_op_get_tsf
,
3587 .get_survey
= wl1271_op_get_survey
,
3588 .sta_add
= wl1271_op_sta_add
,
3589 .sta_remove
= wl1271_op_sta_remove
,
3590 .ampdu_action
= wl1271_op_ampdu_action
,
3591 .tx_frames_pending
= wl1271_tx_frames_pending
,
3592 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
3596 u8
wl1271_rate_to_idx(int rate
, enum ieee80211_band band
)
3600 BUG_ON(band
>= sizeof(wl1271_band_rate_to_idx
)/sizeof(u8
*));
3602 if (unlikely(rate
>= CONF_HW_RXTX_RATE_MAX
)) {
3603 wl1271_error("Illegal RX rate from HW: %d", rate
);
3607 idx
= wl1271_band_rate_to_idx
[band
][rate
];
3608 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
3609 wl1271_error("Unsupported RX rate from HW: %d", rate
);
3616 static ssize_t
wl1271_sysfs_show_bt_coex_state(struct device
*dev
,
3617 struct device_attribute
*attr
,
3620 struct wl1271
*wl
= dev_get_drvdata(dev
);
3625 mutex_lock(&wl
->mutex
);
3626 len
= snprintf(buf
, len
, "%d\n\n0 - off\n1 - on\n",
3628 mutex_unlock(&wl
->mutex
);
3634 static ssize_t
wl1271_sysfs_store_bt_coex_state(struct device
*dev
,
3635 struct device_attribute
*attr
,
3636 const char *buf
, size_t count
)
3638 struct wl1271
*wl
= dev_get_drvdata(dev
);
3642 ret
= kstrtoul(buf
, 10, &res
);
3644 wl1271_warning("incorrect value written to bt_coex_mode");
3648 mutex_lock(&wl
->mutex
);
3652 if (res
== wl
->sg_enabled
)
3655 wl
->sg_enabled
= res
;
3657 if (wl
->state
== WL1271_STATE_OFF
)
3660 ret
= wl1271_ps_elp_wakeup(wl
);
3664 wl1271_acx_sg_enable(wl
, wl
->sg_enabled
);
3665 wl1271_ps_elp_sleep(wl
);
3668 mutex_unlock(&wl
->mutex
);
3672 static DEVICE_ATTR(bt_coex_state
, S_IRUGO
| S_IWUSR
,
3673 wl1271_sysfs_show_bt_coex_state
,
3674 wl1271_sysfs_store_bt_coex_state
);
3676 static ssize_t
wl1271_sysfs_show_hw_pg_ver(struct device
*dev
,
3677 struct device_attribute
*attr
,
3680 struct wl1271
*wl
= dev_get_drvdata(dev
);
3685 mutex_lock(&wl
->mutex
);
3686 if (wl
->hw_pg_ver
>= 0)
3687 len
= snprintf(buf
, len
, "%d\n", wl
->hw_pg_ver
);
3689 len
= snprintf(buf
, len
, "n/a\n");
3690 mutex_unlock(&wl
->mutex
);
3695 static DEVICE_ATTR(hw_pg_ver
, S_IRUGO
| S_IWUSR
,
3696 wl1271_sysfs_show_hw_pg_ver
, NULL
);
3698 int wl1271_register_hw(struct wl1271
*wl
)
3702 if (wl
->mac80211_registered
)
3705 ret
= wl1271_fetch_nvs(wl
);
3707 /* NOTE: The wl->nvs->nvs element must be first, in
3708 * order to simplify the casting, we assume it is at
3709 * the beginning of the wl->nvs structure.
3711 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
3713 wl
->mac_addr
[0] = nvs_ptr
[11];
3714 wl
->mac_addr
[1] = nvs_ptr
[10];
3715 wl
->mac_addr
[2] = nvs_ptr
[6];
3716 wl
->mac_addr
[3] = nvs_ptr
[5];
3717 wl
->mac_addr
[4] = nvs_ptr
[4];
3718 wl
->mac_addr
[5] = nvs_ptr
[3];
3721 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
3723 ret
= ieee80211_register_hw(wl
->hw
);
3725 wl1271_error("unable to register mac80211 hw: %d", ret
);
3729 wl
->mac80211_registered
= true;
3731 wl1271_debugfs_init(wl
);
3733 register_netdevice_notifier(&wl1271_dev_notifier
);
3735 wl1271_notice("loaded");
3739 EXPORT_SYMBOL_GPL(wl1271_register_hw
);
3741 void wl1271_unregister_hw(struct wl1271
*wl
)
3743 if (wl
->state
== WL1271_STATE_PLT
)
3744 __wl1271_plt_stop(wl
);
3746 unregister_netdevice_notifier(&wl1271_dev_notifier
);
3747 ieee80211_unregister_hw(wl
->hw
);
3748 wl
->mac80211_registered
= false;
3751 EXPORT_SYMBOL_GPL(wl1271_unregister_hw
);
3753 int wl1271_init_ieee80211(struct wl1271
*wl
)
3755 static const u32 cipher_suites
[] = {
3756 WLAN_CIPHER_SUITE_WEP40
,
3757 WLAN_CIPHER_SUITE_WEP104
,
3758 WLAN_CIPHER_SUITE_TKIP
,
3759 WLAN_CIPHER_SUITE_CCMP
,
3760 WL1271_CIPHER_SUITE_GEM
,
3763 /* The tx descriptor buffer and the TKIP space. */
3764 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
3765 sizeof(struct wl1271_tx_hw_descr
);
3768 /* FIXME: find a proper value */
3769 wl
->hw
->channel_change_time
= 10000;
3770 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
3772 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
3773 IEEE80211_HW_BEACON_FILTER
|
3774 IEEE80211_HW_SUPPORTS_PS
|
3775 IEEE80211_HW_SUPPORTS_UAPSD
|
3776 IEEE80211_HW_HAS_RATE_CONTROL
|
3777 IEEE80211_HW_CONNECTION_MONITOR
|
3778 IEEE80211_HW_SUPPORTS_CQM_RSSI
|
3779 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
3780 IEEE80211_HW_SPECTRUM_MGMT
|
3781 IEEE80211_HW_AP_LINK_PS
;
3783 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
3784 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
3786 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
3787 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
3788 wl
->hw
->wiphy
->max_scan_ssids
= 1;
3790 * Maximum length of elements in scanning probe request templates
3791 * should be the maximum length possible for a template, without
3792 * the IEEE80211 header of the template
3794 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
3795 sizeof(struct ieee80211_header
);
3797 /* make sure all our channels fit in the scanned_ch bitmask */
3798 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
3799 ARRAY_SIZE(wl1271_channels_5ghz
) >
3800 WL1271_MAX_CHANNELS
);
3802 * We keep local copies of the band structs because we need to
3803 * modify them on a per-device basis.
3805 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
3806 sizeof(wl1271_band_2ghz
));
3807 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
3808 sizeof(wl1271_band_5ghz
));
3810 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
3811 &wl
->bands
[IEEE80211_BAND_2GHZ
];
3812 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
3813 &wl
->bands
[IEEE80211_BAND_5GHZ
];
3816 wl
->hw
->max_rates
= 1;
3818 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
3820 SET_IEEE80211_DEV(wl
->hw
, wl1271_wl_to_dev(wl
));
3822 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
3824 wl
->hw
->max_rx_aggregation_subframes
= 8;
3828 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211
);
3830 #define WL1271_DEFAULT_CHANNEL 0
3832 struct ieee80211_hw
*wl1271_alloc_hw(void)
3834 struct ieee80211_hw
*hw
;
3835 struct platform_device
*plat_dev
= NULL
;
3840 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
3842 wl1271_error("could not alloc ieee80211_hw");
3847 plat_dev
= kmemdup(&wl1271_device
, sizeof(wl1271_device
), GFP_KERNEL
);
3849 wl1271_error("could not allocate platform_device");
3851 goto err_plat_alloc
;
3855 memset(wl
, 0, sizeof(*wl
));
3857 INIT_LIST_HEAD(&wl
->list
);
3860 wl
->plat_dev
= plat_dev
;
3862 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
3863 skb_queue_head_init(&wl
->tx_queue
[i
]);
3865 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
3866 for (j
= 0; j
< AP_MAX_LINKS
; j
++)
3867 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
3869 skb_queue_head_init(&wl
->deferred_rx_queue
);
3870 skb_queue_head_init(&wl
->deferred_tx_queue
);
3872 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
3873 INIT_DELAYED_WORK(&wl
->pspoll_work
, wl1271_pspoll_work
);
3874 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
3875 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
3876 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
3877 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
3878 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
3879 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
3880 wl
->default_key
= 0;
3882 wl
->rx_config
= WL1271_DEFAULT_STA_RX_CONFIG
;
3883 wl
->rx_filter
= WL1271_DEFAULT_STA_RX_FILTER
;
3884 wl
->psm_entry_retry
= 0;
3885 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
3886 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
3887 wl
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
3888 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
3889 wl
->band
= IEEE80211_BAND_2GHZ
;
3892 wl
->sg_enabled
= true;
3894 wl
->bss_type
= MAX_BSS_TYPE
;
3895 wl
->set_bss_type
= MAX_BSS_TYPE
;
3896 wl
->fw_bss_type
= MAX_BSS_TYPE
;
3897 wl
->last_tx_hlid
= 0;
3899 wl
->ap_fw_ps_map
= 0;
3901 wl
->platform_quirks
= 0;
3902 wl
->sched_scanning
= false;
3904 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
3905 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
3906 wl
->tx_frames
[i
] = NULL
;
3908 spin_lock_init(&wl
->wl_lock
);
3910 wl
->state
= WL1271_STATE_OFF
;
3911 mutex_init(&wl
->mutex
);
3913 /* Apply default driver configuration. */
3914 wl1271_conf_init(wl
);
3916 order
= get_order(WL1271_AGGR_BUFFER_SIZE
);
3917 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
3918 if (!wl
->aggr_buf
) {
3923 wl
->dummy_packet
= wl12xx_alloc_dummy_packet(wl
);
3924 if (!wl
->dummy_packet
) {
3929 /* Register platform device */
3930 ret
= platform_device_register(wl
->plat_dev
);
3932 wl1271_error("couldn't register platform device");
3933 goto err_dummy_packet
;
3935 dev_set_drvdata(&wl
->plat_dev
->dev
, wl
);
3937 /* Create sysfs file to control bt coex state */
3938 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
3940 wl1271_error("failed to create sysfs file bt_coex_state");
3944 /* Create sysfs file to get HW PG version */
3945 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
3947 wl1271_error("failed to create sysfs file hw_pg_ver");
3948 goto err_bt_coex_state
;
3954 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
3957 platform_device_unregister(wl
->plat_dev
);
3960 dev_kfree_skb(wl
->dummy_packet
);
3963 free_pages((unsigned long)wl
->aggr_buf
, order
);
3966 wl1271_debugfs_exit(wl
);
3970 ieee80211_free_hw(hw
);
3974 return ERR_PTR(ret
);
3976 EXPORT_SYMBOL_GPL(wl1271_alloc_hw
);
3978 int wl1271_free_hw(struct wl1271
*wl
)
3980 platform_device_unregister(wl
->plat_dev
);
3981 dev_kfree_skb(wl
->dummy_packet
);
3982 free_pages((unsigned long)wl
->aggr_buf
,
3983 get_order(WL1271_AGGR_BUFFER_SIZE
));
3984 kfree(wl
->plat_dev
);
3986 wl1271_debugfs_exit(wl
);
3993 kfree(wl
->fw_status
);
3994 kfree(wl
->tx_res_if
);
3996 ieee80211_free_hw(wl
->hw
);
4000 EXPORT_SYMBOL_GPL(wl1271_free_hw
);
4002 u32 wl12xx_debug_level
= DEBUG_NONE
;
4003 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
4004 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
4005 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
4007 MODULE_LICENSE("GPL");
4008 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4009 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");