2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
33 #include <linux/wl12xx.h>
36 #include "wl12xx_80211.h"
50 #define WL1271_BOOT_RETRIES 3
52 static struct conf_drv_settings default_conf = {
55 [CONF_SG_BT_PER_THRESHOLD] = 7500,
56 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
57 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
58 [CONF_SG_BT_LOAD_RATIO] = 200,
59 [CONF_SG_AUTO_PS_MODE] = 1,
60 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
61 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
62 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
63 [CONF_SG_BEACON_MISS_PERCENT] = 60,
64 [CONF_SG_RATE_ADAPT_THRESH] = 12,
65 [CONF_SG_RATE_ADAPT_SNR] = 0,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
67 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
68 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
70 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
71 /* Note: with UPSD, this should be 4 */
72 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
74 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
75 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
76 /* Note: with UPDS, this should be 15 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
78 /* Note: with UPDS, this should be 50 */
79 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
80 /* Note: with UPDS, this should be 10 */
81 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
84 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
85 [CONF_SG_PS_POLL_TIMEOUT] = 10,
86 [CONF_SG_UPSD_TIMEOUT] = 10,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
92 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
94 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
95 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
97 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
98 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
99 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
100 [CONF_SG_HV3_MAX_SERVED] = 6,
101 [CONF_SG_DHCP_TIME] = 5000,
102 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
104 .state = CONF_SG_PROTECTIVE,
107 .rx_msdu_life_time = 512000,
108 .packet_detection_threshold = 0,
109 .ps_poll_timeout = 15,
111 .rts_threshold = 2347,
112 .rx_cca_threshold = 0,
113 .irq_blk_threshold = 0xFFFF,
114 .irq_pkt_threshold = 0,
116 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
119 .tx_energy_detection = 0,
122 .short_retry_limit = 10,
123 .long_retry_limit = 10,
146 .aifsn = CONF_TX_AIFS_PIFS,
153 .aifsn = CONF_TX_AIFS_PIFS,
159 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
160 .short_retry_limit = 10,
161 .long_retry_limit = 10,
165 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
166 .short_retry_limit = 10,
167 .long_retry_limit = 10,
171 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
172 .short_retry_limit = 10,
173 .long_retry_limit = 10,
177 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
178 .short_retry_limit = 10,
179 .long_retry_limit = 10,
184 .enabled_rates = CONF_TX_AP_DEFAULT_MGMT_RATES,
185 .short_retry_limit = 10,
186 .long_retry_limit = 10,
190 .enabled_rates = CONF_HW_BIT_RATE_1MBPS,
191 .short_retry_limit = 10,
192 .long_retry_limit = 10,
195 .ap_max_tx_retries = 100,
199 .queue_id = CONF_TX_AC_BE,
200 .channel_type = CONF_CHANNEL_TYPE_EDCF,
201 .tsid = CONF_TX_AC_BE,
202 .ps_scheme = CONF_PS_SCHEME_LEGACY,
203 .ack_policy = CONF_ACK_POLICY_LEGACY,
207 .queue_id = CONF_TX_AC_BK,
208 .channel_type = CONF_CHANNEL_TYPE_EDCF,
209 .tsid = CONF_TX_AC_BK,
210 .ps_scheme = CONF_PS_SCHEME_LEGACY,
211 .ack_policy = CONF_ACK_POLICY_LEGACY,
215 .queue_id = CONF_TX_AC_VI,
216 .channel_type = CONF_CHANNEL_TYPE_EDCF,
217 .tsid = CONF_TX_AC_VI,
218 .ps_scheme = CONF_PS_SCHEME_LEGACY,
219 .ack_policy = CONF_ACK_POLICY_LEGACY,
223 .queue_id = CONF_TX_AC_VO,
224 .channel_type = CONF_CHANNEL_TYPE_EDCF,
225 .tsid = CONF_TX_AC_VO,
226 .ps_scheme = CONF_PS_SCHEME_LEGACY,
227 .ack_policy = CONF_ACK_POLICY_LEGACY,
231 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
232 .tx_compl_timeout = 700,
233 .tx_compl_threshold = 4,
234 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
235 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
236 .tmpl_short_retry_limit = 10,
237 .tmpl_long_retry_limit = 10,
240 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
241 .listen_interval = 1,
242 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
243 .bcn_filt_ie_count = 1,
246 .ie = WLAN_EID_CHANNEL_SWITCH,
247 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
250 .synch_fail_thold = 10,
251 .bss_lose_timeout = 100,
252 .beacon_rx_timeout = 10000,
253 .broadcast_timeout = 20000,
254 .rx_broadcast_in_ps = 1,
255 .ps_poll_threshold = 10,
256 .ps_poll_recovery_period = 700,
257 .bet_enable = CONF_BET_MODE_ENABLE,
258 .bet_max_consecutive = 50,
259 .psm_entry_retries = 5,
260 .psm_exit_retries = 255,
261 .psm_entry_nullfunc_retries = 3,
262 .psm_entry_hangover_period = 1,
263 .keep_alive_interval = 55000,
264 .max_listen_interval = 20,
271 .host_clk_settling_time = 5000,
272 .host_fast_wakeup_support = false
276 .avg_weight_rssi_beacon = 20,
277 .avg_weight_rssi_data = 10,
278 .avg_weight_snr_beacon = 20,
279 .avg_weight_snr_data = 10,
282 .min_dwell_time_active = 7500,
283 .max_dwell_time_active = 30000,
284 .min_dwell_time_passive = 100000,
285 .max_dwell_time_passive = 100000,
289 .tx_per_channel_power_compensation_2 = {
290 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
292 .tx_per_channel_power_compensation_5 = {
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
295 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
299 .tx_ba_win_size = 64,
300 .inactivity_timeout = 10000,
306 .tx_min_block_num = 40,
308 .min_req_tx_blocks = 100,
309 .min_req_rx_blocks = 22,
316 .tx_min_block_num = 40,
318 .min_req_tx_blocks = 45,
319 .min_req_rx_blocks = 22,
322 .hci_io_ds = HCI_IO_DS_6MA,
325 static void __wl1271_op_remove_interface(struct wl1271 *wl);
326 static void wl1271_free_ap_keys(struct wl1271 *wl);
329 static void wl1271_device_release(struct device *dev)
334 static struct platform_device wl1271_device = {
338 /* device model insists to have a release function */
340 .release = wl1271_device_release,
344 static DEFINE_MUTEX(wl_list_mutex);
345 static LIST_HEAD(wl_list);
347 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
350 struct net_device *dev = arg;
351 struct wireless_dev *wdev;
353 struct ieee80211_hw *hw;
355 struct wl1271 *wl_temp;
358 /* Check that this notification is for us. */
359 if (what != NETDEV_CHANGE)
362 wdev = dev->ieee80211_ptr;
370 hw = wiphy_priv(wiphy);
375 mutex_lock(&wl_list_mutex);
376 list_for_each_entry(wl, &wl_list, list) {
380 mutex_unlock(&wl_list_mutex);
384 mutex_lock(&wl->mutex);
386 if (wl->state == WL1271_STATE_OFF)
389 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
392 ret = wl1271_ps_elp_wakeup(wl);
396 if ((dev->operstate == IF_OPER_UP) &&
397 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
398 wl1271_cmd_set_sta_state(wl);
399 wl1271_info("Association completed.");
402 wl1271_ps_elp_sleep(wl);
405 mutex_unlock(&wl->mutex);
410 static int wl1271_reg_notify(struct wiphy *wiphy,
411 struct regulatory_request *request)
413 struct ieee80211_supported_band *band;
414 struct ieee80211_channel *ch;
417 band = wiphy->bands[IEEE80211_BAND_5GHZ];
418 for (i = 0; i < band->n_channels; i++) {
419 ch = &band->channels[i];
420 if (ch->flags & IEEE80211_CHAN_DISABLED)
423 if (ch->flags & IEEE80211_CHAN_RADAR)
424 ch->flags |= IEEE80211_CHAN_NO_IBSS |
425 IEEE80211_CHAN_PASSIVE_SCAN;
432 static void wl1271_conf_init(struct wl1271 *wl)
436 * This function applies the default configuration to the driver. This
437 * function is invoked upon driver load (spi probe.)
439 * The configuration is stored in a run-time structure in order to
440 * facilitate for run-time adjustment of any of the parameters. Making
441 * changes to the configuration structure will apply the new values on
442 * the next interface up (wl1271_op_start.)
445 /* apply driver default configuration */
446 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
450 static int wl1271_plt_init(struct wl1271 *wl)
452 struct conf_tx_ac_category *conf_ac;
453 struct conf_tx_tid *conf_tid;
456 if (wl->chip.id == CHIP_ID_1283_PG20)
457 ret = wl128x_cmd_general_parms(wl);
459 ret = wl1271_cmd_general_parms(wl);
463 if (wl->chip.id == CHIP_ID_1283_PG20)
464 ret = wl128x_cmd_radio_parms(wl);
466 ret = wl1271_cmd_radio_parms(wl);
470 if (wl->chip.id != CHIP_ID_1283_PG20) {
471 ret = wl1271_cmd_ext_radio_parms(wl);
478 /* Chip-specific initializations */
479 ret = wl1271_chip_specific_init(wl);
483 ret = wl1271_sta_init_templates_config(wl);
487 ret = wl1271_acx_init_mem_config(wl);
491 /* PHY layer config */
492 ret = wl1271_init_phy_config(wl);
494 goto out_free_memmap;
496 ret = wl1271_acx_dco_itrim_params(wl);
498 goto out_free_memmap;
500 /* Initialize connection monitoring thresholds */
501 ret = wl1271_acx_conn_monit_params(wl, false);
503 goto out_free_memmap;
505 /* Bluetooth WLAN coexistence */
506 ret = wl1271_init_pta(wl);
508 goto out_free_memmap;
510 /* Energy detection */
511 ret = wl1271_init_energy_detection(wl);
513 goto out_free_memmap;
515 ret = wl1271_acx_sta_mem_cfg(wl);
517 goto out_free_memmap;
519 /* Default fragmentation threshold */
520 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
522 goto out_free_memmap;
524 /* Default TID/AC configuration */
525 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
526 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
527 conf_ac = &wl->conf.tx.ac_conf[i];
528 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
529 conf_ac->cw_max, conf_ac->aifsn,
530 conf_ac->tx_op_limit);
532 goto out_free_memmap;
534 conf_tid = &wl->conf.tx.tid_conf[i];
535 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
536 conf_tid->channel_type,
539 conf_tid->ack_policy,
540 conf_tid->apsd_conf[0],
541 conf_tid->apsd_conf[1]);
543 goto out_free_memmap;
546 /* Enable data path */
547 ret = wl1271_cmd_data_path(wl, 1);
549 goto out_free_memmap;
551 /* Configure for CAM power saving (ie. always active) */
552 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
554 goto out_free_memmap;
557 ret = wl1271_acx_pm_config(wl);
559 goto out_free_memmap;
564 kfree(wl->target_mem_map);
565 wl->target_mem_map = NULL;
570 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
574 /* only regulate station links */
575 if (hlid < WL1271_AP_STA_HLID_START)
578 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
581 * Wake up from high level PS if the STA is asleep with too little
582 * blocks in FW or if the STA is awake.
584 if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
585 wl1271_ps_link_end(wl, hlid);
587 /* Start high-level PS if the STA is asleep with enough blocks in FW */
588 else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
589 wl1271_ps_link_start(wl, hlid, true);
592 static void wl1271_irq_update_links_status(struct wl1271 *wl,
593 struct wl1271_fw_ap_status *status)
598 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
599 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
600 wl1271_debug(DEBUG_PSM,
601 "link ps prev 0x%x cur 0x%x changed 0x%x",
602 wl->ap_fw_ps_map, cur_fw_ps_map,
603 wl->ap_fw_ps_map ^ cur_fw_ps_map);
605 wl->ap_fw_ps_map = cur_fw_ps_map;
608 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
609 u8 cnt = status->tx_lnk_free_blks[hlid] -
610 wl->links[hlid].prev_freed_blks;
612 wl->links[hlid].prev_freed_blks =
613 status->tx_lnk_free_blks[hlid];
614 wl->links[hlid].allocated_blks -= cnt;
616 wl1271_irq_ps_regulate_link(wl, hlid,
617 wl->links[hlid].allocated_blks);
621 static void wl1271_fw_status(struct wl1271 *wl,
622 struct wl1271_fw_full_status *full_status)
624 struct wl1271_fw_common_status *status = &full_status->common;
626 u32 old_tx_blk_count = wl->tx_blocks_available;
627 u32 freed_blocks = 0;
630 if (wl->bss_type == BSS_TYPE_AP_BSS) {
631 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
632 sizeof(struct wl1271_fw_ap_status), false);
634 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
635 sizeof(struct wl1271_fw_sta_status), false);
638 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
639 "drv_rx_counter = %d, tx_results_counter = %d)",
641 status->fw_rx_counter,
642 status->drv_rx_counter,
643 status->tx_results_counter);
645 /* update number of available TX blocks */
646 for (i = 0; i < NUM_TX_QUEUES; i++) {
647 freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
648 wl->tx_blocks_freed[i];
650 wl->tx_blocks_freed[i] =
651 le32_to_cpu(status->tx_released_blks[i]);
654 wl->tx_allocated_blocks -= freed_blocks;
656 if (wl->bss_type == BSS_TYPE_AP_BSS) {
657 /* Update num of allocated TX blocks per link and ps status */
658 wl1271_irq_update_links_status(wl, &full_status->ap);
659 wl->tx_blocks_available += freed_blocks;
661 int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
664 * The FW might change the total number of TX memblocks before
665 * we get a notification about blocks being released. Thus, the
666 * available blocks calculation might yield a temporary result
667 * which is lower than the actual available blocks. Keeping in
668 * mind that only blocks that were allocated can be moved from
669 * TX to RX, tx_blocks_available should never decrease here.
671 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
675 /* if more blocks are available now, tx work can be scheduled */
676 if (wl->tx_blocks_available > old_tx_blk_count)
677 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
679 /* update the host-chipset time offset */
681 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
682 (s64)le32_to_cpu(status->fw_localtime);
685 static void wl1271_flush_deferred_work(struct wl1271 *wl)
689 /* Pass all received frames to the network stack */
690 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
691 ieee80211_rx_ni(wl->hw, skb);
693 /* Return sent skbs to the network stack */
694 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
695 ieee80211_tx_status(wl->hw, skb);
698 static void wl1271_netstack_work(struct work_struct *work)
701 container_of(work, struct wl1271, netstack_work);
704 wl1271_flush_deferred_work(wl);
705 } while (skb_queue_len(&wl->deferred_rx_queue));
708 #define WL1271_IRQ_MAX_LOOPS 256
710 irqreturn_t wl1271_irq(int irq, void *cookie)
714 int loopcount = WL1271_IRQ_MAX_LOOPS;
715 struct wl1271 *wl = (struct wl1271 *)cookie;
717 unsigned int defer_count;
720 /* TX might be handled here, avoid redundant work */
721 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
722 cancel_work_sync(&wl->tx_work);
725 * In case edge triggered interrupt must be used, we cannot iterate
726 * more than once without introducing race conditions with the hardirq.
728 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
731 mutex_lock(&wl->mutex);
733 wl1271_debug(DEBUG_IRQ, "IRQ work");
735 if (unlikely(wl->state == WL1271_STATE_OFF))
738 ret = wl1271_ps_elp_wakeup(wl);
742 while (!done && loopcount--) {
744 * In order to avoid a race with the hardirq, clear the flag
745 * before acknowledging the chip. Since the mutex is held,
746 * wl1271_ps_elp_wakeup cannot be called concurrently.
748 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
749 smp_mb__after_clear_bit();
751 wl1271_fw_status(wl, wl->fw_status);
752 intr = le32_to_cpu(wl->fw_status->common.intr);
753 intr &= WL1271_INTR_MASK;
759 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
760 wl1271_error("watchdog interrupt received! "
761 "starting recovery.");
762 ieee80211_queue_work(wl->hw, &wl->recovery_work);
764 /* restarting the chip. ignore any other interrupt. */
768 if (likely(intr & WL1271_ACX_INTR_DATA)) {
769 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
771 wl1271_rx(wl, &wl->fw_status->common);
773 /* Check if any tx blocks were freed */
774 spin_lock_irqsave(&wl->wl_lock, flags);
775 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
776 wl->tx_queue_count) {
777 spin_unlock_irqrestore(&wl->wl_lock, flags);
779 * In order to avoid starvation of the TX path,
780 * call the work function directly.
782 wl1271_tx_work_locked(wl);
784 spin_unlock_irqrestore(&wl->wl_lock, flags);
787 /* check for tx results */
788 if (wl->fw_status->common.tx_results_counter !=
789 (wl->tx_results_count & 0xff))
790 wl1271_tx_complete(wl);
792 /* Make sure the deferred queues don't get too long */
793 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
794 skb_queue_len(&wl->deferred_rx_queue);
795 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
796 wl1271_flush_deferred_work(wl);
799 if (intr & WL1271_ACX_INTR_EVENT_A) {
800 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
801 wl1271_event_handle(wl, 0);
804 if (intr & WL1271_ACX_INTR_EVENT_B) {
805 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
806 wl1271_event_handle(wl, 1);
809 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
810 wl1271_debug(DEBUG_IRQ,
811 "WL1271_ACX_INTR_INIT_COMPLETE");
813 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
814 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
817 wl1271_ps_elp_sleep(wl);
820 spin_lock_irqsave(&wl->wl_lock, flags);
821 /* In case TX was not handled here, queue TX work */
822 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
823 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
825 ieee80211_queue_work(wl->hw, &wl->tx_work);
826 spin_unlock_irqrestore(&wl->wl_lock, flags);
828 mutex_unlock(&wl->mutex);
832 EXPORT_SYMBOL_GPL(wl1271_irq);
834 static int wl1271_fetch_firmware(struct wl1271 *wl)
836 const struct firmware *fw;
840 switch (wl->bss_type) {
841 case BSS_TYPE_AP_BSS:
842 if (wl->chip.id == CHIP_ID_1283_PG20)
843 fw_name = WL128X_AP_FW_NAME;
845 fw_name = WL127X_AP_FW_NAME;
848 case BSS_TYPE_STA_BSS:
849 if (wl->chip.id == CHIP_ID_1283_PG20)
850 fw_name = WL128X_FW_NAME;
852 fw_name = WL1271_FW_NAME;
855 wl1271_error("no compatible firmware for bss_type %d",
860 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
862 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
865 wl1271_error("could not get firmware: %d", ret);
870 wl1271_error("firmware size is not multiple of 32 bits: %zu",
877 wl->fw_len = fw->size;
878 wl->fw = vmalloc(wl->fw_len);
881 wl1271_error("could not allocate memory for the firmware");
886 memcpy(wl->fw, fw->data, wl->fw_len);
887 wl->fw_bss_type = wl->bss_type;
891 release_firmware(fw);
896 static int wl1271_fetch_nvs(struct wl1271 *wl)
898 const struct firmware *fw;
901 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
904 wl1271_error("could not get nvs file: %d", ret);
908 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
911 wl1271_error("could not allocate memory for the nvs file");
916 wl->nvs_len = fw->size;
919 release_firmware(fw);
924 static void wl1271_recovery_work(struct work_struct *work)
927 container_of(work, struct wl1271, recovery_work);
929 mutex_lock(&wl->mutex);
931 if (wl->state != WL1271_STATE_ON)
934 wl1271_info("Hardware recovery in progress.");
936 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
937 ieee80211_connection_loss(wl->vif);
939 /* reboot the chipset */
940 __wl1271_op_remove_interface(wl);
941 ieee80211_restart_hw(wl->hw);
944 mutex_unlock(&wl->mutex);
947 static void wl1271_fw_wakeup(struct wl1271 *wl)
951 elp_reg = ELPCTRL_WAKE_UP;
952 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
955 static int wl1271_setup(struct wl1271 *wl)
957 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
961 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
962 if (!wl->tx_res_if) {
963 kfree(wl->fw_status);
970 static int wl1271_chip_wakeup(struct wl1271 *wl)
972 struct wl1271_partition_set partition;
975 msleep(WL1271_PRE_POWER_ON_SLEEP);
976 ret = wl1271_power_on(wl);
979 msleep(WL1271_POWER_ON_SLEEP);
983 /* We don't need a real memory partition here, because we only want
984 * to use the registers at this point. */
985 memset(&partition, 0, sizeof(partition));
986 partition.reg.start = REGISTERS_BASE;
987 partition.reg.size = REGISTERS_DOWN_SIZE;
988 wl1271_set_partition(wl, &partition);
990 /* ELP module wake up */
991 wl1271_fw_wakeup(wl);
993 /* whal_FwCtrl_BootSm() */
995 /* 0. read chip id from CHIP_ID */
996 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
998 /* 1. check if chip id is valid */
1000 switch (wl->chip.id) {
1001 case CHIP_ID_1271_PG10:
1002 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1005 ret = wl1271_setup(wl);
1009 case CHIP_ID_1271_PG20:
1010 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1013 ret = wl1271_setup(wl);
1017 case CHIP_ID_1283_PG20:
1018 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1021 ret = wl1271_setup(wl);
1024 if (wl1271_set_block_size(wl))
1025 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1027 case CHIP_ID_1283_PG10:
1029 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1034 /* Make sure the firmware type matches the BSS type */
1035 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
1036 ret = wl1271_fetch_firmware(wl);
1041 /* No NVS from netlink, try to get it from the filesystem */
1042 if (wl->nvs == NULL) {
1043 ret = wl1271_fetch_nvs(wl);
1052 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1054 unsigned int quirks = 0;
1055 unsigned int *fw_ver = wl->chip.fw_ver;
1057 /* Only for wl127x */
1058 if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1059 /* Check STA version */
1060 (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1061 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1062 /* Check AP version */
1063 ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1064 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1065 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1070 int wl1271_plt_start(struct wl1271 *wl)
1072 int retries = WL1271_BOOT_RETRIES;
1075 mutex_lock(&wl->mutex);
1077 wl1271_notice("power up");
1079 if (wl->state != WL1271_STATE_OFF) {
1080 wl1271_error("cannot go into PLT state because not "
1081 "in off state: %d", wl->state);
1086 wl->bss_type = BSS_TYPE_STA_BSS;
1090 ret = wl1271_chip_wakeup(wl);
1094 ret = wl1271_boot(wl);
1098 ret = wl1271_plt_init(wl);
1102 wl->state = WL1271_STATE_PLT;
1103 wl1271_notice("firmware booted in PLT mode (%s)",
1104 wl->chip.fw_ver_str);
1106 /* Check if any quirks are needed with older fw versions */
1107 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1111 mutex_unlock(&wl->mutex);
1112 /* Unlocking the mutex in the middle of handling is
1113 inherently unsafe. In this case we deem it safe to do,
1114 because we need to let any possibly pending IRQ out of
1115 the system (and while we are WL1271_STATE_OFF the IRQ
1116 work function will not do anything.) Also, any other
1117 possible concurrent operations will fail due to the
1118 current state, hence the wl1271 struct should be safe. */
1119 wl1271_disable_interrupts(wl);
1120 wl1271_flush_deferred_work(wl);
1121 cancel_work_sync(&wl->netstack_work);
1122 mutex_lock(&wl->mutex);
1124 wl1271_power_off(wl);
1127 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1128 WL1271_BOOT_RETRIES);
1130 mutex_unlock(&wl->mutex);
1135 static int __wl1271_plt_stop(struct wl1271 *wl)
1139 wl1271_notice("power down");
1141 if (wl->state != WL1271_STATE_PLT) {
1142 wl1271_error("cannot power down because not in PLT "
1143 "state: %d", wl->state);
1148 wl1271_power_off(wl);
1150 wl->state = WL1271_STATE_OFF;
1153 mutex_unlock(&wl->mutex);
1154 wl1271_disable_interrupts(wl);
1155 wl1271_flush_deferred_work(wl);
1156 cancel_work_sync(&wl->netstack_work);
1157 cancel_work_sync(&wl->recovery_work);
1158 mutex_lock(&wl->mutex);
1163 int wl1271_plt_stop(struct wl1271 *wl)
1167 mutex_lock(&wl->mutex);
1168 ret = __wl1271_plt_stop(wl);
1169 mutex_unlock(&wl->mutex);
1173 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1175 struct wl1271 *wl = hw->priv;
1176 unsigned long flags;
1180 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1182 if (wl->bss_type == BSS_TYPE_AP_BSS)
1183 hlid = wl1271_tx_get_hlid(skb);
1185 spin_lock_irqsave(&wl->wl_lock, flags);
1187 wl->tx_queue_count++;
1190 * The workqueue is slow to process the tx_queue and we need stop
1191 * the queue here, otherwise the queue will get too long.
1193 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1194 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1195 ieee80211_stop_queues(wl->hw);
1196 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1199 /* queue the packet */
1200 if (wl->bss_type == BSS_TYPE_AP_BSS) {
1201 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1202 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1204 skb_queue_tail(&wl->tx_queue[q], skb);
1208 * The chip specific setup must run before the first TX packet -
1209 * before that, the tx_work will not be initialized!
1212 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1213 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1214 ieee80211_queue_work(wl->hw, &wl->tx_work);
1216 spin_unlock_irqrestore(&wl->wl_lock, flags);
1219 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1221 unsigned long flags;
1223 spin_lock_irqsave(&wl->wl_lock, flags);
1224 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1225 wl->tx_queue_count++;
1226 spin_unlock_irqrestore(&wl->wl_lock, flags);
1228 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1229 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1230 wl1271_tx_work_locked(wl);
1233 * If the FW TX is busy, TX work will be scheduled by the threaded
1234 * interrupt handler function
1240 * The size of the dummy packet should be at least 1400 bytes. However, in
1241 * order to minimize the number of bus transactions, aligning it to 512 bytes
1242 * boundaries could be beneficial, performance wise
1244 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1246 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1248 struct sk_buff *skb;
1249 struct ieee80211_hdr_3addr *hdr;
1250 unsigned int dummy_packet_size;
1252 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1253 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1255 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1257 wl1271_warning("Failed to allocate a dummy packet skb");
1261 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1263 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1264 memset(hdr, 0, sizeof(*hdr));
1265 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1266 IEEE80211_STYPE_NULLFUNC |
1267 IEEE80211_FCTL_TODS);
1269 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1271 /* Dummy packets require the TID to be management */
1272 skb->priority = WL1271_TID_MGMT;
1274 /* Initialize all fields that might be used */
1275 skb->queue_mapping = 0;
1276 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1282 static struct notifier_block wl1271_dev_notifier = {
1283 .notifier_call = wl1271_dev_notify,
1286 static int wl1271_op_start(struct ieee80211_hw *hw)
1288 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1291 * We have to delay the booting of the hardware because
1292 * we need to know the local MAC address before downloading and
1293 * initializing the firmware. The MAC address cannot be changed
1294 * after boot, and without the proper MAC address, the firmware
1295 * will not function properly.
1297 * The MAC address is first known when the corresponding interface
1298 * is added. That is where we will initialize the hardware.
1300 * In addition, we currently have different firmwares for AP and managed
1301 * operation. We will know which to boot according to interface type.
1307 static void wl1271_op_stop(struct ieee80211_hw *hw)
1309 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1312 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1313 struct ieee80211_vif *vif)
1315 struct wl1271 *wl = hw->priv;
1316 struct wiphy *wiphy = hw->wiphy;
1317 int retries = WL1271_BOOT_RETRIES;
1319 bool booted = false;
1321 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1322 vif->type, vif->addr);
1324 mutex_lock(&wl->mutex);
1326 wl1271_debug(DEBUG_MAC80211,
1327 "multiple vifs are not supported yet");
1333 * in some very corner case HW recovery scenarios its possible to
1334 * get here before __wl1271_op_remove_interface is complete, so
1335 * opt out if that is the case.
1337 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1342 switch (vif->type) {
1343 case NL80211_IFTYPE_STATION:
1344 wl->bss_type = BSS_TYPE_STA_BSS;
1345 wl->set_bss_type = BSS_TYPE_STA_BSS;
1347 case NL80211_IFTYPE_ADHOC:
1348 wl->bss_type = BSS_TYPE_IBSS;
1349 wl->set_bss_type = BSS_TYPE_STA_BSS;
1351 case NL80211_IFTYPE_AP:
1352 wl->bss_type = BSS_TYPE_AP_BSS;
1359 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1361 if (wl->state != WL1271_STATE_OFF) {
1362 wl1271_error("cannot start because not in off state: %d",
1370 ret = wl1271_chip_wakeup(wl);
1374 ret = wl1271_boot(wl);
1378 ret = wl1271_hw_init(wl);
1386 mutex_unlock(&wl->mutex);
1387 /* Unlocking the mutex in the middle of handling is
1388 inherently unsafe. In this case we deem it safe to do,
1389 because we need to let any possibly pending IRQ out of
1390 the system (and while we are WL1271_STATE_OFF the IRQ
1391 work function will not do anything.) Also, any other
1392 possible concurrent operations will fail due to the
1393 current state, hence the wl1271 struct should be safe. */
1394 wl1271_disable_interrupts(wl);
1395 wl1271_flush_deferred_work(wl);
1396 cancel_work_sync(&wl->netstack_work);
1397 mutex_lock(&wl->mutex);
1399 wl1271_power_off(wl);
1403 wl1271_error("firmware boot failed despite %d retries",
1404 WL1271_BOOT_RETRIES);
1409 wl->state = WL1271_STATE_ON;
1410 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1411 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1413 /* update hw/fw version info in wiphy struct */
1414 wiphy->hw_version = wl->chip.id;
1415 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1416 sizeof(wiphy->fw_version));
1418 /* Check if any quirks are needed with older fw versions */
1419 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1422 * Now we know if 11a is supported (info from the NVS), so disable
1423 * 11a channels if not supported
1425 if (!wl->enable_11a)
1426 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1428 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1429 wl->enable_11a ? "" : "not ");
1432 mutex_unlock(&wl->mutex);
1434 mutex_lock(&wl_list_mutex);
1436 list_add(&wl->list, &wl_list);
1437 mutex_unlock(&wl_list_mutex);
1442 static void __wl1271_op_remove_interface(struct wl1271 *wl)
1446 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1448 /* because of hardware recovery, we may get here twice */
1449 if (wl->state != WL1271_STATE_ON)
1452 wl1271_info("down");
1454 mutex_lock(&wl_list_mutex);
1455 list_del(&wl->list);
1456 mutex_unlock(&wl_list_mutex);
1458 /* enable dyn ps just in case (if left on due to fw crash etc) */
1459 if (wl->bss_type == BSS_TYPE_STA_BSS)
1460 ieee80211_enable_dyn_ps(wl->vif);
1462 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1463 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1464 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1465 wl->scan.req = NULL;
1466 ieee80211_scan_completed(wl->hw, true);
1470 * this must be before the cancel_work calls below, so that the work
1471 * functions don't perform further work.
1473 wl->state = WL1271_STATE_OFF;
1475 mutex_unlock(&wl->mutex);
1477 wl1271_disable_interrupts(wl);
1478 wl1271_flush_deferred_work(wl);
1479 cancel_delayed_work_sync(&wl->scan_complete_work);
1480 cancel_work_sync(&wl->netstack_work);
1481 cancel_work_sync(&wl->tx_work);
1482 cancel_delayed_work_sync(&wl->pspoll_work);
1483 cancel_delayed_work_sync(&wl->elp_work);
1485 mutex_lock(&wl->mutex);
1487 /* let's notify MAC80211 about the remaining pending TX frames */
1488 wl1271_tx_reset(wl);
1489 wl1271_power_off(wl);
1491 memset(wl->bssid, 0, ETH_ALEN);
1492 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1494 wl->bss_type = MAX_BSS_TYPE;
1495 wl->set_bss_type = MAX_BSS_TYPE;
1496 wl->band = IEEE80211_BAND_2GHZ;
1499 wl->psm_entry_retry = 0;
1500 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1501 wl->tx_blocks_available = 0;
1502 wl->tx_allocated_blocks = 0;
1503 wl->tx_results_count = 0;
1504 wl->tx_packets_count = 0;
1505 wl->tx_security_last_seq = 0;
1506 wl->tx_security_seq = 0;
1507 wl->time_offset = 0;
1508 wl->session_counter = 0;
1509 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1512 wl1271_free_ap_keys(wl);
1513 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1514 wl->ap_fw_ps_map = 0;
1518 * this is performed after the cancel_work calls and the associated
1519 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1520 * get executed before all these vars have been reset.
1524 for (i = 0; i < NUM_TX_QUEUES; i++)
1525 wl->tx_blocks_freed[i] = 0;
1527 wl1271_debugfs_reset(wl);
1529 kfree(wl->fw_status);
1530 wl->fw_status = NULL;
1531 kfree(wl->tx_res_if);
1532 wl->tx_res_if = NULL;
1533 kfree(wl->target_mem_map);
1534 wl->target_mem_map = NULL;
1537 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1538 struct ieee80211_vif *vif)
1540 struct wl1271 *wl = hw->priv;
1542 mutex_lock(&wl->mutex);
1544 * wl->vif can be null here if someone shuts down the interface
1545 * just when hardware recovery has been started.
1548 WARN_ON(wl->vif != vif);
1549 __wl1271_op_remove_interface(wl);
1552 mutex_unlock(&wl->mutex);
1553 cancel_work_sync(&wl->recovery_work);
1556 void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1558 wl1271_set_default_filters(wl);
1560 /* combine requested filters with current filter config */
1561 filters = wl->filters | filters;
1563 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1565 if (filters & FIF_PROMISC_IN_BSS) {
1566 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1567 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1568 wl->rx_config |= CFG_BSSID_FILTER_EN;
1570 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1571 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1572 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1573 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1575 if (filters & FIF_OTHER_BSS) {
1576 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1577 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1579 if (filters & FIF_CONTROL) {
1580 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1581 wl->rx_filter |= CFG_RX_CTL_EN;
1583 if (filters & FIF_FCSFAIL) {
1584 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1585 wl->rx_filter |= CFG_RX_FCS_ERROR;
1589 static int wl1271_dummy_join(struct wl1271 *wl)
1592 /* we need to use a dummy BSSID for now */
1593 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1596 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1598 /* pass through frames from all BSS */
1599 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1601 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1605 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1611 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1616 * One of the side effects of the JOIN command is that is clears
1617 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1618 * to a WPA/WPA2 access point will therefore kill the data-path.
1619 * Currently the only valid scenario for JOIN during association
1620 * is on roaming, in which case we will also be given new keys.
1621 * Keep the below message for now, unless it starts bothering
1622 * users who really like to roam a lot :)
1624 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1625 wl1271_info("JOIN while associated.");
1628 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1630 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1634 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1636 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1640 * The join command disable the keep-alive mode, shut down its process,
1641 * and also clear the template config, so we need to reset it all after
1642 * the join. The acx_aid starts the keep-alive process, and the order
1643 * of the commands below is relevant.
1645 ret = wl1271_acx_keep_alive_mode(wl, true);
1649 ret = wl1271_acx_aid(wl, wl->aid);
1653 ret = wl1271_cmd_build_klv_null_data(wl);
1657 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1658 ACX_KEEP_ALIVE_TPL_VALID);
1666 static int wl1271_unjoin(struct wl1271 *wl)
1670 /* to stop listening to a channel, we disconnect */
1671 ret = wl1271_cmd_disconnect(wl);
1675 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1676 memset(wl->bssid, 0, ETH_ALEN);
1678 /* stop filtering packets based on bssid */
1679 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1685 static void wl1271_set_band_rate(struct wl1271 *wl)
1687 if (wl->band == IEEE80211_BAND_2GHZ)
1688 wl->basic_rate_set = wl->conf.tx.basic_rate;
1690 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1693 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1698 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1699 ret = wl1271_unjoin(wl);
1703 wl->rate_set = wl1271_tx_min_rate_get(wl);
1704 ret = wl1271_acx_sta_rate_policies(wl);
1707 ret = wl1271_acx_keep_alive_config(
1708 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1709 ACX_KEEP_ALIVE_TPL_INVALID);
1712 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1714 /* increment the session counter */
1715 wl->session_counter++;
1716 if (wl->session_counter >= SESSION_COUNTER_MAX)
1717 wl->session_counter = 0;
1718 ret = wl1271_dummy_join(wl);
1721 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1728 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1730 struct wl1271 *wl = hw->priv;
1731 struct ieee80211_conf *conf = &hw->conf;
1732 int channel, ret = 0;
1735 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1737 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1740 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1742 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1746 * mac80211 will go to idle nearly immediately after transmitting some
1747 * frames, such as the deauth. To make sure those frames reach the air,
1748 * wait here until the TX queue is fully flushed.
1750 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1751 (conf->flags & IEEE80211_CONF_IDLE))
1752 wl1271_tx_flush(wl);
1754 mutex_lock(&wl->mutex);
1756 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1757 /* we support configuring the channel and band while off */
1758 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1759 wl->band = conf->channel->band;
1760 wl->channel = channel;
1766 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1768 ret = wl1271_ps_elp_wakeup(wl);
1772 /* if the channel changes while joined, join again */
1773 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1774 ((wl->band != conf->channel->band) ||
1775 (wl->channel != channel))) {
1776 wl->band = conf->channel->band;
1777 wl->channel = channel;
1781 * FIXME: the mac80211 should really provide a fixed
1782 * rate to use here. for now, just use the smallest
1783 * possible rate for the band as a fixed rate for
1784 * association frames and other control messages.
1786 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1787 wl1271_set_band_rate(wl);
1789 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1790 ret = wl1271_acx_sta_rate_policies(wl);
1792 wl1271_warning("rate policy for channel "
1795 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1796 ret = wl1271_join(wl, false);
1798 wl1271_warning("cmd join on channel "
1804 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1805 ret = wl1271_sta_handle_idle(wl,
1806 conf->flags & IEEE80211_CONF_IDLE);
1808 wl1271_warning("idle mode change failed %d", ret);
1812 * if mac80211 changes the PSM mode, make sure the mode is not
1813 * incorrectly changed after the pspoll failure active window.
1815 if (changed & IEEE80211_CONF_CHANGE_PS)
1816 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1818 if (conf->flags & IEEE80211_CONF_PS &&
1819 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1820 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1823 * We enter PSM only if we're already associated.
1824 * If we're not, we'll enter it when joining an SSID,
1825 * through the bss_info_changed() hook.
1827 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1828 wl1271_debug(DEBUG_PSM, "psm enabled");
1829 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1830 wl->basic_rate, true);
1832 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1833 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1834 wl1271_debug(DEBUG_PSM, "psm disabled");
1836 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1838 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1839 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1840 wl->basic_rate, true);
1843 if (conf->power_level != wl->power_level) {
1844 ret = wl1271_acx_tx_power(wl, conf->power_level);
1848 wl->power_level = conf->power_level;
1852 wl1271_ps_elp_sleep(wl);
1855 mutex_unlock(&wl->mutex);
1860 struct wl1271_filter_params {
1863 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1866 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1867 struct netdev_hw_addr_list *mc_list)
1869 struct wl1271_filter_params *fp;
1870 struct netdev_hw_addr *ha;
1871 struct wl1271 *wl = hw->priv;
1873 if (unlikely(wl->state == WL1271_STATE_OFF))
1876 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1878 wl1271_error("Out of memory setting filters.");
1882 /* update multicast filtering parameters */
1883 fp->mc_list_length = 0;
1884 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1885 fp->enabled = false;
1888 netdev_hw_addr_list_for_each(ha, mc_list) {
1889 memcpy(fp->mc_list[fp->mc_list_length],
1890 ha->addr, ETH_ALEN);
1891 fp->mc_list_length++;
1895 return (u64)(unsigned long)fp;
1898 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1901 FIF_BCN_PRBRESP_PROMISC | \
1905 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1906 unsigned int changed,
1907 unsigned int *total, u64 multicast)
1909 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1910 struct wl1271 *wl = hw->priv;
1913 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
1914 " total %x", changed, *total);
1916 mutex_lock(&wl->mutex);
1918 *total &= WL1271_SUPPORTED_FILTERS;
1919 changed &= WL1271_SUPPORTED_FILTERS;
1921 if (unlikely(wl->state == WL1271_STATE_OFF))
1924 ret = wl1271_ps_elp_wakeup(wl);
1928 if (wl->bss_type != BSS_TYPE_AP_BSS) {
1929 if (*total & FIF_ALLMULTI)
1930 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1932 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1934 fp->mc_list_length);
1939 /* determine, whether supported filter values have changed */
1943 /* configure filters */
1944 wl->filters = *total;
1945 wl1271_configure_filters(wl, 0);
1947 /* apply configured filters */
1948 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1953 wl1271_ps_elp_sleep(wl);
1956 mutex_unlock(&wl->mutex);
1960 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
1961 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1964 struct wl1271_ap_key *ap_key;
1967 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
1969 if (key_size > MAX_KEY_SIZE)
1973 * Find next free entry in ap_keys. Also check we are not replacing
1976 for (i = 0; i < MAX_NUM_KEYS; i++) {
1977 if (wl->recorded_ap_keys[i] == NULL)
1980 if (wl->recorded_ap_keys[i]->id == id) {
1981 wl1271_warning("trying to record key replacement");
1986 if (i == MAX_NUM_KEYS)
1989 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
1994 ap_key->key_type = key_type;
1995 ap_key->key_size = key_size;
1996 memcpy(ap_key->key, key, key_size);
1997 ap_key->hlid = hlid;
1998 ap_key->tx_seq_32 = tx_seq_32;
1999 ap_key->tx_seq_16 = tx_seq_16;
2001 wl->recorded_ap_keys[i] = ap_key;
2005 static void wl1271_free_ap_keys(struct wl1271 *wl)
2009 for (i = 0; i < MAX_NUM_KEYS; i++) {
2010 kfree(wl->recorded_ap_keys[i]);
2011 wl->recorded_ap_keys[i] = NULL;
2015 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2018 struct wl1271_ap_key *key;
2019 bool wep_key_added = false;
2021 for (i = 0; i < MAX_NUM_KEYS; i++) {
2022 if (wl->recorded_ap_keys[i] == NULL)
2025 key = wl->recorded_ap_keys[i];
2026 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2027 key->id, key->key_type,
2028 key->key_size, key->key,
2029 key->hlid, key->tx_seq_32,
2034 if (key->key_type == KEY_WEP)
2035 wep_key_added = true;
2038 if (wep_key_added) {
2039 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2045 wl1271_free_ap_keys(wl);
2049 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2050 u8 key_size, const u8 *key, u32 tx_seq_32,
2051 u16 tx_seq_16, struct ieee80211_sta *sta)
2054 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2057 struct wl1271_station *wl_sta;
2061 wl_sta = (struct wl1271_station *)sta->drv_priv;
2062 hlid = wl_sta->hlid;
2064 hlid = WL1271_AP_BROADCAST_HLID;
2067 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2069 * We do not support removing keys after AP shutdown.
2070 * Pretend we do to make mac80211 happy.
2072 if (action != KEY_ADD_OR_REPLACE)
2075 ret = wl1271_record_ap_key(wl, id,
2077 key, hlid, tx_seq_32,
2080 ret = wl1271_cmd_set_ap_key(wl, action,
2081 id, key_type, key_size,
2082 key, hlid, tx_seq_32,
2090 static const u8 bcast_addr[ETH_ALEN] = {
2091 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2094 addr = sta ? sta->addr : bcast_addr;
2096 if (is_zero_ether_addr(addr)) {
2097 /* We dont support TX only encryption */
2101 /* The wl1271 does not allow to remove unicast keys - they
2102 will be cleared automatically on next CMD_JOIN. Ignore the
2103 request silently, as we dont want the mac80211 to emit
2104 an error message. */
2105 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2108 ret = wl1271_cmd_set_sta_key(wl, action,
2109 id, key_type, key_size,
2110 key, addr, tx_seq_32,
2115 /* the default WEP key needs to be configured at least once */
2116 if (key_type == KEY_WEP) {
2117 ret = wl1271_cmd_set_sta_default_wep_key(wl,
2127 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2128 struct ieee80211_vif *vif,
2129 struct ieee80211_sta *sta,
2130 struct ieee80211_key_conf *key_conf)
2132 struct wl1271 *wl = hw->priv;
2138 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2140 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2141 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2142 key_conf->cipher, key_conf->keyidx,
2143 key_conf->keylen, key_conf->flags);
2144 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2146 mutex_lock(&wl->mutex);
2148 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2153 ret = wl1271_ps_elp_wakeup(wl);
2157 switch (key_conf->cipher) {
2158 case WLAN_CIPHER_SUITE_WEP40:
2159 case WLAN_CIPHER_SUITE_WEP104:
2162 key_conf->hw_key_idx = key_conf->keyidx;
2164 case WLAN_CIPHER_SUITE_TKIP:
2165 key_type = KEY_TKIP;
2167 key_conf->hw_key_idx = key_conf->keyidx;
2168 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2169 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2171 case WLAN_CIPHER_SUITE_CCMP:
2174 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2175 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2176 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2178 case WL1271_CIPHER_SUITE_GEM:
2180 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2181 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2184 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2192 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2193 key_conf->keyidx, key_type,
2194 key_conf->keylen, key_conf->key,
2195 tx_seq_32, tx_seq_16, sta);
2197 wl1271_error("Could not add or replace key");
2203 ret = wl1271_set_key(wl, KEY_REMOVE,
2204 key_conf->keyidx, key_type,
2205 key_conf->keylen, key_conf->key,
2208 wl1271_error("Could not remove key");
2214 wl1271_error("Unsupported key cmd 0x%x", cmd);
2220 wl1271_ps_elp_sleep(wl);
2223 mutex_unlock(&wl->mutex);
2228 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2229 struct ieee80211_vif *vif,
2230 struct cfg80211_scan_request *req)
2232 struct wl1271 *wl = hw->priv;
2237 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2240 ssid = req->ssids[0].ssid;
2241 len = req->ssids[0].ssid_len;
2244 mutex_lock(&wl->mutex);
2246 if (wl->state == WL1271_STATE_OFF) {
2248 * We cannot return -EBUSY here because cfg80211 will expect
2249 * a call to ieee80211_scan_completed if we do - in this case
2250 * there won't be any call.
2256 ret = wl1271_ps_elp_wakeup(wl);
2260 ret = wl1271_scan(hw->priv, ssid, len, req);
2262 wl1271_ps_elp_sleep(wl);
2265 mutex_unlock(&wl->mutex);
2270 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2272 struct wl1271 *wl = hw->priv;
2275 mutex_lock(&wl->mutex);
2277 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2282 ret = wl1271_ps_elp_wakeup(wl);
2286 ret = wl1271_acx_frag_threshold(wl, (u16)value);
2288 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2290 wl1271_ps_elp_sleep(wl);
2293 mutex_unlock(&wl->mutex);
2298 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2300 struct wl1271 *wl = hw->priv;
2303 mutex_lock(&wl->mutex);
2305 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2310 ret = wl1271_ps_elp_wakeup(wl);
2314 ret = wl1271_acx_rts_threshold(wl, (u16) value);
2316 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2318 wl1271_ps_elp_sleep(wl);
2321 mutex_unlock(&wl->mutex);
2326 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2329 u8 *ptr = skb->data + offset;
2331 /* find the location of the ssid in the beacon */
2332 while (ptr < skb->data + skb->len) {
2333 if (ptr[0] == WLAN_EID_SSID) {
2334 wl->ssid_len = ptr[1];
2335 memcpy(wl->ssid, ptr+2, wl->ssid_len);
2338 ptr += (ptr[1] + 2);
2341 wl1271_error("No SSID in IEs!\n");
2345 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2346 struct ieee80211_bss_conf *bss_conf,
2351 if (changed & BSS_CHANGED_ERP_SLOT) {
2352 if (bss_conf->use_short_slot)
2353 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2355 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2357 wl1271_warning("Set slot time failed %d", ret);
2362 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2363 if (bss_conf->use_short_preamble)
2364 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2366 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2369 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2370 if (bss_conf->use_cts_prot)
2371 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2373 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2375 wl1271_warning("Set ctsprotect failed %d", ret);
2384 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2385 struct ieee80211_vif *vif,
2386 struct ieee80211_bss_conf *bss_conf,
2389 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2392 if ((changed & BSS_CHANGED_BEACON_INT)) {
2393 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2394 bss_conf->beacon_int);
2396 wl->beacon_int = bss_conf->beacon_int;
2399 if ((changed & BSS_CHANGED_BEACON)) {
2400 struct ieee80211_hdr *hdr;
2401 int ieoffset = offsetof(struct ieee80211_mgmt,
2403 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2409 wl1271_debug(DEBUG_MASTER, "beacon updated");
2411 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2413 dev_kfree_skb(beacon);
2416 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2418 ret = wl1271_cmd_template_set(wl, tmpl_id,
2421 wl1271_tx_min_rate_get(wl));
2423 dev_kfree_skb(beacon);
2427 hdr = (struct ieee80211_hdr *) beacon->data;
2428 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2429 IEEE80211_STYPE_PROBE_RESP);
2431 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2432 CMD_TEMPL_PROBE_RESPONSE;
2433 ret = wl1271_cmd_template_set(wl,
2437 wl1271_tx_min_rate_get(wl));
2438 dev_kfree_skb(beacon);
2447 /* AP mode changes */
2448 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2449 struct ieee80211_vif *vif,
2450 struct ieee80211_bss_conf *bss_conf,
2455 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2456 u32 rates = bss_conf->basic_rates;
2457 struct conf_tx_rate_class mgmt_rc;
2459 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2460 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2461 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
2462 wl->basic_rate_set);
2464 /* update the AP management rate policy with the new rates */
2465 mgmt_rc.enabled_rates = wl->basic_rate_set;
2466 mgmt_rc.long_retry_limit = 10;
2467 mgmt_rc.short_retry_limit = 10;
2469 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
2470 ACX_TX_AP_MODE_MGMT_RATE);
2472 wl1271_error("AP mgmt policy change failed %d", ret);
2477 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2481 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2482 if (bss_conf->enable_beacon) {
2483 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2484 ret = wl1271_cmd_start_bss(wl);
2488 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2489 wl1271_debug(DEBUG_AP, "started AP");
2491 ret = wl1271_ap_init_hwenc(wl);
2496 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2497 ret = wl1271_cmd_stop_bss(wl);
2501 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2502 wl1271_debug(DEBUG_AP, "stopped AP");
2507 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2514 /* STA/IBSS mode changes */
2515 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2516 struct ieee80211_vif *vif,
2517 struct ieee80211_bss_conf *bss_conf,
2520 bool do_join = false, set_assoc = false;
2521 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2522 u32 sta_rate_set = 0;
2524 struct ieee80211_sta *sta;
2525 bool sta_exists = false;
2526 struct ieee80211_sta_ht_cap sta_ht_cap;
2529 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2535 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2538 /* Need to update the SSID (for filtering etc) */
2539 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2542 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2543 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2544 bss_conf->enable_beacon ? "enabled" : "disabled");
2546 if (bss_conf->enable_beacon)
2547 wl->set_bss_type = BSS_TYPE_IBSS;
2549 wl->set_bss_type = BSS_TYPE_STA_BSS;
2553 if ((changed & BSS_CHANGED_CQM)) {
2554 bool enable = false;
2555 if (bss_conf->cqm_rssi_thold)
2557 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2558 bss_conf->cqm_rssi_thold,
2559 bss_conf->cqm_rssi_hyst);
2562 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2565 if ((changed & BSS_CHANGED_BSSID) &&
2567 * Now we know the correct bssid, so we send a new join command
2568 * and enable the BSSID filter
2570 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2571 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2573 if (!is_zero_ether_addr(wl->bssid)) {
2574 ret = wl1271_cmd_build_null_data(wl);
2578 ret = wl1271_build_qos_null_data(wl);
2582 /* filter out all packets not from this BSSID */
2583 wl1271_configure_filters(wl, 0);
2585 /* Need to update the BSSID (for filtering etc) */
2591 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2593 /* save the supp_rates of the ap */
2594 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2595 if (sta->ht_cap.ht_supported)
2597 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
2598 sta_ht_cap = sta->ht_cap;
2604 /* handle new association with HT and HT information change */
2605 if ((changed & BSS_CHANGED_HT) &&
2606 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2607 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2610 wl1271_warning("Set ht cap true failed %d",
2614 ret = wl1271_acx_set_ht_information(wl,
2615 bss_conf->ht_operation_mode);
2617 wl1271_warning("Set ht information failed %d",
2622 /* handle new association without HT and disassociation */
2623 else if (changed & BSS_CHANGED_ASSOC) {
2624 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2627 wl1271_warning("Set ht cap false failed %d",
2634 if ((changed & BSS_CHANGED_ASSOC)) {
2635 if (bss_conf->assoc) {
2638 wl->aid = bss_conf->aid;
2641 wl->ps_poll_failures = 0;
2644 * use basic rates from AP, and determine lowest rate
2645 * to use with control frames.
2647 rates = bss_conf->basic_rates;
2648 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2650 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2652 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2654 ret = wl1271_acx_sta_rate_policies(wl);
2659 * with wl1271, we don't need to update the
2660 * beacon_int and dtim_period, because the firmware
2661 * updates it by itself when the first beacon is
2662 * received after a join.
2664 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2669 * Get a template for hardware connection maintenance
2671 dev_kfree_skb(wl->probereq);
2672 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2673 ieoffset = offsetof(struct ieee80211_mgmt,
2674 u.probe_req.variable);
2675 wl1271_ssid_set(wl, wl->probereq, ieoffset);
2677 /* enable the connection monitoring feature */
2678 ret = wl1271_acx_conn_monit_params(wl, true);
2682 /* If we want to go in PSM but we're not there yet */
2683 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2684 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2685 enum wl1271_cmd_ps_mode mode;
2687 mode = STATION_POWER_SAVE_MODE;
2688 ret = wl1271_ps_set_mode(wl, mode,
2695 /* use defaults when not associated */
2696 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2697 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2700 /* free probe-request template */
2701 dev_kfree_skb(wl->probereq);
2702 wl->probereq = NULL;
2704 /* re-enable dynamic ps - just in case */
2705 ieee80211_enable_dyn_ps(wl->vif);
2707 /* revert back to minimum rates for the current band */
2708 wl1271_set_band_rate(wl);
2709 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2710 ret = wl1271_acx_sta_rate_policies(wl);
2714 /* disable connection monitor features */
2715 ret = wl1271_acx_conn_monit_params(wl, false);
2717 /* Disable the keep-alive feature */
2718 ret = wl1271_acx_keep_alive_mode(wl, false);
2722 /* restore the bssid filter and go to dummy bssid */
2724 wl1271_dummy_join(wl);
2728 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2732 if (changed & BSS_CHANGED_ARP_FILTER) {
2733 __be32 addr = bss_conf->arp_addr_list[0];
2734 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2736 if (bss_conf->arp_addr_cnt == 1 &&
2737 bss_conf->arp_filter_enabled) {
2739 * The template should have been configured only upon
2740 * association. however, it seems that the correct ip
2741 * isn't being set (when sending), so we have to
2742 * reconfigure the template upon every ip change.
2744 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2746 wl1271_warning("build arp rsp failed: %d", ret);
2750 ret = wl1271_acx_arp_ip_filter(wl,
2751 ACX_ARP_FILTER_ARP_FILTERING,
2754 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
2761 ret = wl1271_join(wl, set_assoc);
2763 wl1271_warning("cmd join failed %d", ret);
2772 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2773 struct ieee80211_vif *vif,
2774 struct ieee80211_bss_conf *bss_conf,
2777 struct wl1271 *wl = hw->priv;
2778 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2781 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2784 mutex_lock(&wl->mutex);
2786 if (unlikely(wl->state == WL1271_STATE_OFF))
2789 ret = wl1271_ps_elp_wakeup(wl);
2794 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2796 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2798 wl1271_ps_elp_sleep(wl);
2801 mutex_unlock(&wl->mutex);
2804 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2805 const struct ieee80211_tx_queue_params *params)
2807 struct wl1271 *wl = hw->priv;
2811 mutex_lock(&wl->mutex);
2813 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2816 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2818 ps_scheme = CONF_PS_SCHEME_LEGACY;
2820 if (wl->state == WL1271_STATE_OFF) {
2822 * If the state is off, the parameters will be recorded and
2823 * configured on init. This happens in AP-mode.
2825 struct conf_tx_ac_category *conf_ac =
2826 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2827 struct conf_tx_tid *conf_tid =
2828 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2830 conf_ac->ac = wl1271_tx_get_queue(queue);
2831 conf_ac->cw_min = (u8)params->cw_min;
2832 conf_ac->cw_max = params->cw_max;
2833 conf_ac->aifsn = params->aifs;
2834 conf_ac->tx_op_limit = params->txop << 5;
2836 conf_tid->queue_id = wl1271_tx_get_queue(queue);
2837 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
2838 conf_tid->tsid = wl1271_tx_get_queue(queue);
2839 conf_tid->ps_scheme = ps_scheme;
2840 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
2841 conf_tid->apsd_conf[0] = 0;
2842 conf_tid->apsd_conf[1] = 0;
2846 ret = wl1271_ps_elp_wakeup(wl);
2851 * the txop is confed in units of 32us by the mac80211,
2854 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2855 params->cw_min, params->cw_max,
2856 params->aifs, params->txop << 5);
2860 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2861 CONF_CHANNEL_TYPE_EDCF,
2862 wl1271_tx_get_queue(queue),
2863 ps_scheme, CONF_ACK_POLICY_LEGACY,
2867 wl1271_ps_elp_sleep(wl);
2870 mutex_unlock(&wl->mutex);
2875 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2878 struct wl1271 *wl = hw->priv;
2879 u64 mactime = ULLONG_MAX;
2882 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2884 mutex_lock(&wl->mutex);
2886 if (unlikely(wl->state == WL1271_STATE_OFF))
2889 ret = wl1271_ps_elp_wakeup(wl);
2893 ret = wl1271_acx_tsf_info(wl, &mactime);
2898 wl1271_ps_elp_sleep(wl);
2901 mutex_unlock(&wl->mutex);
2905 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2906 struct survey_info *survey)
2908 struct wl1271 *wl = hw->priv;
2909 struct ieee80211_conf *conf = &hw->conf;
2914 survey->channel = conf->channel;
2915 survey->filled = SURVEY_INFO_NOISE_DBM;
2916 survey->noise = wl->noise;
2921 static int wl1271_allocate_sta(struct wl1271 *wl,
2922 struct ieee80211_sta *sta,
2925 struct wl1271_station *wl_sta;
2928 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
2929 if (id >= AP_MAX_STATIONS) {
2930 wl1271_warning("could not allocate HLID - too much stations");
2934 wl_sta = (struct wl1271_station *)sta->drv_priv;
2935 __set_bit(id, wl->ap_hlid_map);
2936 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
2937 *hlid = wl_sta->hlid;
2938 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
2942 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
2944 int id = hlid - WL1271_AP_STA_HLID_START;
2946 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2949 __clear_bit(id, wl->ap_hlid_map);
2950 memset(wl->links[hlid].addr, 0, ETH_ALEN);
2951 wl1271_tx_reset_link_queues(wl, hlid);
2952 __clear_bit(hlid, &wl->ap_ps_map);
2953 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
2956 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
2957 struct ieee80211_vif *vif,
2958 struct ieee80211_sta *sta)
2960 struct wl1271 *wl = hw->priv;
2964 mutex_lock(&wl->mutex);
2966 if (unlikely(wl->state == WL1271_STATE_OFF))
2969 if (wl->bss_type != BSS_TYPE_AP_BSS)
2972 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
2974 ret = wl1271_allocate_sta(wl, sta, &hlid);
2978 ret = wl1271_ps_elp_wakeup(wl);
2982 ret = wl1271_cmd_add_sta(wl, sta, hlid);
2987 wl1271_ps_elp_sleep(wl);
2991 wl1271_free_sta(wl, hlid);
2994 mutex_unlock(&wl->mutex);
2998 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
2999 struct ieee80211_vif *vif,
3000 struct ieee80211_sta *sta)
3002 struct wl1271 *wl = hw->priv;
3003 struct wl1271_station *wl_sta;
3006 mutex_lock(&wl->mutex);
3008 if (unlikely(wl->state == WL1271_STATE_OFF))
3011 if (wl->bss_type != BSS_TYPE_AP_BSS)
3014 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3016 wl_sta = (struct wl1271_station *)sta->drv_priv;
3017 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3018 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3021 ret = wl1271_ps_elp_wakeup(wl);
3025 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3029 wl1271_free_sta(wl, wl_sta->hlid);
3032 wl1271_ps_elp_sleep(wl);
3035 mutex_unlock(&wl->mutex);
3039 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3040 struct ieee80211_vif *vif,
3041 enum ieee80211_ampdu_mlme_action action,
3042 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3045 struct wl1271 *wl = hw->priv;
3048 mutex_lock(&wl->mutex);
3050 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3055 ret = wl1271_ps_elp_wakeup(wl);
3060 case IEEE80211_AMPDU_RX_START:
3061 if (wl->ba_support) {
3062 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3065 wl->ba_rx_bitmap |= BIT(tid);
3071 case IEEE80211_AMPDU_RX_STOP:
3072 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3074 wl->ba_rx_bitmap &= ~BIT(tid);
3078 * The BA initiator session management in FW independently.
3079 * Falling break here on purpose for all TX APDU commands.
3081 case IEEE80211_AMPDU_TX_START:
3082 case IEEE80211_AMPDU_TX_STOP:
3083 case IEEE80211_AMPDU_TX_OPERATIONAL:
3088 wl1271_error("Incorrect ampdu action id=%x\n", action);
3092 wl1271_ps_elp_sleep(wl);
3095 mutex_unlock(&wl->mutex);
3100 /* can't be const, mac80211 writes to this */
3101 static struct ieee80211_rate wl1271_rates[] = {
3103 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3104 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3106 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3107 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3108 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3110 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3111 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3112 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3114 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3115 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3116 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3118 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3119 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3121 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3122 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3124 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3125 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3127 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3128 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3130 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3131 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3133 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3134 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3136 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3137 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3139 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3140 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3143 /* can't be const, mac80211 writes to this */
3144 static struct ieee80211_channel wl1271_channels[] = {
3145 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3146 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3147 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3148 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3149 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3150 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3151 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3152 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3153 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3154 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3155 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3156 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3157 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3158 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3161 /* mapping to indexes for wl1271_rates */
3162 static const u8 wl1271_rate_to_idx_2ghz[] = {
3163 /* MCS rates are used only with 11n */
3164 7, /* CONF_HW_RXTX_RATE_MCS7 */
3165 6, /* CONF_HW_RXTX_RATE_MCS6 */
3166 5, /* CONF_HW_RXTX_RATE_MCS5 */
3167 4, /* CONF_HW_RXTX_RATE_MCS4 */
3168 3, /* CONF_HW_RXTX_RATE_MCS3 */
3169 2, /* CONF_HW_RXTX_RATE_MCS2 */
3170 1, /* CONF_HW_RXTX_RATE_MCS1 */
3171 0, /* CONF_HW_RXTX_RATE_MCS0 */
3173 11, /* CONF_HW_RXTX_RATE_54 */
3174 10, /* CONF_HW_RXTX_RATE_48 */
3175 9, /* CONF_HW_RXTX_RATE_36 */
3176 8, /* CONF_HW_RXTX_RATE_24 */
3178 /* TI-specific rate */
3179 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3181 7, /* CONF_HW_RXTX_RATE_18 */
3182 6, /* CONF_HW_RXTX_RATE_12 */
3183 3, /* CONF_HW_RXTX_RATE_11 */
3184 5, /* CONF_HW_RXTX_RATE_9 */
3185 4, /* CONF_HW_RXTX_RATE_6 */
3186 2, /* CONF_HW_RXTX_RATE_5_5 */
3187 1, /* CONF_HW_RXTX_RATE_2 */
3188 0 /* CONF_HW_RXTX_RATE_1 */
3191 /* 11n STA capabilities */
3192 #define HW_RX_HIGHEST_RATE 72
3194 #ifdef CONFIG_WL12XX_HT
3195 #define WL12XX_HT_CAP { \
3196 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3197 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3198 .ht_supported = true, \
3199 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3200 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3202 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3203 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3204 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3208 #define WL12XX_HT_CAP { \
3209 .ht_supported = false, \
3213 /* can't be const, mac80211 writes to this */
3214 static struct ieee80211_supported_band wl1271_band_2ghz = {
3215 .channels = wl1271_channels,
3216 .n_channels = ARRAY_SIZE(wl1271_channels),
3217 .bitrates = wl1271_rates,
3218 .n_bitrates = ARRAY_SIZE(wl1271_rates),
3219 .ht_cap = WL12XX_HT_CAP,
3222 /* 5 GHz data rates for WL1273 */
3223 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3225 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3226 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3228 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3229 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3231 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3232 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3234 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3235 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3237 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3238 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3240 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3241 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3243 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3244 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3246 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3247 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3250 /* 5 GHz band channels for WL1273 */
3251 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3252 { .hw_value = 7, .center_freq = 5035},
3253 { .hw_value = 8, .center_freq = 5040},
3254 { .hw_value = 9, .center_freq = 5045},
3255 { .hw_value = 11, .center_freq = 5055},
3256 { .hw_value = 12, .center_freq = 5060},
3257 { .hw_value = 16, .center_freq = 5080},
3258 { .hw_value = 34, .center_freq = 5170},
3259 { .hw_value = 36, .center_freq = 5180},
3260 { .hw_value = 38, .center_freq = 5190},
3261 { .hw_value = 40, .center_freq = 5200},
3262 { .hw_value = 42, .center_freq = 5210},
3263 { .hw_value = 44, .center_freq = 5220},
3264 { .hw_value = 46, .center_freq = 5230},
3265 { .hw_value = 48, .center_freq = 5240},
3266 { .hw_value = 52, .center_freq = 5260},
3267 { .hw_value = 56, .center_freq = 5280},
3268 { .hw_value = 60, .center_freq = 5300},
3269 { .hw_value = 64, .center_freq = 5320},
3270 { .hw_value = 100, .center_freq = 5500},
3271 { .hw_value = 104, .center_freq = 5520},
3272 { .hw_value = 108, .center_freq = 5540},
3273 { .hw_value = 112, .center_freq = 5560},
3274 { .hw_value = 116, .center_freq = 5580},
3275 { .hw_value = 120, .center_freq = 5600},
3276 { .hw_value = 124, .center_freq = 5620},
3277 { .hw_value = 128, .center_freq = 5640},
3278 { .hw_value = 132, .center_freq = 5660},
3279 { .hw_value = 136, .center_freq = 5680},
3280 { .hw_value = 140, .center_freq = 5700},
3281 { .hw_value = 149, .center_freq = 5745},
3282 { .hw_value = 153, .center_freq = 5765},
3283 { .hw_value = 157, .center_freq = 5785},
3284 { .hw_value = 161, .center_freq = 5805},
3285 { .hw_value = 165, .center_freq = 5825},
3288 /* mapping to indexes for wl1271_rates_5ghz */
3289 static const u8 wl1271_rate_to_idx_5ghz[] = {
3290 /* MCS rates are used only with 11n */
3291 7, /* CONF_HW_RXTX_RATE_MCS7 */
3292 6, /* CONF_HW_RXTX_RATE_MCS6 */
3293 5, /* CONF_HW_RXTX_RATE_MCS5 */
3294 4, /* CONF_HW_RXTX_RATE_MCS4 */
3295 3, /* CONF_HW_RXTX_RATE_MCS3 */
3296 2, /* CONF_HW_RXTX_RATE_MCS2 */
3297 1, /* CONF_HW_RXTX_RATE_MCS1 */
3298 0, /* CONF_HW_RXTX_RATE_MCS0 */
3300 7, /* CONF_HW_RXTX_RATE_54 */
3301 6, /* CONF_HW_RXTX_RATE_48 */
3302 5, /* CONF_HW_RXTX_RATE_36 */
3303 4, /* CONF_HW_RXTX_RATE_24 */
3305 /* TI-specific rate */
3306 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3308 3, /* CONF_HW_RXTX_RATE_18 */
3309 2, /* CONF_HW_RXTX_RATE_12 */
3310 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3311 1, /* CONF_HW_RXTX_RATE_9 */
3312 0, /* CONF_HW_RXTX_RATE_6 */
3313 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3314 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3315 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3318 static struct ieee80211_supported_band wl1271_band_5ghz = {
3319 .channels = wl1271_channels_5ghz,
3320 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3321 .bitrates = wl1271_rates_5ghz,
3322 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3323 .ht_cap = WL12XX_HT_CAP,
3326 static const u8 *wl1271_band_rate_to_idx[] = {
3327 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3328 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3331 static const struct ieee80211_ops wl1271_ops = {
3332 .start = wl1271_op_start,
3333 .stop = wl1271_op_stop,
3334 .add_interface = wl1271_op_add_interface,
3335 .remove_interface = wl1271_op_remove_interface,
3336 .config = wl1271_op_config,
3337 .prepare_multicast = wl1271_op_prepare_multicast,
3338 .configure_filter = wl1271_op_configure_filter,
3340 .set_key = wl1271_op_set_key,
3341 .hw_scan = wl1271_op_hw_scan,
3342 .bss_info_changed = wl1271_op_bss_info_changed,
3343 .set_frag_threshold = wl1271_op_set_frag_threshold,
3344 .set_rts_threshold = wl1271_op_set_rts_threshold,
3345 .conf_tx = wl1271_op_conf_tx,
3346 .get_tsf = wl1271_op_get_tsf,
3347 .get_survey = wl1271_op_get_survey,
3348 .sta_add = wl1271_op_sta_add,
3349 .sta_remove = wl1271_op_sta_remove,
3350 .ampdu_action = wl1271_op_ampdu_action,
3351 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3355 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3359 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3361 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3362 wl1271_error("Illegal RX rate from HW: %d", rate);
3366 idx = wl1271_band_rate_to_idx[band][rate];
3367 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3368 wl1271_error("Unsupported RX rate from HW: %d", rate);
3375 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3376 struct device_attribute *attr,
3379 struct wl1271 *wl = dev_get_drvdata(dev);
3384 mutex_lock(&wl->mutex);
3385 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3387 mutex_unlock(&wl->mutex);
3393 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3394 struct device_attribute *attr,
3395 const char *buf, size_t count)
3397 struct wl1271 *wl = dev_get_drvdata(dev);
3401 ret = kstrtoul(buf, 10, &res);
3403 wl1271_warning("incorrect value written to bt_coex_mode");
3407 mutex_lock(&wl->mutex);
3411 if (res == wl->sg_enabled)
3414 wl->sg_enabled = res;
3416 if (wl->state == WL1271_STATE_OFF)
3419 ret = wl1271_ps_elp_wakeup(wl);
3423 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3424 wl1271_ps_elp_sleep(wl);
3427 mutex_unlock(&wl->mutex);
3431 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3432 wl1271_sysfs_show_bt_coex_state,
3433 wl1271_sysfs_store_bt_coex_state);
3435 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3436 struct device_attribute *attr,
3439 struct wl1271 *wl = dev_get_drvdata(dev);
3444 mutex_lock(&wl->mutex);
3445 if (wl->hw_pg_ver >= 0)
3446 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3448 len = snprintf(buf, len, "n/a\n");
3449 mutex_unlock(&wl->mutex);
3454 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3455 wl1271_sysfs_show_hw_pg_ver, NULL);
3457 int wl1271_register_hw(struct wl1271 *wl)
3461 if (wl->mac80211_registered)
3464 ret = wl1271_fetch_nvs(wl);
3466 /* NOTE: The wl->nvs->nvs element must be first, in
3467 * order to simplify the casting, we assume it is at
3468 * the beginning of the wl->nvs structure.
3470 u8 *nvs_ptr = (u8 *)wl->nvs;
3472 wl->mac_addr[0] = nvs_ptr[11];
3473 wl->mac_addr[1] = nvs_ptr[10];
3474 wl->mac_addr[2] = nvs_ptr[6];
3475 wl->mac_addr[3] = nvs_ptr[5];
3476 wl->mac_addr[4] = nvs_ptr[4];
3477 wl->mac_addr[5] = nvs_ptr[3];
3480 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3482 ret = ieee80211_register_hw(wl->hw);
3484 wl1271_error("unable to register mac80211 hw: %d", ret);
3488 wl->mac80211_registered = true;
3490 wl1271_debugfs_init(wl);
3492 register_netdevice_notifier(&wl1271_dev_notifier);
3494 wl1271_notice("loaded");
3498 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3500 void wl1271_unregister_hw(struct wl1271 *wl)
3502 if (wl->state == WL1271_STATE_PLT)
3503 __wl1271_plt_stop(wl);
3505 unregister_netdevice_notifier(&wl1271_dev_notifier);
3506 ieee80211_unregister_hw(wl->hw);
3507 wl->mac80211_registered = false;
3510 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3512 int wl1271_init_ieee80211(struct wl1271 *wl)
3514 static const u32 cipher_suites[] = {
3515 WLAN_CIPHER_SUITE_WEP40,
3516 WLAN_CIPHER_SUITE_WEP104,
3517 WLAN_CIPHER_SUITE_TKIP,
3518 WLAN_CIPHER_SUITE_CCMP,
3519 WL1271_CIPHER_SUITE_GEM,
3522 /* The tx descriptor buffer and the TKIP space. */
3523 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3524 sizeof(struct wl1271_tx_hw_descr);
3527 /* FIXME: find a proper value */
3528 wl->hw->channel_change_time = 10000;
3529 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3531 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3532 IEEE80211_HW_BEACON_FILTER |
3533 IEEE80211_HW_SUPPORTS_PS |
3534 IEEE80211_HW_SUPPORTS_UAPSD |
3535 IEEE80211_HW_HAS_RATE_CONTROL |
3536 IEEE80211_HW_CONNECTION_MONITOR |
3537 IEEE80211_HW_SUPPORTS_CQM_RSSI |
3538 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3539 IEEE80211_HW_AP_LINK_PS;
3541 wl->hw->wiphy->cipher_suites = cipher_suites;
3542 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3544 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3545 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3546 wl->hw->wiphy->max_scan_ssids = 1;
3548 * Maximum length of elements in scanning probe request templates
3549 * should be the maximum length possible for a template, without
3550 * the IEEE80211 header of the template
3552 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3553 sizeof(struct ieee80211_header);
3555 /* make sure all our channels fit in the scanned_ch bitmask */
3556 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3557 ARRAY_SIZE(wl1271_channels_5ghz) >
3558 WL1271_MAX_CHANNELS);
3560 * We keep local copies of the band structs because we need to
3561 * modify them on a per-device basis.
3563 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3564 sizeof(wl1271_band_2ghz));
3565 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3566 sizeof(wl1271_band_5ghz));
3568 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3569 &wl->bands[IEEE80211_BAND_2GHZ];
3570 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3571 &wl->bands[IEEE80211_BAND_5GHZ];
3574 wl->hw->max_rates = 1;
3576 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3578 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3580 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3582 wl->hw->max_rx_aggregation_subframes = 8;
3586 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3588 #define WL1271_DEFAULT_CHANNEL 0
3590 struct ieee80211_hw *wl1271_alloc_hw(void)
3592 struct ieee80211_hw *hw;
3593 struct platform_device *plat_dev = NULL;
3598 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3600 wl1271_error("could not alloc ieee80211_hw");
3605 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3607 wl1271_error("could not allocate platform_device");
3609 goto err_plat_alloc;
3613 memset(wl, 0, sizeof(*wl));
3615 INIT_LIST_HEAD(&wl->list);
3618 wl->plat_dev = plat_dev;
3620 for (i = 0; i < NUM_TX_QUEUES; i++)
3621 skb_queue_head_init(&wl->tx_queue[i]);
3623 for (i = 0; i < NUM_TX_QUEUES; i++)
3624 for (j = 0; j < AP_MAX_LINKS; j++)
3625 skb_queue_head_init(&wl->links[j].tx_queue[i]);
3627 skb_queue_head_init(&wl->deferred_rx_queue);
3628 skb_queue_head_init(&wl->deferred_tx_queue);
3630 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3631 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3632 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
3633 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3634 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3635 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3636 wl->channel = WL1271_DEFAULT_CHANNEL;
3637 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3638 wl->default_key = 0;
3640 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3641 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3642 wl->psm_entry_retry = 0;
3643 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3644 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3645 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3646 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3647 wl->band = IEEE80211_BAND_2GHZ;
3650 wl->sg_enabled = true;
3652 wl->bss_type = MAX_BSS_TYPE;
3653 wl->set_bss_type = MAX_BSS_TYPE;
3654 wl->fw_bss_type = MAX_BSS_TYPE;
3655 wl->last_tx_hlid = 0;
3657 wl->ap_fw_ps_map = 0;
3659 wl->platform_quirks = 0;
3661 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3662 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
3663 wl->tx_frames[i] = NULL;
3665 spin_lock_init(&wl->wl_lock);
3667 wl->state = WL1271_STATE_OFF;
3668 mutex_init(&wl->mutex);
3670 /* Apply default driver configuration. */
3671 wl1271_conf_init(wl);
3673 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3674 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3675 if (!wl->aggr_buf) {
3680 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
3681 if (!wl->dummy_packet) {
3686 /* Register platform device */
3687 ret = platform_device_register(wl->plat_dev);
3689 wl1271_error("couldn't register platform device");
3690 goto err_dummy_packet;
3692 dev_set_drvdata(&wl->plat_dev->dev, wl);
3694 /* Create sysfs file to control bt coex state */
3695 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3697 wl1271_error("failed to create sysfs file bt_coex_state");
3701 /* Create sysfs file to get HW PG version */
3702 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3704 wl1271_error("failed to create sysfs file hw_pg_ver");
3705 goto err_bt_coex_state;
3711 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3714 platform_device_unregister(wl->plat_dev);
3717 dev_kfree_skb(wl->dummy_packet);
3720 free_pages((unsigned long)wl->aggr_buf, order);
3723 wl1271_debugfs_exit(wl);
3727 ieee80211_free_hw(hw);
3731 return ERR_PTR(ret);
3733 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
3735 int wl1271_free_hw(struct wl1271 *wl)
3737 platform_device_unregister(wl->plat_dev);
3738 dev_kfree_skb(wl->dummy_packet);
3739 free_pages((unsigned long)wl->aggr_buf,
3740 get_order(WL1271_AGGR_BUFFER_SIZE));
3741 kfree(wl->plat_dev);
3743 wl1271_debugfs_exit(wl);
3750 kfree(wl->fw_status);
3751 kfree(wl->tx_res_if);
3753 ieee80211_free_hw(wl->hw);
3757 EXPORT_SYMBOL_GPL(wl1271_free_hw);
3759 u32 wl12xx_debug_level = DEBUG_NONE;
3760 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
3761 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
3762 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3764 MODULE_LICENSE("GPL");
3765 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
3766 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");