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
] = 200,
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
= 50,
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
= 100,
308 .min_req_rx_blocks
= 22,
315 .tx_min_block_num
= 40,
317 .min_req_tx_blocks
= 45,
318 .min_req_rx_blocks
= 22,
323 static void __wl1271_op_remove_interface(struct wl1271
*wl
);
324 static void wl1271_free_ap_keys(struct wl1271
*wl
);
327 static void wl1271_device_release(struct device
*dev
)
332 static struct platform_device wl1271_device
= {
336 /* device model insists to have a release function */
338 .release
= wl1271_device_release
,
342 static DEFINE_MUTEX(wl_list_mutex
);
343 static LIST_HEAD(wl_list
);
345 static int wl1271_dev_notify(struct notifier_block
*me
, unsigned long what
,
348 struct net_device
*dev
= arg
;
349 struct wireless_dev
*wdev
;
351 struct ieee80211_hw
*hw
;
353 struct wl1271
*wl_temp
;
356 /* Check that this notification is for us. */
357 if (what
!= NETDEV_CHANGE
)
360 wdev
= dev
->ieee80211_ptr
;
368 hw
= wiphy_priv(wiphy
);
373 mutex_lock(&wl_list_mutex
);
374 list_for_each_entry(wl
, &wl_list
, list
) {
378 mutex_unlock(&wl_list_mutex
);
382 mutex_lock(&wl
->mutex
);
384 if (wl
->state
== WL1271_STATE_OFF
)
387 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
390 ret
= wl1271_ps_elp_wakeup(wl
);
394 if ((dev
->operstate
== IF_OPER_UP
) &&
395 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
)) {
396 wl1271_cmd_set_sta_state(wl
);
397 wl1271_info("Association completed.");
400 wl1271_ps_elp_sleep(wl
);
403 mutex_unlock(&wl
->mutex
);
408 static int wl1271_reg_notify(struct wiphy
*wiphy
,
409 struct regulatory_request
*request
)
411 struct ieee80211_supported_band
*band
;
412 struct ieee80211_channel
*ch
;
415 band
= wiphy
->bands
[IEEE80211_BAND_5GHZ
];
416 for (i
= 0; i
< band
->n_channels
; i
++) {
417 ch
= &band
->channels
[i
];
418 if (ch
->flags
& IEEE80211_CHAN_DISABLED
)
421 if (ch
->flags
& IEEE80211_CHAN_RADAR
)
422 ch
->flags
|= IEEE80211_CHAN_NO_IBSS
|
423 IEEE80211_CHAN_PASSIVE_SCAN
;
430 static void wl1271_conf_init(struct wl1271
*wl
)
434 * This function applies the default configuration to the driver. This
435 * function is invoked upon driver load (spi probe.)
437 * The configuration is stored in a run-time structure in order to
438 * facilitate for run-time adjustment of any of the parameters. Making
439 * changes to the configuration structure will apply the new values on
440 * the next interface up (wl1271_op_start.)
443 /* apply driver default configuration */
444 memcpy(&wl
->conf
, &default_conf
, sizeof(default_conf
));
448 static int wl1271_plt_init(struct wl1271
*wl
)
450 struct conf_tx_ac_category
*conf_ac
;
451 struct conf_tx_tid
*conf_tid
;
454 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
455 ret
= wl128x_cmd_general_parms(wl
);
457 ret
= wl1271_cmd_general_parms(wl
);
461 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
462 ret
= wl128x_cmd_radio_parms(wl
);
464 ret
= wl1271_cmd_radio_parms(wl
);
468 if (wl
->chip
.id
!= CHIP_ID_1283_PG20
) {
469 ret
= wl1271_cmd_ext_radio_parms(wl
);
476 /* Chip-specific initializations */
477 ret
= wl1271_chip_specific_init(wl
);
481 ret
= wl1271_sta_init_templates_config(wl
);
485 ret
= wl1271_acx_init_mem_config(wl
);
489 /* PHY layer config */
490 ret
= wl1271_init_phy_config(wl
);
492 goto out_free_memmap
;
494 ret
= wl1271_acx_dco_itrim_params(wl
);
496 goto out_free_memmap
;
498 /* Initialize connection monitoring thresholds */
499 ret
= wl1271_acx_conn_monit_params(wl
, false);
501 goto out_free_memmap
;
503 /* Bluetooth WLAN coexistence */
504 ret
= wl1271_init_pta(wl
);
506 goto out_free_memmap
;
508 /* Energy detection */
509 ret
= wl1271_init_energy_detection(wl
);
511 goto out_free_memmap
;
513 ret
= wl1271_acx_sta_mem_cfg(wl
);
515 goto out_free_memmap
;
517 /* Default fragmentation threshold */
518 ret
= wl1271_acx_frag_threshold(wl
, wl
->conf
.tx
.frag_threshold
);
520 goto out_free_memmap
;
522 /* Default TID/AC configuration */
523 BUG_ON(wl
->conf
.tx
.tid_conf_count
!= wl
->conf
.tx
.ac_conf_count
);
524 for (i
= 0; i
< wl
->conf
.tx
.tid_conf_count
; i
++) {
525 conf_ac
= &wl
->conf
.tx
.ac_conf
[i
];
526 ret
= wl1271_acx_ac_cfg(wl
, conf_ac
->ac
, conf_ac
->cw_min
,
527 conf_ac
->cw_max
, conf_ac
->aifsn
,
528 conf_ac
->tx_op_limit
);
530 goto out_free_memmap
;
532 conf_tid
= &wl
->conf
.tx
.tid_conf
[i
];
533 ret
= wl1271_acx_tid_cfg(wl
, conf_tid
->queue_id
,
534 conf_tid
->channel_type
,
537 conf_tid
->ack_policy
,
538 conf_tid
->apsd_conf
[0],
539 conf_tid
->apsd_conf
[1]);
541 goto out_free_memmap
;
544 /* Enable data path */
545 ret
= wl1271_cmd_data_path(wl
, 1);
547 goto out_free_memmap
;
549 /* Configure for CAM power saving (ie. always active) */
550 ret
= wl1271_acx_sleep_auth(wl
, WL1271_PSM_CAM
);
552 goto out_free_memmap
;
555 ret
= wl1271_acx_pm_config(wl
);
557 goto out_free_memmap
;
562 kfree(wl
->target_mem_map
);
563 wl
->target_mem_map
= NULL
;
568 static void wl1271_irq_ps_regulate_link(struct wl1271
*wl
, u8 hlid
, u8 tx_blks
)
572 /* only regulate station links */
573 if (hlid
< WL1271_AP_STA_HLID_START
)
576 fw_ps
= test_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
579 * Wake up from high level PS if the STA is asleep with too little
580 * blocks in FW or if the STA is awake.
582 if (!fw_ps
|| tx_blks
< WL1271_PS_STA_MAX_BLOCKS
)
583 wl1271_ps_link_end(wl
, hlid
);
585 /* Start high-level PS if the STA is asleep with enough blocks in FW */
586 else if (fw_ps
&& tx_blks
>= WL1271_PS_STA_MAX_BLOCKS
)
587 wl1271_ps_link_start(wl
, hlid
, true);
590 static void wl1271_irq_update_links_status(struct wl1271
*wl
,
591 struct wl1271_fw_ap_status
*status
)
596 cur_fw_ps_map
= le32_to_cpu(status
->link_ps_bitmap
);
597 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
598 wl1271_debug(DEBUG_PSM
,
599 "link ps prev 0x%x cur 0x%x changed 0x%x",
600 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
601 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
603 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
606 for (hlid
= WL1271_AP_STA_HLID_START
; hlid
< AP_MAX_LINKS
; hlid
++) {
607 u8 cnt
= status
->tx_lnk_free_blks
[hlid
] -
608 wl
->links
[hlid
].prev_freed_blks
;
610 wl
->links
[hlid
].prev_freed_blks
=
611 status
->tx_lnk_free_blks
[hlid
];
612 wl
->links
[hlid
].allocated_blks
-= cnt
;
614 wl1271_irq_ps_regulate_link(wl
, hlid
,
615 wl
->links
[hlid
].allocated_blks
);
619 static void wl1271_fw_status(struct wl1271
*wl
,
620 struct wl1271_fw_full_status
*full_status
)
622 struct wl1271_fw_common_status
*status
= &full_status
->common
;
624 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
628 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
629 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
630 sizeof(struct wl1271_fw_ap_status
), false);
632 wl1271_raw_read(wl
, FW_STATUS_ADDR
, status
,
633 sizeof(struct wl1271_fw_sta_status
), false);
635 /* Update tx total blocks change */
637 ((struct wl1271_fw_sta_status
*)status
)->tx_total
-
640 /* Update total tx blocks */
642 ((struct wl1271_fw_sta_status
*)status
)->tx_total
;
645 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
646 "drv_rx_counter = %d, tx_results_counter = %d)",
648 status
->fw_rx_counter
,
649 status
->drv_rx_counter
,
650 status
->tx_results_counter
);
652 /* update number of available TX blocks */
653 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
654 total
+= le32_to_cpu(status
->tx_released_blks
[i
]) -
655 wl
->tx_blocks_freed
[i
];
657 wl
->tx_blocks_freed
[i
] =
658 le32_to_cpu(status
->tx_released_blks
[i
]);
663 * By adding the freed blocks to tx_total_diff we are actually
664 * moving them to the RX pool.
666 wl
->tx_total_diff
+= total
;
668 /* if we have positive difference, add the blocks to the TX pool */
669 if (wl
->tx_total_diff
>= 0) {
670 wl
->tx_blocks_available
+= wl
->tx_total_diff
;
671 wl
->tx_total_diff
= 0;
674 /* if more blocks are available now, tx work can be scheduled */
675 if (wl
->tx_blocks_available
> old_tx_blk_count
)
676 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
678 /* for AP update num of allocated TX blocks per link and ps status */
679 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
680 wl1271_irq_update_links_status(wl
, &full_status
->ap
);
682 /* update the host-chipset time offset */
684 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
685 (s64
)le32_to_cpu(status
->fw_localtime
);
688 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
692 /* Pass all received frames to the network stack */
693 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
694 ieee80211_rx_ni(wl
->hw
, skb
);
696 /* Return sent skbs to the network stack */
697 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
698 ieee80211_tx_status(wl
->hw
, skb
);
701 static void wl1271_netstack_work(struct work_struct
*work
)
704 container_of(work
, struct wl1271
, netstack_work
);
707 wl1271_flush_deferred_work(wl
);
708 } while (skb_queue_len(&wl
->deferred_rx_queue
));
711 #define WL1271_IRQ_MAX_LOOPS 256
713 irqreturn_t
wl1271_irq(int irq
, void *cookie
)
717 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
718 struct wl1271
*wl
= (struct wl1271
*)cookie
;
720 unsigned int defer_count
;
723 /* TX might be handled here, avoid redundant work */
724 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
725 cancel_work_sync(&wl
->tx_work
);
727 mutex_lock(&wl
->mutex
);
729 wl1271_debug(DEBUG_IRQ
, "IRQ work");
731 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
734 ret
= wl1271_ps_elp_wakeup(wl
);
738 while (!done
&& loopcount
--) {
740 * In order to avoid a race with the hardirq, clear the flag
741 * before acknowledging the chip. Since the mutex is held,
742 * wl1271_ps_elp_wakeup cannot be called concurrently.
744 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
745 smp_mb__after_clear_bit();
747 wl1271_fw_status(wl
, wl
->fw_status
);
748 intr
= le32_to_cpu(wl
->fw_status
->common
.intr
);
749 intr
&= WL1271_INTR_MASK
;
755 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
756 wl1271_error("watchdog interrupt received! "
757 "starting recovery.");
758 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
760 /* restarting the chip. ignore any other interrupt. */
764 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
765 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
767 wl1271_rx(wl
, &wl
->fw_status
->common
);
769 /* Check if any tx blocks were freed */
770 spin_lock_irqsave(&wl
->wl_lock
, flags
);
771 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
772 wl
->tx_queue_count
) {
773 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
775 * In order to avoid starvation of the TX path,
776 * call the work function directly.
778 wl1271_tx_work_locked(wl
);
780 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
783 /* check for tx results */
784 if (wl
->fw_status
->common
.tx_results_counter
!=
785 (wl
->tx_results_count
& 0xff))
786 wl1271_tx_complete(wl
);
788 /* Make sure the deferred queues don't get too long */
789 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
790 skb_queue_len(&wl
->deferred_rx_queue
);
791 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
792 wl1271_flush_deferred_work(wl
);
795 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
796 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
797 wl1271_event_handle(wl
, 0);
800 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
801 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
802 wl1271_event_handle(wl
, 1);
805 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
806 wl1271_debug(DEBUG_IRQ
,
807 "WL1271_ACX_INTR_INIT_COMPLETE");
809 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
810 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
813 wl1271_ps_elp_sleep(wl
);
816 spin_lock_irqsave(&wl
->wl_lock
, flags
);
817 /* In case TX was not handled here, queue TX work */
818 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
819 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
821 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
822 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
824 mutex_unlock(&wl
->mutex
);
828 EXPORT_SYMBOL_GPL(wl1271_irq
);
830 static int wl1271_fetch_firmware(struct wl1271
*wl
)
832 const struct firmware
*fw
;
836 switch (wl
->bss_type
) {
837 case BSS_TYPE_AP_BSS
:
838 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
839 fw_name
= WL128X_AP_FW_NAME
;
841 fw_name
= WL127X_AP_FW_NAME
;
844 case BSS_TYPE_STA_BSS
:
845 if (wl
->chip
.id
== CHIP_ID_1283_PG20
)
846 fw_name
= WL128X_FW_NAME
;
848 fw_name
= WL1271_FW_NAME
;
851 wl1271_error("no compatible firmware for bss_type %d",
856 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
858 ret
= request_firmware(&fw
, fw_name
, wl1271_wl_to_dev(wl
));
861 wl1271_error("could not get firmware: %d", ret
);
866 wl1271_error("firmware size is not multiple of 32 bits: %zu",
873 wl
->fw_len
= fw
->size
;
874 wl
->fw
= vmalloc(wl
->fw_len
);
877 wl1271_error("could not allocate memory for the firmware");
882 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
883 wl
->fw_bss_type
= wl
->bss_type
;
887 release_firmware(fw
);
892 static int wl1271_fetch_nvs(struct wl1271
*wl
)
894 const struct firmware
*fw
;
897 ret
= request_firmware(&fw
, WL12XX_NVS_NAME
, wl1271_wl_to_dev(wl
));
900 wl1271_error("could not get nvs file: %d", ret
);
904 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
907 wl1271_error("could not allocate memory for the nvs file");
912 wl
->nvs_len
= fw
->size
;
915 release_firmware(fw
);
920 static void wl1271_recovery_work(struct work_struct
*work
)
923 container_of(work
, struct wl1271
, recovery_work
);
925 mutex_lock(&wl
->mutex
);
927 if (wl
->state
!= WL1271_STATE_ON
)
930 wl1271_info("Hardware recovery in progress.");
932 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
933 ieee80211_connection_loss(wl
->vif
);
935 /* reboot the chipset */
936 __wl1271_op_remove_interface(wl
);
937 ieee80211_restart_hw(wl
->hw
);
940 mutex_unlock(&wl
->mutex
);
943 static void wl1271_fw_wakeup(struct wl1271
*wl
)
947 elp_reg
= ELPCTRL_WAKE_UP
;
948 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
951 static int wl1271_setup(struct wl1271
*wl
)
953 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
957 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
958 if (!wl
->tx_res_if
) {
959 kfree(wl
->fw_status
);
966 static int wl1271_chip_wakeup(struct wl1271
*wl
)
968 struct wl1271_partition_set partition
;
971 msleep(WL1271_PRE_POWER_ON_SLEEP
);
972 ret
= wl1271_power_on(wl
);
975 msleep(WL1271_POWER_ON_SLEEP
);
979 /* We don't need a real memory partition here, because we only want
980 * to use the registers at this point. */
981 memset(&partition
, 0, sizeof(partition
));
982 partition
.reg
.start
= REGISTERS_BASE
;
983 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
984 wl1271_set_partition(wl
, &partition
);
986 /* ELP module wake up */
987 wl1271_fw_wakeup(wl
);
989 /* whal_FwCtrl_BootSm() */
991 /* 0. read chip id from CHIP_ID */
992 wl
->chip
.id
= wl1271_read32(wl
, CHIP_ID_B
);
994 /* 1. check if chip id is valid */
996 switch (wl
->chip
.id
) {
997 case CHIP_ID_1271_PG10
:
998 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1001 ret
= wl1271_setup(wl
);
1005 case CHIP_ID_1271_PG20
:
1006 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
1009 ret
= wl1271_setup(wl
);
1013 case CHIP_ID_1283_PG20
:
1014 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1283 PG20)",
1017 ret
= wl1271_setup(wl
);
1021 case CHIP_ID_1283_PG10
:
1023 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
1028 /* Make sure the firmware type matches the BSS type */
1029 if (wl
->fw
== NULL
|| wl
->fw_bss_type
!= wl
->bss_type
) {
1030 ret
= wl1271_fetch_firmware(wl
);
1035 /* No NVS from netlink, try to get it from the filesystem */
1036 if (wl
->nvs
== NULL
) {
1037 ret
= wl1271_fetch_nvs(wl
);
1046 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271
*wl
)
1048 unsigned int quirks
= 0;
1049 unsigned int *fw_ver
= wl
->chip
.fw_ver
;
1051 /* Only for wl127x */
1052 if ((fw_ver
[FW_VER_CHIP
] == FW_VER_CHIP_WL127X
) &&
1053 /* Check STA version */
1054 (((fw_ver
[FW_VER_IF_TYPE
] == FW_VER_IF_TYPE_STA
) &&
1055 (fw_ver
[FW_VER_MINOR
] < FW_VER_MINOR_1_SPARE_STA_MIN
)) ||
1056 /* Check AP version */
1057 ((fw_ver
[FW_VER_IF_TYPE
] == FW_VER_IF_TYPE_AP
) &&
1058 (fw_ver
[FW_VER_MINOR
] < FW_VER_MINOR_1_SPARE_AP_MIN
))))
1059 quirks
|= WL12XX_QUIRK_USE_2_SPARE_BLOCKS
;
1064 int wl1271_plt_start(struct wl1271
*wl
)
1066 int retries
= WL1271_BOOT_RETRIES
;
1069 mutex_lock(&wl
->mutex
);
1071 wl1271_notice("power up");
1073 if (wl
->state
!= WL1271_STATE_OFF
) {
1074 wl1271_error("cannot go into PLT state because not "
1075 "in off state: %d", wl
->state
);
1080 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1084 ret
= wl1271_chip_wakeup(wl
);
1088 ret
= wl1271_boot(wl
);
1092 ret
= wl1271_plt_init(wl
);
1096 wl
->state
= WL1271_STATE_PLT
;
1097 wl1271_notice("firmware booted in PLT mode (%s)",
1098 wl
->chip
.fw_ver_str
);
1100 /* Check if any quirks are needed with older fw versions */
1101 wl
->quirks
|= wl1271_get_fw_ver_quirks(wl
);
1105 mutex_unlock(&wl
->mutex
);
1106 /* Unlocking the mutex in the middle of handling is
1107 inherently unsafe. In this case we deem it safe to do,
1108 because we need to let any possibly pending IRQ out of
1109 the system (and while we are WL1271_STATE_OFF the IRQ
1110 work function will not do anything.) Also, any other
1111 possible concurrent operations will fail due to the
1112 current state, hence the wl1271 struct should be safe. */
1113 wl1271_disable_interrupts(wl
);
1114 wl1271_flush_deferred_work(wl
);
1115 cancel_work_sync(&wl
->netstack_work
);
1116 mutex_lock(&wl
->mutex
);
1118 wl1271_power_off(wl
);
1121 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1122 WL1271_BOOT_RETRIES
);
1124 mutex_unlock(&wl
->mutex
);
1129 static int __wl1271_plt_stop(struct wl1271
*wl
)
1133 wl1271_notice("power down");
1135 if (wl
->state
!= WL1271_STATE_PLT
) {
1136 wl1271_error("cannot power down because not in PLT "
1137 "state: %d", wl
->state
);
1142 wl1271_power_off(wl
);
1144 wl
->state
= WL1271_STATE_OFF
;
1147 mutex_unlock(&wl
->mutex
);
1148 wl1271_disable_interrupts(wl
);
1149 wl1271_flush_deferred_work(wl
);
1150 cancel_work_sync(&wl
->netstack_work
);
1151 cancel_work_sync(&wl
->recovery_work
);
1152 mutex_lock(&wl
->mutex
);
1157 int wl1271_plt_stop(struct wl1271
*wl
)
1161 mutex_lock(&wl
->mutex
);
1162 ret
= __wl1271_plt_stop(wl
);
1163 mutex_unlock(&wl
->mutex
);
1167 static void wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
1169 struct wl1271
*wl
= hw
->priv
;
1170 unsigned long flags
;
1174 q
= wl1271_tx_get_queue(skb_get_queue_mapping(skb
));
1176 if (wl
->bss_type
== BSS_TYPE_AP_BSS
)
1177 hlid
= wl1271_tx_get_hlid(skb
);
1179 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1181 wl
->tx_queue_count
++;
1184 * The workqueue is slow to process the tx_queue and we need stop
1185 * the queue here, otherwise the queue will get too long.
1187 if (wl
->tx_queue_count
>= WL1271_TX_QUEUE_HIGH_WATERMARK
) {
1188 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues");
1189 ieee80211_stop_queues(wl
->hw
);
1190 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED
, &wl
->flags
);
1193 /* queue the packet */
1194 if (wl
->bss_type
== BSS_TYPE_AP_BSS
) {
1195 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d", hlid
, q
);
1196 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1198 skb_queue_tail(&wl
->tx_queue
[q
], skb
);
1202 * The chip specific setup must run before the first TX packet -
1203 * before that, the tx_work will not be initialized!
1206 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1207 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1208 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1210 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1213 #define TX_DUMMY_PACKET_SIZE 1400
1214 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1216 struct sk_buff
*skb
= NULL
;
1217 struct ieee80211_hdr_3addr
*hdr
;
1220 skb
= dev_alloc_skb(
1221 sizeof(struct wl1271_tx_hw_descr
) + sizeof(*hdr
) +
1222 TX_DUMMY_PACKET_SIZE
);
1224 wl1271_warning("failed to allocate buffer for dummy packet");
1229 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1231 hdr
= (struct ieee80211_hdr_3addr
*) skb_put(skb
, sizeof(*hdr
));
1232 memset(hdr
, 0, sizeof(*hdr
));
1233 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1234 IEEE80211_FCTL_TODS
|
1235 IEEE80211_STYPE_NULLFUNC
);
1237 memcpy(hdr
->addr1
, wl
->bssid
, ETH_ALEN
);
1238 memcpy(hdr
->addr2
, wl
->mac_addr
, ETH_ALEN
);
1239 memcpy(hdr
->addr3
, wl
->bssid
, ETH_ALEN
);
1241 skb_put(skb
, TX_DUMMY_PACKET_SIZE
);
1243 memset(skb
->data
, 0, TX_DUMMY_PACKET_SIZE
);
1245 skb
->pkt_type
= TX_PKT_TYPE_DUMMY_REQ
;
1246 /* Dummy packets require the TID to be management */
1247 skb
->priority
= WL1271_TID_MGMT
;
1249 skb
->queue_mapping
= 0;
1251 wl1271_op_tx(wl
->hw
, skb
);
1257 static struct notifier_block wl1271_dev_notifier
= {
1258 .notifier_call
= wl1271_dev_notify
,
1261 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1263 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1266 * We have to delay the booting of the hardware because
1267 * we need to know the local MAC address before downloading and
1268 * initializing the firmware. The MAC address cannot be changed
1269 * after boot, and without the proper MAC address, the firmware
1270 * will not function properly.
1272 * The MAC address is first known when the corresponding interface
1273 * is added. That is where we will initialize the hardware.
1275 * In addition, we currently have different firmwares for AP and managed
1276 * operation. We will know which to boot according to interface type.
1282 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
1284 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1287 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1288 struct ieee80211_vif
*vif
)
1290 struct wl1271
*wl
= hw
->priv
;
1291 struct wiphy
*wiphy
= hw
->wiphy
;
1292 int retries
= WL1271_BOOT_RETRIES
;
1294 bool booted
= false;
1296 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1297 vif
->type
, vif
->addr
);
1299 mutex_lock(&wl
->mutex
);
1301 wl1271_debug(DEBUG_MAC80211
,
1302 "multiple vifs are not supported yet");
1307 switch (vif
->type
) {
1308 case NL80211_IFTYPE_STATION
:
1309 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1310 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1312 case NL80211_IFTYPE_ADHOC
:
1313 wl
->bss_type
= BSS_TYPE_IBSS
;
1314 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
1316 case NL80211_IFTYPE_AP
:
1317 wl
->bss_type
= BSS_TYPE_AP_BSS
;
1324 memcpy(wl
->mac_addr
, vif
->addr
, ETH_ALEN
);
1326 if (wl
->state
!= WL1271_STATE_OFF
) {
1327 wl1271_error("cannot start because not in off state: %d",
1335 ret
= wl1271_chip_wakeup(wl
);
1339 ret
= wl1271_boot(wl
);
1343 ret
= wl1271_hw_init(wl
);
1351 mutex_unlock(&wl
->mutex
);
1352 /* Unlocking the mutex in the middle of handling is
1353 inherently unsafe. In this case we deem it safe to do,
1354 because we need to let any possibly pending IRQ out of
1355 the system (and while we are WL1271_STATE_OFF the IRQ
1356 work function will not do anything.) Also, any other
1357 possible concurrent operations will fail due to the
1358 current state, hence the wl1271 struct should be safe. */
1359 wl1271_disable_interrupts(wl
);
1360 wl1271_flush_deferred_work(wl
);
1361 cancel_work_sync(&wl
->netstack_work
);
1362 mutex_lock(&wl
->mutex
);
1364 wl1271_power_off(wl
);
1368 wl1271_error("firmware boot failed despite %d retries",
1369 WL1271_BOOT_RETRIES
);
1374 wl
->state
= WL1271_STATE_ON
;
1375 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
1377 /* update hw/fw version info in wiphy struct */
1378 wiphy
->hw_version
= wl
->chip
.id
;
1379 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1380 sizeof(wiphy
->fw_version
));
1382 /* Check if any quirks are needed with older fw versions */
1383 wl
->quirks
|= wl1271_get_fw_ver_quirks(wl
);
1386 * Now we know if 11a is supported (info from the NVS), so disable
1387 * 11a channels if not supported
1389 if (!wl
->enable_11a
)
1390 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
1392 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
1393 wl
->enable_11a
? "" : "not ");
1396 mutex_unlock(&wl
->mutex
);
1398 mutex_lock(&wl_list_mutex
);
1400 list_add(&wl
->list
, &wl_list
);
1401 mutex_unlock(&wl_list_mutex
);
1406 static void __wl1271_op_remove_interface(struct wl1271
*wl
)
1410 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
1412 wl1271_info("down");
1414 mutex_lock(&wl_list_mutex
);
1415 list_del(&wl
->list
);
1416 mutex_unlock(&wl_list_mutex
);
1418 WARN_ON(wl
->state
!= WL1271_STATE_ON
);
1420 /* enable dyn ps just in case (if left on due to fw crash etc) */
1421 if (wl
->bss_type
== BSS_TYPE_STA_BSS
)
1422 ieee80211_enable_dyn_ps(wl
->vif
);
1424 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
1425 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
1426 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
1427 wl
->scan
.req
= NULL
;
1428 ieee80211_scan_completed(wl
->hw
, true);
1431 wl
->state
= WL1271_STATE_OFF
;
1433 mutex_unlock(&wl
->mutex
);
1435 wl1271_disable_interrupts(wl
);
1436 wl1271_flush_deferred_work(wl
);
1437 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1438 cancel_work_sync(&wl
->netstack_work
);
1439 cancel_work_sync(&wl
->tx_work
);
1440 cancel_delayed_work_sync(&wl
->pspoll_work
);
1441 cancel_delayed_work_sync(&wl
->elp_work
);
1443 mutex_lock(&wl
->mutex
);
1445 /* let's notify MAC80211 about the remaining pending TX frames */
1446 wl1271_tx_reset(wl
);
1447 wl1271_power_off(wl
);
1449 memset(wl
->bssid
, 0, ETH_ALEN
);
1450 memset(wl
->ssid
, 0, IW_ESSID_MAX_SIZE
+ 1);
1452 wl
->bss_type
= MAX_BSS_TYPE
;
1453 wl
->set_bss_type
= MAX_BSS_TYPE
;
1454 wl
->band
= IEEE80211_BAND_2GHZ
;
1457 wl
->psm_entry_retry
= 0;
1458 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1459 wl
->tx_blocks_available
= 0;
1460 wl
->tx_results_count
= 0;
1461 wl
->tx_packets_count
= 0;
1462 wl
->tx_security_last_seq
= 0;
1463 wl
->tx_security_seq
= 0;
1464 wl
->time_offset
= 0;
1465 wl
->session_counter
= 0;
1466 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1470 wl1271_free_ap_keys(wl
);
1471 memset(wl
->ap_hlid_map
, 0, sizeof(wl
->ap_hlid_map
));
1472 wl
->ap_fw_ps_map
= 0;
1476 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
1477 wl
->tx_blocks_freed
[i
] = 0;
1479 wl1271_debugfs_reset(wl
);
1481 kfree(wl
->fw_status
);
1482 wl
->fw_status
= NULL
;
1483 kfree(wl
->tx_res_if
);
1484 wl
->tx_res_if
= NULL
;
1485 kfree(wl
->target_mem_map
);
1486 wl
->target_mem_map
= NULL
;
1489 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
1490 struct ieee80211_vif
*vif
)
1492 struct wl1271
*wl
= hw
->priv
;
1494 mutex_lock(&wl
->mutex
);
1496 * wl->vif can be null here if someone shuts down the interface
1497 * just when hardware recovery has been started.
1500 WARN_ON(wl
->vif
!= vif
);
1501 __wl1271_op_remove_interface(wl
);
1504 mutex_unlock(&wl
->mutex
);
1505 cancel_work_sync(&wl
->recovery_work
);
1508 static void wl1271_configure_filters(struct wl1271
*wl
, unsigned int filters
)
1510 wl1271_set_default_filters(wl
);
1512 /* combine requested filters with current filter config */
1513 filters
= wl
->filters
| filters
;
1515 wl1271_debug(DEBUG_FILTERS
, "RX filters set: ");
1517 if (filters
& FIF_PROMISC_IN_BSS
) {
1518 wl1271_debug(DEBUG_FILTERS
, " - FIF_PROMISC_IN_BSS");
1519 wl
->rx_config
&= ~CFG_UNI_FILTER_EN
;
1520 wl
->rx_config
|= CFG_BSSID_FILTER_EN
;
1522 if (filters
& FIF_BCN_PRBRESP_PROMISC
) {
1523 wl1271_debug(DEBUG_FILTERS
, " - FIF_BCN_PRBRESP_PROMISC");
1524 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1525 wl
->rx_config
&= ~CFG_SSID_FILTER_EN
;
1527 if (filters
& FIF_OTHER_BSS
) {
1528 wl1271_debug(DEBUG_FILTERS
, " - FIF_OTHER_BSS");
1529 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1531 if (filters
& FIF_CONTROL
) {
1532 wl1271_debug(DEBUG_FILTERS
, " - FIF_CONTROL");
1533 wl
->rx_filter
|= CFG_RX_CTL_EN
;
1535 if (filters
& FIF_FCSFAIL
) {
1536 wl1271_debug(DEBUG_FILTERS
, " - FIF_FCSFAIL");
1537 wl
->rx_filter
|= CFG_RX_FCS_ERROR
;
1541 static int wl1271_dummy_join(struct wl1271
*wl
)
1544 /* we need to use a dummy BSSID for now */
1545 static const u8 dummy_bssid
[ETH_ALEN
] = { 0x0b, 0xad, 0xde,
1548 memcpy(wl
->bssid
, dummy_bssid
, ETH_ALEN
);
1550 /* pass through frames from all BSS */
1551 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
1553 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
1557 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1563 static int wl1271_join(struct wl1271
*wl
, bool set_assoc
)
1568 * One of the side effects of the JOIN command is that is clears
1569 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1570 * to a WPA/WPA2 access point will therefore kill the data-path.
1571 * Currently there is no supported scenario for JOIN during
1572 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1573 * must be handled somehow.
1576 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1577 wl1271_info("JOIN while associated.");
1580 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
1582 ret
= wl1271_cmd_join(wl
, wl
->set_bss_type
);
1586 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1588 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1592 * The join command disable the keep-alive mode, shut down its process,
1593 * and also clear the template config, so we need to reset it all after
1594 * the join. The acx_aid starts the keep-alive process, and the order
1595 * of the commands below is relevant.
1597 ret
= wl1271_acx_keep_alive_mode(wl
, true);
1601 ret
= wl1271_acx_aid(wl
, wl
->aid
);
1605 ret
= wl1271_cmd_build_klv_null_data(wl
);
1609 ret
= wl1271_acx_keep_alive_config(wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
1610 ACX_KEEP_ALIVE_TPL_VALID
);
1618 static int wl1271_unjoin(struct wl1271
*wl
)
1622 /* to stop listening to a channel, we disconnect */
1623 ret
= wl1271_cmd_disconnect(wl
);
1627 clear_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1628 memset(wl
->bssid
, 0, ETH_ALEN
);
1630 /* stop filterting packets based on bssid */
1631 wl1271_configure_filters(wl
, FIF_OTHER_BSS
);
1637 static void wl1271_set_band_rate(struct wl1271
*wl
)
1639 if (wl
->band
== IEEE80211_BAND_2GHZ
)
1640 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate
;
1642 wl
->basic_rate_set
= wl
->conf
.tx
.basic_rate_5
;
1645 static int wl1271_sta_handle_idle(struct wl1271
*wl
, bool idle
)
1650 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
1651 ret
= wl1271_unjoin(wl
);
1655 wl
->rate_set
= wl1271_tx_min_rate_get(wl
);
1656 ret
= wl1271_acx_sta_rate_policies(wl
);
1659 ret
= wl1271_acx_keep_alive_config(
1660 wl
, CMD_TEMPL_KLV_IDX_NULL_DATA
,
1661 ACX_KEEP_ALIVE_TPL_INVALID
);
1664 set_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
1666 /* increment the session counter */
1667 wl
->session_counter
++;
1668 if (wl
->session_counter
>= SESSION_COUNTER_MAX
)
1669 wl
->session_counter
= 0;
1670 ret
= wl1271_dummy_join(wl
);
1673 clear_bit(WL1271_FLAG_IDLE
, &wl
->flags
);
1680 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
1682 struct wl1271
*wl
= hw
->priv
;
1683 struct ieee80211_conf
*conf
= &hw
->conf
;
1684 int channel
, ret
= 0;
1687 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
1689 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s"
1692 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
1694 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
1698 * mac80211 will go to idle nearly immediately after transmitting some
1699 * frames, such as the deauth. To make sure those frames reach the air,
1700 * wait here until the TX queue is fully flushed.
1702 if ((changed
& IEEE80211_CONF_CHANGE_IDLE
) &&
1703 (conf
->flags
& IEEE80211_CONF_IDLE
))
1704 wl1271_tx_flush(wl
);
1706 mutex_lock(&wl
->mutex
);
1708 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
1709 /* we support configuring the channel and band while off */
1710 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
)) {
1711 wl
->band
= conf
->channel
->band
;
1712 wl
->channel
= channel
;
1718 is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
1720 ret
= wl1271_ps_elp_wakeup(wl
);
1724 /* if the channel changes while joined, join again */
1725 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
&&
1726 ((wl
->band
!= conf
->channel
->band
) ||
1727 (wl
->channel
!= channel
))) {
1728 wl
->band
= conf
->channel
->band
;
1729 wl
->channel
= channel
;
1733 * FIXME: the mac80211 should really provide a fixed
1734 * rate to use here. for now, just use the smallest
1735 * possible rate for the band as a fixed rate for
1736 * association frames and other control messages.
1738 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
))
1739 wl1271_set_band_rate(wl
);
1741 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
1742 ret
= wl1271_acx_sta_rate_policies(wl
);
1744 wl1271_warning("rate policy for channel "
1747 if (test_bit(WL1271_FLAG_JOINED
, &wl
->flags
)) {
1748 ret
= wl1271_join(wl
, false);
1750 wl1271_warning("cmd join on channel "
1756 if (changed
& IEEE80211_CONF_CHANGE_IDLE
&& !is_ap
) {
1757 ret
= wl1271_sta_handle_idle(wl
,
1758 conf
->flags
& IEEE80211_CONF_IDLE
);
1760 wl1271_warning("idle mode change failed %d", ret
);
1764 * if mac80211 changes the PSM mode, make sure the mode is not
1765 * incorrectly changed after the pspoll failure active window.
1767 if (changed
& IEEE80211_CONF_CHANGE_PS
)
1768 clear_bit(WL1271_FLAG_PSPOLL_FAILURE
, &wl
->flags
);
1770 if (conf
->flags
& IEEE80211_CONF_PS
&&
1771 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1772 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1775 * We enter PSM only if we're already associated.
1776 * If we're not, we'll enter it when joining an SSID,
1777 * through the bss_info_changed() hook.
1779 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
1780 wl1271_debug(DEBUG_PSM
, "psm enabled");
1781 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
,
1782 wl
->basic_rate
, true);
1784 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
1785 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1786 wl1271_debug(DEBUG_PSM
, "psm disabled");
1788 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1790 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
1791 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
,
1792 wl
->basic_rate
, true);
1795 if (conf
->power_level
!= wl
->power_level
) {
1796 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
1800 wl
->power_level
= conf
->power_level
;
1804 wl1271_ps_elp_sleep(wl
);
1807 mutex_unlock(&wl
->mutex
);
1812 struct wl1271_filter_params
{
1815 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
1818 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
1819 struct netdev_hw_addr_list
*mc_list
)
1821 struct wl1271_filter_params
*fp
;
1822 struct netdev_hw_addr
*ha
;
1823 struct wl1271
*wl
= hw
->priv
;
1825 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
1828 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
1830 wl1271_error("Out of memory setting filters.");
1834 /* update multicast filtering parameters */
1835 fp
->mc_list_length
= 0;
1836 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
1837 fp
->enabled
= false;
1840 netdev_hw_addr_list_for_each(ha
, mc_list
) {
1841 memcpy(fp
->mc_list
[fp
->mc_list_length
],
1842 ha
->addr
, ETH_ALEN
);
1843 fp
->mc_list_length
++;
1847 return (u64
)(unsigned long)fp
;
1850 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1853 FIF_BCN_PRBRESP_PROMISC | \
1857 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
1858 unsigned int changed
,
1859 unsigned int *total
, u64 multicast
)
1861 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
1862 struct wl1271
*wl
= hw
->priv
;
1865 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
1866 " total %x", changed
, *total
);
1868 mutex_lock(&wl
->mutex
);
1870 *total
&= WL1271_SUPPORTED_FILTERS
;
1871 changed
&= WL1271_SUPPORTED_FILTERS
;
1873 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
1876 ret
= wl1271_ps_elp_wakeup(wl
);
1880 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
) {
1881 if (*total
& FIF_ALLMULTI
)
1882 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
1884 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
1886 fp
->mc_list_length
);
1891 /* determine, whether supported filter values have changed */
1895 /* configure filters */
1896 wl
->filters
= *total
;
1897 wl1271_configure_filters(wl
, 0);
1899 /* apply configured filters */
1900 ret
= wl1271_acx_rx_config(wl
, wl
->rx_config
, wl
->rx_filter
);
1905 wl1271_ps_elp_sleep(wl
);
1908 mutex_unlock(&wl
->mutex
);
1912 static int wl1271_record_ap_key(struct wl1271
*wl
, u8 id
, u8 key_type
,
1913 u8 key_size
, const u8
*key
, u8 hlid
, u32 tx_seq_32
,
1916 struct wl1271_ap_key
*ap_key
;
1919 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
1921 if (key_size
> MAX_KEY_SIZE
)
1925 * Find next free entry in ap_keys. Also check we are not replacing
1928 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
1929 if (wl
->recorded_ap_keys
[i
] == NULL
)
1932 if (wl
->recorded_ap_keys
[i
]->id
== id
) {
1933 wl1271_warning("trying to record key replacement");
1938 if (i
== MAX_NUM_KEYS
)
1941 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
1946 ap_key
->key_type
= key_type
;
1947 ap_key
->key_size
= key_size
;
1948 memcpy(ap_key
->key
, key
, key_size
);
1949 ap_key
->hlid
= hlid
;
1950 ap_key
->tx_seq_32
= tx_seq_32
;
1951 ap_key
->tx_seq_16
= tx_seq_16
;
1953 wl
->recorded_ap_keys
[i
] = ap_key
;
1957 static void wl1271_free_ap_keys(struct wl1271
*wl
)
1961 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
1962 kfree(wl
->recorded_ap_keys
[i
]);
1963 wl
->recorded_ap_keys
[i
] = NULL
;
1967 static int wl1271_ap_init_hwenc(struct wl1271
*wl
)
1970 struct wl1271_ap_key
*key
;
1971 bool wep_key_added
= false;
1973 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
1974 if (wl
->recorded_ap_keys
[i
] == NULL
)
1977 key
= wl
->recorded_ap_keys
[i
];
1978 ret
= wl1271_cmd_set_ap_key(wl
, KEY_ADD_OR_REPLACE
,
1979 key
->id
, key
->key_type
,
1980 key
->key_size
, key
->key
,
1981 key
->hlid
, key
->tx_seq_32
,
1986 if (key
->key_type
== KEY_WEP
)
1987 wep_key_added
= true;
1990 if (wep_key_added
) {
1991 ret
= wl1271_cmd_set_ap_default_wep_key(wl
, wl
->default_key
);
1997 wl1271_free_ap_keys(wl
);
2001 static int wl1271_set_key(struct wl1271
*wl
, u16 action
, u8 id
, u8 key_type
,
2002 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
2003 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
2006 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2009 struct wl1271_station
*wl_sta
;
2013 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2014 hlid
= wl_sta
->hlid
;
2016 hlid
= WL1271_AP_BROADCAST_HLID
;
2019 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2021 * We do not support removing keys after AP shutdown.
2022 * Pretend we do to make mac80211 happy.
2024 if (action
!= KEY_ADD_OR_REPLACE
)
2027 ret
= wl1271_record_ap_key(wl
, id
,
2029 key
, hlid
, tx_seq_32
,
2032 ret
= wl1271_cmd_set_ap_key(wl
, action
,
2033 id
, key_type
, key_size
,
2034 key
, hlid
, tx_seq_32
,
2042 static const u8 bcast_addr
[ETH_ALEN
] = {
2043 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2046 addr
= sta
? sta
->addr
: bcast_addr
;
2048 if (is_zero_ether_addr(addr
)) {
2049 /* We dont support TX only encryption */
2053 /* The wl1271 does not allow to remove unicast keys - they
2054 will be cleared automatically on next CMD_JOIN. Ignore the
2055 request silently, as we dont want the mac80211 to emit
2056 an error message. */
2057 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
2060 ret
= wl1271_cmd_set_sta_key(wl
, action
,
2061 id
, key_type
, key_size
,
2062 key
, addr
, tx_seq_32
,
2067 /* the default WEP key needs to be configured at least once */
2068 if (key_type
== KEY_WEP
) {
2069 ret
= wl1271_cmd_set_sta_default_wep_key(wl
,
2079 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
2080 struct ieee80211_vif
*vif
,
2081 struct ieee80211_sta
*sta
,
2082 struct ieee80211_key_conf
*key_conf
)
2084 struct wl1271
*wl
= hw
->priv
;
2090 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
2092 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
2093 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2094 key_conf
->cipher
, key_conf
->keyidx
,
2095 key_conf
->keylen
, key_conf
->flags
);
2096 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
2098 mutex_lock(&wl
->mutex
);
2100 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2105 ret
= wl1271_ps_elp_wakeup(wl
);
2109 switch (key_conf
->cipher
) {
2110 case WLAN_CIPHER_SUITE_WEP40
:
2111 case WLAN_CIPHER_SUITE_WEP104
:
2114 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2116 case WLAN_CIPHER_SUITE_TKIP
:
2117 key_type
= KEY_TKIP
;
2119 key_conf
->hw_key_idx
= key_conf
->keyidx
;
2120 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2121 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2123 case WLAN_CIPHER_SUITE_CCMP
:
2126 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2127 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2128 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2130 case WL1271_CIPHER_SUITE_GEM
:
2132 tx_seq_32
= WL1271_TX_SECURITY_HI32(wl
->tx_security_seq
);
2133 tx_seq_16
= WL1271_TX_SECURITY_LO16(wl
->tx_security_seq
);
2136 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
2144 ret
= wl1271_set_key(wl
, KEY_ADD_OR_REPLACE
,
2145 key_conf
->keyidx
, key_type
,
2146 key_conf
->keylen
, key_conf
->key
,
2147 tx_seq_32
, tx_seq_16
, sta
);
2149 wl1271_error("Could not add or replace key");
2155 ret
= wl1271_set_key(wl
, KEY_REMOVE
,
2156 key_conf
->keyidx
, key_type
,
2157 key_conf
->keylen
, key_conf
->key
,
2160 wl1271_error("Could not remove key");
2166 wl1271_error("Unsupported key cmd 0x%x", cmd
);
2172 wl1271_ps_elp_sleep(wl
);
2175 mutex_unlock(&wl
->mutex
);
2180 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
2181 struct ieee80211_vif
*vif
,
2182 struct cfg80211_scan_request
*req
)
2184 struct wl1271
*wl
= hw
->priv
;
2189 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
2192 ssid
= req
->ssids
[0].ssid
;
2193 len
= req
->ssids
[0].ssid_len
;
2196 mutex_lock(&wl
->mutex
);
2198 if (wl
->state
== WL1271_STATE_OFF
) {
2200 * We cannot return -EBUSY here because cfg80211 will expect
2201 * a call to ieee80211_scan_completed if we do - in this case
2202 * there won't be any call.
2208 ret
= wl1271_ps_elp_wakeup(wl
);
2212 ret
= wl1271_scan(hw
->priv
, ssid
, len
, req
);
2214 wl1271_ps_elp_sleep(wl
);
2217 mutex_unlock(&wl
->mutex
);
2222 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
2224 struct wl1271
*wl
= hw
->priv
;
2227 mutex_lock(&wl
->mutex
);
2229 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2234 ret
= wl1271_ps_elp_wakeup(wl
);
2238 ret
= wl1271_acx_frag_threshold(wl
, (u16
)value
);
2240 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
2242 wl1271_ps_elp_sleep(wl
);
2245 mutex_unlock(&wl
->mutex
);
2250 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
2252 struct wl1271
*wl
= hw
->priv
;
2255 mutex_lock(&wl
->mutex
);
2257 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
2262 ret
= wl1271_ps_elp_wakeup(wl
);
2266 ret
= wl1271_acx_rts_threshold(wl
, (u16
) value
);
2268 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
2270 wl1271_ps_elp_sleep(wl
);
2273 mutex_unlock(&wl
->mutex
);
2278 static int wl1271_ssid_set(struct wl1271
*wl
, struct sk_buff
*skb
,
2281 u8
*ptr
= skb
->data
+ offset
;
2283 /* find the location of the ssid in the beacon */
2284 while (ptr
< skb
->data
+ skb
->len
) {
2285 if (ptr
[0] == WLAN_EID_SSID
) {
2286 wl
->ssid_len
= ptr
[1];
2287 memcpy(wl
->ssid
, ptr
+2, wl
->ssid_len
);
2290 ptr
+= (ptr
[1] + 2);
2293 wl1271_error("No SSID in IEs!\n");
2297 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
2298 struct ieee80211_bss_conf
*bss_conf
,
2303 if (changed
& BSS_CHANGED_ERP_SLOT
) {
2304 if (bss_conf
->use_short_slot
)
2305 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
2307 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
2309 wl1271_warning("Set slot time failed %d", ret
);
2314 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
2315 if (bss_conf
->use_short_preamble
)
2316 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
2318 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
2321 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
2322 if (bss_conf
->use_cts_prot
)
2323 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
2325 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
2327 wl1271_warning("Set ctsprotect failed %d", ret
);
2336 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
2337 struct ieee80211_vif
*vif
,
2338 struct ieee80211_bss_conf
*bss_conf
,
2341 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2344 if ((changed
& BSS_CHANGED_BEACON_INT
)) {
2345 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
2346 bss_conf
->beacon_int
);
2348 wl
->beacon_int
= bss_conf
->beacon_int
;
2351 if ((changed
& BSS_CHANGED_BEACON
)) {
2352 struct ieee80211_hdr
*hdr
;
2353 int ieoffset
= offsetof(struct ieee80211_mgmt
,
2355 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
2361 wl1271_debug(DEBUG_MASTER
, "beacon updated");
2363 ret
= wl1271_ssid_set(wl
, beacon
, ieoffset
);
2365 dev_kfree_skb(beacon
);
2368 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
2370 ret
= wl1271_cmd_template_set(wl
, tmpl_id
,
2373 wl1271_tx_min_rate_get(wl
));
2375 dev_kfree_skb(beacon
);
2379 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
2380 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
2381 IEEE80211_STYPE_PROBE_RESP
);
2383 tmpl_id
= is_ap
? CMD_TEMPL_AP_PROBE_RESPONSE
:
2384 CMD_TEMPL_PROBE_RESPONSE
;
2385 ret
= wl1271_cmd_template_set(wl
,
2389 wl1271_tx_min_rate_get(wl
));
2390 dev_kfree_skb(beacon
);
2399 /* AP mode changes */
2400 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
2401 struct ieee80211_vif
*vif
,
2402 struct ieee80211_bss_conf
*bss_conf
,
2407 if ((changed
& BSS_CHANGED_BASIC_RATES
)) {
2408 u32 rates
= bss_conf
->basic_rates
;
2409 struct conf_tx_rate_class mgmt_rc
;
2411 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
);
2412 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2413 wl1271_debug(DEBUG_AP
, "basic rates: 0x%x",
2414 wl
->basic_rate_set
);
2416 /* update the AP management rate policy with the new rates */
2417 mgmt_rc
.enabled_rates
= wl
->basic_rate_set
;
2418 mgmt_rc
.long_retry_limit
= 10;
2419 mgmt_rc
.short_retry_limit
= 10;
2421 ret
= wl1271_acx_ap_rate_policy(wl
, &mgmt_rc
,
2422 ACX_TX_AP_MODE_MGMT_RATE
);
2424 wl1271_error("AP mgmt policy change failed %d", ret
);
2429 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
2433 if ((changed
& BSS_CHANGED_BEACON_ENABLED
)) {
2434 if (bss_conf
->enable_beacon
) {
2435 if (!test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2436 ret
= wl1271_cmd_start_bss(wl
);
2440 set_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
2441 wl1271_debug(DEBUG_AP
, "started AP");
2443 ret
= wl1271_ap_init_hwenc(wl
);
2448 if (test_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
)) {
2449 ret
= wl1271_cmd_stop_bss(wl
);
2453 clear_bit(WL1271_FLAG_AP_STARTED
, &wl
->flags
);
2454 wl1271_debug(DEBUG_AP
, "stopped AP");
2459 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
2466 /* STA/IBSS mode changes */
2467 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
2468 struct ieee80211_vif
*vif
,
2469 struct ieee80211_bss_conf
*bss_conf
,
2472 bool do_join
= false, set_assoc
= false;
2473 bool is_ibss
= (wl
->bss_type
== BSS_TYPE_IBSS
);
2474 u32 sta_rate_set
= 0;
2476 struct ieee80211_sta
*sta
;
2477 bool sta_exists
= false;
2478 struct ieee80211_sta_ht_cap sta_ht_cap
;
2481 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
2487 if ((changed
& BSS_CHANGED_BEACON_INT
) && is_ibss
)
2490 /* Need to update the SSID (for filtering etc) */
2491 if ((changed
& BSS_CHANGED_BEACON
) && is_ibss
)
2494 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && is_ibss
) {
2495 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
2496 bss_conf
->enable_beacon
? "enabled" : "disabled");
2498 if (bss_conf
->enable_beacon
)
2499 wl
->set_bss_type
= BSS_TYPE_IBSS
;
2501 wl
->set_bss_type
= BSS_TYPE_STA_BSS
;
2505 if ((changed
& BSS_CHANGED_CQM
)) {
2506 bool enable
= false;
2507 if (bss_conf
->cqm_rssi_thold
)
2509 ret
= wl1271_acx_rssi_snr_trigger(wl
, enable
,
2510 bss_conf
->cqm_rssi_thold
,
2511 bss_conf
->cqm_rssi_hyst
);
2514 wl
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
2517 if ((changed
& BSS_CHANGED_BSSID
) &&
2519 * Now we know the correct bssid, so we send a new join command
2520 * and enable the BSSID filter
2522 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
2523 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
2525 if (!is_zero_ether_addr(wl
->bssid
)) {
2526 ret
= wl1271_cmd_build_null_data(wl
);
2530 ret
= wl1271_build_qos_null_data(wl
);
2534 /* filter out all packets not from this BSSID */
2535 wl1271_configure_filters(wl
, 0);
2537 /* Need to update the BSSID (for filtering etc) */
2543 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
2545 /* save the supp_rates of the ap */
2546 sta_rate_set
= sta
->supp_rates
[wl
->hw
->conf
.channel
->band
];
2547 if (sta
->ht_cap
.ht_supported
)
2549 (sta
->ht_cap
.mcs
.rx_mask
[0] << HW_HT_RATES_OFFSET
);
2550 sta_ht_cap
= sta
->ht_cap
;
2556 /* handle new association with HT and HT information change */
2557 if ((changed
& BSS_CHANGED_HT
) &&
2558 (bss_conf
->channel_type
!= NL80211_CHAN_NO_HT
)) {
2559 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
2562 wl1271_warning("Set ht cap true failed %d",
2566 ret
= wl1271_acx_set_ht_information(wl
,
2567 bss_conf
->ht_operation_mode
);
2569 wl1271_warning("Set ht information failed %d",
2574 /* handle new association without HT and disassociation */
2575 else if (changed
& BSS_CHANGED_ASSOC
) {
2576 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta_ht_cap
,
2579 wl1271_warning("Set ht cap false failed %d",
2586 if ((changed
& BSS_CHANGED_ASSOC
)) {
2587 if (bss_conf
->assoc
) {
2590 wl
->aid
= bss_conf
->aid
;
2593 wl
->ps_poll_failures
= 0;
2596 * use basic rates from AP, and determine lowest rate
2597 * to use with control frames.
2599 rates
= bss_conf
->basic_rates
;
2600 wl
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
,
2602 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2604 wl
->rate_set
= wl1271_tx_enabled_rates_get(wl
,
2606 ret
= wl1271_acx_sta_rate_policies(wl
);
2611 * with wl1271, we don't need to update the
2612 * beacon_int and dtim_period, because the firmware
2613 * updates it by itself when the first beacon is
2614 * received after a join.
2616 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
2621 * Get a template for hardware connection maintenance
2623 dev_kfree_skb(wl
->probereq
);
2624 wl
->probereq
= wl1271_cmd_build_ap_probe_req(wl
, NULL
);
2625 ieoffset
= offsetof(struct ieee80211_mgmt
,
2626 u
.probe_req
.variable
);
2627 wl1271_ssid_set(wl
, wl
->probereq
, ieoffset
);
2629 /* enable the connection monitoring feature */
2630 ret
= wl1271_acx_conn_monit_params(wl
, true);
2634 /* If we want to go in PSM but we're not there yet */
2635 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
2636 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
2637 enum wl1271_cmd_ps_mode mode
;
2639 mode
= STATION_POWER_SAVE_MODE
;
2640 ret
= wl1271_ps_set_mode(wl
, mode
,
2647 /* use defaults when not associated */
2648 clear_bit(WL1271_FLAG_STA_STATE_SENT
, &wl
->flags
);
2649 clear_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
2652 /* free probe-request template */
2653 dev_kfree_skb(wl
->probereq
);
2654 wl
->probereq
= NULL
;
2656 /* re-enable dynamic ps - just in case */
2657 ieee80211_enable_dyn_ps(wl
->vif
);
2659 /* revert back to minimum rates for the current band */
2660 wl1271_set_band_rate(wl
);
2661 wl
->basic_rate
= wl1271_tx_min_rate_get(wl
);
2662 ret
= wl1271_acx_sta_rate_policies(wl
);
2666 /* disable connection monitor features */
2667 ret
= wl1271_acx_conn_monit_params(wl
, false);
2669 /* Disable the keep-alive feature */
2670 ret
= wl1271_acx_keep_alive_mode(wl
, false);
2674 /* restore the bssid filter and go to dummy bssid */
2676 wl1271_dummy_join(wl
);
2680 ret
= wl1271_bss_erp_info_changed(wl
, bss_conf
, changed
);
2684 if (changed
& BSS_CHANGED_ARP_FILTER
) {
2685 __be32 addr
= bss_conf
->arp_addr_list
[0];
2686 WARN_ON(wl
->bss_type
!= BSS_TYPE_STA_BSS
);
2688 if (bss_conf
->arp_addr_cnt
== 1 &&
2689 bss_conf
->arp_filter_enabled
) {
2691 * The template should have been configured only upon
2692 * association. however, it seems that the correct ip
2693 * isn't being set (when sending), so we have to
2694 * reconfigure the template upon every ip change.
2696 ret
= wl1271_cmd_build_arp_rsp(wl
, addr
);
2698 wl1271_warning("build arp rsp failed: %d", ret
);
2702 ret
= wl1271_acx_arp_ip_filter(wl
,
2703 ACX_ARP_FILTER_ARP_FILTERING
,
2706 ret
= wl1271_acx_arp_ip_filter(wl
, 0, addr
);
2713 ret
= wl1271_join(wl
, set_assoc
);
2715 wl1271_warning("cmd join failed %d", ret
);
2724 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
2725 struct ieee80211_vif
*vif
,
2726 struct ieee80211_bss_conf
*bss_conf
,
2729 struct wl1271
*wl
= hw
->priv
;
2730 bool is_ap
= (wl
->bss_type
== BSS_TYPE_AP_BSS
);
2733 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed 0x%x",
2736 mutex_lock(&wl
->mutex
);
2738 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2741 ret
= wl1271_ps_elp_wakeup(wl
);
2746 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
2748 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
2750 wl1271_ps_elp_sleep(wl
);
2753 mutex_unlock(&wl
->mutex
);
2756 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
, u16 queue
,
2757 const struct ieee80211_tx_queue_params
*params
)
2759 struct wl1271
*wl
= hw
->priv
;
2763 mutex_lock(&wl
->mutex
);
2765 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
2768 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
2770 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
2772 if (wl
->state
== WL1271_STATE_OFF
) {
2774 * If the state is off, the parameters will be recorded and
2775 * configured on init. This happens in AP-mode.
2777 struct conf_tx_ac_category
*conf_ac
=
2778 &wl
->conf
.tx
.ac_conf
[wl1271_tx_get_queue(queue
)];
2779 struct conf_tx_tid
*conf_tid
=
2780 &wl
->conf
.tx
.tid_conf
[wl1271_tx_get_queue(queue
)];
2782 conf_ac
->ac
= wl1271_tx_get_queue(queue
);
2783 conf_ac
->cw_min
= (u8
)params
->cw_min
;
2784 conf_ac
->cw_max
= params
->cw_max
;
2785 conf_ac
->aifsn
= params
->aifs
;
2786 conf_ac
->tx_op_limit
= params
->txop
<< 5;
2788 conf_tid
->queue_id
= wl1271_tx_get_queue(queue
);
2789 conf_tid
->channel_type
= CONF_CHANNEL_TYPE_EDCF
;
2790 conf_tid
->tsid
= wl1271_tx_get_queue(queue
);
2791 conf_tid
->ps_scheme
= ps_scheme
;
2792 conf_tid
->ack_policy
= CONF_ACK_POLICY_LEGACY
;
2793 conf_tid
->apsd_conf
[0] = 0;
2794 conf_tid
->apsd_conf
[1] = 0;
2798 ret
= wl1271_ps_elp_wakeup(wl
);
2803 * the txop is confed in units of 32us by the mac80211,
2806 ret
= wl1271_acx_ac_cfg(wl
, wl1271_tx_get_queue(queue
),
2807 params
->cw_min
, params
->cw_max
,
2808 params
->aifs
, params
->txop
<< 5);
2812 ret
= wl1271_acx_tid_cfg(wl
, wl1271_tx_get_queue(queue
),
2813 CONF_CHANNEL_TYPE_EDCF
,
2814 wl1271_tx_get_queue(queue
),
2815 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
2819 wl1271_ps_elp_sleep(wl
);
2822 mutex_unlock(&wl
->mutex
);
2827 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
)
2830 struct wl1271
*wl
= hw
->priv
;
2831 u64 mactime
= ULLONG_MAX
;
2834 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
2836 mutex_lock(&wl
->mutex
);
2838 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2841 ret
= wl1271_ps_elp_wakeup(wl
);
2845 ret
= wl1271_acx_tsf_info(wl
, &mactime
);
2850 wl1271_ps_elp_sleep(wl
);
2853 mutex_unlock(&wl
->mutex
);
2857 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
2858 struct survey_info
*survey
)
2860 struct wl1271
*wl
= hw
->priv
;
2861 struct ieee80211_conf
*conf
= &hw
->conf
;
2866 survey
->channel
= conf
->channel
;
2867 survey
->filled
= SURVEY_INFO_NOISE_DBM
;
2868 survey
->noise
= wl
->noise
;
2873 static int wl1271_allocate_sta(struct wl1271
*wl
,
2874 struct ieee80211_sta
*sta
,
2877 struct wl1271_station
*wl_sta
;
2880 id
= find_first_zero_bit(wl
->ap_hlid_map
, AP_MAX_STATIONS
);
2881 if (id
>= AP_MAX_STATIONS
) {
2882 wl1271_warning("could not allocate HLID - too much stations");
2886 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2887 __set_bit(id
, wl
->ap_hlid_map
);
2888 wl_sta
->hlid
= WL1271_AP_STA_HLID_START
+ id
;
2889 *hlid
= wl_sta
->hlid
;
2890 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
2894 static void wl1271_free_sta(struct wl1271
*wl
, u8 hlid
)
2896 int id
= hlid
- WL1271_AP_STA_HLID_START
;
2898 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
2901 __clear_bit(id
, wl
->ap_hlid_map
);
2902 memset(wl
->links
[hlid
].addr
, 0, ETH_ALEN
);
2903 wl1271_tx_reset_link_queues(wl
, hlid
);
2904 __clear_bit(hlid
, &wl
->ap_ps_map
);
2905 __clear_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
2908 static int wl1271_op_sta_add(struct ieee80211_hw
*hw
,
2909 struct ieee80211_vif
*vif
,
2910 struct ieee80211_sta
*sta
)
2912 struct wl1271
*wl
= hw
->priv
;
2916 mutex_lock(&wl
->mutex
);
2918 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2921 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
2924 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
2926 ret
= wl1271_allocate_sta(wl
, sta
, &hlid
);
2930 ret
= wl1271_ps_elp_wakeup(wl
);
2934 ret
= wl1271_cmd_add_sta(wl
, sta
, hlid
);
2939 wl1271_ps_elp_sleep(wl
);
2943 wl1271_free_sta(wl
, hlid
);
2946 mutex_unlock(&wl
->mutex
);
2950 static int wl1271_op_sta_remove(struct ieee80211_hw
*hw
,
2951 struct ieee80211_vif
*vif
,
2952 struct ieee80211_sta
*sta
)
2954 struct wl1271
*wl
= hw
->priv
;
2955 struct wl1271_station
*wl_sta
;
2958 mutex_lock(&wl
->mutex
);
2960 if (unlikely(wl
->state
== WL1271_STATE_OFF
))
2963 if (wl
->bss_type
!= BSS_TYPE_AP_BSS
)
2966 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
2968 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
2969 id
= wl_sta
->hlid
- WL1271_AP_STA_HLID_START
;
2970 if (WARN_ON(!test_bit(id
, wl
->ap_hlid_map
)))
2973 ret
= wl1271_ps_elp_wakeup(wl
);
2977 ret
= wl1271_cmd_remove_sta(wl
, wl_sta
->hlid
);
2981 wl1271_free_sta(wl
, wl_sta
->hlid
);
2984 wl1271_ps_elp_sleep(wl
);
2987 mutex_unlock(&wl
->mutex
);
2991 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
2992 struct ieee80211_vif
*vif
,
2993 enum ieee80211_ampdu_mlme_action action
,
2994 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
2997 struct wl1271
*wl
= hw
->priv
;
3000 mutex_lock(&wl
->mutex
);
3002 if (unlikely(wl
->state
== WL1271_STATE_OFF
)) {
3007 ret
= wl1271_ps_elp_wakeup(wl
);
3012 case IEEE80211_AMPDU_RX_START
:
3013 if (wl
->ba_support
) {
3014 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, *ssn
,
3017 wl
->ba_rx_bitmap
|= BIT(tid
);
3023 case IEEE80211_AMPDU_RX_STOP
:
3024 ret
= wl1271_acx_set_ba_receiver_session(wl
, tid
, 0, false);
3026 wl
->ba_rx_bitmap
&= ~BIT(tid
);
3030 * The BA initiator session management in FW independently.
3031 * Falling break here on purpose for all TX APDU commands.
3033 case IEEE80211_AMPDU_TX_START
:
3034 case IEEE80211_AMPDU_TX_STOP
:
3035 case IEEE80211_AMPDU_TX_OPERATIONAL
:
3040 wl1271_error("Incorrect ampdu action id=%x\n", action
);
3044 wl1271_ps_elp_sleep(wl
);
3047 mutex_unlock(&wl
->mutex
);
3052 /* can't be const, mac80211 writes to this */
3053 static struct ieee80211_rate wl1271_rates
[] = {
3055 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
3056 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
3058 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
3059 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
3060 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3062 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
3063 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
3064 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3066 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
3067 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
3068 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
3070 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3071 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3073 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3074 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3076 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3077 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3079 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3080 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3082 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3083 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3085 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3086 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3088 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3089 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3091 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3092 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3095 /* can't be const, mac80211 writes to this */
3096 static struct ieee80211_channel wl1271_channels
[] = {
3097 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
3098 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
3099 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
3100 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
3101 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
3102 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
3103 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
3104 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
3105 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
3106 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
3107 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
3108 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
3109 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
3110 { .hw_value
= 14, .center_freq
= 2484, .max_power
= 25 },
3113 /* mapping to indexes for wl1271_rates */
3114 static const u8 wl1271_rate_to_idx_2ghz
[] = {
3115 /* MCS rates are used only with 11n */
3116 7, /* CONF_HW_RXTX_RATE_MCS7 */
3117 6, /* CONF_HW_RXTX_RATE_MCS6 */
3118 5, /* CONF_HW_RXTX_RATE_MCS5 */
3119 4, /* CONF_HW_RXTX_RATE_MCS4 */
3120 3, /* CONF_HW_RXTX_RATE_MCS3 */
3121 2, /* CONF_HW_RXTX_RATE_MCS2 */
3122 1, /* CONF_HW_RXTX_RATE_MCS1 */
3123 0, /* CONF_HW_RXTX_RATE_MCS0 */
3125 11, /* CONF_HW_RXTX_RATE_54 */
3126 10, /* CONF_HW_RXTX_RATE_48 */
3127 9, /* CONF_HW_RXTX_RATE_36 */
3128 8, /* CONF_HW_RXTX_RATE_24 */
3130 /* TI-specific rate */
3131 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3133 7, /* CONF_HW_RXTX_RATE_18 */
3134 6, /* CONF_HW_RXTX_RATE_12 */
3135 3, /* CONF_HW_RXTX_RATE_11 */
3136 5, /* CONF_HW_RXTX_RATE_9 */
3137 4, /* CONF_HW_RXTX_RATE_6 */
3138 2, /* CONF_HW_RXTX_RATE_5_5 */
3139 1, /* CONF_HW_RXTX_RATE_2 */
3140 0 /* CONF_HW_RXTX_RATE_1 */
3143 /* 11n STA capabilities */
3144 #define HW_RX_HIGHEST_RATE 72
3146 #ifdef CONFIG_WL12XX_HT
3147 #define WL12XX_HT_CAP { \
3148 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3149 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3150 .ht_supported = true, \
3151 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3152 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3154 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3155 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3156 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3160 #define WL12XX_HT_CAP { \
3161 .ht_supported = false, \
3165 /* can't be const, mac80211 writes to this */
3166 static struct ieee80211_supported_band wl1271_band_2ghz
= {
3167 .channels
= wl1271_channels
,
3168 .n_channels
= ARRAY_SIZE(wl1271_channels
),
3169 .bitrates
= wl1271_rates
,
3170 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
3171 .ht_cap
= WL12XX_HT_CAP
,
3174 /* 5 GHz data rates for WL1273 */
3175 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
3177 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
3178 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
3180 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
3181 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
3183 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
3184 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
3186 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
3187 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
3189 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
3190 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
3192 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
3193 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
3195 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
3196 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
3198 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
3199 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
3202 /* 5 GHz band channels for WL1273 */
3203 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
3204 { .hw_value
= 7, .center_freq
= 5035},
3205 { .hw_value
= 8, .center_freq
= 5040},
3206 { .hw_value
= 9, .center_freq
= 5045},
3207 { .hw_value
= 11, .center_freq
= 5055},
3208 { .hw_value
= 12, .center_freq
= 5060},
3209 { .hw_value
= 16, .center_freq
= 5080},
3210 { .hw_value
= 34, .center_freq
= 5170},
3211 { .hw_value
= 36, .center_freq
= 5180},
3212 { .hw_value
= 38, .center_freq
= 5190},
3213 { .hw_value
= 40, .center_freq
= 5200},
3214 { .hw_value
= 42, .center_freq
= 5210},
3215 { .hw_value
= 44, .center_freq
= 5220},
3216 { .hw_value
= 46, .center_freq
= 5230},
3217 { .hw_value
= 48, .center_freq
= 5240},
3218 { .hw_value
= 52, .center_freq
= 5260},
3219 { .hw_value
= 56, .center_freq
= 5280},
3220 { .hw_value
= 60, .center_freq
= 5300},
3221 { .hw_value
= 64, .center_freq
= 5320},
3222 { .hw_value
= 100, .center_freq
= 5500},
3223 { .hw_value
= 104, .center_freq
= 5520},
3224 { .hw_value
= 108, .center_freq
= 5540},
3225 { .hw_value
= 112, .center_freq
= 5560},
3226 { .hw_value
= 116, .center_freq
= 5580},
3227 { .hw_value
= 120, .center_freq
= 5600},
3228 { .hw_value
= 124, .center_freq
= 5620},
3229 { .hw_value
= 128, .center_freq
= 5640},
3230 { .hw_value
= 132, .center_freq
= 5660},
3231 { .hw_value
= 136, .center_freq
= 5680},
3232 { .hw_value
= 140, .center_freq
= 5700},
3233 { .hw_value
= 149, .center_freq
= 5745},
3234 { .hw_value
= 153, .center_freq
= 5765},
3235 { .hw_value
= 157, .center_freq
= 5785},
3236 { .hw_value
= 161, .center_freq
= 5805},
3237 { .hw_value
= 165, .center_freq
= 5825},
3240 /* mapping to indexes for wl1271_rates_5ghz */
3241 static const u8 wl1271_rate_to_idx_5ghz
[] = {
3242 /* MCS rates are used only with 11n */
3243 7, /* CONF_HW_RXTX_RATE_MCS7 */
3244 6, /* CONF_HW_RXTX_RATE_MCS6 */
3245 5, /* CONF_HW_RXTX_RATE_MCS5 */
3246 4, /* CONF_HW_RXTX_RATE_MCS4 */
3247 3, /* CONF_HW_RXTX_RATE_MCS3 */
3248 2, /* CONF_HW_RXTX_RATE_MCS2 */
3249 1, /* CONF_HW_RXTX_RATE_MCS1 */
3250 0, /* CONF_HW_RXTX_RATE_MCS0 */
3252 7, /* CONF_HW_RXTX_RATE_54 */
3253 6, /* CONF_HW_RXTX_RATE_48 */
3254 5, /* CONF_HW_RXTX_RATE_36 */
3255 4, /* CONF_HW_RXTX_RATE_24 */
3257 /* TI-specific rate */
3258 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_22 */
3260 3, /* CONF_HW_RXTX_RATE_18 */
3261 2, /* CONF_HW_RXTX_RATE_12 */
3262 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_11 */
3263 1, /* CONF_HW_RXTX_RATE_9 */
3264 0, /* CONF_HW_RXTX_RATE_6 */
3265 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_5_5 */
3266 CONF_HW_RXTX_RATE_UNSUPPORTED
, /* CONF_HW_RXTX_RATE_2 */
3267 CONF_HW_RXTX_RATE_UNSUPPORTED
/* CONF_HW_RXTX_RATE_1 */
3270 static struct ieee80211_supported_band wl1271_band_5ghz
= {
3271 .channels
= wl1271_channels_5ghz
,
3272 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
3273 .bitrates
= wl1271_rates_5ghz
,
3274 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
3275 .ht_cap
= WL12XX_HT_CAP
,
3278 static const u8
*wl1271_band_rate_to_idx
[] = {
3279 [IEEE80211_BAND_2GHZ
] = wl1271_rate_to_idx_2ghz
,
3280 [IEEE80211_BAND_5GHZ
] = wl1271_rate_to_idx_5ghz
3283 static const struct ieee80211_ops wl1271_ops
= {
3284 .start
= wl1271_op_start
,
3285 .stop
= wl1271_op_stop
,
3286 .add_interface
= wl1271_op_add_interface
,
3287 .remove_interface
= wl1271_op_remove_interface
,
3288 .config
= wl1271_op_config
,
3289 .prepare_multicast
= wl1271_op_prepare_multicast
,
3290 .configure_filter
= wl1271_op_configure_filter
,
3292 .set_key
= wl1271_op_set_key
,
3293 .hw_scan
= wl1271_op_hw_scan
,
3294 .bss_info_changed
= wl1271_op_bss_info_changed
,
3295 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
3296 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
3297 .conf_tx
= wl1271_op_conf_tx
,
3298 .get_tsf
= wl1271_op_get_tsf
,
3299 .get_survey
= wl1271_op_get_survey
,
3300 .sta_add
= wl1271_op_sta_add
,
3301 .sta_remove
= wl1271_op_sta_remove
,
3302 .ampdu_action
= wl1271_op_ampdu_action
,
3303 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
3307 u8
wl1271_rate_to_idx(int rate
, enum ieee80211_band band
)
3311 BUG_ON(band
>= sizeof(wl1271_band_rate_to_idx
)/sizeof(u8
*));
3313 if (unlikely(rate
>= CONF_HW_RXTX_RATE_MAX
)) {
3314 wl1271_error("Illegal RX rate from HW: %d", rate
);
3318 idx
= wl1271_band_rate_to_idx
[band
][rate
];
3319 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
3320 wl1271_error("Unsupported RX rate from HW: %d", rate
);
3327 static ssize_t
wl1271_sysfs_show_bt_coex_state(struct device
*dev
,
3328 struct device_attribute
*attr
,
3331 struct wl1271
*wl
= dev_get_drvdata(dev
);
3336 mutex_lock(&wl
->mutex
);
3337 len
= snprintf(buf
, len
, "%d\n\n0 - off\n1 - on\n",
3339 mutex_unlock(&wl
->mutex
);
3345 static ssize_t
wl1271_sysfs_store_bt_coex_state(struct device
*dev
,
3346 struct device_attribute
*attr
,
3347 const char *buf
, size_t count
)
3349 struct wl1271
*wl
= dev_get_drvdata(dev
);
3353 ret
= strict_strtoul(buf
, 10, &res
);
3356 wl1271_warning("incorrect value written to bt_coex_mode");
3360 mutex_lock(&wl
->mutex
);
3364 if (res
== wl
->sg_enabled
)
3367 wl
->sg_enabled
= res
;
3369 if (wl
->state
== WL1271_STATE_OFF
)
3372 ret
= wl1271_ps_elp_wakeup(wl
);
3376 wl1271_acx_sg_enable(wl
, wl
->sg_enabled
);
3377 wl1271_ps_elp_sleep(wl
);
3380 mutex_unlock(&wl
->mutex
);
3384 static DEVICE_ATTR(bt_coex_state
, S_IRUGO
| S_IWUSR
,
3385 wl1271_sysfs_show_bt_coex_state
,
3386 wl1271_sysfs_store_bt_coex_state
);
3388 static ssize_t
wl1271_sysfs_show_hw_pg_ver(struct device
*dev
,
3389 struct device_attribute
*attr
,
3392 struct wl1271
*wl
= dev_get_drvdata(dev
);
3397 mutex_lock(&wl
->mutex
);
3398 if (wl
->hw_pg_ver
>= 0)
3399 len
= snprintf(buf
, len
, "%d\n", wl
->hw_pg_ver
);
3401 len
= snprintf(buf
, len
, "n/a\n");
3402 mutex_unlock(&wl
->mutex
);
3407 static DEVICE_ATTR(hw_pg_ver
, S_IRUGO
| S_IWUSR
,
3408 wl1271_sysfs_show_hw_pg_ver
, NULL
);
3410 int wl1271_register_hw(struct wl1271
*wl
)
3414 if (wl
->mac80211_registered
)
3417 ret
= wl1271_fetch_nvs(wl
);
3419 /* NOTE: The wl->nvs->nvs element must be first, in
3420 * order to simplify the casting, we assume it is at
3421 * the beginning of the wl->nvs structure.
3423 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
3425 wl
->mac_addr
[0] = nvs_ptr
[11];
3426 wl
->mac_addr
[1] = nvs_ptr
[10];
3427 wl
->mac_addr
[2] = nvs_ptr
[6];
3428 wl
->mac_addr
[3] = nvs_ptr
[5];
3429 wl
->mac_addr
[4] = nvs_ptr
[4];
3430 wl
->mac_addr
[5] = nvs_ptr
[3];
3433 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
3435 ret
= ieee80211_register_hw(wl
->hw
);
3437 wl1271_error("unable to register mac80211 hw: %d", ret
);
3441 wl
->mac80211_registered
= true;
3443 wl1271_debugfs_init(wl
);
3445 register_netdevice_notifier(&wl1271_dev_notifier
);
3447 wl1271_notice("loaded");
3451 EXPORT_SYMBOL_GPL(wl1271_register_hw
);
3453 void wl1271_unregister_hw(struct wl1271
*wl
)
3455 if (wl
->state
== WL1271_STATE_PLT
)
3456 __wl1271_plt_stop(wl
);
3458 unregister_netdevice_notifier(&wl1271_dev_notifier
);
3459 ieee80211_unregister_hw(wl
->hw
);
3460 wl
->mac80211_registered
= false;
3463 EXPORT_SYMBOL_GPL(wl1271_unregister_hw
);
3465 int wl1271_init_ieee80211(struct wl1271
*wl
)
3467 static const u32 cipher_suites
[] = {
3468 WLAN_CIPHER_SUITE_WEP40
,
3469 WLAN_CIPHER_SUITE_WEP104
,
3470 WLAN_CIPHER_SUITE_TKIP
,
3471 WLAN_CIPHER_SUITE_CCMP
,
3472 WL1271_CIPHER_SUITE_GEM
,
3475 /* The tx descriptor buffer and the TKIP space. */
3476 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
3477 sizeof(struct wl1271_tx_hw_descr
);
3480 /* FIXME: find a proper value */
3481 wl
->hw
->channel_change_time
= 10000;
3482 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
3484 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
3485 IEEE80211_HW_BEACON_FILTER
|
3486 IEEE80211_HW_SUPPORTS_PS
|
3487 IEEE80211_HW_SUPPORTS_UAPSD
|
3488 IEEE80211_HW_HAS_RATE_CONTROL
|
3489 IEEE80211_HW_CONNECTION_MONITOR
|
3490 IEEE80211_HW_SUPPORTS_CQM_RSSI
|
3491 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
3492 IEEE80211_HW_AP_LINK_PS
;
3494 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
3495 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
3497 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
3498 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
3499 wl
->hw
->wiphy
->max_scan_ssids
= 1;
3501 * Maximum length of elements in scanning probe request templates
3502 * should be the maximum length possible for a template, without
3503 * the IEEE80211 header of the template
3505 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
3506 sizeof(struct ieee80211_header
);
3508 /* make sure all our channels fit in the scanned_ch bitmask */
3509 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
3510 ARRAY_SIZE(wl1271_channels_5ghz
) >
3511 WL1271_MAX_CHANNELS
);
3513 * We keep local copies of the band structs because we need to
3514 * modify them on a per-device basis.
3516 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
3517 sizeof(wl1271_band_2ghz
));
3518 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
3519 sizeof(wl1271_band_5ghz
));
3521 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
3522 &wl
->bands
[IEEE80211_BAND_2GHZ
];
3523 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
3524 &wl
->bands
[IEEE80211_BAND_5GHZ
];
3527 wl
->hw
->max_rates
= 1;
3529 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
3531 SET_IEEE80211_DEV(wl
->hw
, wl1271_wl_to_dev(wl
));
3533 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
3535 wl
->hw
->max_rx_aggregation_subframes
= 8;
3539 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211
);
3541 #define WL1271_DEFAULT_CHANNEL 0
3543 struct ieee80211_hw
*wl1271_alloc_hw(void)
3545 struct ieee80211_hw
*hw
;
3546 struct platform_device
*plat_dev
= NULL
;
3551 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
3553 wl1271_error("could not alloc ieee80211_hw");
3558 plat_dev
= kmemdup(&wl1271_device
, sizeof(wl1271_device
), GFP_KERNEL
);
3560 wl1271_error("could not allocate platform_device");
3562 goto err_plat_alloc
;
3566 memset(wl
, 0, sizeof(*wl
));
3568 INIT_LIST_HEAD(&wl
->list
);
3571 wl
->plat_dev
= plat_dev
;
3573 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
3574 skb_queue_head_init(&wl
->tx_queue
[i
]);
3576 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
3577 for (j
= 0; j
< AP_MAX_LINKS
; j
++)
3578 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
3580 skb_queue_head_init(&wl
->deferred_rx_queue
);
3581 skb_queue_head_init(&wl
->deferred_tx_queue
);
3583 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
3584 INIT_DELAYED_WORK(&wl
->pspoll_work
, wl1271_pspoll_work
);
3585 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
3586 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
3587 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
3588 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
3589 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
3590 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
3591 wl
->default_key
= 0;
3593 wl
->rx_config
= WL1271_DEFAULT_STA_RX_CONFIG
;
3594 wl
->rx_filter
= WL1271_DEFAULT_STA_RX_FILTER
;
3595 wl
->psm_entry_retry
= 0;
3596 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
3597 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
3598 wl
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
3599 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
3600 wl
->band
= IEEE80211_BAND_2GHZ
;
3603 wl
->sg_enabled
= true;
3605 wl
->bss_type
= MAX_BSS_TYPE
;
3606 wl
->set_bss_type
= MAX_BSS_TYPE
;
3607 wl
->fw_bss_type
= MAX_BSS_TYPE
;
3608 wl
->last_tx_hlid
= 0;
3610 wl
->ap_fw_ps_map
= 0;
3614 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
3615 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
3616 wl
->tx_frames
[i
] = NULL
;
3618 spin_lock_init(&wl
->wl_lock
);
3620 wl
->state
= WL1271_STATE_OFF
;
3621 mutex_init(&wl
->mutex
);
3623 /* Apply default driver configuration. */
3624 wl1271_conf_init(wl
);
3626 order
= get_order(WL1271_AGGR_BUFFER_SIZE
);
3627 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
3628 if (!wl
->aggr_buf
) {
3633 /* Register platform device */
3634 ret
= platform_device_register(wl
->plat_dev
);
3636 wl1271_error("couldn't register platform device");
3639 dev_set_drvdata(&wl
->plat_dev
->dev
, wl
);
3641 /* Create sysfs file to control bt coex state */
3642 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
3644 wl1271_error("failed to create sysfs file bt_coex_state");
3648 /* Create sysfs file to get HW PG version */
3649 ret
= device_create_file(&wl
->plat_dev
->dev
, &dev_attr_hw_pg_ver
);
3651 wl1271_error("failed to create sysfs file hw_pg_ver");
3652 goto err_bt_coex_state
;
3658 device_remove_file(&wl
->plat_dev
->dev
, &dev_attr_bt_coex_state
);
3661 platform_device_unregister(wl
->plat_dev
);
3664 free_pages((unsigned long)wl
->aggr_buf
, order
);
3667 wl1271_debugfs_exit(wl
);
3671 ieee80211_free_hw(hw
);
3675 return ERR_PTR(ret
);
3677 EXPORT_SYMBOL_GPL(wl1271_alloc_hw
);
3679 int wl1271_free_hw(struct wl1271
*wl
)
3681 platform_device_unregister(wl
->plat_dev
);
3682 free_pages((unsigned long)wl
->aggr_buf
,
3683 get_order(WL1271_AGGR_BUFFER_SIZE
));
3684 kfree(wl
->plat_dev
);
3686 wl1271_debugfs_exit(wl
);
3693 kfree(wl
->fw_status
);
3694 kfree(wl
->tx_res_if
);
3696 ieee80211_free_hw(wl
->hw
);
3700 EXPORT_SYMBOL_GPL(wl1271_free_hw
);
3702 u32 wl12xx_debug_level
= DEBUG_NONE
;
3703 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
3704 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
3705 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
3707 MODULE_LICENSE("GPL");
3708 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
3709 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");