2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
33 #include <linux/wl12xx.h>
34 #include <linux/sched.h>
37 #include "wl12xx_80211.h"
51 #define WL1271_BOOT_RETRIES 3
53 static struct conf_drv_settings default_conf
= {
56 [CONF_SG_ACL_BT_MASTER_MIN_BR
] = 10,
57 [CONF_SG_ACL_BT_MASTER_MAX_BR
] = 180,
58 [CONF_SG_ACL_BT_SLAVE_MIN_BR
] = 10,
59 [CONF_SG_ACL_BT_SLAVE_MAX_BR
] = 180,
60 [CONF_SG_ACL_BT_MASTER_MIN_EDR
] = 10,
61 [CONF_SG_ACL_BT_MASTER_MAX_EDR
] = 80,
62 [CONF_SG_ACL_BT_SLAVE_MIN_EDR
] = 10,
63 [CONF_SG_ACL_BT_SLAVE_MAX_EDR
] = 80,
64 [CONF_SG_ACL_WLAN_PS_MASTER_BR
] = 8,
65 [CONF_SG_ACL_WLAN_PS_SLAVE_BR
] = 8,
66 [CONF_SG_ACL_WLAN_PS_MASTER_EDR
] = 20,
67 [CONF_SG_ACL_WLAN_PS_SLAVE_EDR
] = 20,
68 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_BR
] = 20,
69 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_BR
] = 35,
70 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_BR
] = 16,
71 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_BR
] = 35,
72 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MIN_EDR
] = 32,
73 [CONF_SG_ACL_WLAN_ACTIVE_MASTER_MAX_EDR
] = 50,
74 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MIN_EDR
] = 28,
75 [CONF_SG_ACL_WLAN_ACTIVE_SLAVE_MAX_EDR
] = 50,
76 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_BR
] = 10,
77 [CONF_SG_ACL_ACTIVE_SCAN_WLAN_EDR
] = 20,
78 [CONF_SG_ACL_PASSIVE_SCAN_BT_BR
] = 75,
79 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_BR
] = 15,
80 [CONF_SG_ACL_PASSIVE_SCAN_BT_EDR
] = 27,
81 [CONF_SG_ACL_PASSIVE_SCAN_WLAN_EDR
] = 17,
82 /* active scan params */
83 [CONF_SG_AUTO_SCAN_PROBE_REQ
] = 170,
84 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3
] = 50,
85 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP
] = 100,
86 /* passive scan params */
87 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_BR
] = 800,
88 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP_EDR
] = 200,
89 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3
] = 200,
90 /* passive scan in dual antenna params */
91 [CONF_SG_CONSECUTIVE_HV3_IN_PASSIVE_SCAN
] = 0,
92 [CONF_SG_BCN_HV3_COLLISION_THRESH_IN_PASSIVE_SCAN
] = 0,
93 [CONF_SG_TX_RX_PROTECTION_BWIDTH_IN_PASSIVE_SCAN
] = 0,
95 [CONF_SG_STA_FORCE_PS_IN_BT_SCO
] = 1,
96 [CONF_SG_ANTENNA_CONFIGURATION
] = 0,
97 [CONF_SG_BEACON_MISS_PERCENT
] = 60,
98 [CONF_SG_DHCP_TIME
] = 5000,
100 [CONF_SG_TXT
] = 1000,
101 [CONF_SG_ADAPTIVE_RXT_TXT
] = 1,
102 [CONF_SG_GENERAL_USAGE_BIT_MAP
] = 3,
103 [CONF_SG_HV3_MAX_SERVED
] = 6,
104 [CONF_SG_PS_POLL_TIMEOUT
] = 10,
105 [CONF_SG_UPSD_TIMEOUT
] = 10,
106 [CONF_SG_CONSECUTIVE_CTS_THRESHOLD
] = 2,
107 [CONF_SG_STA_RX_WINDOW_AFTER_DTIM
] = 5,
108 [CONF_SG_STA_CONNECTION_PROTECTION_TIME
] = 30,
110 [CONF_AP_BEACON_MISS_TX
] = 3,
111 [CONF_AP_RX_WINDOW_AFTER_BEACON
] = 10,
112 [CONF_AP_BEACON_WINDOW_INTERVAL
] = 2,
113 [CONF_AP_CONNECTION_PROTECTION_TIME
] = 0,
114 [CONF_AP_BT_ACL_VAL_BT_SERVE_TIME
] = 25,
115 [CONF_AP_BT_ACL_VAL_WL_SERVE_TIME
] = 25,
117 .state
= CONF_SG_PROTECTIVE
,
120 .rx_msdu_life_time
= 512000,
121 .packet_detection_threshold
= 0,
122 .ps_poll_timeout
= 15,
124 .rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
,
125 .rx_cca_threshold
= 0,
126 .irq_blk_threshold
= 0xFFFF,
127 .irq_pkt_threshold
= 0,
129 .queue_type
= CONF_RX_QUEUE_TYPE_LOW_PRIORITY
,
132 .tx_energy_detection
= 0,
135 .short_retry_limit
= 10,
136 .long_retry_limit
= 10,
159 .aifsn
= CONF_TX_AIFS_PIFS
,
166 .aifsn
= CONF_TX_AIFS_PIFS
,
170 .max_tx_retries
= 100,
171 .ap_aging_period
= 300,
175 .queue_id
= CONF_TX_AC_BE
,
176 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
177 .tsid
= CONF_TX_AC_BE
,
178 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
179 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
183 .queue_id
= CONF_TX_AC_BK
,
184 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
185 .tsid
= CONF_TX_AC_BK
,
186 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
187 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
191 .queue_id
= CONF_TX_AC_VI
,
192 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
193 .tsid
= CONF_TX_AC_VI
,
194 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
195 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
199 .queue_id
= CONF_TX_AC_VO
,
200 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
201 .tsid
= CONF_TX_AC_VO
,
202 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
203 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
207 .frag_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
,
208 .tx_compl_timeout
= 700,
209 .tx_compl_threshold
= 4,
210 .basic_rate
= CONF_HW_BIT_RATE_1MBPS
,
211 .basic_rate_5
= CONF_HW_BIT_RATE_6MBPS
,
212 .tmpl_short_retry_limit
= 10,
213 .tmpl_long_retry_limit
= 10,
216 .wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
,
217 .listen_interval
= 1,
218 .bcn_filt_mode
= CONF_BCN_FILT_MODE_ENABLED
,
219 .bcn_filt_ie_count
= 2,
222 .ie
= WLAN_EID_CHANNEL_SWITCH
,
223 .rule
= CONF_BCN_RULE_PASS_ON_APPEARANCE
,
226 .ie
= WLAN_EID_HT_INFORMATION
,
227 .rule
= CONF_BCN_RULE_PASS_ON_CHANGE
,
230 .synch_fail_thold
= 10,
231 .bss_lose_timeout
= 100,
232 .beacon_rx_timeout
= 10000,
233 .broadcast_timeout
= 20000,
234 .rx_broadcast_in_ps
= 1,
235 .ps_poll_threshold
= 10,
236 .ps_poll_recovery_period
= 700,
237 .bet_enable
= CONF_BET_MODE_ENABLE
,
238 .bet_max_consecutive
= 50,
239 .psm_entry_retries
= 8,
240 .psm_exit_retries
= 16,
241 .psm_entry_nullfunc_retries
= 3,
242 .keep_alive_interval
= 55000,
243 .max_listen_interval
= 20,
250 .host_clk_settling_time
= 5000,
251 .host_fast_wakeup_support
= false
255 .avg_weight_rssi_beacon
= 20,
256 .avg_weight_rssi_data
= 10,
257 .avg_weight_snr_beacon
= 20,
258 .avg_weight_snr_data
= 10,
261 .min_dwell_time_active
= 7500,
262 .max_dwell_time_active
= 30000,
263 .min_dwell_time_passive
= 100000,
264 .max_dwell_time_passive
= 100000,
268 /* sched_scan requires dwell times in TU instead of TU/1000 */
269 .min_dwell_time_active
= 30,
270 .max_dwell_time_active
= 60,
271 .dwell_time_passive
= 100,
272 .dwell_time_dfs
= 150,
274 .rssi_threshold
= -90,
278 .tx_per_channel_power_compensation_2
= {
279 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
281 .tx_per_channel_power_compensation_5
= {
282 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
283 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
284 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
289 .tx_ba_win_size
= 64,
290 .inactivity_timeout
= 10000,
291 .tx_ba_tid_bitmap
= CONF_TX_BA_ENABLED_TID_BITMAP
,
297 .tx_min_block_num
= 40,
299 .min_req_tx_blocks
= 100,
300 .min_req_rx_blocks
= 22,
307 .tx_min_block_num
= 40,
309 .min_req_tx_blocks
= 45,
310 .min_req_rx_blocks
= 22,
316 .n_divider_fref_set_1
= 0xff, /* default */
317 .n_divider_fref_set_2
= 12,
318 .m_divider_fref_set_1
= 148,
319 .m_divider_fref_set_2
= 0xffff, /* default */
320 .coex_pll_stabilization_time
= 0xffffffff, /* default */
321 .ldo_stabilization_time
= 0xffff, /* default */
322 .fm_disturbed_band_margin
= 0xff, /* default */
323 .swallow_clk_diff
= 0xff, /* default */
332 .mode
= WL12XX_FWLOG_ON_DEMAND
,
335 .timestamp
= WL12XX_FWLOG_TIMESTAMP_DISABLED
,
336 .output
= WL12XX_FWLOG_OUTPUT_HOST
,
339 .hci_io_ds
= HCI_IO_DS_6MA
,
341 .rate_retry_score
= 32000,
346 .inverse_curiosity_factor
= 5,
348 .tx_fail_high_th
= 10,
349 .per_alpha_shift
= 4,
351 .per_beta1_shift
= 10,
352 .per_beta2_shift
= 8,
354 .rate_check_down
= 12,
355 .rate_retry_policy
= {
356 0x00, 0x00, 0x00, 0x00, 0x00,
357 0x00, 0x00, 0x00, 0x00, 0x00,
363 .hangover_period
= 20,
365 .early_termination_mode
= 1,
376 static char *fwlog_param
;
377 static bool bug_on_recovery
;
379 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
380 bool reset_tx_queues
);
381 static void wl1271_free_ap_keys(struct wl1271
*wl
);
384 static void wl1271_device_release(struct device
*dev
)
389 static struct platform_device wl1271_device
= {
393 /* device model insists to have a release function */
395 .release
= wl1271_device_release
,
399 static DEFINE_MUTEX(wl_list_mutex
);
400 static LIST_HEAD(wl_list
);
402 static int wl1271_check_operstate(struct wl1271
*wl
, unsigned char operstate
)
405 if (operstate
!= IF_OPER_UP
)
408 if (test_and_set_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
))
411 ret
= wl12xx_cmd_set_peer_state(wl
, wl
->sta_hlid
);
415 wl12xx_croc(wl
, wl
->role_id
);
417 wl1271_info("Association completed.");
420 static int wl1271_dev_notify(struct notifier_block
*me
, unsigned long what
,
423 struct net_device
*dev
= arg
;
424 struct wireless_dev
*wdev
;
426 struct ieee80211_hw
*hw
;
428 struct wl1271
*wl_temp
;
431 /* Check that this notification is for us. */
432 if (what
!= NETDEV_CHANGE
)
435 wdev
= dev
->ieee80211_ptr
;
443 hw
= wiphy_priv(wiphy
);
448 mutex_lock(&wl_list_mutex
);
449 list_for_each_entry(wl
, &wl_list
, list
) {
453 mutex_unlock(&wl_list_mutex
);
457 mutex_lock(&wl
->mutex
);
459 if (wl
->state
== WL1271_STATE_OFF
)
462 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
465 ret
= wl1271_ps_elp_wakeup(wl
);
469 wl1271_check_operstate(wl
, dev
->operstate
);
471 wl1271_ps_elp_sleep(wl
);
474 mutex_unlock(&wl
->mutex
);
479 static int wl1271_reg_notify(struct wiphy
*wiphy
,
480 struct regulatory_request
*request
)
482 struct ieee80211_supported_band
*band
;
483 struct ieee80211_channel
*ch
;
486 band
= wiphy
->bands
[IEEE80211_BAND_5GHZ
];
487 for (i
= 0; i
< band
->n_channels
; i
++) {
488 ch
= &band
->channels
[i
];
489 if (ch
->flags
& IEEE80211_CHAN_DISABLED
)
492 if (ch
->flags
& IEEE80211_CHAN_RADAR
)
493 ch
->flags
|= IEEE80211_CHAN_NO_IBSS
|
494 IEEE80211_CHAN_PASSIVE_SCAN
;
501 static int wl1271_set_rx_streaming(struct wl1271
*wl
, bool enable
)
505 /* we should hold wl->mutex */
506 ret
= wl1271_acx_ps_rx_streaming(wl
, enable
);
511 set_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
);
513 clear_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
);
519 * this function is being called when the rx_streaming interval
520 * has beed changed or rx_streaming should be disabled
522 int wl1271_recalc_rx_streaming(struct wl1271
*wl
)
525 int period
= wl
->conf
.rx_streaming
.interval
;
527 /* don't reconfigure if rx_streaming is disabled */
528 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
))
531 /* reconfigure/disable according to new streaming_period */
533 test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) &&
534 (wl
->conf
.rx_streaming
.always
||
535 test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
536 ret
= wl1271_set_rx_streaming(wl
, true);
538 ret
= wl1271_set_rx_streaming(wl
, false);
539 /* don't cancel_work_sync since we might deadlock */
540 del_timer_sync(&wl
->rx_streaming_timer
);
546 static void wl1271_rx_streaming_enable_work(struct work_struct
*work
)
550 container_of(work
, struct wl1271
, rx_streaming_enable_work
);
552 mutex_lock(&wl
->mutex
);
554 if (test_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
) ||
555 !test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) ||
556 (!wl
->conf
.rx_streaming
.always
&&
557 !test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
560 if (!wl
->conf
.rx_streaming
.interval
)
563 ret
= wl1271_ps_elp_wakeup(wl
);
567 ret
= wl1271_set_rx_streaming(wl
, true);
571 /* stop it after some time of inactivity */
572 mod_timer(&wl
->rx_streaming_timer
,
573 jiffies
+ msecs_to_jiffies(wl
->conf
.rx_streaming
.duration
));
576 wl1271_ps_elp_sleep(wl
);
578 mutex_unlock(&wl
->mutex
);
581 static void wl1271_rx_streaming_disable_work(struct work_struct
*work
)
585 container_of(work
, struct wl1271
, rx_streaming_disable_work
);
587 mutex_lock(&wl
->mutex
);
589 if (!test_bit(WL1271_FLAG_RX_STREAMING_STARTED
, &wl
->flags
))
592 ret
= wl1271_ps_elp_wakeup(wl
);
596 ret
= wl1271_set_rx_streaming(wl
, false);
601 wl1271_ps_elp_sleep(wl
);
603 mutex_unlock(&wl
->mutex
);
606 static void wl1271_rx_streaming_timer(unsigned long data
)
608 struct wl1271
*wl
= (struct wl1271
*)data
;
609 ieee80211_queue_work(wl
->hw
, &wl
->rx_streaming_disable_work
);
612 static void wl1271_conf_init(struct wl1271
*wl
)
616 * This function applies the default configuration to the driver. This
617 * function is invoked upon driver load (spi probe.)
619 * The configuration is stored in a run-time structure in order to
620 * facilitate for run-time adjustment of any of the parameters. Making
621 * changes to the configuration structure will apply the new values on
622 * the next interface up (wl1271_op_start.)
625 /* apply driver default configuration */
626 memcpy(&wl
->conf
, &default_conf
, sizeof(default_conf
));
628 /* Adjust settings according to optional module parameters */
630 if (!strcmp(fwlog_param
, "continuous")) {
631 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
632 } else if (!strcmp(fwlog_param
, "ondemand")) {
633 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_ON_DEMAND
;
634 } else if (!strcmp(fwlog_param
, "dbgpins")) {
635 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
636 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_DBG_PINS
;
637 } else if (!strcmp(fwlog_param
, "disable")) {
638 wl
->conf
.fwlog
.mem_blocks
= 0;
639 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_NONE
;
641 wl1271_error("Unknown fwlog parameter %s", fwlog_param
);
646 static int wl1271_plt_init(struct wl1271
*wl
)
648 struct conf_tx_ac_category
*conf_ac
;
649 struct conf_tx_tid
*conf_tid
;
652 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
653 ret
= wl128x_cmd_general_parms(wl
);
655 ret
= wl1271_cmd_general_parms(wl
);
659 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
660 ret
= wl128x_cmd_radio_parms(wl
);
662 ret
= wl1271_cmd_radio_parms(wl
);
666 if (wl
->chip
.id
!= CHIP_ID_1283_PG20
) {
667 ret
= wl1271_cmd_ext_radio_parms(wl
);
674 /* Chip-specific initializations */
675 ret
= wl1271_chip_specific_init(wl
);
679 ret
= wl1271_sta_init_templates_config(wl
);
683 ret
= wl1271_acx_init_mem_config(wl
);
687 /* PHY layer config */
688 ret
= wl1271_init_phy_config(wl
);
690 goto out_free_memmap
;
692 ret
= wl1271_acx_dco_itrim_params(wl
);
694 goto out_free_memmap
;
696 /* Initialize connection monitoring thresholds */
697 ret
= wl1271_acx_conn_monit_params(wl
, false);
699 goto out_free_memmap
;
701 /* Bluetooth WLAN coexistence */
702 ret
= wl1271_init_pta(wl
);
704 goto out_free_memmap
;
706 /* FM WLAN coexistence */
707 ret
= wl1271_acx_fm_coex(wl
);
709 goto out_free_memmap
;
711 /* Energy detection */
712 ret
= wl1271_init_energy_detection(wl
);
714 goto out_free_memmap
;
716 ret
= wl12xx_acx_mem_cfg(wl
);
718 goto out_free_memmap
;
720 /* Default fragmentation threshold */
721 ret
= wl1271_acx_frag_threshold(wl
, wl
->conf
.tx
.frag_threshold
);
723 goto out_free_memmap
;
725 /* Default TID/AC configuration */
726 BUG_ON(wl
->conf
.tx
.tid_conf_count
!= wl
->conf
.tx
.ac_conf_count
);
727 for (i
= 0; i
< wl
->conf
.tx
.tid_conf_count
; i
++) {
728 conf_ac
= &wl
->conf
.tx
.ac_conf
[i
];
729 ret
= wl1271_acx_ac_cfg(wl
, conf_ac
->ac
, conf_ac
->cw_min
,
730 conf_ac
->cw_max
, conf_ac
->aifsn
,
731 conf_ac
->tx_op_limit
);
733 goto out_free_memmap
;
735 conf_tid
= &wl
->conf
.tx
.tid_conf
[i
];
736 ret
= wl1271_acx_tid_cfg(wl
, conf_tid
->queue_id
,
737 conf_tid
->channel_type
,
740 conf_tid
->ack_policy
,
741 conf_tid
->apsd_conf
[0],
742 conf_tid
->apsd_conf
[1]);
744 goto out_free_memmap
;
747 /* Enable data path */
748 ret
= wl1271_cmd_data_path(wl
, 1);
750 goto out_free_memmap
;
752 /* Configure for CAM power saving (ie. always active) */
753 ret
= wl1271_acx_sleep_auth(wl
, WL1271_PSM_CAM
);
755 goto out_free_memmap
;
758 ret
= wl1271_acx_pm_config(wl
);
760 goto out_free_memmap
;
765 kfree(wl
->target_mem_map
);
766 wl
->target_mem_map
= NULL
;
771 static void wl12xx_irq_ps_regulate_link(struct wl1271
*wl
, u8 hlid
, u8 tx_pkts
)
773 bool fw_ps
, single_sta
;
775 /* only regulate station links */
776 if (hlid
< WL1271_AP_STA_HLID_START
)
779 fw_ps
= test_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
780 single_sta
= (wl
->active_sta_count
== 1);
783 * Wake up from high level PS if the STA is asleep with too little
784 * packets in FW or if the STA is awake.
786 if (!fw_ps
|| tx_pkts
< WL1271_PS_STA_MAX_PACKETS
)
787 wl1271_ps_link_end(wl
, hlid
);
790 * Start high-level PS if the STA is asleep with enough blocks in FW.
791 * Make an exception if this is the only connected station. In this
792 * case FW-memory congestion is not a problem.
794 else if (!single_sta
&& fw_ps
&& tx_pkts
>= WL1271_PS_STA_MAX_PACKETS
)
795 wl1271_ps_link_start(wl
, hlid
, true);
798 bool wl1271_is_active_sta(struct wl1271
*wl
, u8 hlid
)
802 /* global/broadcast "stations" are always active */
803 if (hlid
< WL1271_AP_STA_HLID_START
)
806 id
= hlid
- WL1271_AP_STA_HLID_START
;
807 return test_bit(id
, wl
->ap_hlid_map
);
810 static void wl12xx_irq_update_links_status(struct wl1271
*wl
,
811 struct wl12xx_fw_status
*status
)
816 /* TODO: also use link_fast_bitmap here */
818 cur_fw_ps_map
= le32_to_cpu(status
->link_ps_bitmap
);
819 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
820 wl1271_debug(DEBUG_PSM
,
821 "link ps prev 0x%x cur 0x%x changed 0x%x",
822 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
823 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
825 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
828 for (hlid
= WL1271_AP_STA_HLID_START
; hlid
< AP_MAX_LINKS
; hlid
++) {
829 if (!wl1271_is_active_sta(wl
, hlid
))
832 cnt
= status
->tx_lnk_free_pkts
[hlid
] -
833 wl
->links
[hlid
].prev_freed_pkts
;
835 wl
->links
[hlid
].prev_freed_pkts
=
836 status
->tx_lnk_free_pkts
[hlid
];
837 wl
->links
[hlid
].allocated_pkts
-= cnt
;
839 wl12xx_irq_ps_regulate_link(wl
, hlid
,
840 wl
->links
[hlid
].allocated_pkts
);
844 static void wl12xx_fw_status(struct wl1271
*wl
,
845 struct wl12xx_fw_status
*status
)
848 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
849 int avail
, freed_blocks
;
852 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
, sizeof(*status
), false);
854 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
855 "drv_rx_counter = %d, tx_results_counter = %d)",
857 status
->fw_rx_counter
,
858 status
->drv_rx_counter
,
859 status
->tx_results_counter
);
861 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
862 /* prevent wrap-around in freed-packets counter */
863 wl
->tx_allocated_pkts
[i
] -=
864 (status
->tx_released_pkts
[i
] -
865 wl
->tx_pkts_freed
[i
]) & 0xff;
867 wl
->tx_pkts_freed
[i
] = status
->tx_released_pkts
[i
];
870 /* prevent wrap-around in total blocks counter */
871 if (likely(wl
->tx_blocks_freed
<=
872 le32_to_cpu(status
->total_released_blks
)))
873 freed_blocks
= le32_to_cpu(status
->total_released_blks
) -
876 freed_blocks
= 0x100000000LL
- wl
->tx_blocks_freed
+
877 le32_to_cpu(status
->total_released_blks
);
879 wl
->tx_blocks_freed
= le32_to_cpu(status
->total_released_blks
);
881 wl
->tx_allocated_blocks
-= freed_blocks
;
883 avail
= le32_to_cpu(status
->tx_total
) - wl
->tx_allocated_blocks
;
886 * The FW might change the total number of TX memblocks before
887 * we get a notification about blocks being released. Thus, the
888 * available blocks calculation might yield a temporary result
889 * which is lower than the actual available blocks. Keeping in
890 * mind that only blocks that were allocated can be moved from
891 * TX to RX, tx_blocks_available should never decrease here.
893 wl
->tx_blocks_available
= max((int)wl
->tx_blocks_available
,
896 /* if more blocks are available now, tx work can be scheduled */
897 if (wl
->tx_blocks_available
> old_tx_blk_count
)
898 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
900 /* for AP update num of allocated TX blocks per link and ps status */
901 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
902 wl12xx_irq_update_links_status(wl
, status
);
904 /* update the host-chipset time offset */
906 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
907 (s64
)le32_to_cpu(status
->fw_localtime
);
910 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
914 /* Pass all received frames to the network stack */
915 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
916 ieee80211_rx_ni(wl
->hw
, skb
);
918 /* Return sent skbs to the network stack */
919 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
920 ieee80211_tx_status_ni(wl
->hw
, skb
);
923 static void wl1271_netstack_work(struct work_struct
*work
)
926 container_of(work
, struct wl1271
, netstack_work
);
929 wl1271_flush_deferred_work(wl
);
930 } while (skb_queue_len(&wl
->deferred_rx_queue
));
933 #define WL1271_IRQ_MAX_LOOPS 256
935 irqreturn_t
wl1271_irq(int irq
, void *cookie
)
939 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
940 struct wl1271
*wl
= (struct wl1271
*)cookie
;
942 unsigned int defer_count
;
945 /* TX might be handled here, avoid redundant work */
946 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
947 cancel_work_sync(&wl
->tx_work
);
950 * In case edge triggered interrupt must be used, we cannot iterate
951 * more than once without introducing race conditions with the hardirq.
953 if (wl
->platform_quirks
& WL12XX_PLATFORM_QUIRK_EDGE_IRQ
)
956 mutex_lock(&wl
->mutex
);
958 wl1271_debug(DEBUG_IRQ
, "IRQ work");
960 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
963 ret
= wl1271_ps_elp_wakeup(wl
);
967 while (!done
&& loopcount
--) {
969 * In order to avoid a race with the hardirq, clear the flag
970 * before acknowledging the chip. Since the mutex is held,
971 * wl1271_ps_elp_wakeup cannot be called concurrently.
973 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
974 smp_mb__after_clear_bit();
976 wl12xx_fw_status(wl
, wl
->fw_status
);
977 intr
= le32_to_cpu(wl
->fw_status
->intr
);
978 intr
&= WL1271_INTR_MASK
;
984 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
985 wl1271_error("watchdog interrupt received! "
986 "starting recovery.");
987 wl12xx_queue_recovery_work(wl
);
989 /* restarting the chip. ignore any other interrupt. */
993 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
994 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
996 wl12xx_rx(wl
, wl
->fw_status
);
998 /* Check if any tx blocks were freed */
999 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1000 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1001 wl1271_tx_total_queue_count(wl
) > 0) {
1002 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1004 * In order to avoid starvation of the TX path,
1005 * call the work function directly.
1007 wl1271_tx_work_locked(wl
);
1009 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1012 /* check for tx results */
1013 if (wl
->fw_status
->tx_results_counter
!=
1014 (wl
->tx_results_count
& 0xff))
1015 wl1271_tx_complete(wl
);
1017 /* Make sure the deferred queues don't get too long */
1018 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
1019 skb_queue_len(&wl
->deferred_rx_queue
);
1020 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
1021 wl1271_flush_deferred_work(wl
);
1024 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
1025 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
1026 wl1271_event_handle(wl
, 0);
1029 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
1030 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
1031 wl1271_event_handle(wl
, 1);
1034 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
1035 wl1271_debug(DEBUG_IRQ
,
1036 "WL1271_ACX_INTR_INIT_COMPLETE");
1038 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
1039 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
1042 wl1271_ps_elp_sleep(wl
);
1045 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1046 /* In case TX was not handled here, queue TX work */
1047 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
1048 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1049 wl1271_tx_total_queue_count(wl
) > 0)
1050 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1051 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1053 mutex_unlock(&wl
->mutex
);
1057 EXPORT_SYMBOL_GPL(wl1271_irq
);
1059 static int wl1271_fetch_firmware(struct wl1271
*wl
)
1061 const struct firmware
*fw
;
1062 const char *fw_name
;
1065 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
1066 fw_name
= WL128X_FW_NAME
;
1068 fw_name
= WL127X_FW_NAME
;
1070 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
1072 ret
= request_firmware(&fw
, fw_name
, wl1271_wl_to_dev(wl
));
1075 wl1271_error("could not get firmware: %d", ret
);
1080 wl1271_error("firmware size is not multiple of 32 bits: %zu",
1087 wl
->fw_len
= fw
->size
;
1088 wl
->fw
= vmalloc(wl
->fw_len
);
1091 wl1271_error("could not allocate memory for the firmware");
1096 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
1100 release_firmware(fw
);
1105 static int wl1271_fetch_nvs(struct wl1271
*wl
)
1107 const struct firmware
*fw
;
1110 ret
= request_firmware(&fw
, WL12XX_NVS_NAME
, wl1271_wl_to_dev(wl
));
1113 wl1271_error("could not get nvs file: %d", ret
);
1117 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
1120 wl1271_error("could not allocate memory for the nvs file");
1125 wl
->nvs_len
= fw
->size
;
1128 release_firmware(fw
);
1133 void wl12xx_queue_recovery_work(struct wl1271
*wl
)
1135 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1136 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
1139 size_t wl12xx_copy_fwlog(struct wl1271
*wl
, u8
*memblock
, size_t maxlen
)
1143 /* The FW log is a length-value list, find where the log end */
1144 while (len
< maxlen
) {
1145 if (memblock
[len
] == 0)
1147 if (len
+ memblock
[len
] + 1 > maxlen
)
1149 len
+= memblock
[len
] + 1;
1152 /* Make sure we have enough room */
1153 len
= min(len
, (size_t)(PAGE_SIZE
- wl
->fwlog_size
));
1155 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1156 memcpy(wl
->fwlog
+ wl
->fwlog_size
, memblock
, len
);
1157 wl
->fwlog_size
+= len
;
1162 static void wl12xx_read_fwlog_panic(struct wl1271
*wl
)
1168 if ((wl
->quirks
& WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED
) ||
1169 (wl
->conf
.fwlog
.mode
!= WL12XX_FWLOG_ON_DEMAND
) ||
1170 (wl
->conf
.fwlog
.mem_blocks
== 0))
1173 wl1271_info("Reading FW panic log");
1175 block
= kmalloc(WL12XX_HW_BLOCK_SIZE
, GFP_KERNEL
);
1180 * Make sure the chip is awake and the logger isn't active.
1181 * This might fail if the firmware hanged.
1183 if (!wl1271_ps_elp_wakeup(wl
))
1184 wl12xx_cmd_stop_fwlog(wl
);
1186 /* Read the first memory block address */
1187 wl12xx_fw_status(wl
, wl
->fw_status
);
1188 first_addr
= le32_to_cpu(wl
->fw_status
->log_start_addr
);
1192 /* Traverse the memory blocks linked list */
1195 memset(block
, 0, WL12XX_HW_BLOCK_SIZE
);
1196 wl1271_read_hwaddr(wl
, addr
, block
, WL12XX_HW_BLOCK_SIZE
,
1200 * Memory blocks are linked to one another. The first 4 bytes
1201 * of each memory block hold the hardware address of the next
1202 * one. The last memory block points to the first one.
1204 addr
= le32_to_cpup((__le32
*)block
);
1205 if (!wl12xx_copy_fwlog(wl
, block
+ sizeof(addr
),
1206 WL12XX_HW_BLOCK_SIZE
- sizeof(addr
)))
1208 } while (addr
&& (addr
!= first_addr
));
1210 wake_up_interruptible(&wl
->fwlog_waitq
);
1216 static void wl1271_recovery_work(struct work_struct
*work
)
1219 container_of(work
, struct wl1271
, recovery_work
);
1221 mutex_lock(&wl
->mutex
);
1223 if (wl
->state
!= WL1271_STATE_ON
)
1226 /* Avoid a recursive recovery */
1227 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
1229 wl12xx_read_fwlog_panic(wl
);
1231 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1232 wl
->chip
.fw_ver_str
, wl1271_read32(wl
, SCR_PAD4
));
1234 BUG_ON(bug_on_recovery
);
1237 * Advance security sequence number to overcome potential progress
1238 * in the firmware during recovery. This doens't hurt if the network is
1241 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
) ||
1242 test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
))
1243 wl
->tx_security_seq
+= WL1271_TX_SQN_POST_RECOVERY_PADDING
;
1245 /* Prevent spurious TX during FW restart */
1246 ieee80211_stop_queues(wl
->hw
);
1248 if (wl
->sched_scanning
) {
1249 ieee80211_sched_scan_stopped(wl
->hw
);
1250 wl
->sched_scanning
= false;
1253 /* reboot the chipset */
1254 __wl1271_op_remove_interface(wl
, false);
1256 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
1258 ieee80211_restart_hw(wl
->hw
);
1261 * Its safe to enable TX now - the queues are stopped after a request
1262 * to restart the HW.
1264 ieee80211_wake_queues(wl
->hw
);
1267 mutex_unlock(&wl
->mutex
);
1270 static void wl1271_fw_wakeup(struct wl1271
*wl
)
1274 elp_reg
= ELPCTRL_WAKE_UP
;
1275 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
1278 static int wl1271_setup(struct wl1271
*wl
)
1280 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
1284 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
1285 if (!wl
->tx_res_if
) {
1286 kfree(wl
->fw_status
);
1293 static int wl1271_chip_wakeup(struct wl1271
*wl
)
1295 struct wl1271_partition_set partition
;
1298 msleep(WL1271_PRE_POWER_ON_SLEEP
);
1299 ret
= wl1271_power_on(wl
);
1302 msleep(WL1271_POWER_ON_SLEEP
);
1303 wl1271_io_reset(wl
);
1306 /* We don't need a real memory partition here, because we only want
1307 * to use the registers at this point. */
1308 memset(&partition
, 0, sizeof(partition
));
1309 partition
.reg
.start
= REGISTERS_BASE
;
1310 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
1311 wl1271_set_partition(wl
, &partition
);
1313 /* ELP module wake up */
1314 wl1271_fw_wakeup(wl
);
1316 /* whal_FwCtrl_BootSm() */
1318 /* 0. read chip id from CHIP_ID */
1319 wl
->chip
.id
= wl1271_read32(wl
, CHIP_ID_B
);
1321 /* 1. check if chip id is valid */
1323 switch (wl
->chip
.id
) {
1324 case CHIP_ID_1271_PG10
:
1325 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1328 ret
= wl1271_setup(wl
);
1332 case CHIP_ID_1271_PG20
:
1333 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
1337 * 'end-of-transaction flag' and 'LPD mode flag'
1338 * should be set in wl127x AP mode only
1340 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1341 wl
->quirks
|= (WL12XX_QUIRK_END_OF_TRANSACTION
|
1342 WL12XX_QUIRK_LPD_MODE
);
1344 ret
= wl1271_setup(wl
);
1348 case CHIP_ID_1283_PG20
:
1349 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1283 PG20)",
1352 ret
= wl1271_setup(wl
);
1356 if (wl1271_set_block_size(wl
))
1357 wl
->quirks
|= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT
;
1359 case CHIP_ID_1283_PG10
:
1361 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
1366 if (wl
->fw
== NULL
) {
1367 ret
= wl1271_fetch_firmware(wl
);
1372 /* No NVS from netlink, try to get it from the filesystem */
1373 if (wl
->nvs
== NULL
) {
1374 ret
= wl1271_fetch_nvs(wl
);
1383 int wl1271_plt_start(struct wl1271
*wl
)
1385 int retries
= WL1271_BOOT_RETRIES
;
1386 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
1389 mutex_lock(&wl
->mutex
);
1391 wl1271_notice("power up");
1393 if (wl
->state
!= WL1271_STATE_OFF
) {
1394 wl1271_error("cannot go into PLT state because not "
1395 "in off state: %d", wl
->state
);
1400 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1404 ret
= wl1271_chip_wakeup(wl
);
1408 ret
= wl1271_boot(wl
);
1412 ret
= wl1271_plt_init(wl
);
1416 wl
->state
= WL1271_STATE_PLT
;
1417 wl1271_notice("firmware booted in PLT mode (%s)",
1418 wl
->chip
.fw_ver_str
);
1420 /* update hw/fw version info in wiphy struct */
1421 wiphy
->hw_version
= wl
->chip
.id
;
1422 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1423 sizeof(wiphy
->fw_version
));
1428 mutex_unlock(&wl
->mutex
);
1429 /* Unlocking the mutex in the middle of handling is
1430 inherently unsafe. In this case we deem it safe to do,
1431 because we need to let any possibly pending IRQ out of
1432 the system (and while we are WL1271_STATE_OFF the IRQ
1433 work function will not do anything.) Also, any other
1434 possible concurrent operations will fail due to the
1435 current state, hence the wl1271 struct should be safe. */
1436 wl1271_disable_interrupts(wl
);
1437 wl1271_flush_deferred_work(wl
);
1438 cancel_work_sync(&wl
->netstack_work
);
1439 mutex_lock(&wl
->mutex
);
1441 wl1271_power_off(wl
);
1444 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1445 WL1271_BOOT_RETRIES
);
1447 mutex_unlock(&wl
->mutex
);
1452 static int __wl1271_plt_stop(struct wl1271
*wl
)
1456 wl1271_notice("power down");
1458 if (wl
->state
!= WL1271_STATE_PLT
) {
1459 wl1271_error("cannot power down because not in PLT "
1460 "state: %d", wl
->state
);
1465 wl1271_power_off(wl
);
1467 wl
->state
= WL1271_STATE_OFF
;
1470 mutex_unlock(&wl
->mutex
);
1471 wl1271_disable_interrupts(wl
);
1472 wl1271_flush_deferred_work(wl
);
1473 cancel_work_sync(&wl
->netstack_work
);
1474 cancel_work_sync(&wl
->recovery_work
);
1475 mutex_lock(&wl
->mutex
);
1480 int wl1271_plt_stop(struct wl1271
*wl
)
1484 mutex_lock(&wl
->mutex
);
1485 ret
= __wl1271_plt_stop(wl
);
1486 mutex_unlock(&wl
->mutex
);
1490 static void wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
1492 struct wl1271
*wl
= hw
->priv
;
1493 unsigned long flags
;
1497 mapping
= skb_get_queue_mapping(skb
);
1498 q
= wl1271_tx_get_queue(mapping
);
1500 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1501 hlid
= wl12xx_tx_get_hlid_ap(wl
, skb
);
1503 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1505 /* queue the packet */
1506 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
1507 if (!wl1271_is_active_sta(wl
, hlid
)) {
1508 wl1271_debug(DEBUG_TX
, "DROP skb hlid %d q %d",
1514 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d", hlid
, q
);
1515 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1517 skb_queue_tail(&wl
->tx_queue
[q
], skb
);
1520 wl
->tx_queue_count
[q
]++;
1523 * The workqueue is slow to process the tx_queue and we need stop
1524 * the queue here, otherwise the queue will get too long.
1526 if (wl
->tx_queue_count
[q
] >= WL1271_TX_QUEUE_HIGH_WATERMARK
) {
1527 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues for q %d", q
);
1528 ieee80211_stop_queue(wl
->hw
, mapping
);
1529 set_bit(q
, &wl
->stopped_queues_map
);
1533 * The chip specific setup must run before the first TX packet -
1534 * before that, the tx_work will not be initialized!
1537 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1538 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1539 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1542 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1545 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1547 unsigned long flags
;
1550 /* no need to queue a new dummy packet if one is already pending */
1551 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
))
1554 q
= wl1271_tx_get_queue(skb_get_queue_mapping(wl
->dummy_packet
));
1556 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1557 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
);
1558 wl
->tx_queue_count
[q
]++;
1559 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1561 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1562 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1563 wl1271_tx_work_locked(wl
);
1566 * If the FW TX is busy, TX work will be scheduled by the threaded
1567 * interrupt handler function
1573 * The size of the dummy packet should be at least 1400 bytes. However, in
1574 * order to minimize the number of bus transactions, aligning it to 512 bytes
1575 * boundaries could be beneficial, performance wise
1577 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1579 static struct sk_buff
*wl12xx_alloc_dummy_packet(struct wl1271
*wl
)
1581 struct sk_buff
*skb
;
1582 struct ieee80211_hdr_3addr
*hdr
;
1583 unsigned int dummy_packet_size
;
1585 dummy_packet_size
= TOTAL_TX_DUMMY_PACKET_SIZE
-
1586 sizeof(struct wl1271_tx_hw_descr
) - sizeof(*hdr
);
1588 skb
= dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE
);
1590 wl1271_warning("Failed to allocate a dummy packet skb");
1594 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1596 hdr
= (struct ieee80211_hdr_3addr
*) skb_put(skb
, sizeof(*hdr
));
1597 memset(hdr
, 0, sizeof(*hdr
));
1598 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1599 IEEE80211_STYPE_NULLFUNC
|
1600 IEEE80211_FCTL_TODS
);
1602 memset(skb_put(skb
, dummy_packet_size
), 0, dummy_packet_size
);
1604 /* Dummy packets require the TID to be management */
1605 skb
->priority
= WL1271_TID_MGMT
;
1607 /* Initialize all fields that might be used */
1608 skb_set_queue_mapping(skb
, 0);
1609 memset(IEEE80211_SKB_CB(skb
), 0, sizeof(struct ieee80211_tx_info
));
1615 static struct notifier_block wl1271_dev_notifier
= {
1616 .notifier_call
= wl1271_dev_notify
,
1620 static int wl1271_configure_suspend_sta(struct wl1271
*wl
)
1624 mutex_lock(&wl
->mutex
);
1626 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1629 ret
= wl1271_ps_elp_wakeup(wl
);
1633 /* enter psm if needed*/
1634 if (!test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
1635 DECLARE_COMPLETION_ONSTACK(compl);
1637 wl
->ps_compl
= &compl;
1638 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
1639 wl
->basic_rate
, true);
1643 /* we must unlock here so we will be able to get events */
1644 wl1271_ps_elp_sleep(wl
);
1645 mutex_unlock(&wl
->mutex
);
1647 ret
= wait_for_completion_timeout(
1648 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT
));
1650 wl1271_warning("couldn't enter ps mode!");
1655 /* take mutex again, and wakeup */
1656 mutex_lock(&wl
->mutex
);
1658 ret
= wl1271_ps_elp_wakeup(wl
);
1663 wl1271_ps_elp_sleep(wl
);
1665 mutex_unlock(&wl
->mutex
);
1671 static int wl1271_configure_suspend_ap(struct wl1271
*wl
)
1675 mutex_lock(&wl
->mutex
);
1677 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
))
1680 ret
= wl1271_ps_elp_wakeup(wl
);
1684 ret
= wl1271_acx_beacon_filter_opt(wl
, true);
1686 wl1271_ps_elp_sleep(wl
);
1688 mutex_unlock(&wl
->mutex
);
1693 static int wl1271_configure_suspend(struct wl1271
*wl
)
1695 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1696 return wl1271_configure_suspend_sta(wl
);
1697 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1698 return wl1271_configure_suspend_ap(wl
);
1702 static void wl1271_configure_resume(struct wl1271
*wl
)
1705 bool is_sta
= wl
->bss_type
== BSS_TYPE_STA_BSS
;
1706 bool is_ap
= wl
->bss_type
== BSS_TYPE_AP_BSS
;
1708 if (!is_sta
&& !is_ap
)
1711 mutex_lock(&wl
->mutex
);
1712 ret
= wl1271_ps_elp_wakeup(wl
);
1717 /* exit psm if it wasn't configured */
1718 if (!test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
))
1719 wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
1720 wl
->basic_rate
, true);
1722 wl1271_acx_beacon_filter_opt(wl
, false);
1725 wl1271_ps_elp_sleep(wl
);
1727 mutex_unlock(&wl
->mutex
);
1730 static int wl1271_op_suspend(struct ieee80211_hw
*hw
,
1731 struct cfg80211_wowlan
*wow
)
1733 struct wl1271
*wl
= hw
->priv
;
1736 wl1271_debug(DEBUG_MAC80211
, "mac80211 suspend wow=%d", !!wow
);
1737 WARN_ON(!wow
|| !wow
->any
);
1739 wl
->wow_enabled
= true;
1740 ret
= wl1271_configure_suspend(wl
);
1742 wl1271_warning("couldn't prepare device to suspend");
1745 /* flush any remaining work */
1746 wl1271_debug(DEBUG_MAC80211
, "flushing remaining works");
1749 * disable and re-enable interrupts in order to flush
1752 wl1271_disable_interrupts(wl
);
1755 * set suspended flag to avoid triggering a new threaded_irq
1756 * work. no need for spinlock as interrupts are disabled.
1758 set_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1760 wl1271_enable_interrupts(wl
);
1761 flush_work(&wl
->tx_work
);
1762 flush_delayed_work(&wl
->pspoll_work
);
1763 flush_delayed_work(&wl
->elp_work
);
1768 static int wl1271_op_resume(struct ieee80211_hw
*hw
)
1770 struct wl1271
*wl
= hw
->priv
;
1771 unsigned long flags
;
1772 bool run_irq_work
= false;
1774 wl1271_debug(DEBUG_MAC80211
, "mac80211 resume wow=%d",
1776 WARN_ON(!wl
->wow_enabled
);
1779 * re-enable irq_work enqueuing, and call irq_work directly if
1780 * there is a pending work.
1782 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1783 clear_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1784 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
))
1785 run_irq_work
= true;
1786 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1789 wl1271_debug(DEBUG_MAC80211
,
1790 "run postponed irq_work directly");
1792 wl1271_enable_interrupts(wl
);
1794 wl1271_configure_resume(wl
);
1795 wl
->wow_enabled
= false;
1801 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1803 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1806 * We have to delay the booting of the hardware because
1807 * we need to know the local MAC address before downloading and
1808 * initializing the firmware. The MAC address cannot be changed
1809 * after boot, and without the proper MAC address, the firmware
1810 * will not function properly.
1812 * The MAC address is first known when the corresponding interface
1813 * is added. That is where we will initialize the hardware.
1819 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
1821 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1824 static u8
wl12xx_get_role_type(struct wl1271
*wl
)
1826 switch (wl
->bss_type
) {
1827 case BSS_TYPE_AP_BSS
:
1829 return WL1271_ROLE_P2P_GO
;
1831 return WL1271_ROLE_AP
;
1833 case BSS_TYPE_STA_BSS
:
1835 return WL1271_ROLE_P2P_CL
;
1837 return WL1271_ROLE_STA
;
1840 return WL1271_ROLE_IBSS
;
1843 wl1271_error("invalid bss_type: %d", wl
->bss_type
);
1845 return WL12XX_INVALID_ROLE_TYPE
;
1848 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1849 struct ieee80211_vif
*vif
)
1851 struct wl1271
*wl
= hw
->priv
;
1852 struct wiphy
*wiphy
= hw
->wiphy
;
1853 int retries
= WL1271_BOOT_RETRIES
;
1856 bool booted
= false;
1858 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1859 ieee80211_vif_type_p2p(vif
), vif
->addr
);
1861 mutex_lock(&wl
->mutex
);
1863 wl1271_debug(DEBUG_MAC80211
,
1864 "multiple vifs are not supported yet");
1870 * in some very corner case HW recovery scenarios its possible to
1871 * get here before __wl1271_op_remove_interface is complete, so
1872 * opt out if that is the case.
1874 if (test_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
)) {
1879 switch (ieee80211_vif_type_p2p(vif
)) {
1880 case NL80211_IFTYPE_P2P_CLIENT
:
1883 case NL80211_IFTYPE_STATION
:
1884 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1885 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1887 case NL80211_IFTYPE_ADHOC
:
1888 wl
->bss_type
= BSS_TYPE_IBSS
;
1889 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1891 case NL80211_IFTYPE_P2P_GO
:
1894 case NL80211_IFTYPE_AP
:
1895 wl
->bss_type
= BSS_TYPE_AP_BSS
;
1902 role_type
= wl12xx_get_role_type(wl
);
1903 if (role_type
== WL12XX_INVALID_ROLE_TYPE
) {
1907 memcpy(wl
->mac_addr
, vif
->addr
, ETH_ALEN
);
1909 if (wl
->state
!= WL1271_STATE_OFF
) {
1910 wl1271_error("cannot start because not in off state: %d",
1918 ret
= wl1271_chip_wakeup(wl
);
1922 ret
= wl1271_boot(wl
);
1926 if (wl
->bss_type
== BSS_TYPE_STA_BSS
||
1927 wl
->bss_type
== BSS_TYPE_IBSS
) {
1929 * The device role is a special role used for
1930 * rx and tx frames prior to association (as
1931 * the STA role can get packets only from
1932 * its associated bssid)
1934 ret
= wl12xx_cmd_role_enable(wl
,
1941 ret
= wl12xx_cmd_role_enable(wl
, role_type
, &wl
->role_id
);
1945 ret
= wl1271_hw_init(wl
);
1953 mutex_unlock(&wl
->mutex
);
1954 /* Unlocking the mutex in the middle of handling is
1955 inherently unsafe. In this case we deem it safe to do,
1956 because we need to let any possibly pending IRQ out of
1957 the system (and while we are WL1271_STATE_OFF the IRQ
1958 work function will not do anything.) Also, any other
1959 possible concurrent operations will fail due to the
1960 current state, hence the wl1271 struct should be safe. */
1961 wl1271_disable_interrupts(wl
);
1962 wl1271_flush_deferred_work(wl
);
1963 cancel_work_sync(&wl
->netstack_work
);
1964 mutex_lock(&wl
->mutex
);
1966 wl1271_power_off(wl
);
1970 wl1271_error("firmware boot failed despite %d retries",
1971 WL1271_BOOT_RETRIES
);
1976 wl
->state
= WL1271_STATE_ON
;
1977 set_bit(WL1271_FLAG_IF_INITIALIZED
, &wl
->flags
);
1978 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
1980 /* update hw/fw version info in wiphy struct */
1981 wiphy
->hw_version
= wl
->chip
.id
;
1982 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1983 sizeof(wiphy
->fw_version
));
1986 * Now we know if 11a is supported (info from the NVS), so disable
1987 * 11a channels if not supported
1989 if (!wl
->enable_11a
)
1990 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
1992 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
1993 wl
->enable_11a
? "" : "not ");
1996 mutex_unlock(&wl
->mutex
);
1998 mutex_lock(&wl_list_mutex
);
2000 list_add(&wl
->list
, &wl_list
);
2001 mutex_unlock(&wl_list_mutex
);
2006 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
2007 bool reset_tx_queues
)
2011 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
2013 /* because of hardware recovery, we may get here twice */
2014 if (wl
->state
!= WL1271_STATE_ON
)
2017 wl1271_info("down");
2019 mutex_lock(&wl_list_mutex
);
2020 list_del(&wl
->list
);
2021 mutex_unlock(&wl_list_mutex
);
2023 /* enable dyn ps just in case (if left on due to fw crash etc) */
2024 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
2025 ieee80211_enable_dyn_ps(wl
->vif
);
2027 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
2028 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
2029 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
2030 wl
->scan
.req
= NULL
;
2031 ieee80211_scan_completed(wl
->hw
, true);
2034 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
)) {
2035 /* disable active roles */
2036 ret
= wl1271_ps_elp_wakeup(wl
);
2040 if (wl
->bss_type
== BSS_TYPE_STA_BSS
) {
2041 ret
= wl12xx_cmd_role_disable(wl
, &wl
->dev_role_id
);
2046 ret
= wl12xx_cmd_role_disable(wl
, &wl
->role_id
);
2050 wl1271_ps_elp_sleep(wl
);
2053 /* clear all hlids (except system_hlid) */
2054 wl
->sta_hlid
= WL12XX_INVALID_LINK_ID
;
2055 wl
->dev_hlid
= WL12XX_INVALID_LINK_ID
;
2056 wl
->ap_bcast_hlid
= WL12XX_INVALID_LINK_ID
;
2057 wl
->ap_global_hlid
= WL12XX_INVALID_LINK_ID
;
2060 * this must be before the cancel_work calls below, so that the work
2061 * functions don't perform further work.
2063 wl
->state
= WL1271_STATE_OFF
;
2065 mutex_unlock(&wl
->mutex
);
2067 wl1271_disable_interrupts(wl
);
2068 wl1271_flush_deferred_work(wl
);
2069 cancel_delayed_work_sync(&wl
->scan_complete_work
);
2070 cancel_work_sync(&wl
->netstack_work
);
2071 cancel_work_sync(&wl
->tx_work
);
2072 del_timer_sync(&wl
->rx_streaming_timer
);
2073 cancel_work_sync(&wl
->rx_streaming_enable_work
);
2074 cancel_work_sync(&wl
->rx_streaming_disable_work
);
2075 cancel_delayed_work_sync(&wl
->pspoll_work
);
2076 cancel_delayed_work_sync(&wl
->elp_work
);
2078 mutex_lock(&wl
->mutex
);
2080 /* let's notify MAC80211 about the remaining pending TX frames */
2081 wl1271_tx_reset(wl
, reset_tx_queues
);
2082 wl1271_power_off(wl
);
2084 memset(wl
->bssid
, 0, ETH_ALEN
);
2085 memset(wl
->ssid
, 0, IEEE80211_MAX_SSID_LEN
+ 1);
2087 wl
->bss_type
= MAX_BSS_TYPE
;
2088 wl
->set_bss_type
= MAX_BSS_TYPE
;
2090 wl
->band
= IEEE80211_BAND_2GHZ
;
2093 wl
->psm_entry_retry
= 0;
2094 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
2095 wl
->tx_blocks_available
= 0;
2096 wl
->tx_allocated_blocks
= 0;
2097 wl
->tx_results_count
= 0;
2098 wl
->tx_packets_count
= 0;
2099 wl
->time_offset
= 0;
2100 wl
->session_counter
= 0;
2101 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
2102 wl
->bitrate_masks
[IEEE80211_BAND_2GHZ
] = wl
->conf
.tx
.basic_rate
;
2103 wl
->bitrate_masks
[IEEE80211_BAND_5GHZ
] = wl
->conf
.tx
.basic_rate_5
;
2105 wl
->tx_spare_blocks
= TX_HW_BLOCK_SPARE_DEFAULT
;
2106 wl1271_free_ap_keys(wl
);
2107 memset(wl
->ap_hlid_map
, 0, sizeof(wl
->ap_hlid_map
));
2108 wl
->ap_fw_ps_map
= 0;
2110 wl
->sched_scanning
= false;
2111 wl
->role_id
= WL12XX_INVALID_ROLE_ID
;
2112 wl
->dev_role_id
= WL12XX_INVALID_ROLE_ID
;
2113 memset(wl
->roles_map
, 0, sizeof(wl
->roles_map
));
2114 memset(wl
->links_map
, 0, sizeof(wl
->links_map
));
2115 memset(wl
->roc_map
, 0, sizeof(wl
->roc_map
));
2116 wl
->active_sta_count
= 0;
2118 /* The system link is always allocated */
2119 __set_bit(WL12XX_SYSTEM_HLID
, wl
->links_map
);
2122 * this is performed after the cancel_work calls and the associated
2123 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2124 * get executed before all these vars have been reset.
2128 wl
->tx_blocks_freed
= 0;
2130 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
2131 wl
->tx_pkts_freed
[i
] = 0;
2132 wl
->tx_allocated_pkts
[i
] = 0;
2135 wl1271_debugfs_reset(wl
);
2137 kfree(wl
->fw_status
);
2138 wl
->fw_status
= NULL
;
2139 kfree(wl
->tx_res_if
);
2140 wl
->tx_res_if
= NULL
;
2141 kfree(wl
->target_mem_map
);
2142 wl
->target_mem_map
= NULL
;
2145 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
2146 struct ieee80211_vif
*vif
)
2148 struct wl1271
*wl
= hw
->priv
;
2150 mutex_lock(&wl
->mutex
);
2152 * wl->vif can be null here if someone shuts down the interface
2153 * just when hardware recovery has been started.
2156 WARN_ON(wl
->vif
!= vif
);
2157 __wl1271_op_remove_interface(wl
, true);
2160 mutex_unlock(&wl
->mutex
);
2161 cancel_work_sync(&wl
->recovery_work
);
2164 static int wl1271_join(struct wl1271
*wl
, bool set_assoc
)
2167 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
2170 * One of the side effects of the JOIN command is that is clears
2171 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2172 * to a WPA/WPA2 access point will therefore kill the data-path.
2173 * Currently the only valid scenario for JOIN during association
2174 * is on roaming, in which case we will also be given new keys.
2175 * Keep the below message for now, unless it starts bothering
2176 * users who really like to roam a lot :)
2178 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2179 wl1271_info("JOIN while associated.");
2182 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
2185 ret
= wl12xx_cmd_role_start_ibss(wl
);
2187 ret
= wl12xx_cmd_role_start_sta(wl
);
2191 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2195 * The join command disable the keep-alive mode, shut down its process,
2196 * and also clear the template config, so we need to reset it all after
2197 * the join. The acx_aid starts the keep-alive process, and the order
2198 * of the commands below is relevant.
2200 ret
= wl1271_acx_keep_alive_mode(wl
, true);
2204 ret
= wl1271_acx_aid(wl
, wl
->aid
);
2208 ret
= wl1271_cmd_build_klv_null_data(wl
);
2212 ret
= wl1271_acx_keep_alive_config(wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
2213 ACX_KEEP_ALIVE_TPL_VALID
);
2221 static int wl1271_unjoin(struct wl1271
*wl
)
2225 /* to stop listening to a channel, we disconnect */
2226 ret
= wl12xx_cmd_role_stop_sta(wl
);
2230 memset(wl
->bssid
, 0, ETH_ALEN
);
2232 /* reset TX security counters on a clean disconnect */
2233 wl
->tx_security_last_seq_lsb
= 0;
2234 wl
->tx_security_seq
= 0;
2240 static void wl1271_set_band_rate(struct wl1271
*wl
)
2242 wl
->basic_rate_set
= wl
->bitrate_masks
[wl
->band
];
2243 wl
->rate_set
= wl
->basic_rate_set
;
2246 static bool wl12xx_is_roc(struct wl1271
*wl
)
2250 role_id
= find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
);
2251 if (role_id
>= WL12XX_MAX_ROLES
)
2257 static int wl1271_sta_handle_idle(struct wl1271
*wl
, bool idle
)
2262 /* no need to croc if we weren't busy (e.g. during boot) */
2263 if (wl12xx_is_roc(wl
)) {
2264 ret
= wl12xx_croc(wl
, wl
->dev_role_id
);
2268 ret
= wl12xx_cmd_role_stop_dev(wl
);
2272 wl
->rate_set
= wl1271_tx_min_rate_get(wl
, wl
->basic_rate_set
);
2273 ret
= wl1271_acx_sta_rate_policies(wl
);
2276 ret
= wl1271_acx_keep_alive_config(
2277 wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
2278 ACX_KEEP_ALIVE_TPL_INVALID
);
2281 set_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
2283 /* The current firmware only supports sched_scan in idle */
2284 if (wl
->sched_scanning
) {
2285 wl1271_scan_sched_scan_stop(wl
);
2286 ieee80211_sched_scan_stopped(wl
->hw
);
2289 ret
= wl12xx_cmd_role_start_dev(wl
);
2293 ret
= wl12xx_roc(wl
, wl
->dev_role_id
);
2296 clear_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
2303 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
2305 struct wl1271
*wl
= hw
->priv
;
2306 struct ieee80211_conf
*conf
= &hw
->conf
;
2307 int channel
, ret
= 0;
2310 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
2312 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s"
2315 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
2317 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
2321 * mac80211 will go to idle nearly immediately after transmitting some
2322 * frames, such as the deauth. To make sure those frames reach the air,
2323 * wait here until the TX queue is fully flushed.
2325 if ((changed
& IEEE80211_CONF_CHANGE_IDLE
) &&
2326 (conf
->flags
& IEEE80211_CONF_IDLE
))
2327 wl1271_tx_flush(wl
);
2329 mutex_lock(&wl
->mutex
);
2331 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2332 /* we support configuring the channel and band while off */
2333 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
)) {
2334 wl
->band
= conf
->channel
->band
;
2335 wl
->channel
= channel
;
2338 if ((changed
& IEEE80211_CONF_CHANGE_POWER
))
2339 wl
->power_level
= conf
->power_level
;
2344 is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2346 ret
= wl1271_ps_elp_wakeup(wl
);
2350 /* if the channel changes while joined, join again */
2351 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
&&
2352 ((wl
->band
!= conf
->channel
->band
) ||
2353 (wl
->channel
!= channel
))) {
2354 /* send all pending packets */
2355 wl1271_tx_work_locked(wl
);
2356 wl
->band
= conf
->channel
->band
;
2357 wl
->channel
= channel
;
2361 * FIXME: the mac80211 should really provide a fixed
2362 * rate to use here. for now, just use the smallest
2363 * possible rate for the band as a fixed rate for
2364 * association frames and other control messages.
2366 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
2367 wl1271_set_band_rate(wl
);
2370 wl1271_tx_min_rate_get(wl
, wl
->basic_rate_set
);
2371 ret
= wl1271_acx_sta_rate_policies(wl
);
2373 wl1271_warning("rate policy for channel "
2376 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
2377 if (wl12xx_is_roc(wl
)) {
2379 ret
= wl12xx_croc(wl
, wl
->dev_role_id
);
2383 ret
= wl1271_join(wl
, false);
2385 wl1271_warning("cmd join on channel "
2389 * change the ROC channel. do it only if we are
2390 * not idle. otherwise, CROC will be called
2393 if (wl12xx_is_roc(wl
) &&
2394 !(conf
->flags
& IEEE80211_CONF_IDLE
)) {
2395 ret
= wl12xx_croc(wl
, wl
->dev_role_id
);
2399 ret
= wl12xx_roc(wl
, wl
->dev_role_id
);
2401 wl1271_warning("roc failed %d",
2408 if (changed
& IEEE80211_CONF_CHANGE_IDLE
&& !is_ap
) {
2409 ret
= wl1271_sta_handle_idle(wl
,
2410 conf
->flags
& IEEE80211_CONF_IDLE
);
2412 wl1271_warning("idle mode change failed %d", ret
);
2416 * if mac80211 changes the PSM mode, make sure the mode is not
2417 * incorrectly changed after the pspoll failure active window.
2419 if (changed
& IEEE80211_CONF_CHANGE_PS
)
2420 clear_bit(WL1271_FLAG_PSPOLL_FAILURE
, &wl
->flags
);
2422 if (conf
->flags
& IEEE80211_CONF_PS
&&
2423 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
2424 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
2427 * We enter PSM only if we're already associated.
2428 * If we're not, we'll enter it when joining an SSID,
2429 * through the bss_info_changed() hook.
2431 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
2432 wl1271_debug(DEBUG_PSM
, "psm enabled");
2433 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
2434 wl
->basic_rate
, true);
2436 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
2437 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
2438 wl1271_debug(DEBUG_PSM
, "psm disabled");
2440 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
2442 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
2443 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
2444 wl
->basic_rate
, true);
2447 if (conf
->power_level
!= wl
->power_level
) {
2448 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
2452 wl
->power_level
= conf
->power_level
;
2456 wl1271_ps_elp_sleep(wl
);
2459 mutex_unlock(&wl
->mutex
);
2464 struct wl1271_filter_params
{
2467 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
2470 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
2471 struct netdev_hw_addr_list
*mc_list
)
2473 struct wl1271_filter_params
*fp
;
2474 struct netdev_hw_addr
*ha
;
2475 struct wl1271
*wl
= hw
->priv
;
2477 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2480 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
2482 wl1271_error("Out of memory setting filters.");
2486 /* update multicast filtering parameters */
2487 fp
->mc_list_length
= 0;
2488 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
2489 fp
->enabled
= false;
2492 netdev_hw_addr_list_for_each(ha
, mc_list
) {
2493 memcpy(fp
->mc_list
[fp
->mc_list_length
],
2494 ha
->addr
, ETH_ALEN
);
2495 fp
->mc_list_length
++;
2499 return (u64
)(unsigned long)fp
;
2502 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2505 FIF_BCN_PRBRESP_PROMISC | \
2509 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
2510 unsigned int changed
,
2511 unsigned int *total
, u64 multicast
)
2513 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
2514 struct wl1271
*wl
= hw
->priv
;
2517 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
2518 " total %x", changed
, *total
);
2520 mutex_lock(&wl
->mutex
);
2522 *total
&= WL1271_SUPPORTED_FILTERS
;
2523 changed
&= WL1271_SUPPORTED_FILTERS
;
2525 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2528 ret
= wl1271_ps_elp_wakeup(wl
);
2532 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
) {
2533 if (*total
& FIF_ALLMULTI
)
2534 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
2536 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
2538 fp
->mc_list_length
);
2544 * the fw doesn't provide an api to configure the filters. instead,
2545 * the filters configuration is based on the active roles / ROC
2550 wl1271_ps_elp_sleep(wl
);
2553 mutex_unlock(&wl
->mutex
);
2557 static int wl1271_record_ap_key(struct wl1271
*wl
, u8 id
, u8 key_type
,
2558 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
2561 struct wl1271_ap_key
*ap_key
;
2564 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
2566 if (key_size
> MAX_KEY_SIZE
)
2570 * Find next free entry in ap_keys. Also check we are not replacing
2573 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2574 if (wl
->recorded_ap_keys
[i
] == NULL
)
2577 if (wl
->recorded_ap_keys
[i
]->id
== id
) {
2578 wl1271_warning("trying to record key replacement");
2583 if (i
== MAX_NUM_KEYS
)
2586 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
2591 ap_key
->key_type
= key_type
;
2592 ap_key
->key_size
= key_size
;
2593 memcpy(ap_key
->key
, key
, key_size
);
2594 ap_key
->hlid
= hlid
;
2595 ap_key
->tx_seq_32
= tx_seq_32
;
2596 ap_key
->tx_seq_16
= tx_seq_16
;
2598 wl
->recorded_ap_keys
[i
] = ap_key
;
2602 static void wl1271_free_ap_keys(struct wl1271
*wl
)
2606 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2607 kfree(wl
->recorded_ap_keys
[i
]);
2608 wl
->recorded_ap_keys
[i
] = NULL
;
2612 static int wl1271_ap_init_hwenc(struct wl1271
*wl
)
2615 struct wl1271_ap_key
*key
;
2616 bool wep_key_added
= false;
2618 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
2620 if (wl
->recorded_ap_keys
[i
] == NULL
)
2623 key
= wl
->recorded_ap_keys
[i
];
2625 if (hlid
== WL12XX_INVALID_LINK_ID
)
2626 hlid
= wl
->ap_bcast_hlid
;
2628 ret
= wl1271_cmd_set_ap_key(wl
, KEY_ADD_OR_REPLACE
,
2629 key
->id
, key
->key_type
,
2630 key
->key_size
, key
->key
,
2631 hlid
, key
->tx_seq_32
,
2636 if (key
->key_type
== KEY_WEP
)
2637 wep_key_added
= true;
2640 if (wep_key_added
) {
2641 ret
= wl12xx_cmd_set_default_wep_key(wl
, wl
->default_key
,
2648 wl1271_free_ap_keys(wl
);
2652 static int wl1271_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
2653 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
2654 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
2657 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2660 struct wl1271_station
*wl_sta
;
2664 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2665 hlid
= wl_sta
->hlid
;
2667 hlid
= wl
->ap_bcast_hlid
;
2670 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2672 * We do not support removing keys after AP shutdown.
2673 * Pretend we do to make mac80211 happy.
2675 if (action
!= KEY_ADD_OR_REPLACE
)
2678 ret
= wl1271_record_ap_key(wl
, id
,
2680 key
, hlid
, tx_seq_32
,
2683 ret
= wl1271_cmd_set_ap_key(wl
, action
,
2684 id
, key_type
, key_size
,
2685 key
, hlid
, tx_seq_32
,
2693 static const u8 bcast_addr
[ETH_ALEN
] = {
2694 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2698 * A STA set to GEM cipher requires 2 tx spare blocks.
2699 * Return to default value when GEM cipher key is removed
2701 if (key_type
== KEY_GEM
) {
2702 if (action
== KEY_ADD_OR_REPLACE
)
2703 wl
->tx_spare_blocks
= 2;
2704 else if (action
== KEY_REMOVE
)
2705 wl
->tx_spare_blocks
= TX_HW_BLOCK_SPARE_DEFAULT
;
2708 addr
= sta
? sta
->addr
: bcast_addr
;
2710 if (is_zero_ether_addr(addr
)) {
2711 /* We dont support TX only encryption */
2715 /* The wl1271 does not allow to remove unicast keys - they
2716 will be cleared automatically on next CMD_JOIN. Ignore the
2717 request silently, as we dont want the mac80211 to emit
2718 an error message. */
2719 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
2722 /* don't remove key if hlid was already deleted */
2723 if (action
== KEY_REMOVE
&&
2724 wl
->sta_hlid
== WL12XX_INVALID_LINK_ID
)
2727 ret
= wl1271_cmd_set_sta_key(wl
, action
,
2728 id
, key_type
, key_size
,
2729 key
, addr
, tx_seq_32
,
2734 /* the default WEP key needs to be configured at least once */
2735 if (key_type
== KEY_WEP
) {
2736 ret
= wl12xx_cmd_set_default_wep_key(wl
,
2747 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
2748 struct ieee80211_vif
*vif
,
2749 struct ieee80211_sta
*sta
,
2750 struct ieee80211_key_conf
*key_conf
)
2752 struct wl1271
*wl
= hw
->priv
;
2758 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
2760 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
2761 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2762 key_conf
->cipher
, key_conf
->keyidx
,
2763 key_conf
->keylen
, key_conf
->flags
);
2764 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
2766 mutex_lock(&wl
->mutex
);
2768 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2773 ret
= wl1271_ps_elp_wakeup(wl
);
2777 switch (key_conf
->cipher
) {
2778 case WLAN_CIPHER_SUITE_WEP40
:
2779 case WLAN_CIPHER_SUITE_WEP104
:
2782 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2784 case WLAN_CIPHER_SUITE_TKIP
:
2785 key_type
= KEY_TKIP
;
2787 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2788 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2789 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2791 case WLAN_CIPHER_SUITE_CCMP
:
2794 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2795 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2796 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2798 case WL1271_CIPHER_SUITE_GEM
:
2800 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2801 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2804 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
2812 ret
= wl1271_set_key(wl
, KEY_ADD_OR_REPLACE
,
2813 key_conf
->keyidx
, key_type
,
2814 key_conf
->keylen
, key_conf
->key
,
2815 tx_seq_32
, tx_seq_16
, sta
);
2817 wl1271_error("Could not add or replace key");
2823 ret
= wl1271_set_key(wl
, KEY_REMOVE
,
2824 key_conf
->keyidx
, key_type
,
2825 key_conf
->keylen
, key_conf
->key
,
2828 wl1271_error("Could not remove key");
2834 wl1271_error("Unsupported key cmd 0x%x", cmd
);
2840 wl1271_ps_elp_sleep(wl
);
2843 mutex_unlock(&wl
->mutex
);
2848 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
2849 struct ieee80211_vif
*vif
,
2850 struct cfg80211_scan_request
*req
)
2852 struct wl1271
*wl
= hw
->priv
;
2857 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
2860 ssid
= req
->ssids
[0].ssid
;
2861 len
= req
->ssids
[0].ssid_len
;
2864 mutex_lock(&wl
->mutex
);
2866 if (wl
->state
== WL1271_STATE_OFF
) {
2868 * We cannot return -EBUSY here because cfg80211 will expect
2869 * a call to ieee80211_scan_completed if we do - in this case
2870 * there won't be any call.
2876 ret
= wl1271_ps_elp_wakeup(wl
);
2880 /* cancel ROC before scanning */
2881 if (wl12xx_is_roc(wl
)) {
2882 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
2883 /* don't allow scanning right now */
2887 wl12xx_croc(wl
, wl
->dev_role_id
);
2888 wl12xx_cmd_role_stop_dev(wl
);
2891 ret
= wl1271_scan(hw
->priv
, ssid
, len
, req
);
2893 wl1271_ps_elp_sleep(wl
);
2895 mutex_unlock(&wl
->mutex
);
2900 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw
*hw
,
2901 struct ieee80211_vif
*vif
)
2903 struct wl1271
*wl
= hw
->priv
;
2906 wl1271_debug(DEBUG_MAC80211
, "mac80211 cancel hw scan");
2908 mutex_lock(&wl
->mutex
);
2910 if (wl
->state
== WL1271_STATE_OFF
)
2913 if (wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
)
2916 ret
= wl1271_ps_elp_wakeup(wl
);
2920 if (wl
->scan
.state
!= WL1271_SCAN_STATE_DONE
) {
2921 ret
= wl1271_scan_stop(wl
);
2925 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
2926 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
2927 wl
->scan
.req
= NULL
;
2928 ieee80211_scan_completed(wl
->hw
, true);
2931 wl1271_ps_elp_sleep(wl
);
2933 mutex_unlock(&wl
->mutex
);
2935 cancel_delayed_work_sync(&wl
->scan_complete_work
);
2938 static int wl1271_op_sched_scan_start(struct ieee80211_hw
*hw
,
2939 struct ieee80211_vif
*vif
,
2940 struct cfg80211_sched_scan_request
*req
,
2941 struct ieee80211_sched_scan_ies
*ies
)
2943 struct wl1271
*wl
= hw
->priv
;
2946 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_start");
2948 mutex_lock(&wl
->mutex
);
2950 ret
= wl1271_ps_elp_wakeup(wl
);
2954 ret
= wl1271_scan_sched_scan_config(wl
, req
, ies
);
2958 ret
= wl1271_scan_sched_scan_start(wl
);
2962 wl
->sched_scanning
= true;
2965 wl1271_ps_elp_sleep(wl
);
2967 mutex_unlock(&wl
->mutex
);
2971 static void wl1271_op_sched_scan_stop(struct ieee80211_hw
*hw
,
2972 struct ieee80211_vif
*vif
)
2974 struct wl1271
*wl
= hw
->priv
;
2977 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_stop");
2979 mutex_lock(&wl
->mutex
);
2981 ret
= wl1271_ps_elp_wakeup(wl
);
2985 wl1271_scan_sched_scan_stop(wl
);
2987 wl1271_ps_elp_sleep(wl
);
2989 mutex_unlock(&wl
->mutex
);
2992 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
2994 struct wl1271
*wl
= hw
->priv
;
2997 mutex_lock(&wl
->mutex
);
2999 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
3004 ret
= wl1271_ps_elp_wakeup(wl
);
3008 ret
= wl1271_acx_frag_threshold(wl
, value
);
3010 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
3012 wl1271_ps_elp_sleep(wl
);
3015 mutex_unlock(&wl
->mutex
);
3020 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
3022 struct wl1271
*wl
= hw
->priv
;
3025 mutex_lock(&wl
->mutex
);
3027 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
3032 ret
= wl1271_ps_elp_wakeup(wl
);
3036 ret
= wl1271_acx_rts_threshold(wl
, value
);
3038 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
3040 wl1271_ps_elp_sleep(wl
);
3043 mutex_unlock(&wl
->mutex
);
3048 static int wl1271_ssid_set(struct wl1271
*wl
, struct sk_buff
*skb
,
3052 const u8
*ptr
= cfg80211_find_ie(WLAN_EID_SSID
, skb
->data
+ offset
,
3056 wl1271_error("No SSID in IEs!");
3061 if (ssid_len
> IEEE80211_MAX_SSID_LEN
) {
3062 wl1271_error("SSID is too long!");
3066 wl
->ssid_len
= ssid_len
;
3067 memcpy(wl
->ssid
, ptr
+2, ssid_len
);
3071 static void wl12xx_remove_ie(struct sk_buff
*skb
, u8 eid
, int ieoffset
)
3074 const u8
*next
, *end
= skb
->data
+ skb
->len
;
3075 u8
*ie
= (u8
*)cfg80211_find_ie(eid
, skb
->data
+ ieoffset
,
3076 skb
->len
- ieoffset
);
3081 memmove(ie
, next
, end
- next
);
3082 skb_trim(skb
, skb
->len
- len
);
3085 static void wl12xx_remove_vendor_ie(struct sk_buff
*skb
,
3086 unsigned int oui
, u8 oui_type
,
3090 const u8
*next
, *end
= skb
->data
+ skb
->len
;
3091 u8
*ie
= (u8
*)cfg80211_find_vendor_ie(oui
, oui_type
,
3092 skb
->data
+ ieoffset
,
3093 skb
->len
- ieoffset
);
3098 memmove(ie
, next
, end
- next
);
3099 skb_trim(skb
, skb
->len
- len
);
3102 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271
*wl
,
3104 size_t probe_rsp_len
,
3107 struct ieee80211_bss_conf
*bss_conf
= &wl
->vif
->bss_conf
;
3108 u8 probe_rsp_templ
[WL1271_CMD_TEMPL_MAX_SIZE
];
3109 int ssid_ie_offset
, ie_offset
, templ_len
;
3112 /* no need to change probe response if the SSID is set correctly */
3113 if (wl
->ssid_len
> 0)
3114 return wl1271_cmd_template_set(wl
,
3115 CMD_TEMPL_AP_PROBE_RESPONSE
,
3120 if (probe_rsp_len
+ bss_conf
->ssid_len
> WL1271_CMD_TEMPL_MAX_SIZE
) {
3121 wl1271_error("probe_rsp template too big");
3125 /* start searching from IE offset */
3126 ie_offset
= offsetof(struct ieee80211_mgmt
, u
.probe_resp
.variable
);
3128 ptr
= cfg80211_find_ie(WLAN_EID_SSID
, probe_rsp_data
+ ie_offset
,
3129 probe_rsp_len
- ie_offset
);
3131 wl1271_error("No SSID in beacon!");
3135 ssid_ie_offset
= ptr
- probe_rsp_data
;
3136 ptr
+= (ptr
[1] + 2);
3138 memcpy(probe_rsp_templ
, probe_rsp_data
, ssid_ie_offset
);
3140 /* insert SSID from bss_conf */
3141 probe_rsp_templ
[ssid_ie_offset
] = WLAN_EID_SSID
;
3142 probe_rsp_templ
[ssid_ie_offset
+ 1] = bss_conf
->ssid_len
;
3143 memcpy(probe_rsp_templ
+ ssid_ie_offset
+ 2,
3144 bss_conf
->ssid
, bss_conf
->ssid_len
);
3145 templ_len
= ssid_ie_offset
+ 2 + bss_conf
->ssid_len
;
3147 memcpy(probe_rsp_templ
+ ssid_ie_offset
+ 2 + bss_conf
->ssid_len
,
3148 ptr
, probe_rsp_len
- (ptr
- probe_rsp_data
));
3149 templ_len
+= probe_rsp_len
- (ptr
- probe_rsp_data
);
3151 return wl1271_cmd_template_set(wl
,
3152 CMD_TEMPL_AP_PROBE_RESPONSE
,
3158 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
3159 struct ieee80211_bss_conf
*bss_conf
,
3164 if (changed
& BSS_CHANGED_ERP_SLOT
) {
3165 if (bss_conf
->use_short_slot
)
3166 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
3168 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
3170 wl1271_warning("Set slot time failed %d", ret
);
3175 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
3176 if (bss_conf
->use_short_preamble
)
3177 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
3179 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
3182 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
3183 if (bss_conf
->use_cts_prot
)
3184 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
3186 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
3188 wl1271_warning("Set ctsprotect failed %d", ret
);
3197 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
3198 struct ieee80211_vif
*vif
,
3199 struct ieee80211_bss_conf
*bss_conf
,
3202 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
3205 if ((changed
& BSS_CHANGED_BEACON_INT
)) {
3206 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
3207 bss_conf
->beacon_int
);
3209 wl
->beacon_int
= bss_conf
->beacon_int
;
3212 if ((changed
& BSS_CHANGED_BEACON
)) {
3213 struct ieee80211_hdr
*hdr
;
3215 int ieoffset
= offsetof(struct ieee80211_mgmt
,
3217 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
3223 wl1271_debug(DEBUG_MASTER
, "beacon updated");
3225 ret
= wl1271_ssid_set(wl
, beacon
, ieoffset
);
3227 dev_kfree_skb(beacon
);
3230 min_rate
= wl1271_tx_min_rate_get(wl
, wl
->basic_rate_set
);
3231 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
3233 ret
= wl1271_cmd_template_set(wl
, tmpl_id
,
3238 dev_kfree_skb(beacon
);
3242 /* remove TIM ie from probe response */
3243 wl12xx_remove_ie(beacon
, WLAN_EID_TIM
, ieoffset
);
3246 * remove p2p ie from probe response.
3247 * the fw reponds to probe requests that don't include
3248 * the p2p ie. probe requests with p2p ie will be passed,
3249 * and will be responded by the supplicant (the spec
3250 * forbids including the p2p ie when responding to probe
3251 * requests that didn't include it).
3253 wl12xx_remove_vendor_ie(beacon
, WLAN_OUI_WFA
,
3254 WLAN_OUI_TYPE_WFA_P2P
, ieoffset
);
3256 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
3257 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
3258 IEEE80211_STYPE_PROBE_RESP
);
3260 ret
= wl1271_ap_set_probe_resp_tmpl(wl
,
3265 ret
= wl1271_cmd_template_set(wl
,
3266 CMD_TEMPL_PROBE_RESPONSE
,
3270 dev_kfree_skb(beacon
);
3279 /* AP mode changes */
3280 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
3281 struct ieee80211_vif
*vif
,
3282 struct ieee80211_bss_conf
*bss_conf
,
3287 if ((changed
& BSS_CHANGED_BASIC_RATES
)) {
3288 u32 rates
= bss_conf
->basic_rates
;
3290 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
,
3292 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
,
3293 wl
->basic_rate_set
);
3295 ret
= wl1271_init_ap_rates(wl
);
3297 wl1271_error("AP rate policy change failed %d", ret
);
3301 ret
= wl1271_ap_init_templates(wl
);
3306 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
3310 if ((changed
& BSS_CHANGED_BEACON_ENABLED
)) {
3311 if (bss_conf
->enable_beacon
) {
3312 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
3313 ret
= wl12xx_cmd_role_start_ap(wl
);
3317 ret
= wl1271_ap_init_hwenc(wl
);
3321 set_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
3322 wl1271_debug(DEBUG_AP
, "started AP");
3325 if (test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
3326 ret
= wl12xx_cmd_role_stop_ap(wl
);
3330 clear_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
3331 wl1271_debug(DEBUG_AP
, "stopped AP");
3336 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
3340 /* Handle HT information change */
3341 if ((changed
& BSS_CHANGED_HT
) &&
3342 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
3343 ret
= wl1271_acx_set_ht_information(wl
,
3344 bss_conf
->ht_operation_mode
);
3346 wl1271_warning("Set ht information failed %d", ret
);
3355 /* STA/IBSS mode changes */
3356 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
3357 struct ieee80211_vif
*vif
,
3358 struct ieee80211_bss_conf
*bss_conf
,
3361 bool do_join
= false, set_assoc
= false;
3362 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
3363 bool ibss_joined
= false;
3364 u32 sta_rate_set
= 0;
3366 struct ieee80211_sta
*sta
;
3367 bool sta_exists
= false;
3368 struct ieee80211_sta_ht_cap sta_ht_cap
;
3371 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
3377 if (changed
& BSS_CHANGED_IBSS
) {
3378 if (bss_conf
->ibss_joined
) {
3379 set_bit(WL1271_FLAG_IBSS_JOINED
, &wl
->flags
);
3382 if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED
,
3385 wl12xx_cmd_role_start_dev(wl
);
3386 wl12xx_roc(wl
, wl
->dev_role_id
);
3391 if ((changed
& BSS_CHANGED_BEACON_INT
) && ibss_joined
)
3394 /* Need to update the SSID (for filtering etc) */
3395 if ((changed
& BSS_CHANGED_BEACON
) && ibss_joined
)
3398 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && ibss_joined
) {
3399 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
3400 bss_conf
->enable_beacon
? "enabled" : "disabled");
3402 if (bss_conf
->enable_beacon
)
3403 wl
->set_bss_type
= BSS_TYPE_IBSS
;
3405 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
3409 if ((changed
& BSS_CHANGED_CQM
)) {
3410 bool enable
= false;
3411 if (bss_conf
->cqm_rssi_thold
)
3413 ret
= wl1271_acx_rssi_snr_trigger(wl
, enable
,
3414 bss_conf
->cqm_rssi_thold
,
3415 bss_conf
->cqm_rssi_hyst
);
3418 wl
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
3421 if ((changed
& BSS_CHANGED_BSSID
) &&
3423 * Now we know the correct bssid, so we send a new join command
3424 * and enable the BSSID filter
3426 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
3427 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
3429 if (!is_zero_ether_addr(wl
->bssid
)) {
3430 ret
= wl1271_cmd_build_null_data(wl
);
3434 ret
= wl1271_build_qos_null_data(wl
);
3438 /* Need to update the BSSID (for filtering etc) */
3443 if (changed
& (BSS_CHANGED_ASSOC
| BSS_CHANGED_HT
)) {
3445 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
3449 /* save the supp_rates of the ap */
3450 sta_rate_set
= sta
->supp_rates
[wl
->hw
->conf
.channel
->band
];
3451 if (sta
->ht_cap
.ht_supported
)
3453 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
);
3454 sta_ht_cap
= sta
->ht_cap
;
3461 if ((changed
& BSS_CHANGED_ASSOC
)) {
3462 if (bss_conf
->assoc
) {
3465 wl
->aid
= bss_conf
->aid
;
3468 wl
->ps_poll_failures
= 0;
3471 * use basic rates from AP, and determine lowest rate
3472 * to use with control frames.
3474 rates
= bss_conf
->basic_rates
;
3475 wl
->basic_rate_set
=
3476 wl1271_tx_enabled_rates_get(wl
, rates
,
3479 wl1271_tx_min_rate_get(wl
, wl
->basic_rate_set
);
3481 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
,
3484 ret
= wl1271_acx_sta_rate_policies(wl
);
3489 * with wl1271, we don't need to update the
3490 * beacon_int and dtim_period, because the firmware
3491 * updates it by itself when the first beacon is
3492 * received after a join.
3494 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
3499 * Get a template for hardware connection maintenance
3501 dev_kfree_skb(wl
->probereq
);
3502 wl
->probereq
= wl1271_cmd_build_ap_probe_req(wl
, NULL
);
3503 ieoffset
= offsetof(struct ieee80211_mgmt
,
3504 u
.probe_req
.variable
);
3505 wl1271_ssid_set(wl
, wl
->probereq
, ieoffset
);
3507 /* enable the connection monitoring feature */
3508 ret
= wl1271_acx_conn_monit_params(wl
, true);
3512 /* use defaults when not associated */
3514 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED
,
3517 !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT
,
3521 /* free probe-request template */
3522 dev_kfree_skb(wl
->probereq
);
3523 wl
->probereq
= NULL
;
3525 /* re-enable dynamic ps - just in case */
3526 ieee80211_enable_dyn_ps(wl
->vif
);
3528 /* revert back to minimum rates for the current band */
3529 wl1271_set_band_rate(wl
);
3531 wl1271_tx_min_rate_get(wl
, wl
->basic_rate_set
);
3532 ret
= wl1271_acx_sta_rate_policies(wl
);
3536 /* disable connection monitor features */
3537 ret
= wl1271_acx_conn_monit_params(wl
, false);
3539 /* Disable the keep-alive feature */
3540 ret
= wl1271_acx_keep_alive_mode(wl
, false);
3544 /* restore the bssid filter and go to dummy bssid */
3546 u32 conf_flags
= wl
->hw
->conf
.flags
;
3548 * we might have to disable roc, if there was
3549 * no IF_OPER_UP notification.
3552 ret
= wl12xx_croc(wl
, wl
->role_id
);
3557 * (we also need to disable roc in case of
3558 * roaming on the same channel. until we will
3559 * have a better flow...)
3561 if (test_bit(wl
->dev_role_id
, wl
->roc_map
)) {
3562 ret
= wl12xx_croc(wl
, wl
->dev_role_id
);
3568 if (!(conf_flags
& IEEE80211_CONF_IDLE
)) {
3569 wl12xx_cmd_role_start_dev(wl
);
3570 wl12xx_roc(wl
, wl
->dev_role_id
);
3576 if (changed
& BSS_CHANGED_IBSS
) {
3577 wl1271_debug(DEBUG_ADHOC
, "ibss_joined: %d",
3578 bss_conf
->ibss_joined
);
3580 if (bss_conf
->ibss_joined
) {
3581 u32 rates
= bss_conf
->basic_rates
;
3582 wl
->basic_rate_set
=
3583 wl1271_tx_enabled_rates_get(wl
, rates
,
3586 wl1271_tx_min_rate_get(wl
, wl
->basic_rate_set
);
3588 /* by default, use 11b + OFDM rates */
3589 wl
->rate_set
= CONF_TX_IBSS_DEFAULT_RATES
;
3590 ret
= wl1271_acx_sta_rate_policies(wl
);
3596 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
3600 if (changed
& BSS_CHANGED_ARP_FILTER
) {
3601 __be32 addr
= bss_conf
->arp_addr_list
[0];
3602 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
3604 if (bss_conf
->arp_addr_cnt
== 1 &&
3605 bss_conf
->arp_filter_enabled
) {
3607 * The template should have been configured only upon
3608 * association. however, it seems that the correct ip
3609 * isn't being set (when sending), so we have to
3610 * reconfigure the template upon every ip change.
3612 ret
= wl1271_cmd_build_arp_rsp(wl
, addr
);
3614 wl1271_warning("build arp rsp failed: %d", ret
);
3618 ret
= wl1271_acx_arp_ip_filter(wl
,
3619 ACX_ARP_FILTER_ARP_FILTERING
,
3622 ret
= wl1271_acx_arp_ip_filter(wl
, 0, addr
);
3629 ret
= wl1271_join(wl
, set_assoc
);
3631 wl1271_warning("cmd join failed %d", ret
);
3635 /* ROC until connected (after EAPOL exchange) */
3637 ret
= wl12xx_roc(wl
, wl
->role_id
);
3641 wl1271_check_operstate(wl
,
3642 ieee80211_get_operstate(vif
));
3645 * stop device role if started (we might already be in
3646 * STA role). TODO: make it better.
3648 if (wl
->dev_role_id
!= WL12XX_INVALID_ROLE_ID
) {
3649 ret
= wl12xx_croc(wl
, wl
->dev_role_id
);
3653 ret
= wl12xx_cmd_role_stop_dev(wl
);
3658 /* If we want to go in PSM but we're not there yet */
3659 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
3660 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
3661 enum wl1271_cmd_ps_mode mode
;
3663 mode
= STATION_POWER_SAVE_MODE
;
3664 ret
= wl1271_ps_set_mode(wl
, mode
,
3672 /* Handle new association with HT. Do this after join. */
3674 if ((changed
& BSS_CHANGED_HT
) &&
3675 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
3676 ret
= wl1271_acx_set_ht_capabilities(wl
,
3681 wl1271_warning("Set ht cap true failed %d",
3686 /* handle new association without HT and disassociation */
3687 else if (changed
& BSS_CHANGED_ASSOC
) {
3688 ret
= wl1271_acx_set_ht_capabilities(wl
,
3693 wl1271_warning("Set ht cap false failed %d",
3700 /* Handle HT information change. Done after join. */
3701 if ((changed
& BSS_CHANGED_HT
) &&
3702 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
3703 ret
= wl1271_acx_set_ht_information(wl
,
3704 bss_conf
->ht_operation_mode
);
3706 wl1271_warning("Set ht information failed %d", ret
);
3715 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
3716 struct ieee80211_vif
*vif
,
3717 struct ieee80211_bss_conf
*bss_conf
,
3720 struct wl1271
*wl
= hw
->priv
;
3721 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
3724 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed 0x%x",
3727 mutex_lock(&wl
->mutex
);
3729 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3732 ret
= wl1271_ps_elp_wakeup(wl
);
3737 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
3739 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
3741 wl1271_ps_elp_sleep(wl
);
3744 mutex_unlock(&wl
->mutex
);
3747 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
,
3748 struct ieee80211_vif
*vif
, u16 queue
,
3749 const struct ieee80211_tx_queue_params
*params
)
3751 struct wl1271
*wl
= hw
->priv
;
3755 mutex_lock(&wl
->mutex
);
3757 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
3760 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
3762 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
3764 if (wl
->state
== WL1271_STATE_OFF
) {
3766 * If the state is off, the parameters will be recorded and
3767 * configured on init. This happens in AP-mode.
3769 struct conf_tx_ac_category
*conf_ac
=
3770 &wl
->conf
.tx
.ac_conf
[wl1271_tx_get_queue(queue
)];
3771 struct conf_tx_tid
*conf_tid
=
3772 &wl
->conf
.tx
.tid_conf
[wl1271_tx_get_queue(queue
)];
3774 conf_ac
->ac
= wl1271_tx_get_queue(queue
);
3775 conf_ac
->cw_min
= (u8
)params
->cw_min
;
3776 conf_ac
->cw_max
= params
->cw_max
;
3777 conf_ac
->aifsn
= params
->aifs
;
3778 conf_ac
->tx_op_limit
= params
->txop
<< 5;
3780 conf_tid
->queue_id
= wl1271_tx_get_queue(queue
);
3781 conf_tid
->channel_type
= CONF_CHANNEL_TYPE_EDCF
;
3782 conf_tid
->tsid
= wl1271_tx_get_queue(queue
);
3783 conf_tid
->ps_scheme
= ps_scheme
;
3784 conf_tid
->ack_policy
= CONF_ACK_POLICY_LEGACY
;
3785 conf_tid
->apsd_conf
[0] = 0;
3786 conf_tid
->apsd_conf
[1] = 0;
3790 ret
= wl1271_ps_elp_wakeup(wl
);
3795 * the txop is confed in units of 32us by the mac80211,
3798 ret
= wl1271_acx_ac_cfg(wl
, wl1271_tx_get_queue(queue
),
3799 params
->cw_min
, params
->cw_max
,
3800 params
->aifs
, params
->txop
<< 5);
3804 ret
= wl1271_acx_tid_cfg(wl
, wl1271_tx_get_queue(queue
),
3805 CONF_CHANNEL_TYPE_EDCF
,
3806 wl1271_tx_get_queue(queue
),
3807 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
3811 wl1271_ps_elp_sleep(wl
);
3814 mutex_unlock(&wl
->mutex
);
3819 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
,
3820 struct ieee80211_vif
*vif
)
3823 struct wl1271
*wl
= hw
->priv
;
3824 u64 mactime
= ULLONG_MAX
;
3827 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
3829 mutex_lock(&wl
->mutex
);
3831 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3834 ret
= wl1271_ps_elp_wakeup(wl
);
3838 ret
= wl1271_acx_tsf_info(wl
, &mactime
);
3843 wl1271_ps_elp_sleep(wl
);
3846 mutex_unlock(&wl
->mutex
);
3850 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
3851 struct survey_info
*survey
)
3853 struct wl1271
*wl
= hw
->priv
;
3854 struct ieee80211_conf
*conf
= &hw
->conf
;
3859 survey
->channel
= conf
->channel
;
3860 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
3861 survey
->noise
= wl
->noise
;
3866 static int wl1271_allocate_sta(struct wl1271
*wl
,
3867 struct ieee80211_sta
*sta
,
3870 struct wl1271_station
*wl_sta
;
3873 id
= find_first_zero_bit(wl
->ap_hlid_map
, AP_MAX_STATIONS
);
3874 if (id
>= AP_MAX_STATIONS
) {
3875 wl1271_warning("could not allocate HLID - too much stations");
3879 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3880 set_bit(id
, wl
->ap_hlid_map
);
3881 wl_sta
->hlid
= WL1271_AP_STA_HLID_START
+ id
;
3882 *hlid
= wl_sta
->hlid
;
3883 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
3884 wl
->active_sta_count
++;
3888 void wl1271_free_sta(struct wl1271
*wl
, u8 hlid
)
3890 int id
= hlid
- WL1271_AP_STA_HLID_START
;
3892 if (hlid
< WL1271_AP_STA_HLID_START
)
3895 if (!test_bit(id
, wl
->ap_hlid_map
))
3898 clear_bit(id
, wl
->ap_hlid_map
);
3899 memset(wl
->links
[hlid
].addr
, 0, ETH_ALEN
);
3900 wl
->links
[hlid
].ba_bitmap
= 0;
3901 wl1271_tx_reset_link_queues(wl
, hlid
);
3902 __clear_bit(hlid
, &wl
->ap_ps_map
);
3903 __clear_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
3904 wl
->active_sta_count
--;
3907 static int wl1271_op_sta_add(struct ieee80211_hw
*hw
,
3908 struct ieee80211_vif
*vif
,
3909 struct ieee80211_sta
*sta
)
3911 struct wl1271
*wl
= hw
->priv
;
3915 mutex_lock(&wl
->mutex
);
3917 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3920 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3923 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
3925 ret
= wl1271_allocate_sta(wl
, sta
, &hlid
);
3929 ret
= wl1271_ps_elp_wakeup(wl
);
3933 ret
= wl12xx_cmd_add_peer(wl
, sta
, hlid
);
3937 ret
= wl12xx_cmd_set_peer_state(wl
, hlid
);
3941 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta
->ht_cap
, true, hlid
);
3946 wl1271_ps_elp_sleep(wl
);
3950 wl1271_free_sta(wl
, hlid
);
3953 mutex_unlock(&wl
->mutex
);
3957 static int wl1271_op_sta_remove(struct ieee80211_hw
*hw
,
3958 struct ieee80211_vif
*vif
,
3959 struct ieee80211_sta
*sta
)
3961 struct wl1271
*wl
= hw
->priv
;
3962 struct wl1271_station
*wl_sta
;
3965 mutex_lock(&wl
->mutex
);
3967 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
3970 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
3973 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
3975 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3976 id
= wl_sta
->hlid
- WL1271_AP_STA_HLID_START
;
3977 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
3980 ret
= wl1271_ps_elp_wakeup(wl
);
3984 ret
= wl12xx_cmd_remove_peer(wl
, wl_sta
->hlid
);
3988 wl1271_free_sta(wl
, wl_sta
->hlid
);
3991 wl1271_ps_elp_sleep(wl
);
3994 mutex_unlock(&wl
->mutex
);
3998 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
3999 struct ieee80211_vif
*vif
,
4000 enum ieee80211_ampdu_mlme_action action
,
4001 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
4004 struct wl1271
*wl
= hw
->priv
;
4006 u8 hlid
, *ba_bitmap
;
4008 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu action %d tid %d", action
,
4011 /* sanity check - the fields in FW are only 8bits wide */
4012 if (WARN_ON(tid
> 0xFF))
4015 mutex_lock(&wl
->mutex
);
4017 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
4022 if (wl
->bss_type
== BSS_TYPE_STA_BSS
) {
4023 hlid
= wl
->sta_hlid
;
4024 ba_bitmap
= &wl
->ba_rx_bitmap
;
4025 } else if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
4026 struct wl1271_station
*wl_sta
;
4028 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
4029 hlid
= wl_sta
->hlid
;
4030 ba_bitmap
= &wl
->links
[hlid
].ba_bitmap
;
4036 ret
= wl1271_ps_elp_wakeup(wl
);
4040 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu: Rx tid %d action %d",
4044 case IEEE80211_AMPDU_RX_START
:
4045 if (!wl
->ba_support
|| !wl
->ba_allowed
) {
4050 if (wl
->ba_rx_session_count
>= RX_BA_MAX_SESSIONS
) {
4052 wl1271_error("exceeded max RX BA sessions");
4056 if (*ba_bitmap
& BIT(tid
)) {
4058 wl1271_error("cannot enable RX BA session on active "
4063 ret
= wl12xx_acx_set_ba_receiver_session(wl
, tid
, *ssn
, true,
4066 *ba_bitmap
|= BIT(tid
);
4067 wl
->ba_rx_session_count
++;
4071 case IEEE80211_AMPDU_RX_STOP
:
4072 if (!(*ba_bitmap
& BIT(tid
))) {
4074 wl1271_error("no active RX BA session on tid: %d",
4079 ret
= wl12xx_acx_set_ba_receiver_session(wl
, tid
, 0, false,
4082 *ba_bitmap
&= ~BIT(tid
);
4083 wl
->ba_rx_session_count
--;
4088 * The BA initiator session management in FW independently.
4089 * Falling break here on purpose for all TX APDU commands.
4091 case IEEE80211_AMPDU_TX_START
:
4092 case IEEE80211_AMPDU_TX_STOP
:
4093 case IEEE80211_AMPDU_TX_OPERATIONAL
:
4098 wl1271_error("Incorrect ampdu action id=%x\n", action
);
4102 wl1271_ps_elp_sleep(wl
);
4105 mutex_unlock(&wl
->mutex
);
4110 static int wl12xx_set_bitrate_mask(struct ieee80211_hw
*hw
,
4111 struct ieee80211_vif
*vif
,
4112 const struct cfg80211_bitrate_mask
*mask
)
4114 struct wl1271
*wl
= hw
->priv
;
4117 wl1271_debug(DEBUG_MAC80211
, "mac80211 set_bitrate_mask 0x%x 0x%x",
4118 mask
->control
[NL80211_BAND_2GHZ
].legacy
,
4119 mask
->control
[NL80211_BAND_5GHZ
].legacy
);
4121 mutex_lock(&wl
->mutex
);
4123 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++)
4124 wl
->bitrate_masks
[i
] =
4125 wl1271_tx_enabled_rates_get(wl
,
4126 mask
->control
[i
].legacy
,
4128 mutex_unlock(&wl
->mutex
);
4133 static bool wl1271_tx_frames_pending(struct ieee80211_hw
*hw
)
4135 struct wl1271
*wl
= hw
->priv
;
4138 mutex_lock(&wl
->mutex
);
4140 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
4143 /* packets are considered pending if in the TX queue or the FW */
4144 ret
= (wl1271_tx_total_queue_count(wl
) > 0) || (wl
->tx_frames_cnt
> 0);
4146 /* the above is appropriate for STA mode for PS purposes */
4147 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
4150 mutex_unlock(&wl
->mutex
);
4155 /* can't be const, mac80211 writes to this */
4156 static struct ieee80211_rate wl1271_rates
[] = {
4158 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
4159 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
4161 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
4162 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
4163 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
4165 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
4166 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
4167 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
4169 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
4170 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
4171 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
4173 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
4174 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
4176 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
4177 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
4179 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
4180 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
4182 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
4183 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
4185 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
4186 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
4188 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
4189 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
4191 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
4192 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
4194 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
4195 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
4198 /* can't be const, mac80211 writes to this */
4199 static struct ieee80211_channel wl1271_channels
[] = {
4200 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
4201 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
4202 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
4203 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
4204 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
4205 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
4206 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
4207 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
4208 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
4209 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
4210 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
4211 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
4212 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
4213 { .hw_value
= 14, .center_freq
= 2484, .max_power
= 25 },
4216 /* mapping to indexes for wl1271_rates */
4217 static const u8 wl1271_rate_to_idx_2ghz
[] = {
4218 /* MCS rates are used only with 11n */
4219 7, /* CONF_HW_RXTX_RATE_MCS7 */
4220 6, /* CONF_HW_RXTX_RATE_MCS6 */
4221 5, /* CONF_HW_RXTX_RATE_MCS5 */
4222 4, /* CONF_HW_RXTX_RATE_MCS4 */
4223 3, /* CONF_HW_RXTX_RATE_MCS3 */
4224 2, /* CONF_HW_RXTX_RATE_MCS2 */
4225 1, /* CONF_HW_RXTX_RATE_MCS1 */
4226 0, /* CONF_HW_RXTX_RATE_MCS0 */
4228 11, /* CONF_HW_RXTX_RATE_54 */
4229 10, /* CONF_HW_RXTX_RATE_48 */
4230 9, /* CONF_HW_RXTX_RATE_36 */
4231 8, /* CONF_HW_RXTX_RATE_24 */
4233 /* TI-specific rate */
4234 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
4236 7, /* CONF_HW_RXTX_RATE_18 */
4237 6, /* CONF_HW_RXTX_RATE_12 */
4238 3, /* CONF_HW_RXTX_RATE_11 */
4239 5, /* CONF_HW_RXTX_RATE_9 */
4240 4, /* CONF_HW_RXTX_RATE_6 */
4241 2, /* CONF_HW_RXTX_RATE_5_5 */
4242 1, /* CONF_HW_RXTX_RATE_2 */
4243 0 /* CONF_HW_RXTX_RATE_1 */
4246 /* 11n STA capabilities */
4247 #define HW_RX_HIGHEST_RATE 72
4249 #define WL12XX_HT_CAP { \
4250 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4251 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
4252 .ht_supported = true, \
4253 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4254 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4256 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4257 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4258 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4262 /* can't be const, mac80211 writes to this */
4263 static struct ieee80211_supported_band wl1271_band_2ghz
= {
4264 .channels
= wl1271_channels
,
4265 .n_channels
= ARRAY_SIZE(wl1271_channels
),
4266 .bitrates
= wl1271_rates
,
4267 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
4268 .ht_cap
= WL12XX_HT_CAP
,
4271 /* 5 GHz data rates for WL1273 */
4272 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
4274 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
4275 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
4277 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
4278 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
4280 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
4281 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
4283 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
4284 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
4286 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
4287 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
4289 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
4290 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
4292 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
4293 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
4295 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
4296 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
4299 /* 5 GHz band channels for WL1273 */
4300 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
4301 { .hw_value
= 7, .center_freq
= 5035, .max_power
= 25 },
4302 { .hw_value
= 8, .center_freq
= 5040, .max_power
= 25 },
4303 { .hw_value
= 9, .center_freq
= 5045, .max_power
= 25 },
4304 { .hw_value
= 11, .center_freq
= 5055, .max_power
= 25 },
4305 { .hw_value
= 12, .center_freq
= 5060, .max_power
= 25 },
4306 { .hw_value
= 16, .center_freq
= 5080, .max_power
= 25 },
4307 { .hw_value
= 34, .center_freq
= 5170, .max_power
= 25 },
4308 { .hw_value
= 36, .center_freq
= 5180, .max_power
= 25 },
4309 { .hw_value
= 38, .center_freq
= 5190, .max_power
= 25 },
4310 { .hw_value
= 40, .center_freq
= 5200, .max_power
= 25 },
4311 { .hw_value
= 42, .center_freq
= 5210, .max_power
= 25 },
4312 { .hw_value
= 44, .center_freq
= 5220, .max_power
= 25 },
4313 { .hw_value
= 46, .center_freq
= 5230, .max_power
= 25 },
4314 { .hw_value
= 48, .center_freq
= 5240, .max_power
= 25 },
4315 { .hw_value
= 52, .center_freq
= 5260, .max_power
= 25 },
4316 { .hw_value
= 56, .center_freq
= 5280, .max_power
= 25 },
4317 { .hw_value
= 60, .center_freq
= 5300, .max_power
= 25 },
4318 { .hw_value
= 64, .center_freq
= 5320, .max_power
= 25 },
4319 { .hw_value
= 100, .center_freq
= 5500, .max_power
= 25 },
4320 { .hw_value
= 104, .center_freq
= 5520, .max_power
= 25 },
4321 { .hw_value
= 108, .center_freq
= 5540, .max_power
= 25 },
4322 { .hw_value
= 112, .center_freq
= 5560, .max_power
= 25 },
4323 { .hw_value
= 116, .center_freq
= 5580, .max_power
= 25 },
4324 { .hw_value
= 120, .center_freq
= 5600, .max_power
= 25 },
4325 { .hw_value
= 124, .center_freq
= 5620, .max_power
= 25 },
4326 { .hw_value
= 128, .center_freq
= 5640, .max_power
= 25 },
4327 { .hw_value
= 132, .center_freq
= 5660, .max_power
= 25 },
4328 { .hw_value
= 136, .center_freq
= 5680, .max_power
= 25 },
4329 { .hw_value
= 140, .center_freq
= 5700, .max_power
= 25 },
4330 { .hw_value
= 149, .center_freq
= 5745, .max_power
= 25 },
4331 { .hw_value
= 153, .center_freq
= 5765, .max_power
= 25 },
4332 { .hw_value
= 157, .center_freq
= 5785, .max_power
= 25 },
4333 { .hw_value
= 161, .center_freq
= 5805, .max_power
= 25 },
4334 { .hw_value
= 165, .center_freq
= 5825, .max_power
= 25 },
4337 /* mapping to indexes for wl1271_rates_5ghz */
4338 static const u8 wl1271_rate_to_idx_5ghz
[] = {
4339 /* MCS rates are used only with 11n */
4340 7, /* CONF_HW_RXTX_RATE_MCS7 */
4341 6, /* CONF_HW_RXTX_RATE_MCS6 */
4342 5, /* CONF_HW_RXTX_RATE_MCS5 */
4343 4, /* CONF_HW_RXTX_RATE_MCS4 */
4344 3, /* CONF_HW_RXTX_RATE_MCS3 */
4345 2, /* CONF_HW_RXTX_RATE_MCS2 */
4346 1, /* CONF_HW_RXTX_RATE_MCS1 */
4347 0, /* CONF_HW_RXTX_RATE_MCS0 */
4349 7, /* CONF_HW_RXTX_RATE_54 */
4350 6, /* CONF_HW_RXTX_RATE_48 */
4351 5, /* CONF_HW_RXTX_RATE_36 */
4352 4, /* CONF_HW_RXTX_RATE_24 */
4354 /* TI-specific rate */
4355 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
4357 3, /* CONF_HW_RXTX_RATE_18 */
4358 2, /* CONF_HW_RXTX_RATE_12 */
4359 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_11 */
4360 1, /* CONF_HW_RXTX_RATE_9 */
4361 0, /* CONF_HW_RXTX_RATE_6 */
4362 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_5_5 */
4363 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_2 */
4364 CONF_HW_RXTX_RATE_UNSUPPORTED
/* CONF_HW_RXTX_RATE_1 */
4367 static struct ieee80211_supported_band wl1271_band_5ghz
= {
4368 .channels
= wl1271_channels_5ghz
,
4369 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
4370 .bitrates
= wl1271_rates_5ghz
,
4371 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
4372 .ht_cap
= WL12XX_HT_CAP
,
4375 static const u8
*wl1271_band_rate_to_idx
[] = {
4376 [IEEE80211_BAND_2GHZ
] = wl1271_rate_to_idx_2ghz
,
4377 [IEEE80211_BAND_5GHZ
] = wl1271_rate_to_idx_5ghz
4380 static const struct ieee80211_ops wl1271_ops
= {
4381 .start
= wl1271_op_start
,
4382 .stop
= wl1271_op_stop
,
4383 .add_interface
= wl1271_op_add_interface
,
4384 .remove_interface
= wl1271_op_remove_interface
,
4386 .suspend
= wl1271_op_suspend
,
4387 .resume
= wl1271_op_resume
,
4389 .config
= wl1271_op_config
,
4390 .prepare_multicast
= wl1271_op_prepare_multicast
,
4391 .configure_filter
= wl1271_op_configure_filter
,
4393 .set_key
= wl1271_op_set_key
,
4394 .hw_scan
= wl1271_op_hw_scan
,
4395 .cancel_hw_scan
= wl1271_op_cancel_hw_scan
,
4396 .sched_scan_start
= wl1271_op_sched_scan_start
,
4397 .sched_scan_stop
= wl1271_op_sched_scan_stop
,
4398 .bss_info_changed
= wl1271_op_bss_info_changed
,
4399 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
4400 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
4401 .conf_tx
= wl1271_op_conf_tx
,
4402 .get_tsf
= wl1271_op_get_tsf
,
4403 .get_survey
= wl1271_op_get_survey
,
4404 .sta_add
= wl1271_op_sta_add
,
4405 .sta_remove
= wl1271_op_sta_remove
,
4406 .ampdu_action
= wl1271_op_ampdu_action
,
4407 .tx_frames_pending
= wl1271_tx_frames_pending
,
4408 .set_bitrate_mask
= wl12xx_set_bitrate_mask
,
4409 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
4413 u8
wl1271_rate_to_idx(int rate
, enum ieee80211_band band
)
4417 BUG_ON(band
>= sizeof(wl1271_band_rate_to_idx
)/sizeof(u8
*));
4419 if (unlikely(rate
>= CONF_HW_RXTX_RATE_MAX
)) {
4420 wl1271_error("Illegal RX rate from HW: %d", rate
);
4424 idx
= wl1271_band_rate_to_idx
[band
][rate
];
4425 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
4426 wl1271_error("Unsupported RX rate from HW: %d", rate
);
4433 static ssize_t
wl1271_sysfs_show_bt_coex_state(struct device
*dev
,
4434 struct device_attribute
*attr
,
4437 struct wl1271
*wl
= dev_get_drvdata(dev
);
4442 mutex_lock(&wl
->mutex
);
4443 len
= snprintf(buf
, len
, "%d\n\n0 - off\n1 - on\n",
4445 mutex_unlock(&wl
->mutex
);
4451 static ssize_t
wl1271_sysfs_store_bt_coex_state(struct device
*dev
,
4452 struct device_attribute
*attr
,
4453 const char *buf
, size_t count
)
4455 struct wl1271
*wl
= dev_get_drvdata(dev
);
4459 ret
= kstrtoul(buf
, 10, &res
);
4461 wl1271_warning("incorrect value written to bt_coex_mode");
4465 mutex_lock(&wl
->mutex
);
4469 if (res
== wl
->sg_enabled
)
4472 wl
->sg_enabled
= res
;
4474 if (wl
->state
== WL1271_STATE_OFF
)
4477 ret
= wl1271_ps_elp_wakeup(wl
);
4481 wl1271_acx_sg_enable(wl
, wl
->sg_enabled
);
4482 wl1271_ps_elp_sleep(wl
);
4485 mutex_unlock(&wl
->mutex
);
4489 static DEVICE_ATTR(bt_coex_state
, S_IRUGO
| S_IWUSR
,
4490 wl1271_sysfs_show_bt_coex_state
,
4491 wl1271_sysfs_store_bt_coex_state
);
4493 static ssize_t
wl1271_sysfs_show_hw_pg_ver(struct device
*dev
,
4494 struct device_attribute
*attr
,
4497 struct wl1271
*wl
= dev_get_drvdata(dev
);
4502 mutex_lock(&wl
->mutex
);
4503 if (wl
->hw_pg_ver
>= 0)
4504 len
= snprintf(buf
, len
, "%d\n", wl
->hw_pg_ver
);
4506 len
= snprintf(buf
, len
, "n/a\n");
4507 mutex_unlock(&wl
->mutex
);
4512 static DEVICE_ATTR(hw_pg_ver
, S_IRUGO
,
4513 wl1271_sysfs_show_hw_pg_ver
, NULL
);
4515 static ssize_t
wl1271_sysfs_read_fwlog(struct file
*filp
, struct kobject
*kobj
,
4516 struct bin_attribute
*bin_attr
,
4517 char *buffer
, loff_t pos
, size_t count
)
4519 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
4520 struct wl1271
*wl
= dev_get_drvdata(dev
);
4524 ret
= mutex_lock_interruptible(&wl
->mutex
);
4526 return -ERESTARTSYS
;
4528 /* Let only one thread read the log at a time, blocking others */
4529 while (wl
->fwlog_size
== 0) {
4532 prepare_to_wait_exclusive(&wl
->fwlog_waitq
,
4534 TASK_INTERRUPTIBLE
);
4536 if (wl
->fwlog_size
!= 0) {
4537 finish_wait(&wl
->fwlog_waitq
, &wait
);
4541 mutex_unlock(&wl
->mutex
);
4544 finish_wait(&wl
->fwlog_waitq
, &wait
);
4546 if (signal_pending(current
))
4547 return -ERESTARTSYS
;
4549 ret
= mutex_lock_interruptible(&wl
->mutex
);
4551 return -ERESTARTSYS
;
4554 /* Check if the fwlog is still valid */
4555 if (wl
->fwlog_size
< 0) {
4556 mutex_unlock(&wl
->mutex
);
4560 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4561 len
= min(count
, (size_t)wl
->fwlog_size
);
4562 wl
->fwlog_size
-= len
;
4563 memcpy(buffer
, wl
->fwlog
, len
);
4565 /* Make room for new messages */
4566 memmove(wl
->fwlog
, wl
->fwlog
+ len
, wl
->fwlog_size
);
4568 mutex_unlock(&wl
->mutex
);
4573 static struct bin_attribute fwlog_attr
= {
4574 .attr
= {.name
= "fwlog", .mode
= S_IRUSR
},
4575 .read
= wl1271_sysfs_read_fwlog
,
4578 int wl1271_register_hw(struct wl1271
*wl
)
4582 if (wl
->mac80211_registered
)
4585 ret
= wl1271_fetch_nvs(wl
);
4587 /* NOTE: The wl->nvs->nvs element must be first, in
4588 * order to simplify the casting, we assume it is at
4589 * the beginning of the wl->nvs structure.
4591 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
4593 wl
->mac_addr
[0] = nvs_ptr
[11];
4594 wl
->mac_addr
[1] = nvs_ptr
[10];
4595 wl
->mac_addr
[2] = nvs_ptr
[6];
4596 wl
->mac_addr
[3] = nvs_ptr
[5];
4597 wl
->mac_addr
[4] = nvs_ptr
[4];
4598 wl
->mac_addr
[5] = nvs_ptr
[3];
4601 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
4603 ret
= ieee80211_register_hw(wl
->hw
);
4605 wl1271_error("unable to register mac80211 hw: %d", ret
);
4609 wl
->mac80211_registered
= true;
4611 wl1271_debugfs_init(wl
);
4613 register_netdevice_notifier(&wl1271_dev_notifier
);
4615 wl1271_notice("loaded");
4619 EXPORT_SYMBOL_GPL(wl1271_register_hw
);
4621 void wl1271_unregister_hw(struct wl1271
*wl
)
4623 if (wl
->state
== WL1271_STATE_PLT
)
4624 __wl1271_plt_stop(wl
);
4626 unregister_netdevice_notifier(&wl1271_dev_notifier
);
4627 ieee80211_unregister_hw(wl
->hw
);
4628 wl
->mac80211_registered
= false;
4631 EXPORT_SYMBOL_GPL(wl1271_unregister_hw
);
4633 int wl1271_init_ieee80211(struct wl1271
*wl
)
4635 static const u32 cipher_suites
[] = {
4636 WLAN_CIPHER_SUITE_WEP40
,
4637 WLAN_CIPHER_SUITE_WEP104
,
4638 WLAN_CIPHER_SUITE_TKIP
,
4639 WLAN_CIPHER_SUITE_CCMP
,
4640 WL1271_CIPHER_SUITE_GEM
,
4643 /* The tx descriptor buffer and the TKIP space. */
4644 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
4645 sizeof(struct wl1271_tx_hw_descr
);
4648 /* FIXME: find a proper value */
4649 wl
->hw
->channel_change_time
= 10000;
4650 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
4652 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
4653 IEEE80211_HW_BEACON_FILTER
|
4654 IEEE80211_HW_SUPPORTS_PS
|
4655 IEEE80211_HW_SUPPORTS_UAPSD
|
4656 IEEE80211_HW_HAS_RATE_CONTROL
|
4657 IEEE80211_HW_CONNECTION_MONITOR
|
4658 IEEE80211_HW_SUPPORTS_CQM_RSSI
|
4659 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
4660 IEEE80211_HW_SPECTRUM_MGMT
|
4661 IEEE80211_HW_AP_LINK_PS
|
4662 IEEE80211_HW_AMPDU_AGGREGATION
|
4663 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW
;
4665 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
4666 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
4668 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
4669 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
) |
4670 BIT(NL80211_IFTYPE_P2P_CLIENT
) | BIT(NL80211_IFTYPE_P2P_GO
);
4671 wl
->hw
->wiphy
->max_scan_ssids
= 1;
4672 wl
->hw
->wiphy
->max_sched_scan_ssids
= 16;
4673 wl
->hw
->wiphy
->max_match_sets
= 16;
4675 * Maximum length of elements in scanning probe request templates
4676 * should be the maximum length possible for a template, without
4677 * the IEEE80211 header of the template
4679 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_DFLT_SIZE
-
4680 sizeof(struct ieee80211_header
);
4682 wl
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_UAPSD
;
4684 /* make sure all our channels fit in the scanned_ch bitmask */
4685 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
4686 ARRAY_SIZE(wl1271_channels_5ghz
) >
4687 WL1271_MAX_CHANNELS
);
4689 * We keep local copies of the band structs because we need to
4690 * modify them on a per-device basis.
4692 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
4693 sizeof(wl1271_band_2ghz
));
4694 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
4695 sizeof(wl1271_band_5ghz
));
4697 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
4698 &wl
->bands
[IEEE80211_BAND_2GHZ
];
4699 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
4700 &wl
->bands
[IEEE80211_BAND_5GHZ
];
4703 wl
->hw
->max_rates
= 1;
4705 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
4707 SET_IEEE80211_DEV(wl
->hw
, wl1271_wl_to_dev(wl
));
4709 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
4711 wl
->hw
->max_rx_aggregation_subframes
= 8;
4715 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211
);
4717 #define WL1271_DEFAULT_CHANNEL 0
4719 struct ieee80211_hw
*wl1271_alloc_hw(void)
4721 struct ieee80211_hw
*hw
;
4722 struct platform_device
*plat_dev
= NULL
;
4727 BUILD_BUG_ON(AP_MAX_LINKS
> WL12XX_MAX_LINKS
);
4729 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
4731 wl1271_error("could not alloc ieee80211_hw");
4736 plat_dev
= kmemdup(&wl1271_device
, sizeof(wl1271_device
), GFP_KERNEL
);
4738 wl1271_error("could not allocate platform_device");
4740 goto err_plat_alloc
;
4744 memset(wl
, 0, sizeof(*wl
));
4746 INIT_LIST_HEAD(&wl
->list
);
4749 wl
->plat_dev
= plat_dev
;
4751 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
4752 skb_queue_head_init(&wl
->tx_queue
[i
]);
4754 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
4755 for (j
= 0; j
< AP_MAX_LINKS
; j
++)
4756 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
4758 skb_queue_head_init(&wl
->deferred_rx_queue
);
4759 skb_queue_head_init(&wl
->deferred_tx_queue
);
4761 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
4762 INIT_DELAYED_WORK(&wl
->pspoll_work
, wl1271_pspoll_work
);
4763 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
4764 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
4765 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
4766 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
4767 INIT_WORK(&wl
->rx_streaming_enable_work
,
4768 wl1271_rx_streaming_enable_work
);
4769 INIT_WORK(&wl
->rx_streaming_disable_work
,
4770 wl1271_rx_streaming_disable_work
);
4772 wl
->freezable_wq
= create_freezable_workqueue("wl12xx_wq");
4773 if (!wl
->freezable_wq
) {
4778 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
4779 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
4780 wl
->default_key
= 0;
4782 wl
->psm_entry_retry
= 0;
4783 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
4784 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
4785 wl
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
4786 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
4787 wl
->band
= IEEE80211_BAND_2GHZ
;
4790 wl
->sg_enabled
= true;
4792 wl
->bss_type
= MAX_BSS_TYPE
;
4793 wl
->set_bss_type
= MAX_BSS_TYPE
;
4794 wl
->last_tx_hlid
= 0;
4796 wl
->ap_fw_ps_map
= 0;
4798 wl
->platform_quirks
= 0;
4799 wl
->sched_scanning
= false;
4800 wl
->tx_security_seq
= 0;
4801 wl
->tx_security_last_seq_lsb
= 0;
4802 wl
->tx_spare_blocks
= TX_HW_BLOCK_SPARE_DEFAULT
;
4803 wl
->role_id
= WL12XX_INVALID_ROLE_ID
;
4804 wl
->system_hlid
= WL12XX_SYSTEM_HLID
;
4805 wl
->sta_hlid
= WL12XX_INVALID_LINK_ID
;
4806 wl
->dev_role_id
= WL12XX_INVALID_ROLE_ID
;
4807 wl
->dev_hlid
= WL12XX_INVALID_LINK_ID
;
4808 wl
->session_counter
= 0;
4809 wl
->ap_bcast_hlid
= WL12XX_INVALID_LINK_ID
;
4810 wl
->ap_global_hlid
= WL12XX_INVALID_LINK_ID
;
4811 wl
->active_sta_count
= 0;
4812 setup_timer(&wl
->rx_streaming_timer
, wl1271_rx_streaming_timer
,
4813 (unsigned long) wl
);
4815 init_waitqueue_head(&wl
->fwlog_waitq
);
4817 /* The system link is always allocated */
4818 __set_bit(WL12XX_SYSTEM_HLID
, wl
->links_map
);
4820 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
4821 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
4822 wl
->tx_frames
[i
] = NULL
;
4824 spin_lock_init(&wl
->wl_lock
);
4826 wl
->state
= WL1271_STATE_OFF
;
4827 mutex_init(&wl
->mutex
);
4829 /* Apply default driver configuration. */
4830 wl1271_conf_init(wl
);
4831 wl
->bitrate_masks
[IEEE80211_BAND_2GHZ
] = wl
->conf
.tx
.basic_rate
;
4832 wl
->bitrate_masks
[IEEE80211_BAND_5GHZ
] = wl
->conf
.tx
.basic_rate_5
;
4834 order
= get_order(WL1271_AGGR_BUFFER_SIZE
);
4835 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
4836 if (!wl
->aggr_buf
) {
4841 wl
->dummy_packet
= wl12xx_alloc_dummy_packet(wl
);
4842 if (!wl
->dummy_packet
) {
4847 /* Allocate one page for the FW log */
4848 wl
->fwlog
= (u8
*)get_zeroed_page(GFP_KERNEL
);
4851 goto err_dummy_packet
;
4854 /* Register platform device */
4855 ret
= platform_device_register(wl
->plat_dev
);
4857 wl1271_error("couldn't register platform device");
4860 dev_set_drvdata(&wl
->plat_dev
->dev
, wl
);
4862 /* Create sysfs file to control bt coex state */
4863 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4865 wl1271_error("failed to create sysfs file bt_coex_state");
4869 /* Create sysfs file to get HW PG version */
4870 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4872 wl1271_error("failed to create sysfs file hw_pg_ver");
4873 goto err_bt_coex_state
;
4876 /* Create sysfs file for the FW log */
4877 ret
= device_create_bin_file(&wl
->plat_dev
->dev
, &fwlog_attr
);
4879 wl1271_error("failed to create sysfs file fwlog");
4886 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4889 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4892 platform_device_unregister(wl
->plat_dev
);
4895 free_page((unsigned long)wl
->fwlog
);
4898 dev_kfree_skb(wl
->dummy_packet
);
4901 free_pages((unsigned long)wl
->aggr_buf
, order
);
4904 destroy_workqueue(wl
->freezable_wq
);
4907 wl1271_debugfs_exit(wl
);
4911 ieee80211_free_hw(hw
);
4915 return ERR_PTR(ret
);
4917 EXPORT_SYMBOL_GPL(wl1271_alloc_hw
);
4919 int wl1271_free_hw(struct wl1271
*wl
)
4921 /* Unblock any fwlog readers */
4922 mutex_lock(&wl
->mutex
);
4923 wl
->fwlog_size
= -1;
4924 wake_up_interruptible_all(&wl
->fwlog_waitq
);
4925 mutex_unlock(&wl
->mutex
);
4927 device_remove_bin_file(&wl
->plat_dev
->dev
, &fwlog_attr
);
4929 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
4931 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
4932 platform_device_unregister(wl
->plat_dev
);
4933 free_page((unsigned long)wl
->fwlog
);
4934 dev_kfree_skb(wl
->dummy_packet
);
4935 free_pages((unsigned long)wl
->aggr_buf
,
4936 get_order(WL1271_AGGR_BUFFER_SIZE
));
4937 kfree(wl
->plat_dev
);
4939 wl1271_debugfs_exit(wl
);
4946 kfree(wl
->fw_status
);
4947 kfree(wl
->tx_res_if
);
4948 destroy_workqueue(wl
->freezable_wq
);
4950 ieee80211_free_hw(wl
->hw
);
4954 EXPORT_SYMBOL_GPL(wl1271_free_hw
);
4956 u32 wl12xx_debug_level
= DEBUG_NONE
;
4957 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
4958 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
4959 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
4961 module_param_named(fwlog
, fwlog_param
, charp
, 0);
4962 MODULE_PARM_DESC(keymap
,
4963 "FW logger options: continuous, ondemand, dbgpins or disable");
4965 module_param(bug_on_recovery
, bool, S_IRUSR
| S_IWUSR
);
4966 MODULE_PARM_DESC(bug_on_recovery
, "BUG() on fw recovery");
4968 MODULE_LICENSE("GPL");
4969 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4970 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");