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>
35 #include "wl12xx_80211.h"
49 #define WL1271_BOOT_RETRIES 3
51 static struct conf_drv_settings default_conf
= {
54 [CONF_SG_BT_PER_THRESHOLD
] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE
] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL
] = 400,
57 [CONF_SG_BT_LOAD_RATIO
] = 50,
58 [CONF_SG_AUTO_PS_MODE
] = 1,
59 [CONF_SG_AUTO_SCAN_PROBE_REQ
] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3
] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION
] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT
] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH
] = 12,
64 [CONF_SG_RATE_ADAPT_SNR
] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR
] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR
] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR
] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR
] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR
] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR
] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR
] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR
] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR
] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR
] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR
] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR
] = 20,
83 [CONF_SG_ADAPTIVE_RXT_TXT
] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT
] = 10,
85 [CONF_SG_UPSD_TIMEOUT
] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR
] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR
] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR
] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR
] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR
] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR
] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR
] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR
] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR
] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3
] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP
] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME
] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME
] = 15,
99 [CONF_SG_HV3_MAX_SERVED
] = 6,
100 [CONF_SG_DHCP_TIME
] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP
] = 100,
103 .state
= CONF_SG_PROTECTIVE
,
106 .rx_msdu_life_time
= 512000,
107 .packet_detection_threshold
= 0,
108 .ps_poll_timeout
= 15,
110 .rts_threshold
= 2347,
111 .rx_cca_threshold
= 0,
112 .irq_blk_threshold
= 0xFFFF,
113 .irq_pkt_threshold
= 0,
115 .queue_type
= CONF_RX_QUEUE_TYPE_LOW_PRIORITY
,
118 .tx_energy_detection
= 0,
121 .short_retry_limit
= 10,
122 .long_retry_limit
= 10,
145 .aifsn
= CONF_TX_AIFS_PIFS
,
152 .aifsn
= CONF_TX_AIFS_PIFS
,
158 .enabled_rates
= CONF_TX_AP_ENABLED_RATES
,
159 .short_retry_limit
= 10,
160 .long_retry_limit
= 10,
164 .enabled_rates
= CONF_TX_AP_ENABLED_RATES
,
165 .short_retry_limit
= 10,
166 .long_retry_limit
= 10,
170 .enabled_rates
= CONF_TX_AP_ENABLED_RATES
,
171 .short_retry_limit
= 10,
172 .long_retry_limit
= 10,
176 .enabled_rates
= CONF_TX_AP_ENABLED_RATES
,
177 .short_retry_limit
= 10,
178 .long_retry_limit
= 10,
183 .enabled_rates
= CONF_TX_AP_DEFAULT_MGMT_RATES
,
184 .short_retry_limit
= 10,
185 .long_retry_limit
= 10,
189 .enabled_rates
= CONF_HW_BIT_RATE_1MBPS
,
190 .short_retry_limit
= 10,
191 .long_retry_limit
= 10,
194 .ap_max_tx_retries
= 100,
198 .queue_id
= CONF_TX_AC_BE
,
199 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
200 .tsid
= CONF_TX_AC_BE
,
201 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
202 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
206 .queue_id
= CONF_TX_AC_BK
,
207 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
208 .tsid
= CONF_TX_AC_BK
,
209 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
210 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
214 .queue_id
= CONF_TX_AC_VI
,
215 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
216 .tsid
= CONF_TX_AC_VI
,
217 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
218 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
222 .queue_id
= CONF_TX_AC_VO
,
223 .channel_type
= CONF_CHANNEL_TYPE_EDCF
,
224 .tsid
= CONF_TX_AC_VO
,
225 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
226 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
230 .frag_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
,
231 .tx_compl_timeout
= 700,
232 .tx_compl_threshold
= 4,
233 .basic_rate
= CONF_HW_BIT_RATE_1MBPS
,
234 .basic_rate_5
= CONF_HW_BIT_RATE_6MBPS
,
235 .tmpl_short_retry_limit
= 10,
236 .tmpl_long_retry_limit
= 10,
239 .wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
,
240 .listen_interval
= 1,
241 .bcn_filt_mode
= CONF_BCN_FILT_MODE_ENABLED
,
242 .bcn_filt_ie_count
= 1,
245 .ie
= WLAN_EID_CHANNEL_SWITCH
,
246 .rule
= CONF_BCN_RULE_PASS_ON_APPEARANCE
,
249 .synch_fail_thold
= 10,
250 .bss_lose_timeout
= 100,
251 .beacon_rx_timeout
= 10000,
252 .broadcast_timeout
= 20000,
253 .rx_broadcast_in_ps
= 1,
254 .ps_poll_threshold
= 10,
255 .ps_poll_recovery_period
= 700,
256 .bet_enable
= CONF_BET_MODE_ENABLE
,
257 .bet_max_consecutive
= 10,
258 .psm_entry_retries
= 5,
259 .psm_exit_retries
= 255,
260 .psm_entry_nullfunc_retries
= 3,
261 .psm_entry_hangover_period
= 1,
262 .keep_alive_interval
= 55000,
263 .max_listen_interval
= 20,
270 .host_clk_settling_time
= 5000,
271 .host_fast_wakeup_support
= false
275 .avg_weight_rssi_beacon
= 20,
276 .avg_weight_rssi_data
= 10,
277 .avg_weight_snr_beacon
= 20,
278 .avg_weight_snr_data
= 10,
281 .min_dwell_time_active
= 7500,
282 .max_dwell_time_active
= 30000,
283 .min_dwell_time_passive
= 100000,
284 .max_dwell_time_passive
= 100000,
288 .tx_per_channel_power_compensation_2
= {
289 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291 .tx_per_channel_power_compensation_5
= {
292 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
298 .tx_ba_win_size
= 64,
299 .inactivity_timeout
= 10000,
305 .tx_min_block_num
= 40,
307 .min_req_tx_blocks
= 104,
308 .min_req_rx_blocks
= 22,
313 static void __wl1271_op_remove_interface(struct wl1271
*wl
);
314 static void wl1271_free_ap_keys(struct wl1271
*wl
);
317 static void wl1271_device_release(struct device
*dev
)
322 static struct platform_device wl1271_device
= {
326 /* device model insists to have a release function */
328 .release
= wl1271_device_release
,
332 static LIST_HEAD(wl_list
);
334 static int wl1271_dev_notify(struct notifier_block
*me
, unsigned long what
,
337 struct net_device
*dev
= arg
;
338 struct wireless_dev
*wdev
;
340 struct ieee80211_hw
*hw
;
342 struct wl1271
*wl_temp
;
345 /* Check that this notification is for us. */
346 if (what
!= NETDEV_CHANGE
)
349 wdev
= dev
->ieee80211_ptr
;
357 hw
= wiphy_priv(wiphy
);
362 list_for_each_entry(wl
, &wl_list
, list
) {
369 mutex_lock(&wl
->mutex
);
371 if (wl
->state
== WL1271_STATE_OFF
)
374 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
377 ret
= wl1271_ps_elp_wakeup(wl
, false);
381 if ((dev
->operstate
== IF_OPER_UP
) &&
382 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
)) {
383 wl1271_cmd_set_sta_state(wl
);
384 wl1271_info("Association completed.");
387 wl1271_ps_elp_sleep(wl
);
390 mutex_unlock(&wl
->mutex
);
395 static int wl1271_reg_notify(struct wiphy
*wiphy
,
396 struct regulatory_request
*request
)
398 struct ieee80211_supported_band
*band
;
399 struct ieee80211_channel
*ch
;
402 band
= wiphy
->bands
[IEEE80211_BAND_5GHZ
];
403 for (i
= 0; i
< band
->n_channels
; i
++) {
404 ch
= &band
->channels
[i
];
405 if (ch
->flags
& IEEE80211_CHAN_DISABLED
)
408 if (ch
->flags
& IEEE80211_CHAN_RADAR
)
409 ch
->flags
|= IEEE80211_CHAN_NO_IBSS
|
410 IEEE80211_CHAN_PASSIVE_SCAN
;
417 static void wl1271_conf_init(struct wl1271
*wl
)
421 * This function applies the default configuration to the driver. This
422 * function is invoked upon driver load (spi probe.)
424 * The configuration is stored in a run-time structure in order to
425 * facilitate for run-time adjustment of any of the parameters. Making
426 * changes to the configuration structure will apply the new values on
427 * the next interface up (wl1271_op_start.)
430 /* apply driver default configuration */
431 memcpy(&wl
->conf
, &default_conf
, sizeof(default_conf
));
435 static int wl1271_plt_init(struct wl1271
*wl
)
437 struct conf_tx_ac_category
*conf_ac
;
438 struct conf_tx_tid
*conf_tid
;
441 ret
= wl1271_cmd_general_parms(wl
);
445 ret
= wl1271_cmd_radio_parms(wl
);
449 ret
= wl1271_cmd_ext_radio_parms(wl
);
453 ret
= wl1271_sta_init_templates_config(wl
);
457 ret
= wl1271_acx_init_mem_config(wl
);
461 /* PHY layer config */
462 ret
= wl1271_init_phy_config(wl
);
464 goto out_free_memmap
;
466 ret
= wl1271_acx_dco_itrim_params(wl
);
468 goto out_free_memmap
;
470 /* Initialize connection monitoring thresholds */
471 ret
= wl1271_acx_conn_monit_params(wl
, false);
473 goto out_free_memmap
;
475 /* Bluetooth WLAN coexistence */
476 ret
= wl1271_init_pta(wl
);
478 goto out_free_memmap
;
480 /* Energy detection */
481 ret
= wl1271_init_energy_detection(wl
);
483 goto out_free_memmap
;
485 ret
= wl1271_acx_sta_mem_cfg(wl
);
487 goto out_free_memmap
;
489 /* Default fragmentation threshold */
490 ret
= wl1271_acx_frag_threshold(wl
, wl
->conf
.tx
.frag_threshold
);
492 goto out_free_memmap
;
494 /* Default TID/AC configuration */
495 BUG_ON(wl
->conf
.tx
.tid_conf_count
!= wl
->conf
.tx
.ac_conf_count
);
496 for (i
= 0; i
< wl
->conf
.tx
.tid_conf_count
; i
++) {
497 conf_ac
= &wl
->conf
.tx
.ac_conf
[i
];
498 ret
= wl1271_acx_ac_cfg(wl
, conf_ac
->ac
, conf_ac
->cw_min
,
499 conf_ac
->cw_max
, conf_ac
->aifsn
,
500 conf_ac
->tx_op_limit
);
502 goto out_free_memmap
;
504 conf_tid
= &wl
->conf
.tx
.tid_conf
[i
];
505 ret
= wl1271_acx_tid_cfg(wl
, conf_tid
->queue_id
,
506 conf_tid
->channel_type
,
509 conf_tid
->ack_policy
,
510 conf_tid
->apsd_conf
[0],
511 conf_tid
->apsd_conf
[1]);
513 goto out_free_memmap
;
516 /* Enable data path */
517 ret
= wl1271_cmd_data_path(wl
, 1);
519 goto out_free_memmap
;
521 /* Configure for CAM power saving (ie. always active) */
522 ret
= wl1271_acx_sleep_auth(wl
, WL1271_PSM_CAM
);
524 goto out_free_memmap
;
527 ret
= wl1271_acx_pm_config(wl
);
529 goto out_free_memmap
;
534 kfree(wl
->target_mem_map
);
535 wl
->target_mem_map
= NULL
;
540 static void wl1271_fw_status(struct wl1271
*wl
,
541 struct wl1271_fw_full_status
*full_status
)
543 struct wl1271_fw_common_status
*status
= &full_status
->common
;
548 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
549 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
550 sizeof(struct wl1271_fw_ap_status
), false);
552 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
553 sizeof(struct wl1271_fw_sta_status
), false);
555 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
556 "drv_rx_counter = %d, tx_results_counter = %d)",
558 status
->fw_rx_counter
,
559 status
->drv_rx_counter
,
560 status
->tx_results_counter
);
562 /* update number of available TX blocks */
563 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
564 u32 cnt
= le32_to_cpu(status
->tx_released_blks
[i
]) -
565 wl
->tx_blocks_freed
[i
];
567 wl
->tx_blocks_freed
[i
] =
568 le32_to_cpu(status
->tx_released_blks
[i
]);
569 wl
->tx_blocks_available
+= cnt
;
573 /* if more blocks are available now, tx work can be scheduled */
575 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
577 /* update the host-chipset time offset */
579 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
580 (s64
)le32_to_cpu(status
->fw_localtime
);
583 #define WL1271_IRQ_MAX_LOOPS 10
585 static void wl1271_irq_work(struct work_struct
*work
)
589 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
592 container_of(work
, struct wl1271
, irq_work
);
594 mutex_lock(&wl
->mutex
);
596 wl1271_debug(DEBUG_IRQ
, "IRQ work");
598 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
601 ret
= wl1271_ps_elp_wakeup(wl
, true);
605 spin_lock_irqsave(&wl
->wl_lock
, flags
);
606 while (test_bit(WL1271_FLAG_IRQ_PENDING
, &wl
->flags
) && loopcount
) {
607 clear_bit(WL1271_FLAG_IRQ_PENDING
, &wl
->flags
);
608 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
611 wl1271_fw_status(wl
, wl
->fw_status
);
612 intr
= le32_to_cpu(wl
->fw_status
->common
.intr
);
614 wl1271_debug(DEBUG_IRQ
, "Zero interrupt received.");
615 spin_lock_irqsave(&wl
->wl_lock
, flags
);
619 intr
&= WL1271_INTR_MASK
;
621 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
622 wl1271_error("watchdog interrupt received! "
623 "starting recovery.");
624 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
626 /* restarting the chip. ignore any other interrupt. */
630 if (intr
& WL1271_ACX_INTR_DATA
) {
631 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
633 /* check for tx results */
634 if (wl
->fw_status
->common
.tx_results_counter
!=
635 (wl
->tx_results_count
& 0xff))
636 wl1271_tx_complete(wl
);
638 /* Check if any tx blocks were freed */
639 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
640 wl
->tx_queue_count
) {
642 * In order to avoid starvation of the TX path,
643 * call the work function directly.
645 wl1271_tx_work_locked(wl
);
648 wl1271_rx(wl
, &wl
->fw_status
->common
);
651 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
652 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
653 wl1271_event_handle(wl
, 0);
656 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
657 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
658 wl1271_event_handle(wl
, 1);
661 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
662 wl1271_debug(DEBUG_IRQ
,
663 "WL1271_ACX_INTR_INIT_COMPLETE");
665 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
666 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
668 spin_lock_irqsave(&wl
->wl_lock
, flags
);
671 if (test_bit(WL1271_FLAG_IRQ_PENDING
, &wl
->flags
))
672 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
674 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
675 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
677 wl1271_ps_elp_sleep(wl
);
680 mutex_unlock(&wl
->mutex
);
683 static int wl1271_fetch_firmware(struct wl1271
*wl
)
685 const struct firmware
*fw
;
689 switch (wl
->bss_type
) {
690 case BSS_TYPE_AP_BSS
:
691 fw_name
= WL1271_AP_FW_NAME
;
694 case BSS_TYPE_STA_BSS
:
695 fw_name
= WL1271_FW_NAME
;
698 wl1271_error("no compatible firmware for bss_type %d",
703 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
705 ret
= request_firmware(&fw
, fw_name
, wl1271_wl_to_dev(wl
));
708 wl1271_error("could not get firmware: %d", ret
);
713 wl1271_error("firmware size is not multiple of 32 bits: %zu",
720 wl
->fw_len
= fw
->size
;
721 wl
->fw
= vmalloc(wl
->fw_len
);
724 wl1271_error("could not allocate memory for the firmware");
729 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
730 wl
->fw_bss_type
= wl
->bss_type
;
734 release_firmware(fw
);
739 static int wl1271_fetch_nvs(struct wl1271
*wl
)
741 const struct firmware
*fw
;
744 ret
= request_firmware(&fw
, WL1271_NVS_NAME
, wl1271_wl_to_dev(wl
));
747 wl1271_error("could not get nvs file: %d", ret
);
751 wl
->nvs
= kmemdup(fw
->data
, sizeof(struct wl1271_nvs_file
), GFP_KERNEL
);
754 wl1271_error("could not allocate memory for the nvs file");
759 wl
->nvs_len
= fw
->size
;
762 release_firmware(fw
);
767 static void wl1271_recovery_work(struct work_struct
*work
)
770 container_of(work
, struct wl1271
, recovery_work
);
772 mutex_lock(&wl
->mutex
);
774 if (wl
->state
!= WL1271_STATE_ON
)
777 wl1271_info("Hardware recovery in progress.");
779 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
780 ieee80211_connection_loss(wl
->vif
);
782 /* reboot the chipset */
783 __wl1271_op_remove_interface(wl
);
784 ieee80211_restart_hw(wl
->hw
);
787 mutex_unlock(&wl
->mutex
);
790 static void wl1271_fw_wakeup(struct wl1271
*wl
)
794 elp_reg
= ELPCTRL_WAKE_UP
;
795 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
798 static int wl1271_setup(struct wl1271
*wl
)
800 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
804 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
805 if (!wl
->tx_res_if
) {
806 kfree(wl
->fw_status
);
813 static int wl1271_chip_wakeup(struct wl1271
*wl
)
815 struct wl1271_partition_set partition
;
818 msleep(WL1271_PRE_POWER_ON_SLEEP
);
819 ret
= wl1271_power_on(wl
);
822 msleep(WL1271_POWER_ON_SLEEP
);
826 /* We don't need a real memory partition here, because we only want
827 * to use the registers at this point. */
828 memset(&partition
, 0, sizeof(partition
));
829 partition
.reg
.start
= REGISTERS_BASE
;
830 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
831 wl1271_set_partition(wl
, &partition
);
833 /* ELP module wake up */
834 wl1271_fw_wakeup(wl
);
836 /* whal_FwCtrl_BootSm() */
838 /* 0. read chip id from CHIP_ID */
839 wl
->chip
.id
= wl1271_read32(wl
, CHIP_ID_B
);
841 /* 1. check if chip id is valid */
843 switch (wl
->chip
.id
) {
844 case CHIP_ID_1271_PG10
:
845 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
848 ret
= wl1271_setup(wl
);
852 case CHIP_ID_1271_PG20
:
853 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
856 ret
= wl1271_setup(wl
);
861 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
866 /* Make sure the firmware type matches the BSS type */
867 if (wl
->fw
== NULL
|| wl
->fw_bss_type
!= wl
->bss_type
) {
868 ret
= wl1271_fetch_firmware(wl
);
873 /* No NVS from netlink, try to get it from the filesystem */
874 if (wl
->nvs
== NULL
) {
875 ret
= wl1271_fetch_nvs(wl
);
884 int wl1271_plt_start(struct wl1271
*wl
)
886 int retries
= WL1271_BOOT_RETRIES
;
889 mutex_lock(&wl
->mutex
);
891 wl1271_notice("power up");
893 if (wl
->state
!= WL1271_STATE_OFF
) {
894 wl1271_error("cannot go into PLT state because not "
895 "in off state: %d", wl
->state
);
900 wl
->bss_type
= BSS_TYPE_STA_BSS
;
904 ret
= wl1271_chip_wakeup(wl
);
908 ret
= wl1271_boot(wl
);
912 ret
= wl1271_plt_init(wl
);
916 wl
->state
= WL1271_STATE_PLT
;
917 wl1271_notice("firmware booted in PLT mode (%s)",
918 wl
->chip
.fw_ver_str
);
922 wl1271_disable_interrupts(wl
);
923 mutex_unlock(&wl
->mutex
);
924 /* Unlocking the mutex in the middle of handling is
925 inherently unsafe. In this case we deem it safe to do,
926 because we need to let any possibly pending IRQ out of
927 the system (and while we are WL1271_STATE_OFF the IRQ
928 work function will not do anything.) Also, any other
929 possible concurrent operations will fail due to the
930 current state, hence the wl1271 struct should be safe. */
931 cancel_work_sync(&wl
->irq_work
);
932 mutex_lock(&wl
->mutex
);
934 wl1271_power_off(wl
);
937 wl1271_error("firmware boot in PLT mode failed despite %d retries",
938 WL1271_BOOT_RETRIES
);
940 mutex_unlock(&wl
->mutex
);
945 int __wl1271_plt_stop(struct wl1271
*wl
)
949 wl1271_notice("power down");
951 if (wl
->state
!= WL1271_STATE_PLT
) {
952 wl1271_error("cannot power down because not in PLT "
953 "state: %d", wl
->state
);
958 wl1271_disable_interrupts(wl
);
959 wl1271_power_off(wl
);
961 wl
->state
= WL1271_STATE_OFF
;
964 mutex_unlock(&wl
->mutex
);
965 cancel_work_sync(&wl
->irq_work
);
966 cancel_work_sync(&wl
->recovery_work
);
967 mutex_lock(&wl
->mutex
);
972 int wl1271_plt_stop(struct wl1271
*wl
)
976 mutex_lock(&wl
->mutex
);
977 ret
= __wl1271_plt_stop(wl
);
978 mutex_unlock(&wl
->mutex
);
982 static int wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
984 struct wl1271
*wl
= hw
->priv
;
989 spin_lock_irqsave(&wl
->wl_lock
, flags
);
990 wl
->tx_queue_count
++;
993 * The workqueue is slow to process the tx_queue and we need stop
994 * the queue here, otherwise the queue will get too long.
996 if (wl
->tx_queue_count
>= WL1271_TX_QUEUE_HIGH_WATERMARK
) {
997 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues");
998 ieee80211_stop_queues(wl
->hw
);
999 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED
, &wl
->flags
);
1002 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1004 /* queue the packet */
1005 q
= wl1271_tx_get_queue(skb_get_queue_mapping(skb
));
1006 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
1007 hlid
= wl1271_tx_get_hlid(skb
);
1008 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d", hlid
, q
);
1009 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1011 skb_queue_tail(&wl
->tx_queue
[q
], skb
);
1015 * The chip specific setup must run before the first TX packet -
1016 * before that, the tx_work will not be initialized!
1019 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1020 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1022 return NETDEV_TX_OK
;
1025 static struct notifier_block wl1271_dev_notifier
= {
1026 .notifier_call
= wl1271_dev_notify
,
1029 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1031 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1034 * We have to delay the booting of the hardware because
1035 * we need to know the local MAC address before downloading and
1036 * initializing the firmware. The MAC address cannot be changed
1037 * after boot, and without the proper MAC address, the firmware
1038 * will not function properly.
1040 * The MAC address is first known when the corresponding interface
1041 * is added. That is where we will initialize the hardware.
1043 * In addition, we currently have different firmwares for AP and managed
1044 * operation. We will know which to boot according to interface type.
1050 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
1052 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1055 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1056 struct ieee80211_vif
*vif
)
1058 struct wl1271
*wl
= hw
->priv
;
1059 struct wiphy
*wiphy
= hw
->wiphy
;
1060 int retries
= WL1271_BOOT_RETRIES
;
1062 bool booted
= false;
1064 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1065 vif
->type
, vif
->addr
);
1067 mutex_lock(&wl
->mutex
);
1069 wl1271_debug(DEBUG_MAC80211
,
1070 "multiple vifs are not supported yet");
1075 switch (vif
->type
) {
1076 case NL80211_IFTYPE_STATION
:
1077 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1078 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1080 case NL80211_IFTYPE_ADHOC
:
1081 wl
->bss_type
= BSS_TYPE_IBSS
;
1082 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1084 case NL80211_IFTYPE_AP
:
1085 wl
->bss_type
= BSS_TYPE_AP_BSS
;
1092 memcpy(wl
->mac_addr
, vif
->addr
, ETH_ALEN
);
1094 if (wl
->state
!= WL1271_STATE_OFF
) {
1095 wl1271_error("cannot start because not in off state: %d",
1103 ret
= wl1271_chip_wakeup(wl
);
1107 ret
= wl1271_boot(wl
);
1111 ret
= wl1271_hw_init(wl
);
1119 wl1271_disable_interrupts(wl
);
1120 mutex_unlock(&wl
->mutex
);
1121 /* Unlocking the mutex in the middle of handling is
1122 inherently unsafe. In this case we deem it safe to do,
1123 because we need to let any possibly pending IRQ out of
1124 the system (and while we are WL1271_STATE_OFF the IRQ
1125 work function will not do anything.) Also, any other
1126 possible concurrent operations will fail due to the
1127 current state, hence the wl1271 struct should be safe. */
1128 cancel_work_sync(&wl
->irq_work
);
1129 mutex_lock(&wl
->mutex
);
1131 wl1271_power_off(wl
);
1135 wl1271_error("firmware boot failed despite %d retries",
1136 WL1271_BOOT_RETRIES
);
1141 wl
->state
= WL1271_STATE_ON
;
1142 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
1144 /* update hw/fw version info in wiphy struct */
1145 wiphy
->hw_version
= wl
->chip
.id
;
1146 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1147 sizeof(wiphy
->fw_version
));
1150 * Now we know if 11a is supported (info from the NVS), so disable
1151 * 11a channels if not supported
1153 if (!wl
->enable_11a
)
1154 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
1156 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
1157 wl
->enable_11a
? "" : "not ");
1160 mutex_unlock(&wl
->mutex
);
1163 list_add(&wl
->list
, &wl_list
);
1168 static void __wl1271_op_remove_interface(struct wl1271
*wl
)
1172 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
1174 wl1271_info("down");
1176 list_del(&wl
->list
);
1178 WARN_ON(wl
->state
!= WL1271_STATE_ON
);
1180 /* enable dyn ps just in case (if left on due to fw crash etc) */
1181 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1182 ieee80211_enable_dyn_ps(wl
->vif
);
1184 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
1185 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
1186 kfree(wl
->scan
.scanned_ch
);
1187 wl
->scan
.scanned_ch
= NULL
;
1188 wl
->scan
.req
= NULL
;
1189 ieee80211_scan_completed(wl
->hw
, true);
1192 wl
->state
= WL1271_STATE_OFF
;
1194 wl1271_disable_interrupts(wl
);
1196 mutex_unlock(&wl
->mutex
);
1198 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1199 cancel_work_sync(&wl
->irq_work
);
1200 cancel_work_sync(&wl
->tx_work
);
1201 cancel_delayed_work_sync(&wl
->pspoll_work
);
1202 cancel_delayed_work_sync(&wl
->elp_work
);
1204 mutex_lock(&wl
->mutex
);
1206 /* let's notify MAC80211 about the remaining pending TX frames */
1207 wl1271_tx_reset(wl
);
1208 wl1271_power_off(wl
);
1210 memset(wl
->bssid
, 0, ETH_ALEN
);
1211 memset(wl
->ssid
, 0, IW_ESSID_MAX_SIZE
+ 1);
1213 wl
->bss_type
= MAX_BSS_TYPE
;
1214 wl
->set_bss_type
= MAX_BSS_TYPE
;
1215 wl
->band
= IEEE80211_BAND_2GHZ
;
1218 wl
->psm_entry_retry
= 0;
1219 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1220 wl
->tx_blocks_available
= 0;
1221 wl
->tx_results_count
= 0;
1222 wl
->tx_packets_count
= 0;
1223 wl
->tx_security_last_seq
= 0;
1224 wl
->tx_security_seq
= 0;
1225 wl
->time_offset
= 0;
1226 wl
->session_counter
= 0;
1227 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1231 wl1271_free_ap_keys(wl
);
1232 memset(wl
->ap_hlid_map
, 0, sizeof(wl
->ap_hlid_map
));
1234 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
1235 wl
->tx_blocks_freed
[i
] = 0;
1237 wl1271_debugfs_reset(wl
);
1239 kfree(wl
->fw_status
);
1240 wl
->fw_status
= NULL
;
1241 kfree(wl
->tx_res_if
);
1242 wl
->tx_res_if
= NULL
;
1243 kfree(wl
->target_mem_map
);
1244 wl
->target_mem_map
= NULL
;
1247 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
1248 struct ieee80211_vif
*vif
)
1250 struct wl1271
*wl
= hw
->priv
;
1252 mutex_lock(&wl
->mutex
);
1254 * wl->vif can be null here if someone shuts down the interface
1255 * just when hardware recovery has been started.
1258 WARN_ON(wl
->vif
!= vif
);
1259 __wl1271_op_remove_interface(wl
);
1262 mutex_unlock(&wl
->mutex
);
1263 cancel_work_sync(&wl
->recovery_work
);
1266 static void wl1271_configure_filters(struct wl1271
*wl
, unsigned int filters
)
1268 wl1271_set_default_filters(wl
);
1270 /* combine requested filters with current filter config */
1271 filters
= wl
->filters
| filters
;
1273 wl1271_debug(DEBUG_FILTERS
, "RX filters set: ");
1275 if (filters
& FIF_PROMISC_IN_BSS
) {
1276 wl1271_debug(DEBUG_FILTERS
, " - FIF_PROMISC_IN_BSS");
1277 wl
->rx_config
&= ~CFG_UNI_FILTER_EN
;
1278 wl
->rx_config
|= CFG_BSSID_FILTER_EN
;
1280 if (filters
& FIF_BCN_PRBRESP_PROMISC
) {
1281 wl1271_debug(DEBUG_FILTERS
, " - FIF_BCN_PRBRESP_PROMISC");
1282 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1283 wl
->rx_config
&= ~CFG_SSID_FILTER_EN
;
1285 if (filters
& FIF_OTHER_BSS
) {
1286 wl1271_debug(DEBUG_FILTERS
, " - FIF_OTHER_BSS");
1287 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1289 if (filters
& FIF_CONTROL
) {
1290 wl1271_debug(DEBUG_FILTERS
, " - FIF_CONTROL");
1291 wl
->rx_filter
|= CFG_RX_CTL_EN
;
1293 if (filters
& FIF_FCSFAIL
) {
1294 wl1271_debug(DEBUG_FILTERS
, " - FIF_FCSFAIL");
1295 wl
->rx_filter
|= CFG_RX_FCS_ERROR
;
1299 static int wl1271_dummy_join(struct wl1271
*wl
)
1302 /* we need to use a dummy BSSID for now */
1303 static const u8 dummy_bssid
[ETH_ALEN
] = { 0x0b, 0xad, 0xde,
1306 memcpy(wl
->bssid
, dummy_bssid
, ETH_ALEN
);
1308 /* pass through frames from all BSS */
1309 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
1311 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
1315 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1321 static int wl1271_join(struct wl1271
*wl
, bool set_assoc
)
1326 * One of the side effects of the JOIN command is that is clears
1327 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1328 * to a WPA/WPA2 access point will therefore kill the data-path.
1329 * Currently there is no supported scenario for JOIN during
1330 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1331 * must be handled somehow.
1334 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1335 wl1271_info("JOIN while associated.");
1338 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
1340 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
1344 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1346 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1350 * The join command disable the keep-alive mode, shut down its process,
1351 * and also clear the template config, so we need to reset it all after
1352 * the join. The acx_aid starts the keep-alive process, and the order
1353 * of the commands below is relevant.
1355 ret
= wl1271_acx_keep_alive_mode(wl
, true);
1359 ret
= wl1271_acx_aid(wl
, wl
->aid
);
1363 ret
= wl1271_cmd_build_klv_null_data(wl
);
1367 ret
= wl1271_acx_keep_alive_config(wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
1368 ACX_KEEP_ALIVE_TPL_VALID
);
1376 static int wl1271_unjoin(struct wl1271
*wl
)
1380 /* to stop listening to a channel, we disconnect */
1381 ret
= wl1271_cmd_disconnect(wl
);
1385 clear_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1386 memset(wl
->bssid
, 0, ETH_ALEN
);
1388 /* stop filterting packets based on bssid */
1389 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
1395 static void wl1271_set_band_rate(struct wl1271
*wl
)
1397 if (wl
->band
== IEEE80211_BAND_2GHZ
)
1398 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate
;
1400 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate_5
;
1403 static int wl1271_sta_handle_idle(struct wl1271
*wl
, bool idle
)
1408 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
1409 ret
= wl1271_unjoin(wl
);
1413 wl
->rate_set
= wl1271_tx_min_rate_get(wl
);
1414 ret
= wl1271_acx_sta_rate_policies(wl
);
1417 ret
= wl1271_acx_keep_alive_config(
1418 wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
1419 ACX_KEEP_ALIVE_TPL_INVALID
);
1422 set_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
1424 /* increment the session counter */
1425 wl
->session_counter
++;
1426 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
1427 wl
->session_counter
= 0;
1428 ret
= wl1271_dummy_join(wl
);
1431 clear_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
1438 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
1440 struct wl1271
*wl
= hw
->priv
;
1441 struct ieee80211_conf
*conf
= &hw
->conf
;
1442 int channel
, ret
= 0;
1445 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
1447 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s"
1450 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
1452 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
1456 * mac80211 will go to idle nearly immediately after transmitting some
1457 * frames, such as the deauth. To make sure those frames reach the air,
1458 * wait here until the TX queue is fully flushed.
1460 if ((changed
& IEEE80211_CONF_CHANGE_IDLE
) &&
1461 (conf
->flags
& IEEE80211_CONF_IDLE
))
1462 wl1271_tx_flush(wl
);
1464 mutex_lock(&wl
->mutex
);
1466 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
1471 is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
1473 ret
= wl1271_ps_elp_wakeup(wl
, false);
1477 /* if the channel changes while joined, join again */
1478 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
&&
1479 ((wl
->band
!= conf
->channel
->band
) ||
1480 (wl
->channel
!= channel
))) {
1481 wl
->band
= conf
->channel
->band
;
1482 wl
->channel
= channel
;
1486 * FIXME: the mac80211 should really provide a fixed
1487 * rate to use here. for now, just use the smallest
1488 * possible rate for the band as a fixed rate for
1489 * association frames and other control messages.
1491 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1492 wl1271_set_band_rate(wl
);
1494 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
1495 ret
= wl1271_acx_sta_rate_policies(wl
);
1497 wl1271_warning("rate policy for channel "
1500 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
1501 ret
= wl1271_join(wl
, false);
1503 wl1271_warning("cmd join on channel "
1509 if (changed
& IEEE80211_CONF_CHANGE_IDLE
&& !is_ap
) {
1510 ret
= wl1271_sta_handle_idle(wl
,
1511 conf
->flags
& IEEE80211_CONF_IDLE
);
1513 wl1271_warning("idle mode change failed %d", ret
);
1517 * if mac80211 changes the PSM mode, make sure the mode is not
1518 * incorrectly changed after the pspoll failure active window.
1520 if (changed
& IEEE80211_CONF_CHANGE_PS
)
1521 clear_bit(WL1271_FLAG_PSPOLL_FAILURE
, &wl
->flags
);
1523 if (conf
->flags
& IEEE80211_CONF_PS
&&
1524 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1525 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1528 * We enter PSM only if we're already associated.
1529 * If we're not, we'll enter it when joining an SSID,
1530 * through the bss_info_changed() hook.
1532 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
1533 wl1271_debug(DEBUG_PSM
, "psm enabled");
1534 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
1535 wl
->basic_rate
, true);
1537 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
1538 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1539 wl1271_debug(DEBUG_PSM
, "psm disabled");
1541 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1543 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
1544 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
1545 wl
->basic_rate
, true);
1548 if (conf
->power_level
!= wl
->power_level
) {
1549 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
1553 wl
->power_level
= conf
->power_level
;
1557 wl1271_ps_elp_sleep(wl
);
1560 mutex_unlock(&wl
->mutex
);
1565 struct wl1271_filter_params
{
1568 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
1571 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
1572 struct netdev_hw_addr_list
*mc_list
)
1574 struct wl1271_filter_params
*fp
;
1575 struct netdev_hw_addr
*ha
;
1576 struct wl1271
*wl
= hw
->priv
;
1578 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
1581 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
1583 wl1271_error("Out of memory setting filters.");
1587 /* update multicast filtering parameters */
1588 fp
->mc_list_length
= 0;
1589 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
1590 fp
->enabled
= false;
1593 netdev_hw_addr_list_for_each(ha
, mc_list
) {
1594 memcpy(fp
->mc_list
[fp
->mc_list_length
],
1595 ha
->addr
, ETH_ALEN
);
1596 fp
->mc_list_length
++;
1600 return (u64
)(unsigned long)fp
;
1603 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1606 FIF_BCN_PRBRESP_PROMISC | \
1610 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
1611 unsigned int changed
,
1612 unsigned int *total
, u64 multicast
)
1614 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
1615 struct wl1271
*wl
= hw
->priv
;
1618 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
1619 " total %x", changed
, *total
);
1621 mutex_lock(&wl
->mutex
);
1623 *total
&= WL1271_SUPPORTED_FILTERS
;
1624 changed
&= WL1271_SUPPORTED_FILTERS
;
1626 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
1629 ret
= wl1271_ps_elp_wakeup(wl
, false);
1633 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
) {
1634 if (*total
& FIF_ALLMULTI
)
1635 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
1637 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
1639 fp
->mc_list_length
);
1644 /* determine, whether supported filter values have changed */
1648 /* configure filters */
1649 wl
->filters
= *total
;
1650 wl1271_configure_filters(wl
, 0);
1652 /* apply configured filters */
1653 ret
= wl1271_acx_rx_config(wl
, wl
->rx_config
, wl
->rx_filter
);
1658 wl1271_ps_elp_sleep(wl
);
1661 mutex_unlock(&wl
->mutex
);
1665 static int wl1271_record_ap_key(struct wl1271
*wl
, u8 id
, u8 key_type
,
1666 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
1669 struct wl1271_ap_key
*ap_key
;
1672 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
1674 if (key_size
> MAX_KEY_SIZE
)
1678 * Find next free entry in ap_keys. Also check we are not replacing
1681 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
1682 if (wl
->recorded_ap_keys
[i
] == NULL
)
1685 if (wl
->recorded_ap_keys
[i
]->id
== id
) {
1686 wl1271_warning("trying to record key replacement");
1691 if (i
== MAX_NUM_KEYS
)
1694 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
1699 ap_key
->key_type
= key_type
;
1700 ap_key
->key_size
= key_size
;
1701 memcpy(ap_key
->key
, key
, key_size
);
1702 ap_key
->hlid
= hlid
;
1703 ap_key
->tx_seq_32
= tx_seq_32
;
1704 ap_key
->tx_seq_16
= tx_seq_16
;
1706 wl
->recorded_ap_keys
[i
] = ap_key
;
1710 static void wl1271_free_ap_keys(struct wl1271
*wl
)
1714 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
1715 kfree(wl
->recorded_ap_keys
[i
]);
1716 wl
->recorded_ap_keys
[i
] = NULL
;
1720 static int wl1271_ap_init_hwenc(struct wl1271
*wl
)
1723 struct wl1271_ap_key
*key
;
1724 bool wep_key_added
= false;
1726 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
1727 if (wl
->recorded_ap_keys
[i
] == NULL
)
1730 key
= wl
->recorded_ap_keys
[i
];
1731 ret
= wl1271_cmd_set_ap_key(wl
, KEY_ADD_OR_REPLACE
,
1732 key
->id
, key
->key_type
,
1733 key
->key_size
, key
->key
,
1734 key
->hlid
, key
->tx_seq_32
,
1739 if (key
->key_type
== KEY_WEP
)
1740 wep_key_added
= true;
1743 if (wep_key_added
) {
1744 ret
= wl1271_cmd_set_ap_default_wep_key(wl
, wl
->default_key
);
1750 wl1271_free_ap_keys(wl
);
1754 static int wl1271_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
1755 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
1756 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
1759 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
1762 struct wl1271_station
*wl_sta
;
1766 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
1767 hlid
= wl_sta
->hlid
;
1769 hlid
= WL1271_AP_BROADCAST_HLID
;
1772 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
1774 * We do not support removing keys after AP shutdown.
1775 * Pretend we do to make mac80211 happy.
1777 if (action
!= KEY_ADD_OR_REPLACE
)
1780 ret
= wl1271_record_ap_key(wl
, id
,
1782 key
, hlid
, tx_seq_32
,
1785 ret
= wl1271_cmd_set_ap_key(wl
, action
,
1786 id
, key_type
, key_size
,
1787 key
, hlid
, tx_seq_32
,
1795 static const u8 bcast_addr
[ETH_ALEN
] = {
1796 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
1799 addr
= sta
? sta
->addr
: bcast_addr
;
1801 if (is_zero_ether_addr(addr
)) {
1802 /* We dont support TX only encryption */
1806 /* The wl1271 does not allow to remove unicast keys - they
1807 will be cleared automatically on next CMD_JOIN. Ignore the
1808 request silently, as we dont want the mac80211 to emit
1809 an error message. */
1810 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
1813 ret
= wl1271_cmd_set_sta_key(wl
, action
,
1814 id
, key_type
, key_size
,
1815 key
, addr
, tx_seq_32
,
1820 /* the default WEP key needs to be configured at least once */
1821 if (key_type
== KEY_WEP
) {
1822 ret
= wl1271_cmd_set_sta_default_wep_key(wl
,
1832 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
1833 struct ieee80211_vif
*vif
,
1834 struct ieee80211_sta
*sta
,
1835 struct ieee80211_key_conf
*key_conf
)
1837 struct wl1271
*wl
= hw
->priv
;
1843 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
1845 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
1846 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1847 key_conf
->cipher
, key_conf
->keyidx
,
1848 key_conf
->keylen
, key_conf
->flags
);
1849 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
1851 mutex_lock(&wl
->mutex
);
1853 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
1858 ret
= wl1271_ps_elp_wakeup(wl
, false);
1862 switch (key_conf
->cipher
) {
1863 case WLAN_CIPHER_SUITE_WEP40
:
1864 case WLAN_CIPHER_SUITE_WEP104
:
1867 key_conf
->hw_key_idx
= key_conf
->keyidx
;
1869 case WLAN_CIPHER_SUITE_TKIP
:
1870 key_type
= KEY_TKIP
;
1872 key_conf
->hw_key_idx
= key_conf
->keyidx
;
1873 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
1874 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
1876 case WLAN_CIPHER_SUITE_CCMP
:
1879 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
1880 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
1881 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
1883 case WL1271_CIPHER_SUITE_GEM
:
1885 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
1886 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
1889 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
1897 ret
= wl1271_set_key(wl
, KEY_ADD_OR_REPLACE
,
1898 key_conf
->keyidx
, key_type
,
1899 key_conf
->keylen
, key_conf
->key
,
1900 tx_seq_32
, tx_seq_16
, sta
);
1902 wl1271_error("Could not add or replace key");
1908 ret
= wl1271_set_key(wl
, KEY_REMOVE
,
1909 key_conf
->keyidx
, key_type
,
1910 key_conf
->keylen
, key_conf
->key
,
1913 wl1271_error("Could not remove key");
1919 wl1271_error("Unsupported key cmd 0x%x", cmd
);
1925 wl1271_ps_elp_sleep(wl
);
1928 mutex_unlock(&wl
->mutex
);
1933 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
1934 struct ieee80211_vif
*vif
,
1935 struct cfg80211_scan_request
*req
)
1937 struct wl1271
*wl
= hw
->priv
;
1942 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
1945 ssid
= req
->ssids
[0].ssid
;
1946 len
= req
->ssids
[0].ssid_len
;
1949 mutex_lock(&wl
->mutex
);
1951 if (wl
->state
== WL1271_STATE_OFF
) {
1953 * We cannot return -EBUSY here because cfg80211 will expect
1954 * a call to ieee80211_scan_completed if we do - in this case
1955 * there won't be any call.
1961 ret
= wl1271_ps_elp_wakeup(wl
, false);
1965 ret
= wl1271_scan(hw
->priv
, ssid
, len
, req
);
1967 wl1271_ps_elp_sleep(wl
);
1970 mutex_unlock(&wl
->mutex
);
1975 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
1977 struct wl1271
*wl
= hw
->priv
;
1980 mutex_lock(&wl
->mutex
);
1982 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
1987 ret
= wl1271_ps_elp_wakeup(wl
, false);
1991 ret
= wl1271_acx_frag_threshold(wl
, (u16
)value
);
1993 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
1995 wl1271_ps_elp_sleep(wl
);
1998 mutex_unlock(&wl
->mutex
);
2003 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
2005 struct wl1271
*wl
= hw
->priv
;
2008 mutex_lock(&wl
->mutex
);
2010 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2015 ret
= wl1271_ps_elp_wakeup(wl
, false);
2019 ret
= wl1271_acx_rts_threshold(wl
, (u16
) value
);
2021 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
2023 wl1271_ps_elp_sleep(wl
);
2026 mutex_unlock(&wl
->mutex
);
2031 static int wl1271_ssid_set(struct wl1271
*wl
, struct sk_buff
*skb
,
2034 u8
*ptr
= skb
->data
+ offset
;
2036 /* find the location of the ssid in the beacon */
2037 while (ptr
< skb
->data
+ skb
->len
) {
2038 if (ptr
[0] == WLAN_EID_SSID
) {
2039 wl
->ssid_len
= ptr
[1];
2040 memcpy(wl
->ssid
, ptr
+2, wl
->ssid_len
);
2043 ptr
+= (ptr
[1] + 2);
2046 wl1271_error("No SSID in IEs!\n");
2050 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
2051 struct ieee80211_bss_conf
*bss_conf
,
2056 if (changed
& BSS_CHANGED_ERP_SLOT
) {
2057 if (bss_conf
->use_short_slot
)
2058 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
2060 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
2062 wl1271_warning("Set slot time failed %d", ret
);
2067 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
2068 if (bss_conf
->use_short_preamble
)
2069 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
2071 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
2074 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
2075 if (bss_conf
->use_cts_prot
)
2076 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
2078 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
2080 wl1271_warning("Set ctsprotect failed %d", ret
);
2089 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
2090 struct ieee80211_vif
*vif
,
2091 struct ieee80211_bss_conf
*bss_conf
,
2094 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2097 if ((changed
& BSS_CHANGED_BEACON_INT
)) {
2098 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
2099 bss_conf
->beacon_int
);
2101 wl
->beacon_int
= bss_conf
->beacon_int
;
2104 if ((changed
& BSS_CHANGED_BEACON
)) {
2105 struct ieee80211_hdr
*hdr
;
2106 int ieoffset
= offsetof(struct ieee80211_mgmt
,
2108 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
2114 wl1271_debug(DEBUG_MASTER
, "beacon updated");
2116 ret
= wl1271_ssid_set(wl
, beacon
, ieoffset
);
2118 dev_kfree_skb(beacon
);
2121 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
2123 ret
= wl1271_cmd_template_set(wl
, tmpl_id
,
2126 wl1271_tx_min_rate_get(wl
));
2128 dev_kfree_skb(beacon
);
2132 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
2133 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
2134 IEEE80211_STYPE_PROBE_RESP
);
2136 tmpl_id
= is_ap
? CMD_TEMPL_AP_PROBE_RESPONSE
:
2137 CMD_TEMPL_PROBE_RESPONSE
;
2138 ret
= wl1271_cmd_template_set(wl
,
2142 wl1271_tx_min_rate_get(wl
));
2143 dev_kfree_skb(beacon
);
2152 /* AP mode changes */
2153 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
2154 struct ieee80211_vif
*vif
,
2155 struct ieee80211_bss_conf
*bss_conf
,
2160 if ((changed
& BSS_CHANGED_BASIC_RATES
)) {
2161 u32 rates
= bss_conf
->basic_rates
;
2162 struct conf_tx_rate_class mgmt_rc
;
2164 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
);
2165 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2166 wl1271_debug(DEBUG_AP
, "basic rates: 0x%x",
2167 wl
->basic_rate_set
);
2169 /* update the AP management rate policy with the new rates */
2170 mgmt_rc
.enabled_rates
= wl
->basic_rate_set
;
2171 mgmt_rc
.long_retry_limit
= 10;
2172 mgmt_rc
.short_retry_limit
= 10;
2174 ret
= wl1271_acx_ap_rate_policy(wl
, &mgmt_rc
,
2175 ACX_TX_AP_MODE_MGMT_RATE
);
2177 wl1271_error("AP mgmt policy change failed %d", ret
);
2182 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
2186 if ((changed
& BSS_CHANGED_BEACON_ENABLED
)) {
2187 if (bss_conf
->enable_beacon
) {
2188 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2189 ret
= wl1271_cmd_start_bss(wl
);
2193 set_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
2194 wl1271_debug(DEBUG_AP
, "started AP");
2196 ret
= wl1271_ap_init_hwenc(wl
);
2201 if (test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2202 ret
= wl1271_cmd_stop_bss(wl
);
2206 clear_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
2207 wl1271_debug(DEBUG_AP
, "stopped AP");
2212 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
2219 /* STA/IBSS mode changes */
2220 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
2221 struct ieee80211_vif
*vif
,
2222 struct ieee80211_bss_conf
*bss_conf
,
2225 bool do_join
= false, set_assoc
= false;
2226 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
2227 u32 sta_rate_set
= 0;
2229 struct ieee80211_sta
*sta
;
2230 bool sta_exists
= false;
2231 struct ieee80211_sta_ht_cap sta_ht_cap
;
2234 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
2240 if ((changed
& BSS_CHANGED_BEACON_INT
) && is_ibss
)
2243 /* Need to update the SSID (for filtering etc) */
2244 if ((changed
& BSS_CHANGED_BEACON
) && is_ibss
)
2247 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && is_ibss
) {
2248 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
2249 bss_conf
->enable_beacon
? "enabled" : "disabled");
2251 if (bss_conf
->enable_beacon
)
2252 wl
->set_bss_type
= BSS_TYPE_IBSS
;
2254 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
2258 if ((changed
& BSS_CHANGED_CQM
)) {
2259 bool enable
= false;
2260 if (bss_conf
->cqm_rssi_thold
)
2262 ret
= wl1271_acx_rssi_snr_trigger(wl
, enable
,
2263 bss_conf
->cqm_rssi_thold
,
2264 bss_conf
->cqm_rssi_hyst
);
2267 wl
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
2270 if ((changed
& BSS_CHANGED_BSSID
) &&
2272 * Now we know the correct bssid, so we send a new join command
2273 * and enable the BSSID filter
2275 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
2276 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
2278 if (!is_zero_ether_addr(wl
->bssid
)) {
2279 ret
= wl1271_cmd_build_null_data(wl
);
2283 ret
= wl1271_build_qos_null_data(wl
);
2287 /* filter out all packets not from this BSSID */
2288 wl1271_configure_filters(wl
, 0);
2290 /* Need to update the BSSID (for filtering etc) */
2296 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
2298 /* save the supp_rates of the ap */
2299 sta_rate_set
= sta
->supp_rates
[wl
->hw
->conf
.channel
->band
];
2300 if (sta
->ht_cap
.ht_supported
)
2302 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
);
2303 sta_ht_cap
= sta
->ht_cap
;
2309 /* handle new association with HT and HT information change */
2310 if ((changed
& BSS_CHANGED_HT
) &&
2311 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
2312 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
2315 wl1271_warning("Set ht cap true failed %d",
2319 ret
= wl1271_acx_set_ht_information(wl
,
2320 bss_conf
->ht_operation_mode
);
2322 wl1271_warning("Set ht information failed %d",
2327 /* handle new association without HT and disassociation */
2328 else if (changed
& BSS_CHANGED_ASSOC
) {
2329 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
2332 wl1271_warning("Set ht cap false failed %d",
2339 if ((changed
& BSS_CHANGED_ASSOC
)) {
2340 if (bss_conf
->assoc
) {
2343 wl
->aid
= bss_conf
->aid
;
2346 wl
->ps_poll_failures
= 0;
2349 * use basic rates from AP, and determine lowest rate
2350 * to use with control frames.
2352 rates
= bss_conf
->basic_rates
;
2353 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
2355 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2357 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
,
2359 ret
= wl1271_acx_sta_rate_policies(wl
);
2364 * with wl1271, we don't need to update the
2365 * beacon_int and dtim_period, because the firmware
2366 * updates it by itself when the first beacon is
2367 * received after a join.
2369 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
2374 * Get a template for hardware connection maintenance
2376 dev_kfree_skb(wl
->probereq
);
2377 wl
->probereq
= wl1271_cmd_build_ap_probe_req(wl
, NULL
);
2378 ieoffset
= offsetof(struct ieee80211_mgmt
,
2379 u
.probe_req
.variable
);
2380 wl1271_ssid_set(wl
, wl
->probereq
, ieoffset
);
2382 /* enable the connection monitoring feature */
2383 ret
= wl1271_acx_conn_monit_params(wl
, true);
2387 /* If we want to go in PSM but we're not there yet */
2388 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
2389 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
2390 enum wl1271_cmd_ps_mode mode
;
2392 mode
= STATION_POWER_SAVE_MODE
;
2393 ret
= wl1271_ps_set_mode(wl
, mode
,
2400 /* use defaults when not associated */
2401 clear_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
);
2402 clear_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
2405 /* free probe-request template */
2406 dev_kfree_skb(wl
->probereq
);
2407 wl
->probereq
= NULL
;
2409 /* re-enable dynamic ps - just in case */
2410 ieee80211_enable_dyn_ps(wl
->vif
);
2412 /* revert back to minimum rates for the current band */
2413 wl1271_set_band_rate(wl
);
2414 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2415 ret
= wl1271_acx_sta_rate_policies(wl
);
2419 /* disable connection monitor features */
2420 ret
= wl1271_acx_conn_monit_params(wl
, false);
2422 /* Disable the keep-alive feature */
2423 ret
= wl1271_acx_keep_alive_mode(wl
, false);
2427 /* restore the bssid filter and go to dummy bssid */
2429 wl1271_dummy_join(wl
);
2433 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
2437 if (changed
& BSS_CHANGED_ARP_FILTER
) {
2438 __be32 addr
= bss_conf
->arp_addr_list
[0];
2439 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
2441 if (bss_conf
->arp_addr_cnt
== 1 &&
2442 bss_conf
->arp_filter_enabled
) {
2444 * The template should have been configured only upon
2445 * association. however, it seems that the correct ip
2446 * isn't being set (when sending), so we have to
2447 * reconfigure the template upon every ip change.
2449 ret
= wl1271_cmd_build_arp_rsp(wl
, addr
);
2451 wl1271_warning("build arp rsp failed: %d", ret
);
2455 ret
= wl1271_acx_arp_ip_filter(wl
,
2456 ACX_ARP_FILTER_ARP_FILTERING
,
2459 ret
= wl1271_acx_arp_ip_filter(wl
, 0, addr
);
2466 ret
= wl1271_join(wl
, set_assoc
);
2468 wl1271_warning("cmd join failed %d", ret
);
2477 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
2478 struct ieee80211_vif
*vif
,
2479 struct ieee80211_bss_conf
*bss_conf
,
2482 struct wl1271
*wl
= hw
->priv
;
2483 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2486 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed 0x%x",
2489 mutex_lock(&wl
->mutex
);
2491 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2494 ret
= wl1271_ps_elp_wakeup(wl
, false);
2499 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
2501 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
2503 wl1271_ps_elp_sleep(wl
);
2506 mutex_unlock(&wl
->mutex
);
2509 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
, u16 queue
,
2510 const struct ieee80211_tx_queue_params
*params
)
2512 struct wl1271
*wl
= hw
->priv
;
2516 mutex_lock(&wl
->mutex
);
2518 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
2521 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
2523 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
2525 if (wl
->state
== WL1271_STATE_OFF
) {
2527 * If the state is off, the parameters will be recorded and
2528 * configured on init. This happens in AP-mode.
2530 struct conf_tx_ac_category
*conf_ac
=
2531 &wl
->conf
.tx
.ac_conf
[wl1271_tx_get_queue(queue
)];
2532 struct conf_tx_tid
*conf_tid
=
2533 &wl
->conf
.tx
.tid_conf
[wl1271_tx_get_queue(queue
)];
2535 conf_ac
->ac
= wl1271_tx_get_queue(queue
);
2536 conf_ac
->cw_min
= (u8
)params
->cw_min
;
2537 conf_ac
->cw_max
= params
->cw_max
;
2538 conf_ac
->aifsn
= params
->aifs
;
2539 conf_ac
->tx_op_limit
= params
->txop
<< 5;
2541 conf_tid
->queue_id
= wl1271_tx_get_queue(queue
);
2542 conf_tid
->channel_type
= CONF_CHANNEL_TYPE_EDCF
;
2543 conf_tid
->tsid
= wl1271_tx_get_queue(queue
);
2544 conf_tid
->ps_scheme
= ps_scheme
;
2545 conf_tid
->ack_policy
= CONF_ACK_POLICY_LEGACY
;
2546 conf_tid
->apsd_conf
[0] = 0;
2547 conf_tid
->apsd_conf
[1] = 0;
2549 ret
= wl1271_ps_elp_wakeup(wl
, false);
2554 * the txop is confed in units of 32us by the mac80211,
2557 ret
= wl1271_acx_ac_cfg(wl
, wl1271_tx_get_queue(queue
),
2558 params
->cw_min
, params
->cw_max
,
2559 params
->aifs
, params
->txop
<< 5);
2563 ret
= wl1271_acx_tid_cfg(wl
, wl1271_tx_get_queue(queue
),
2564 CONF_CHANNEL_TYPE_EDCF
,
2565 wl1271_tx_get_queue(queue
),
2566 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
2572 wl1271_ps_elp_sleep(wl
);
2576 mutex_unlock(&wl
->mutex
);
2581 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
)
2584 struct wl1271
*wl
= hw
->priv
;
2585 u64 mactime
= ULLONG_MAX
;
2588 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
2590 mutex_lock(&wl
->mutex
);
2592 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2595 ret
= wl1271_ps_elp_wakeup(wl
, false);
2599 ret
= wl1271_acx_tsf_info(wl
, &mactime
);
2604 wl1271_ps_elp_sleep(wl
);
2607 mutex_unlock(&wl
->mutex
);
2611 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
2612 struct survey_info
*survey
)
2614 struct wl1271
*wl
= hw
->priv
;
2615 struct ieee80211_conf
*conf
= &hw
->conf
;
2620 survey
->channel
= conf
->channel
;
2621 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
2622 survey
->noise
= wl
->noise
;
2627 static int wl1271_allocate_hlid(struct wl1271
*wl
,
2628 struct ieee80211_sta
*sta
,
2631 struct wl1271_station
*wl_sta
;
2634 id
= find_first_zero_bit(wl
->ap_hlid_map
, AP_MAX_STATIONS
);
2635 if (id
>= AP_MAX_STATIONS
) {
2636 wl1271_warning("could not allocate HLID - too much stations");
2640 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2642 __set_bit(id
, wl
->ap_hlid_map
);
2643 wl_sta
->hlid
= WL1271_AP_STA_HLID_START
+ id
;
2644 *hlid
= wl_sta
->hlid
;
2648 static void wl1271_free_hlid(struct wl1271
*wl
, u8 hlid
)
2650 int id
= hlid
- WL1271_AP_STA_HLID_START
;
2652 __clear_bit(id
, wl
->ap_hlid_map
);
2653 wl1271_tx_reset_link_queues(wl
, hlid
);
2656 static int wl1271_op_sta_add(struct ieee80211_hw
*hw
,
2657 struct ieee80211_vif
*vif
,
2658 struct ieee80211_sta
*sta
)
2660 struct wl1271
*wl
= hw
->priv
;
2664 mutex_lock(&wl
->mutex
);
2666 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2669 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
2672 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
2674 ret
= wl1271_allocate_hlid(wl
, sta
, &hlid
);
2678 ret
= wl1271_ps_elp_wakeup(wl
, false);
2682 ret
= wl1271_cmd_add_sta(wl
, sta
, hlid
);
2687 wl1271_ps_elp_sleep(wl
);
2690 mutex_unlock(&wl
->mutex
);
2694 static int wl1271_op_sta_remove(struct ieee80211_hw
*hw
,
2695 struct ieee80211_vif
*vif
,
2696 struct ieee80211_sta
*sta
)
2698 struct wl1271
*wl
= hw
->priv
;
2699 struct wl1271_station
*wl_sta
;
2702 mutex_lock(&wl
->mutex
);
2704 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2707 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
2710 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
2712 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2713 id
= wl_sta
->hlid
- WL1271_AP_STA_HLID_START
;
2714 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
2717 ret
= wl1271_ps_elp_wakeup(wl
, false);
2721 ret
= wl1271_cmd_remove_sta(wl
, wl_sta
->hlid
);
2725 wl1271_free_hlid(wl
, wl_sta
->hlid
);
2728 wl1271_ps_elp_sleep(wl
);
2731 mutex_unlock(&wl
->mutex
);
2735 int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
2736 enum ieee80211_ampdu_mlme_action action
,
2737 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
2740 struct wl1271
*wl
= hw
->priv
;
2743 mutex_lock(&wl
->mutex
);
2745 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2750 ret
= wl1271_ps_elp_wakeup(wl
, false);
2755 case IEEE80211_AMPDU_RX_START
:
2756 if (wl
->ba_support
) {
2757 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, *ssn
,
2760 wl
->ba_rx_bitmap
|= BIT(tid
);
2766 case IEEE80211_AMPDU_RX_STOP
:
2767 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, 0, false);
2769 wl
->ba_rx_bitmap
&= ~BIT(tid
);
2773 * The BA initiator session management in FW independently.
2774 * Falling break here on purpose for all TX APDU commands.
2776 case IEEE80211_AMPDU_TX_START
:
2777 case IEEE80211_AMPDU_TX_STOP
:
2778 case IEEE80211_AMPDU_TX_OPERATIONAL
:
2783 wl1271_error("Incorrect ampdu action id=%x\n", action
);
2787 wl1271_ps_elp_sleep(wl
);
2790 mutex_unlock(&wl
->mutex
);
2795 /* can't be const, mac80211 writes to this */
2796 static struct ieee80211_rate wl1271_rates
[] = {
2798 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
2799 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
2801 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
2802 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
2803 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
2805 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
2806 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
2807 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
2809 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
2810 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
2811 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
2813 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
2814 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
2816 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
2817 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
2819 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
2820 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
2822 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
2823 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
2825 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
2826 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
2828 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
2829 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
2831 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
2832 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
2834 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
2835 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
2838 /* can't be const, mac80211 writes to this */
2839 static struct ieee80211_channel wl1271_channels
[] = {
2840 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
2841 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
2842 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
2843 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
2844 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
2845 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
2846 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
2847 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
2848 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
2849 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
2850 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
2851 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
2852 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
2853 { .hw_value
= 14, .center_freq
= 2484, .max_power
= 25 },
2856 /* mapping to indexes for wl1271_rates */
2857 static const u8 wl1271_rate_to_idx_2ghz
[] = {
2858 /* MCS rates are used only with 11n */
2859 7, /* CONF_HW_RXTX_RATE_MCS7 */
2860 6, /* CONF_HW_RXTX_RATE_MCS6 */
2861 5, /* CONF_HW_RXTX_RATE_MCS5 */
2862 4, /* CONF_HW_RXTX_RATE_MCS4 */
2863 3, /* CONF_HW_RXTX_RATE_MCS3 */
2864 2, /* CONF_HW_RXTX_RATE_MCS2 */
2865 1, /* CONF_HW_RXTX_RATE_MCS1 */
2866 0, /* CONF_HW_RXTX_RATE_MCS0 */
2868 11, /* CONF_HW_RXTX_RATE_54 */
2869 10, /* CONF_HW_RXTX_RATE_48 */
2870 9, /* CONF_HW_RXTX_RATE_36 */
2871 8, /* CONF_HW_RXTX_RATE_24 */
2873 /* TI-specific rate */
2874 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
2876 7, /* CONF_HW_RXTX_RATE_18 */
2877 6, /* CONF_HW_RXTX_RATE_12 */
2878 3, /* CONF_HW_RXTX_RATE_11 */
2879 5, /* CONF_HW_RXTX_RATE_9 */
2880 4, /* CONF_HW_RXTX_RATE_6 */
2881 2, /* CONF_HW_RXTX_RATE_5_5 */
2882 1, /* CONF_HW_RXTX_RATE_2 */
2883 0 /* CONF_HW_RXTX_RATE_1 */
2886 /* 11n STA capabilities */
2887 #define HW_RX_HIGHEST_RATE 72
2889 #ifdef CONFIG_WL12XX_HT
2890 #define WL12XX_HT_CAP { \
2891 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2892 .ht_supported = true, \
2893 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2894 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2896 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2897 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2898 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2902 #define WL12XX_HT_CAP { \
2903 .ht_supported = false, \
2907 /* can't be const, mac80211 writes to this */
2908 static struct ieee80211_supported_band wl1271_band_2ghz
= {
2909 .channels
= wl1271_channels
,
2910 .n_channels
= ARRAY_SIZE(wl1271_channels
),
2911 .bitrates
= wl1271_rates
,
2912 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
2913 .ht_cap
= WL12XX_HT_CAP
,
2916 /* 5 GHz data rates for WL1273 */
2917 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
2919 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
2920 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
2922 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
2923 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
2925 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
2926 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
2928 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
2929 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
2931 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
2932 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
2934 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
2935 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
2937 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
2938 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
2940 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
2941 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
2944 /* 5 GHz band channels for WL1273 */
2945 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
2946 { .hw_value
= 7, .center_freq
= 5035},
2947 { .hw_value
= 8, .center_freq
= 5040},
2948 { .hw_value
= 9, .center_freq
= 5045},
2949 { .hw_value
= 11, .center_freq
= 5055},
2950 { .hw_value
= 12, .center_freq
= 5060},
2951 { .hw_value
= 16, .center_freq
= 5080},
2952 { .hw_value
= 34, .center_freq
= 5170},
2953 { .hw_value
= 36, .center_freq
= 5180},
2954 { .hw_value
= 38, .center_freq
= 5190},
2955 { .hw_value
= 40, .center_freq
= 5200},
2956 { .hw_value
= 42, .center_freq
= 5210},
2957 { .hw_value
= 44, .center_freq
= 5220},
2958 { .hw_value
= 46, .center_freq
= 5230},
2959 { .hw_value
= 48, .center_freq
= 5240},
2960 { .hw_value
= 52, .center_freq
= 5260},
2961 { .hw_value
= 56, .center_freq
= 5280},
2962 { .hw_value
= 60, .center_freq
= 5300},
2963 { .hw_value
= 64, .center_freq
= 5320},
2964 { .hw_value
= 100, .center_freq
= 5500},
2965 { .hw_value
= 104, .center_freq
= 5520},
2966 { .hw_value
= 108, .center_freq
= 5540},
2967 { .hw_value
= 112, .center_freq
= 5560},
2968 { .hw_value
= 116, .center_freq
= 5580},
2969 { .hw_value
= 120, .center_freq
= 5600},
2970 { .hw_value
= 124, .center_freq
= 5620},
2971 { .hw_value
= 128, .center_freq
= 5640},
2972 { .hw_value
= 132, .center_freq
= 5660},
2973 { .hw_value
= 136, .center_freq
= 5680},
2974 { .hw_value
= 140, .center_freq
= 5700},
2975 { .hw_value
= 149, .center_freq
= 5745},
2976 { .hw_value
= 153, .center_freq
= 5765},
2977 { .hw_value
= 157, .center_freq
= 5785},
2978 { .hw_value
= 161, .center_freq
= 5805},
2979 { .hw_value
= 165, .center_freq
= 5825},
2982 /* mapping to indexes for wl1271_rates_5ghz */
2983 static const u8 wl1271_rate_to_idx_5ghz
[] = {
2984 /* MCS rates are used only with 11n */
2985 7, /* CONF_HW_RXTX_RATE_MCS7 */
2986 6, /* CONF_HW_RXTX_RATE_MCS6 */
2987 5, /* CONF_HW_RXTX_RATE_MCS5 */
2988 4, /* CONF_HW_RXTX_RATE_MCS4 */
2989 3, /* CONF_HW_RXTX_RATE_MCS3 */
2990 2, /* CONF_HW_RXTX_RATE_MCS2 */
2991 1, /* CONF_HW_RXTX_RATE_MCS1 */
2992 0, /* CONF_HW_RXTX_RATE_MCS0 */
2994 7, /* CONF_HW_RXTX_RATE_54 */
2995 6, /* CONF_HW_RXTX_RATE_48 */
2996 5, /* CONF_HW_RXTX_RATE_36 */
2997 4, /* CONF_HW_RXTX_RATE_24 */
2999 /* TI-specific rate */
3000 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3002 3, /* CONF_HW_RXTX_RATE_18 */
3003 2, /* CONF_HW_RXTX_RATE_12 */
3004 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_11 */
3005 1, /* CONF_HW_RXTX_RATE_9 */
3006 0, /* CONF_HW_RXTX_RATE_6 */
3007 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_5_5 */
3008 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_2 */
3009 CONF_HW_RXTX_RATE_UNSUPPORTED
/* CONF_HW_RXTX_RATE_1 */
3012 static struct ieee80211_supported_band wl1271_band_5ghz
= {
3013 .channels
= wl1271_channels_5ghz
,
3014 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
3015 .bitrates
= wl1271_rates_5ghz
,
3016 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
3017 .ht_cap
= WL12XX_HT_CAP
,
3020 static const u8
*wl1271_band_rate_to_idx
[] = {
3021 [IEEE80211_BAND_2GHZ
] = wl1271_rate_to_idx_2ghz
,
3022 [IEEE80211_BAND_5GHZ
] = wl1271_rate_to_idx_5ghz
3025 static const struct ieee80211_ops wl1271_ops
= {
3026 .start
= wl1271_op_start
,
3027 .stop
= wl1271_op_stop
,
3028 .add_interface
= wl1271_op_add_interface
,
3029 .remove_interface
= wl1271_op_remove_interface
,
3030 .config
= wl1271_op_config
,
3031 .prepare_multicast
= wl1271_op_prepare_multicast
,
3032 .configure_filter
= wl1271_op_configure_filter
,
3034 .set_key
= wl1271_op_set_key
,
3035 .hw_scan
= wl1271_op_hw_scan
,
3036 .bss_info_changed
= wl1271_op_bss_info_changed
,
3037 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
3038 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
3039 .conf_tx
= wl1271_op_conf_tx
,
3040 .get_tsf
= wl1271_op_get_tsf
,
3041 .get_survey
= wl1271_op_get_survey
,
3042 .sta_add
= wl1271_op_sta_add
,
3043 .sta_remove
= wl1271_op_sta_remove
,
3044 .ampdu_action
= wl1271_op_ampdu_action
,
3045 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
3049 u8
wl1271_rate_to_idx(int rate
, enum ieee80211_band band
)
3053 BUG_ON(band
>= sizeof(wl1271_band_rate_to_idx
)/sizeof(u8
*));
3055 if (unlikely(rate
>= CONF_HW_RXTX_RATE_MAX
)) {
3056 wl1271_error("Illegal RX rate from HW: %d", rate
);
3060 idx
= wl1271_band_rate_to_idx
[band
][rate
];
3061 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
3062 wl1271_error("Unsupported RX rate from HW: %d", rate
);
3069 static ssize_t
wl1271_sysfs_show_bt_coex_state(struct device
*dev
,
3070 struct device_attribute
*attr
,
3073 struct wl1271
*wl
= dev_get_drvdata(dev
);
3078 mutex_lock(&wl
->mutex
);
3079 len
= snprintf(buf
, len
, "%d\n\n0 - off\n1 - on\n",
3081 mutex_unlock(&wl
->mutex
);
3087 static ssize_t
wl1271_sysfs_store_bt_coex_state(struct device
*dev
,
3088 struct device_attribute
*attr
,
3089 const char *buf
, size_t count
)
3091 struct wl1271
*wl
= dev_get_drvdata(dev
);
3095 ret
= strict_strtoul(buf
, 10, &res
);
3098 wl1271_warning("incorrect value written to bt_coex_mode");
3102 mutex_lock(&wl
->mutex
);
3106 if (res
== wl
->sg_enabled
)
3109 wl
->sg_enabled
= res
;
3111 if (wl
->state
== WL1271_STATE_OFF
)
3114 ret
= wl1271_ps_elp_wakeup(wl
, false);
3118 wl1271_acx_sg_enable(wl
, wl
->sg_enabled
);
3119 wl1271_ps_elp_sleep(wl
);
3122 mutex_unlock(&wl
->mutex
);
3126 static DEVICE_ATTR(bt_coex_state
, S_IRUGO
| S_IWUSR
,
3127 wl1271_sysfs_show_bt_coex_state
,
3128 wl1271_sysfs_store_bt_coex_state
);
3130 static ssize_t
wl1271_sysfs_show_hw_pg_ver(struct device
*dev
,
3131 struct device_attribute
*attr
,
3134 struct wl1271
*wl
= dev_get_drvdata(dev
);
3139 mutex_lock(&wl
->mutex
);
3140 if (wl
->hw_pg_ver
>= 0)
3141 len
= snprintf(buf
, len
, "%d\n", wl
->hw_pg_ver
);
3143 len
= snprintf(buf
, len
, "n/a\n");
3144 mutex_unlock(&wl
->mutex
);
3149 static DEVICE_ATTR(hw_pg_ver
, S_IRUGO
| S_IWUSR
,
3150 wl1271_sysfs_show_hw_pg_ver
, NULL
);
3152 int wl1271_register_hw(struct wl1271
*wl
)
3156 if (wl
->mac80211_registered
)
3159 ret
= wl1271_fetch_nvs(wl
);
3161 u8
*nvs_ptr
= (u8
*)wl
->nvs
->nvs
;
3163 wl
->mac_addr
[0] = nvs_ptr
[11];
3164 wl
->mac_addr
[1] = nvs_ptr
[10];
3165 wl
->mac_addr
[2] = nvs_ptr
[6];
3166 wl
->mac_addr
[3] = nvs_ptr
[5];
3167 wl
->mac_addr
[4] = nvs_ptr
[4];
3168 wl
->mac_addr
[5] = nvs_ptr
[3];
3171 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
3173 ret
= ieee80211_register_hw(wl
->hw
);
3175 wl1271_error("unable to register mac80211 hw: %d", ret
);
3179 wl
->mac80211_registered
= true;
3181 wl1271_debugfs_init(wl
);
3183 register_netdevice_notifier(&wl1271_dev_notifier
);
3185 wl1271_notice("loaded");
3189 EXPORT_SYMBOL_GPL(wl1271_register_hw
);
3191 void wl1271_unregister_hw(struct wl1271
*wl
)
3193 if (wl
->state
== WL1271_STATE_PLT
)
3194 __wl1271_plt_stop(wl
);
3196 unregister_netdevice_notifier(&wl1271_dev_notifier
);
3197 ieee80211_unregister_hw(wl
->hw
);
3198 wl
->mac80211_registered
= false;
3201 EXPORT_SYMBOL_GPL(wl1271_unregister_hw
);
3203 int wl1271_init_ieee80211(struct wl1271
*wl
)
3205 static const u32 cipher_suites
[] = {
3206 WLAN_CIPHER_SUITE_WEP40
,
3207 WLAN_CIPHER_SUITE_WEP104
,
3208 WLAN_CIPHER_SUITE_TKIP
,
3209 WLAN_CIPHER_SUITE_CCMP
,
3210 WL1271_CIPHER_SUITE_GEM
,
3213 /* The tx descriptor buffer and the TKIP space. */
3214 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
3215 sizeof(struct wl1271_tx_hw_descr
);
3218 /* FIXME: find a proper value */
3219 wl
->hw
->channel_change_time
= 10000;
3220 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
3222 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
3223 IEEE80211_HW_BEACON_FILTER
|
3224 IEEE80211_HW_SUPPORTS_PS
|
3225 IEEE80211_HW_SUPPORTS_UAPSD
|
3226 IEEE80211_HW_HAS_RATE_CONTROL
|
3227 IEEE80211_HW_CONNECTION_MONITOR
|
3228 IEEE80211_HW_SUPPORTS_CQM_RSSI
|
3229 IEEE80211_HW_REPORTS_TX_ACK_STATUS
;
3231 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
3232 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
3234 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
3235 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
3236 wl
->hw
->wiphy
->max_scan_ssids
= 1;
3238 * Maximum length of elements in scanning probe request templates
3239 * should be the maximum length possible for a template, without
3240 * the IEEE80211 header of the template
3242 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
3243 sizeof(struct ieee80211_header
);
3246 * We keep local copies of the band structs because we need to
3247 * modify them on a per-device basis.
3249 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
3250 sizeof(wl1271_band_2ghz
));
3251 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
3252 sizeof(wl1271_band_5ghz
));
3254 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
3255 &wl
->bands
[IEEE80211_BAND_2GHZ
];
3256 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
3257 &wl
->bands
[IEEE80211_BAND_5GHZ
];
3260 wl
->hw
->max_rates
= 1;
3262 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
3264 SET_IEEE80211_DEV(wl
->hw
, wl1271_wl_to_dev(wl
));
3266 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
3268 wl
->hw
->max_rx_aggregation_subframes
= 8;
3272 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211
);
3274 #define WL1271_DEFAULT_CHANNEL 0
3276 struct ieee80211_hw
*wl1271_alloc_hw(void)
3278 struct ieee80211_hw
*hw
;
3279 struct platform_device
*plat_dev
= NULL
;
3284 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
3286 wl1271_error("could not alloc ieee80211_hw");
3291 plat_dev
= kmemdup(&wl1271_device
, sizeof(wl1271_device
), GFP_KERNEL
);
3293 wl1271_error("could not allocate platform_device");
3295 goto err_plat_alloc
;
3299 memset(wl
, 0, sizeof(*wl
));
3301 INIT_LIST_HEAD(&wl
->list
);
3304 wl
->plat_dev
= plat_dev
;
3306 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
3307 skb_queue_head_init(&wl
->tx_queue
[i
]);
3309 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
3310 for (j
= 0; j
< AP_MAX_LINKS
; j
++)
3311 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
3313 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
3314 INIT_DELAYED_WORK(&wl
->pspoll_work
, wl1271_pspoll_work
);
3315 INIT_WORK(&wl
->irq_work
, wl1271_irq_work
);
3316 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
3317 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
3318 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
3319 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
3320 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
3321 wl
->default_key
= 0;
3323 wl
->rx_config
= WL1271_DEFAULT_STA_RX_CONFIG
;
3324 wl
->rx_filter
= WL1271_DEFAULT_STA_RX_FILTER
;
3325 wl
->psm_entry_retry
= 0;
3326 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
3327 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
3328 wl
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
3329 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
3330 wl
->band
= IEEE80211_BAND_2GHZ
;
3333 wl
->sg_enabled
= true;
3335 wl
->bss_type
= MAX_BSS_TYPE
;
3336 wl
->set_bss_type
= MAX_BSS_TYPE
;
3337 wl
->fw_bss_type
= MAX_BSS_TYPE
;
3338 wl
->last_tx_hlid
= 0;
3340 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
3341 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
3342 wl
->tx_frames
[i
] = NULL
;
3344 spin_lock_init(&wl
->wl_lock
);
3346 wl
->state
= WL1271_STATE_OFF
;
3347 mutex_init(&wl
->mutex
);
3349 /* Apply default driver configuration. */
3350 wl1271_conf_init(wl
);
3352 order
= get_order(WL1271_AGGR_BUFFER_SIZE
);
3353 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
3354 if (!wl
->aggr_buf
) {
3359 /* Register platform device */
3360 ret
= platform_device_register(wl
->plat_dev
);
3362 wl1271_error("couldn't register platform device");
3365 dev_set_drvdata(&wl
->plat_dev
->dev
, wl
);
3367 /* Create sysfs file to control bt coex state */
3368 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
3370 wl1271_error("failed to create sysfs file bt_coex_state");
3374 /* Create sysfs file to get HW PG version */
3375 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
3377 wl1271_error("failed to create sysfs file hw_pg_ver");
3378 goto err_bt_coex_state
;
3384 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
3387 platform_device_unregister(wl
->plat_dev
);
3390 free_pages((unsigned long)wl
->aggr_buf
, order
);
3393 wl1271_debugfs_exit(wl
);
3397 ieee80211_free_hw(hw
);
3401 return ERR_PTR(ret
);
3403 EXPORT_SYMBOL_GPL(wl1271_alloc_hw
);
3405 int wl1271_free_hw(struct wl1271
*wl
)
3407 platform_device_unregister(wl
->plat_dev
);
3408 free_pages((unsigned long)wl
->aggr_buf
,
3409 get_order(WL1271_AGGR_BUFFER_SIZE
));
3410 kfree(wl
->plat_dev
);
3412 wl1271_debugfs_exit(wl
);
3419 kfree(wl
->fw_status
);
3420 kfree(wl
->tx_res_if
);
3422 ieee80211_free_hw(wl
->hw
);
3426 EXPORT_SYMBOL_GPL(wl1271_free_hw
);
3428 u32 wl12xx_debug_level
= DEBUG_NONE
;
3429 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
3430 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
3431 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
3433 MODULE_LICENSE("GPL");
3434 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
3435 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");