2 * This file is part of wl1271
4 * Copyright (C) 2008-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
35 #include "wl12xx_80211.h"
49 #define WL1271_BOOT_RETRIES 3
51 static struct conf_drv_settings default_conf = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
58 [CONF_SG_AUTO_PS_MODE] = 1,
59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
103 .state = CONF_SG_PROTECTIVE,
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
110 .rts_threshold = 2347,
111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
118 .tx_energy_detection = 0,
121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
145 .aifsn = CONF_TX_AIFS_PIFS,
152 .aifsn = CONF_TX_AIFS_PIFS,
158 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
159 .short_retry_limit = 10,
160 .long_retry_limit = 10,
164 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
165 .short_retry_limit = 10,
166 .long_retry_limit = 10,
170 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
171 .short_retry_limit = 10,
172 .long_retry_limit = 10,
176 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
177 .short_retry_limit = 10,
178 .long_retry_limit = 10,
183 .enabled_rates = CONF_TX_AP_DEFAULT_MGMT_RATES,
184 .short_retry_limit = 10,
185 .long_retry_limit = 10,
189 .enabled_rates = CONF_HW_BIT_RATE_1MBPS,
190 .short_retry_limit = 10,
191 .long_retry_limit = 10,
194 .ap_max_tx_retries = 100,
198 .queue_id = CONF_TX_AC_BE,
199 .channel_type = CONF_CHANNEL_TYPE_EDCF,
200 .tsid = CONF_TX_AC_BE,
201 .ps_scheme = CONF_PS_SCHEME_LEGACY,
202 .ack_policy = CONF_ACK_POLICY_LEGACY,
206 .queue_id = CONF_TX_AC_BK,
207 .channel_type = CONF_CHANNEL_TYPE_EDCF,
208 .tsid = CONF_TX_AC_BK,
209 .ps_scheme = CONF_PS_SCHEME_LEGACY,
210 .ack_policy = CONF_ACK_POLICY_LEGACY,
214 .queue_id = CONF_TX_AC_VI,
215 .channel_type = CONF_CHANNEL_TYPE_EDCF,
216 .tsid = CONF_TX_AC_VI,
217 .ps_scheme = CONF_PS_SCHEME_LEGACY,
218 .ack_policy = CONF_ACK_POLICY_LEGACY,
222 .queue_id = CONF_TX_AC_VO,
223 .channel_type = CONF_CHANNEL_TYPE_EDCF,
224 .tsid = CONF_TX_AC_VO,
225 .ps_scheme = CONF_PS_SCHEME_LEGACY,
226 .ack_policy = CONF_ACK_POLICY_LEGACY,
230 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
231 .tx_compl_timeout = 700,
232 .tx_compl_threshold = 4,
233 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
234 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
235 .tmpl_short_retry_limit = 10,
236 .tmpl_long_retry_limit = 10,
239 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
240 .listen_interval = 1,
241 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
242 .bcn_filt_ie_count = 1,
245 .ie = WLAN_EID_CHANNEL_SWITCH,
246 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
249 .synch_fail_thold = 10,
250 .bss_lose_timeout = 100,
251 .beacon_rx_timeout = 10000,
252 .broadcast_timeout = 20000,
253 .rx_broadcast_in_ps = 1,
254 .ps_poll_threshold = 10,
255 .ps_poll_recovery_period = 700,
256 .bet_enable = CONF_BET_MODE_ENABLE,
257 .bet_max_consecutive = 10,
258 .psm_entry_retries = 5,
259 .psm_exit_retries = 255,
260 .psm_entry_nullfunc_retries = 3,
261 .psm_entry_hangover_period = 1,
262 .keep_alive_interval = 55000,
263 .max_listen_interval = 20,
270 .host_clk_settling_time = 5000,
271 .host_fast_wakeup_support = false
275 .avg_weight_rssi_beacon = 20,
276 .avg_weight_rssi_data = 10,
277 .avg_weight_snr_beacon = 20,
278 .avg_weight_snr_data = 10,
281 .min_dwell_time_active = 7500,
282 .max_dwell_time_active = 30000,
283 .min_dwell_time_passive = 100000,
284 .max_dwell_time_passive = 100000,
288 .tx_per_channel_power_compensation_2 = {
289 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291 .tx_per_channel_power_compensation_5 = {
292 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
298 .tx_ba_win_size = 64,
299 .inactivity_timeout = 10000,
305 .tx_min_block_num = 40,
307 .min_req_tx_blocks = 104,
308 .min_req_rx_blocks = 22,
313 static void __wl1271_op_remove_interface(struct wl1271 *wl);
314 static void wl1271_free_ap_keys(struct wl1271 *wl);
317 static void wl1271_device_release(struct device *dev)
322 static struct platform_device wl1271_device = {
326 /* device model insists to have a release function */
328 .release = wl1271_device_release,
332 static LIST_HEAD(wl_list);
334 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
337 struct net_device *dev = arg;
338 struct wireless_dev *wdev;
340 struct ieee80211_hw *hw;
342 struct wl1271 *wl_temp;
345 /* Check that this notification is for us. */
346 if (what != NETDEV_CHANGE)
349 wdev = dev->ieee80211_ptr;
357 hw = wiphy_priv(wiphy);
362 list_for_each_entry(wl, &wl_list, list) {
369 mutex_lock(&wl->mutex);
371 if (wl->state == WL1271_STATE_OFF)
374 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
377 ret = wl1271_ps_elp_wakeup(wl, false);
381 if ((dev->operstate == IF_OPER_UP) &&
382 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
383 wl1271_cmd_set_sta_state(wl);
384 wl1271_info("Association completed.");
387 wl1271_ps_elp_sleep(wl);
390 mutex_unlock(&wl->mutex);
395 static int wl1271_reg_notify(struct wiphy *wiphy,
396 struct regulatory_request *request)
398 struct ieee80211_supported_band *band;
399 struct ieee80211_channel *ch;
402 band = wiphy->bands[IEEE80211_BAND_5GHZ];
403 for (i = 0; i < band->n_channels; i++) {
404 ch = &band->channels[i];
405 if (ch->flags & IEEE80211_CHAN_DISABLED)
408 if (ch->flags & IEEE80211_CHAN_RADAR)
409 ch->flags |= IEEE80211_CHAN_NO_IBSS |
410 IEEE80211_CHAN_PASSIVE_SCAN;
417 static void wl1271_conf_init(struct wl1271 *wl)
421 * This function applies the default configuration to the driver. This
422 * function is invoked upon driver load (spi probe.)
424 * The configuration is stored in a run-time structure in order to
425 * facilitate for run-time adjustment of any of the parameters. Making
426 * changes to the configuration structure will apply the new values on
427 * the next interface up (wl1271_op_start.)
430 /* apply driver default configuration */
431 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
435 static int wl1271_plt_init(struct wl1271 *wl)
437 struct conf_tx_ac_category *conf_ac;
438 struct conf_tx_tid *conf_tid;
441 ret = wl1271_cmd_general_parms(wl);
445 ret = wl1271_cmd_radio_parms(wl);
449 ret = wl1271_cmd_ext_radio_parms(wl);
453 ret = wl1271_sta_init_templates_config(wl);
457 ret = wl1271_acx_init_mem_config(wl);
461 /* PHY layer config */
462 ret = wl1271_init_phy_config(wl);
464 goto out_free_memmap;
466 ret = wl1271_acx_dco_itrim_params(wl);
468 goto out_free_memmap;
470 /* Initialize connection monitoring thresholds */
471 ret = wl1271_acx_conn_monit_params(wl, false);
473 goto out_free_memmap;
475 /* Bluetooth WLAN coexistence */
476 ret = wl1271_init_pta(wl);
478 goto out_free_memmap;
480 /* Energy detection */
481 ret = wl1271_init_energy_detection(wl);
483 goto out_free_memmap;
485 ret = wl1271_acx_sta_mem_cfg(wl);
487 goto out_free_memmap;
489 /* Default fragmentation threshold */
490 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
492 goto out_free_memmap;
494 /* Default TID/AC configuration */
495 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
496 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
497 conf_ac = &wl->conf.tx.ac_conf[i];
498 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
499 conf_ac->cw_max, conf_ac->aifsn,
500 conf_ac->tx_op_limit);
502 goto out_free_memmap;
504 conf_tid = &wl->conf.tx.tid_conf[i];
505 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
506 conf_tid->channel_type,
509 conf_tid->ack_policy,
510 conf_tid->apsd_conf[0],
511 conf_tid->apsd_conf[1]);
513 goto out_free_memmap;
516 /* Enable data path */
517 ret = wl1271_cmd_data_path(wl, 1);
519 goto out_free_memmap;
521 /* Configure for CAM power saving (ie. always active) */
522 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
524 goto out_free_memmap;
527 ret = wl1271_acx_pm_config(wl);
529 goto out_free_memmap;
534 kfree(wl->target_mem_map);
535 wl->target_mem_map = NULL;
540 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
544 /* only regulate station links */
545 if (hlid < WL1271_AP_STA_HLID_START)
548 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
551 * Wake up from high level PS if the STA is asleep with too little
552 * blocks in FW or if the STA is awake.
554 if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
555 wl1271_ps_link_end(wl, hlid);
557 /* Start high-level PS if the STA is asleep with enough blocks in FW */
558 else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
559 wl1271_ps_link_start(wl, hlid, true);
562 static void wl1271_irq_update_links_status(struct wl1271 *wl,
563 struct wl1271_fw_ap_status *status)
568 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
569 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
570 wl1271_debug(DEBUG_PSM,
571 "link ps prev 0x%x cur 0x%x changed 0x%x",
572 wl->ap_fw_ps_map, cur_fw_ps_map,
573 wl->ap_fw_ps_map ^ cur_fw_ps_map);
575 wl->ap_fw_ps_map = cur_fw_ps_map;
578 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
579 u8 cnt = status->tx_lnk_free_blks[hlid] -
580 wl->links[hlid].prev_freed_blks;
582 wl->links[hlid].prev_freed_blks =
583 status->tx_lnk_free_blks[hlid];
584 wl->links[hlid].allocated_blks -= cnt;
586 wl1271_irq_ps_regulate_link(wl, hlid,
587 wl->links[hlid].allocated_blks);
591 static void wl1271_fw_status(struct wl1271 *wl,
592 struct wl1271_fw_full_status *full_status)
594 struct wl1271_fw_common_status *status = &full_status->common;
599 if (wl->bss_type == BSS_TYPE_AP_BSS)
600 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
601 sizeof(struct wl1271_fw_ap_status), false);
603 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
604 sizeof(struct wl1271_fw_sta_status), false);
606 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
607 "drv_rx_counter = %d, tx_results_counter = %d)",
609 status->fw_rx_counter,
610 status->drv_rx_counter,
611 status->tx_results_counter);
613 /* update number of available TX blocks */
614 for (i = 0; i < NUM_TX_QUEUES; i++) {
615 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
616 wl->tx_blocks_freed[i];
618 wl->tx_blocks_freed[i] =
619 le32_to_cpu(status->tx_released_blks[i]);
620 wl->tx_blocks_available += cnt;
624 /* if more blocks are available now, tx work can be scheduled */
626 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
628 /* for AP update num of allocated TX blocks per link and ps status */
629 if (wl->bss_type == BSS_TYPE_AP_BSS)
630 wl1271_irq_update_links_status(wl, &full_status->ap);
632 /* update the host-chipset time offset */
634 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
635 (s64)le32_to_cpu(status->fw_localtime);
638 #define WL1271_IRQ_MAX_LOOPS 10
640 static void wl1271_irq_work(struct work_struct *work)
644 int loopcount = WL1271_IRQ_MAX_LOOPS;
647 container_of(work, struct wl1271, irq_work);
649 mutex_lock(&wl->mutex);
651 wl1271_debug(DEBUG_IRQ, "IRQ work");
653 if (unlikely(wl->state == WL1271_STATE_OFF))
656 ret = wl1271_ps_elp_wakeup(wl, true);
660 spin_lock_irqsave(&wl->wl_lock, flags);
661 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
662 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
663 spin_unlock_irqrestore(&wl->wl_lock, flags);
666 wl1271_fw_status(wl, wl->fw_status);
667 intr = le32_to_cpu(wl->fw_status->common.intr);
669 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
670 spin_lock_irqsave(&wl->wl_lock, flags);
674 intr &= WL1271_INTR_MASK;
676 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
677 wl1271_error("watchdog interrupt received! "
678 "starting recovery.");
679 ieee80211_queue_work(wl->hw, &wl->recovery_work);
681 /* restarting the chip. ignore any other interrupt. */
685 if (intr & WL1271_ACX_INTR_DATA) {
686 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
688 /* check for tx results */
689 if (wl->fw_status->common.tx_results_counter !=
690 (wl->tx_results_count & 0xff))
691 wl1271_tx_complete(wl);
693 /* Check if any tx blocks were freed */
694 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
695 wl->tx_queue_count) {
697 * In order to avoid starvation of the TX path,
698 * call the work function directly.
700 wl1271_tx_work_locked(wl);
703 wl1271_rx(wl, &wl->fw_status->common);
706 if (intr & WL1271_ACX_INTR_EVENT_A) {
707 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
708 wl1271_event_handle(wl, 0);
711 if (intr & WL1271_ACX_INTR_EVENT_B) {
712 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
713 wl1271_event_handle(wl, 1);
716 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
717 wl1271_debug(DEBUG_IRQ,
718 "WL1271_ACX_INTR_INIT_COMPLETE");
720 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
721 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
723 spin_lock_irqsave(&wl->wl_lock, flags);
726 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
727 ieee80211_queue_work(wl->hw, &wl->irq_work);
729 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
730 spin_unlock_irqrestore(&wl->wl_lock, flags);
732 wl1271_ps_elp_sleep(wl);
735 mutex_unlock(&wl->mutex);
738 static int wl1271_fetch_firmware(struct wl1271 *wl)
740 const struct firmware *fw;
744 switch (wl->bss_type) {
745 case BSS_TYPE_AP_BSS:
746 fw_name = WL1271_AP_FW_NAME;
749 case BSS_TYPE_STA_BSS:
750 fw_name = WL1271_FW_NAME;
753 wl1271_error("no compatible firmware for bss_type %d",
758 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
760 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
763 wl1271_error("could not get firmware: %d", ret);
768 wl1271_error("firmware size is not multiple of 32 bits: %zu",
775 wl->fw_len = fw->size;
776 wl->fw = vmalloc(wl->fw_len);
779 wl1271_error("could not allocate memory for the firmware");
784 memcpy(wl->fw, fw->data, wl->fw_len);
785 wl->fw_bss_type = wl->bss_type;
789 release_firmware(fw);
794 static int wl1271_fetch_nvs(struct wl1271 *wl)
796 const struct firmware *fw;
799 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
802 wl1271_error("could not get nvs file: %d", ret);
806 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
809 wl1271_error("could not allocate memory for the nvs file");
814 wl->nvs_len = fw->size;
817 release_firmware(fw);
822 static void wl1271_recovery_work(struct work_struct *work)
825 container_of(work, struct wl1271, recovery_work);
827 mutex_lock(&wl->mutex);
829 if (wl->state != WL1271_STATE_ON)
832 wl1271_info("Hardware recovery in progress.");
834 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
835 ieee80211_connection_loss(wl->vif);
837 /* reboot the chipset */
838 __wl1271_op_remove_interface(wl);
839 ieee80211_restart_hw(wl->hw);
842 mutex_unlock(&wl->mutex);
845 static void wl1271_fw_wakeup(struct wl1271 *wl)
849 elp_reg = ELPCTRL_WAKE_UP;
850 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
853 static int wl1271_setup(struct wl1271 *wl)
855 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
859 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
860 if (!wl->tx_res_if) {
861 kfree(wl->fw_status);
868 static int wl1271_chip_wakeup(struct wl1271 *wl)
870 struct wl1271_partition_set partition;
873 msleep(WL1271_PRE_POWER_ON_SLEEP);
874 ret = wl1271_power_on(wl);
877 msleep(WL1271_POWER_ON_SLEEP);
881 /* We don't need a real memory partition here, because we only want
882 * to use the registers at this point. */
883 memset(&partition, 0, sizeof(partition));
884 partition.reg.start = REGISTERS_BASE;
885 partition.reg.size = REGISTERS_DOWN_SIZE;
886 wl1271_set_partition(wl, &partition);
888 /* ELP module wake up */
889 wl1271_fw_wakeup(wl);
891 /* whal_FwCtrl_BootSm() */
893 /* 0. read chip id from CHIP_ID */
894 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
896 /* 1. check if chip id is valid */
898 switch (wl->chip.id) {
899 case CHIP_ID_1271_PG10:
900 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
903 ret = wl1271_setup(wl);
907 case CHIP_ID_1271_PG20:
908 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
911 ret = wl1271_setup(wl);
916 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
921 /* Make sure the firmware type matches the BSS type */
922 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
923 ret = wl1271_fetch_firmware(wl);
928 /* No NVS from netlink, try to get it from the filesystem */
929 if (wl->nvs == NULL) {
930 ret = wl1271_fetch_nvs(wl);
939 int wl1271_plt_start(struct wl1271 *wl)
941 int retries = WL1271_BOOT_RETRIES;
944 mutex_lock(&wl->mutex);
946 wl1271_notice("power up");
948 if (wl->state != WL1271_STATE_OFF) {
949 wl1271_error("cannot go into PLT state because not "
950 "in off state: %d", wl->state);
955 wl->bss_type = BSS_TYPE_STA_BSS;
959 ret = wl1271_chip_wakeup(wl);
963 ret = wl1271_boot(wl);
967 ret = wl1271_plt_init(wl);
971 wl->state = WL1271_STATE_PLT;
972 wl1271_notice("firmware booted in PLT mode (%s)",
973 wl->chip.fw_ver_str);
977 wl1271_disable_interrupts(wl);
978 mutex_unlock(&wl->mutex);
979 /* Unlocking the mutex in the middle of handling is
980 inherently unsafe. In this case we deem it safe to do,
981 because we need to let any possibly pending IRQ out of
982 the system (and while we are WL1271_STATE_OFF the IRQ
983 work function will not do anything.) Also, any other
984 possible concurrent operations will fail due to the
985 current state, hence the wl1271 struct should be safe. */
986 cancel_work_sync(&wl->irq_work);
987 mutex_lock(&wl->mutex);
989 wl1271_power_off(wl);
992 wl1271_error("firmware boot in PLT mode failed despite %d retries",
993 WL1271_BOOT_RETRIES);
995 mutex_unlock(&wl->mutex);
1000 int __wl1271_plt_stop(struct wl1271 *wl)
1004 wl1271_notice("power down");
1006 if (wl->state != WL1271_STATE_PLT) {
1007 wl1271_error("cannot power down because not in PLT "
1008 "state: %d", wl->state);
1013 wl1271_disable_interrupts(wl);
1014 wl1271_power_off(wl);
1016 wl->state = WL1271_STATE_OFF;
1019 mutex_unlock(&wl->mutex);
1020 cancel_work_sync(&wl->irq_work);
1021 cancel_work_sync(&wl->recovery_work);
1022 mutex_lock(&wl->mutex);
1027 int wl1271_plt_stop(struct wl1271 *wl)
1031 mutex_lock(&wl->mutex);
1032 ret = __wl1271_plt_stop(wl);
1033 mutex_unlock(&wl->mutex);
1037 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1039 struct wl1271 *wl = hw->priv;
1040 unsigned long flags;
1044 spin_lock_irqsave(&wl->wl_lock, flags);
1045 wl->tx_queue_count++;
1048 * The workqueue is slow to process the tx_queue and we need stop
1049 * the queue here, otherwise the queue will get too long.
1051 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1052 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1053 ieee80211_stop_queues(wl->hw);
1054 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1057 spin_unlock_irqrestore(&wl->wl_lock, flags);
1059 /* queue the packet */
1060 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1061 if (wl->bss_type == BSS_TYPE_AP_BSS) {
1062 hlid = wl1271_tx_get_hlid(skb);
1063 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1064 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1066 skb_queue_tail(&wl->tx_queue[q], skb);
1070 * The chip specific setup must run before the first TX packet -
1071 * before that, the tx_work will not be initialized!
1074 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1075 ieee80211_queue_work(wl->hw, &wl->tx_work);
1078 static struct notifier_block wl1271_dev_notifier = {
1079 .notifier_call = wl1271_dev_notify,
1082 static int wl1271_op_start(struct ieee80211_hw *hw)
1084 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1087 * We have to delay the booting of the hardware because
1088 * we need to know the local MAC address before downloading and
1089 * initializing the firmware. The MAC address cannot be changed
1090 * after boot, and without the proper MAC address, the firmware
1091 * will not function properly.
1093 * The MAC address is first known when the corresponding interface
1094 * is added. That is where we will initialize the hardware.
1096 * In addition, we currently have different firmwares for AP and managed
1097 * operation. We will know which to boot according to interface type.
1103 static void wl1271_op_stop(struct ieee80211_hw *hw)
1105 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1108 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1109 struct ieee80211_vif *vif)
1111 struct wl1271 *wl = hw->priv;
1112 struct wiphy *wiphy = hw->wiphy;
1113 int retries = WL1271_BOOT_RETRIES;
1115 bool booted = false;
1117 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1118 vif->type, vif->addr);
1120 mutex_lock(&wl->mutex);
1122 wl1271_debug(DEBUG_MAC80211,
1123 "multiple vifs are not supported yet");
1128 switch (vif->type) {
1129 case NL80211_IFTYPE_STATION:
1130 wl->bss_type = BSS_TYPE_STA_BSS;
1131 wl->set_bss_type = BSS_TYPE_STA_BSS;
1133 case NL80211_IFTYPE_ADHOC:
1134 wl->bss_type = BSS_TYPE_IBSS;
1135 wl->set_bss_type = BSS_TYPE_STA_BSS;
1137 case NL80211_IFTYPE_AP:
1138 wl->bss_type = BSS_TYPE_AP_BSS;
1145 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1147 if (wl->state != WL1271_STATE_OFF) {
1148 wl1271_error("cannot start because not in off state: %d",
1156 ret = wl1271_chip_wakeup(wl);
1160 ret = wl1271_boot(wl);
1164 ret = wl1271_hw_init(wl);
1172 wl1271_disable_interrupts(wl);
1173 mutex_unlock(&wl->mutex);
1174 /* Unlocking the mutex in the middle of handling is
1175 inherently unsafe. In this case we deem it safe to do,
1176 because we need to let any possibly pending IRQ out of
1177 the system (and while we are WL1271_STATE_OFF the IRQ
1178 work function will not do anything.) Also, any other
1179 possible concurrent operations will fail due to the
1180 current state, hence the wl1271 struct should be safe. */
1181 cancel_work_sync(&wl->irq_work);
1182 mutex_lock(&wl->mutex);
1184 wl1271_power_off(wl);
1188 wl1271_error("firmware boot failed despite %d retries",
1189 WL1271_BOOT_RETRIES);
1194 wl->state = WL1271_STATE_ON;
1195 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1197 /* update hw/fw version info in wiphy struct */
1198 wiphy->hw_version = wl->chip.id;
1199 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1200 sizeof(wiphy->fw_version));
1203 * Now we know if 11a is supported (info from the NVS), so disable
1204 * 11a channels if not supported
1206 if (!wl->enable_11a)
1207 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1209 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1210 wl->enable_11a ? "" : "not ");
1213 mutex_unlock(&wl->mutex);
1216 list_add(&wl->list, &wl_list);
1221 static void __wl1271_op_remove_interface(struct wl1271 *wl)
1225 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1227 wl1271_info("down");
1229 list_del(&wl->list);
1231 WARN_ON(wl->state != WL1271_STATE_ON);
1233 /* enable dyn ps just in case (if left on due to fw crash etc) */
1234 if (wl->bss_type == BSS_TYPE_STA_BSS)
1235 ieee80211_enable_dyn_ps(wl->vif);
1237 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1238 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1239 kfree(wl->scan.scanned_ch);
1240 wl->scan.scanned_ch = NULL;
1241 wl->scan.req = NULL;
1242 ieee80211_scan_completed(wl->hw, true);
1245 wl->state = WL1271_STATE_OFF;
1247 wl1271_disable_interrupts(wl);
1249 mutex_unlock(&wl->mutex);
1251 cancel_delayed_work_sync(&wl->scan_complete_work);
1252 cancel_work_sync(&wl->irq_work);
1253 cancel_work_sync(&wl->tx_work);
1254 cancel_delayed_work_sync(&wl->pspoll_work);
1255 cancel_delayed_work_sync(&wl->elp_work);
1257 mutex_lock(&wl->mutex);
1259 /* let's notify MAC80211 about the remaining pending TX frames */
1260 wl1271_tx_reset(wl);
1261 wl1271_power_off(wl);
1263 memset(wl->bssid, 0, ETH_ALEN);
1264 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1266 wl->bss_type = MAX_BSS_TYPE;
1267 wl->set_bss_type = MAX_BSS_TYPE;
1268 wl->band = IEEE80211_BAND_2GHZ;
1271 wl->psm_entry_retry = 0;
1272 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1273 wl->tx_blocks_available = 0;
1274 wl->tx_results_count = 0;
1275 wl->tx_packets_count = 0;
1276 wl->tx_security_last_seq = 0;
1277 wl->tx_security_seq = 0;
1278 wl->time_offset = 0;
1279 wl->session_counter = 0;
1280 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1284 wl1271_free_ap_keys(wl);
1285 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1286 wl->ap_fw_ps_map = 0;
1289 for (i = 0; i < NUM_TX_QUEUES; i++)
1290 wl->tx_blocks_freed[i] = 0;
1292 wl1271_debugfs_reset(wl);
1294 kfree(wl->fw_status);
1295 wl->fw_status = NULL;
1296 kfree(wl->tx_res_if);
1297 wl->tx_res_if = NULL;
1298 kfree(wl->target_mem_map);
1299 wl->target_mem_map = NULL;
1302 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1303 struct ieee80211_vif *vif)
1305 struct wl1271 *wl = hw->priv;
1307 mutex_lock(&wl->mutex);
1309 * wl->vif can be null here if someone shuts down the interface
1310 * just when hardware recovery has been started.
1313 WARN_ON(wl->vif != vif);
1314 __wl1271_op_remove_interface(wl);
1317 mutex_unlock(&wl->mutex);
1318 cancel_work_sync(&wl->recovery_work);
1321 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1323 wl1271_set_default_filters(wl);
1325 /* combine requested filters with current filter config */
1326 filters = wl->filters | filters;
1328 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1330 if (filters & FIF_PROMISC_IN_BSS) {
1331 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1332 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1333 wl->rx_config |= CFG_BSSID_FILTER_EN;
1335 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1336 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1337 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1338 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1340 if (filters & FIF_OTHER_BSS) {
1341 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1342 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1344 if (filters & FIF_CONTROL) {
1345 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1346 wl->rx_filter |= CFG_RX_CTL_EN;
1348 if (filters & FIF_FCSFAIL) {
1349 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1350 wl->rx_filter |= CFG_RX_FCS_ERROR;
1354 static int wl1271_dummy_join(struct wl1271 *wl)
1357 /* we need to use a dummy BSSID for now */
1358 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1361 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1363 /* pass through frames from all BSS */
1364 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1366 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1370 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1376 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1381 * One of the side effects of the JOIN command is that is clears
1382 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1383 * to a WPA/WPA2 access point will therefore kill the data-path.
1384 * Currently there is no supported scenario for JOIN during
1385 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1386 * must be handled somehow.
1389 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1390 wl1271_info("JOIN while associated.");
1393 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1395 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1399 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1401 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1405 * The join command disable the keep-alive mode, shut down its process,
1406 * and also clear the template config, so we need to reset it all after
1407 * the join. The acx_aid starts the keep-alive process, and the order
1408 * of the commands below is relevant.
1410 ret = wl1271_acx_keep_alive_mode(wl, true);
1414 ret = wl1271_acx_aid(wl, wl->aid);
1418 ret = wl1271_cmd_build_klv_null_data(wl);
1422 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1423 ACX_KEEP_ALIVE_TPL_VALID);
1431 static int wl1271_unjoin(struct wl1271 *wl)
1435 /* to stop listening to a channel, we disconnect */
1436 ret = wl1271_cmd_disconnect(wl);
1440 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1441 memset(wl->bssid, 0, ETH_ALEN);
1443 /* stop filterting packets based on bssid */
1444 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1450 static void wl1271_set_band_rate(struct wl1271 *wl)
1452 if (wl->band == IEEE80211_BAND_2GHZ)
1453 wl->basic_rate_set = wl->conf.tx.basic_rate;
1455 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1458 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1463 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1464 ret = wl1271_unjoin(wl);
1468 wl->rate_set = wl1271_tx_min_rate_get(wl);
1469 ret = wl1271_acx_sta_rate_policies(wl);
1472 ret = wl1271_acx_keep_alive_config(
1473 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1474 ACX_KEEP_ALIVE_TPL_INVALID);
1477 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1479 /* increment the session counter */
1480 wl->session_counter++;
1481 if (wl->session_counter >= SESSION_COUNTER_MAX)
1482 wl->session_counter = 0;
1483 ret = wl1271_dummy_join(wl);
1486 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1493 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1495 struct wl1271 *wl = hw->priv;
1496 struct ieee80211_conf *conf = &hw->conf;
1497 int channel, ret = 0;
1500 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1502 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1505 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1507 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1511 * mac80211 will go to idle nearly immediately after transmitting some
1512 * frames, such as the deauth. To make sure those frames reach the air,
1513 * wait here until the TX queue is fully flushed.
1515 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1516 (conf->flags & IEEE80211_CONF_IDLE))
1517 wl1271_tx_flush(wl);
1519 mutex_lock(&wl->mutex);
1521 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1526 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1528 ret = wl1271_ps_elp_wakeup(wl, false);
1532 /* if the channel changes while joined, join again */
1533 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1534 ((wl->band != conf->channel->band) ||
1535 (wl->channel != channel))) {
1536 wl->band = conf->channel->band;
1537 wl->channel = channel;
1541 * FIXME: the mac80211 should really provide a fixed
1542 * rate to use here. for now, just use the smallest
1543 * possible rate for the band as a fixed rate for
1544 * association frames and other control messages.
1546 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1547 wl1271_set_band_rate(wl);
1549 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1550 ret = wl1271_acx_sta_rate_policies(wl);
1552 wl1271_warning("rate policy for channel "
1555 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1556 ret = wl1271_join(wl, false);
1558 wl1271_warning("cmd join on channel "
1564 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1565 ret = wl1271_sta_handle_idle(wl,
1566 conf->flags & IEEE80211_CONF_IDLE);
1568 wl1271_warning("idle mode change failed %d", ret);
1572 * if mac80211 changes the PSM mode, make sure the mode is not
1573 * incorrectly changed after the pspoll failure active window.
1575 if (changed & IEEE80211_CONF_CHANGE_PS)
1576 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1578 if (conf->flags & IEEE80211_CONF_PS &&
1579 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1580 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1583 * We enter PSM only if we're already associated.
1584 * If we're not, we'll enter it when joining an SSID,
1585 * through the bss_info_changed() hook.
1587 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1588 wl1271_debug(DEBUG_PSM, "psm enabled");
1589 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1590 wl->basic_rate, true);
1592 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1593 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1594 wl1271_debug(DEBUG_PSM, "psm disabled");
1596 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1598 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1599 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1600 wl->basic_rate, true);
1603 if (conf->power_level != wl->power_level) {
1604 ret = wl1271_acx_tx_power(wl, conf->power_level);
1608 wl->power_level = conf->power_level;
1612 wl1271_ps_elp_sleep(wl);
1615 mutex_unlock(&wl->mutex);
1620 struct wl1271_filter_params {
1623 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1626 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1627 struct netdev_hw_addr_list *mc_list)
1629 struct wl1271_filter_params *fp;
1630 struct netdev_hw_addr *ha;
1631 struct wl1271 *wl = hw->priv;
1633 if (unlikely(wl->state == WL1271_STATE_OFF))
1636 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1638 wl1271_error("Out of memory setting filters.");
1642 /* update multicast filtering parameters */
1643 fp->mc_list_length = 0;
1644 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1645 fp->enabled = false;
1648 netdev_hw_addr_list_for_each(ha, mc_list) {
1649 memcpy(fp->mc_list[fp->mc_list_length],
1650 ha->addr, ETH_ALEN);
1651 fp->mc_list_length++;
1655 return (u64)(unsigned long)fp;
1658 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1661 FIF_BCN_PRBRESP_PROMISC | \
1665 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1666 unsigned int changed,
1667 unsigned int *total, u64 multicast)
1669 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1670 struct wl1271 *wl = hw->priv;
1673 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
1674 " total %x", changed, *total);
1676 mutex_lock(&wl->mutex);
1678 *total &= WL1271_SUPPORTED_FILTERS;
1679 changed &= WL1271_SUPPORTED_FILTERS;
1681 if (unlikely(wl->state == WL1271_STATE_OFF))
1684 ret = wl1271_ps_elp_wakeup(wl, false);
1688 if (wl->bss_type != BSS_TYPE_AP_BSS) {
1689 if (*total & FIF_ALLMULTI)
1690 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1692 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1694 fp->mc_list_length);
1699 /* determine, whether supported filter values have changed */
1703 /* configure filters */
1704 wl->filters = *total;
1705 wl1271_configure_filters(wl, 0);
1707 /* apply configured filters */
1708 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1713 wl1271_ps_elp_sleep(wl);
1716 mutex_unlock(&wl->mutex);
1720 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
1721 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1724 struct wl1271_ap_key *ap_key;
1727 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
1729 if (key_size > MAX_KEY_SIZE)
1733 * Find next free entry in ap_keys. Also check we are not replacing
1736 for (i = 0; i < MAX_NUM_KEYS; i++) {
1737 if (wl->recorded_ap_keys[i] == NULL)
1740 if (wl->recorded_ap_keys[i]->id == id) {
1741 wl1271_warning("trying to record key replacement");
1746 if (i == MAX_NUM_KEYS)
1749 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
1754 ap_key->key_type = key_type;
1755 ap_key->key_size = key_size;
1756 memcpy(ap_key->key, key, key_size);
1757 ap_key->hlid = hlid;
1758 ap_key->tx_seq_32 = tx_seq_32;
1759 ap_key->tx_seq_16 = tx_seq_16;
1761 wl->recorded_ap_keys[i] = ap_key;
1765 static void wl1271_free_ap_keys(struct wl1271 *wl)
1769 for (i = 0; i < MAX_NUM_KEYS; i++) {
1770 kfree(wl->recorded_ap_keys[i]);
1771 wl->recorded_ap_keys[i] = NULL;
1775 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
1778 struct wl1271_ap_key *key;
1779 bool wep_key_added = false;
1781 for (i = 0; i < MAX_NUM_KEYS; i++) {
1782 if (wl->recorded_ap_keys[i] == NULL)
1785 key = wl->recorded_ap_keys[i];
1786 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
1787 key->id, key->key_type,
1788 key->key_size, key->key,
1789 key->hlid, key->tx_seq_32,
1794 if (key->key_type == KEY_WEP)
1795 wep_key_added = true;
1798 if (wep_key_added) {
1799 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
1805 wl1271_free_ap_keys(wl);
1809 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
1810 u8 key_size, const u8 *key, u32 tx_seq_32,
1811 u16 tx_seq_16, struct ieee80211_sta *sta)
1814 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1817 struct wl1271_station *wl_sta;
1821 wl_sta = (struct wl1271_station *)sta->drv_priv;
1822 hlid = wl_sta->hlid;
1824 hlid = WL1271_AP_BROADCAST_HLID;
1827 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
1829 * We do not support removing keys after AP shutdown.
1830 * Pretend we do to make mac80211 happy.
1832 if (action != KEY_ADD_OR_REPLACE)
1835 ret = wl1271_record_ap_key(wl, id,
1837 key, hlid, tx_seq_32,
1840 ret = wl1271_cmd_set_ap_key(wl, action,
1841 id, key_type, key_size,
1842 key, hlid, tx_seq_32,
1850 static const u8 bcast_addr[ETH_ALEN] = {
1851 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
1854 addr = sta ? sta->addr : bcast_addr;
1856 if (is_zero_ether_addr(addr)) {
1857 /* We dont support TX only encryption */
1861 /* The wl1271 does not allow to remove unicast keys - they
1862 will be cleared automatically on next CMD_JOIN. Ignore the
1863 request silently, as we dont want the mac80211 to emit
1864 an error message. */
1865 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
1868 ret = wl1271_cmd_set_sta_key(wl, action,
1869 id, key_type, key_size,
1870 key, addr, tx_seq_32,
1875 /* the default WEP key needs to be configured at least once */
1876 if (key_type == KEY_WEP) {
1877 ret = wl1271_cmd_set_sta_default_wep_key(wl,
1887 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1888 struct ieee80211_vif *vif,
1889 struct ieee80211_sta *sta,
1890 struct ieee80211_key_conf *key_conf)
1892 struct wl1271 *wl = hw->priv;
1898 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1900 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
1901 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1902 key_conf->cipher, key_conf->keyidx,
1903 key_conf->keylen, key_conf->flags);
1904 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1906 mutex_lock(&wl->mutex);
1908 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1913 ret = wl1271_ps_elp_wakeup(wl, false);
1917 switch (key_conf->cipher) {
1918 case WLAN_CIPHER_SUITE_WEP40:
1919 case WLAN_CIPHER_SUITE_WEP104:
1922 key_conf->hw_key_idx = key_conf->keyidx;
1924 case WLAN_CIPHER_SUITE_TKIP:
1925 key_type = KEY_TKIP;
1927 key_conf->hw_key_idx = key_conf->keyidx;
1928 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1929 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1931 case WLAN_CIPHER_SUITE_CCMP:
1934 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1935 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1936 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1938 case WL1271_CIPHER_SUITE_GEM:
1940 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1941 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1944 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1952 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
1953 key_conf->keyidx, key_type,
1954 key_conf->keylen, key_conf->key,
1955 tx_seq_32, tx_seq_16, sta);
1957 wl1271_error("Could not add or replace key");
1963 ret = wl1271_set_key(wl, KEY_REMOVE,
1964 key_conf->keyidx, key_type,
1965 key_conf->keylen, key_conf->key,
1968 wl1271_error("Could not remove key");
1974 wl1271_error("Unsupported key cmd 0x%x", cmd);
1980 wl1271_ps_elp_sleep(wl);
1983 mutex_unlock(&wl->mutex);
1988 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1989 struct ieee80211_vif *vif,
1990 struct cfg80211_scan_request *req)
1992 struct wl1271 *wl = hw->priv;
1997 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2000 ssid = req->ssids[0].ssid;
2001 len = req->ssids[0].ssid_len;
2004 mutex_lock(&wl->mutex);
2006 if (wl->state == WL1271_STATE_OFF) {
2008 * We cannot return -EBUSY here because cfg80211 will expect
2009 * a call to ieee80211_scan_completed if we do - in this case
2010 * there won't be any call.
2016 ret = wl1271_ps_elp_wakeup(wl, false);
2020 ret = wl1271_scan(hw->priv, ssid, len, req);
2022 wl1271_ps_elp_sleep(wl);
2025 mutex_unlock(&wl->mutex);
2030 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2032 struct wl1271 *wl = hw->priv;
2035 mutex_lock(&wl->mutex);
2037 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2042 ret = wl1271_ps_elp_wakeup(wl, false);
2046 ret = wl1271_acx_frag_threshold(wl, (u16)value);
2048 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2050 wl1271_ps_elp_sleep(wl);
2053 mutex_unlock(&wl->mutex);
2058 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2060 struct wl1271 *wl = hw->priv;
2063 mutex_lock(&wl->mutex);
2065 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2070 ret = wl1271_ps_elp_wakeup(wl, false);
2074 ret = wl1271_acx_rts_threshold(wl, (u16) value);
2076 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2078 wl1271_ps_elp_sleep(wl);
2081 mutex_unlock(&wl->mutex);
2086 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2089 u8 *ptr = skb->data + offset;
2091 /* find the location of the ssid in the beacon */
2092 while (ptr < skb->data + skb->len) {
2093 if (ptr[0] == WLAN_EID_SSID) {
2094 wl->ssid_len = ptr[1];
2095 memcpy(wl->ssid, ptr+2, wl->ssid_len);
2098 ptr += (ptr[1] + 2);
2101 wl1271_error("No SSID in IEs!\n");
2105 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2106 struct ieee80211_bss_conf *bss_conf,
2111 if (changed & BSS_CHANGED_ERP_SLOT) {
2112 if (bss_conf->use_short_slot)
2113 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2115 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2117 wl1271_warning("Set slot time failed %d", ret);
2122 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2123 if (bss_conf->use_short_preamble)
2124 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2126 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2129 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2130 if (bss_conf->use_cts_prot)
2131 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2133 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2135 wl1271_warning("Set ctsprotect failed %d", ret);
2144 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2145 struct ieee80211_vif *vif,
2146 struct ieee80211_bss_conf *bss_conf,
2149 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2152 if ((changed & BSS_CHANGED_BEACON_INT)) {
2153 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2154 bss_conf->beacon_int);
2156 wl->beacon_int = bss_conf->beacon_int;
2159 if ((changed & BSS_CHANGED_BEACON)) {
2160 struct ieee80211_hdr *hdr;
2161 int ieoffset = offsetof(struct ieee80211_mgmt,
2163 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2169 wl1271_debug(DEBUG_MASTER, "beacon updated");
2171 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2173 dev_kfree_skb(beacon);
2176 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2178 ret = wl1271_cmd_template_set(wl, tmpl_id,
2181 wl1271_tx_min_rate_get(wl));
2183 dev_kfree_skb(beacon);
2187 hdr = (struct ieee80211_hdr *) beacon->data;
2188 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2189 IEEE80211_STYPE_PROBE_RESP);
2191 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2192 CMD_TEMPL_PROBE_RESPONSE;
2193 ret = wl1271_cmd_template_set(wl,
2197 wl1271_tx_min_rate_get(wl));
2198 dev_kfree_skb(beacon);
2207 /* AP mode changes */
2208 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2209 struct ieee80211_vif *vif,
2210 struct ieee80211_bss_conf *bss_conf,
2215 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2216 u32 rates = bss_conf->basic_rates;
2217 struct conf_tx_rate_class mgmt_rc;
2219 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2220 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2221 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
2222 wl->basic_rate_set);
2224 /* update the AP management rate policy with the new rates */
2225 mgmt_rc.enabled_rates = wl->basic_rate_set;
2226 mgmt_rc.long_retry_limit = 10;
2227 mgmt_rc.short_retry_limit = 10;
2229 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
2230 ACX_TX_AP_MODE_MGMT_RATE);
2232 wl1271_error("AP mgmt policy change failed %d", ret);
2237 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2241 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2242 if (bss_conf->enable_beacon) {
2243 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2244 ret = wl1271_cmd_start_bss(wl);
2248 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2249 wl1271_debug(DEBUG_AP, "started AP");
2251 ret = wl1271_ap_init_hwenc(wl);
2256 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2257 ret = wl1271_cmd_stop_bss(wl);
2261 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2262 wl1271_debug(DEBUG_AP, "stopped AP");
2267 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2274 /* STA/IBSS mode changes */
2275 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2276 struct ieee80211_vif *vif,
2277 struct ieee80211_bss_conf *bss_conf,
2280 bool do_join = false, set_assoc = false;
2281 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2282 u32 sta_rate_set = 0;
2284 struct ieee80211_sta *sta;
2285 bool sta_exists = false;
2286 struct ieee80211_sta_ht_cap sta_ht_cap;
2289 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2295 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2298 /* Need to update the SSID (for filtering etc) */
2299 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2302 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2303 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2304 bss_conf->enable_beacon ? "enabled" : "disabled");
2306 if (bss_conf->enable_beacon)
2307 wl->set_bss_type = BSS_TYPE_IBSS;
2309 wl->set_bss_type = BSS_TYPE_STA_BSS;
2313 if ((changed & BSS_CHANGED_CQM)) {
2314 bool enable = false;
2315 if (bss_conf->cqm_rssi_thold)
2317 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2318 bss_conf->cqm_rssi_thold,
2319 bss_conf->cqm_rssi_hyst);
2322 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2325 if ((changed & BSS_CHANGED_BSSID) &&
2327 * Now we know the correct bssid, so we send a new join command
2328 * and enable the BSSID filter
2330 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2331 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2333 if (!is_zero_ether_addr(wl->bssid)) {
2334 ret = wl1271_cmd_build_null_data(wl);
2338 ret = wl1271_build_qos_null_data(wl);
2342 /* filter out all packets not from this BSSID */
2343 wl1271_configure_filters(wl, 0);
2345 /* Need to update the BSSID (for filtering etc) */
2351 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2353 /* save the supp_rates of the ap */
2354 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2355 if (sta->ht_cap.ht_supported)
2357 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
2358 sta_ht_cap = sta->ht_cap;
2364 /* handle new association with HT and HT information change */
2365 if ((changed & BSS_CHANGED_HT) &&
2366 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2367 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2370 wl1271_warning("Set ht cap true failed %d",
2374 ret = wl1271_acx_set_ht_information(wl,
2375 bss_conf->ht_operation_mode);
2377 wl1271_warning("Set ht information failed %d",
2382 /* handle new association without HT and disassociation */
2383 else if (changed & BSS_CHANGED_ASSOC) {
2384 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2387 wl1271_warning("Set ht cap false failed %d",
2394 if ((changed & BSS_CHANGED_ASSOC)) {
2395 if (bss_conf->assoc) {
2398 wl->aid = bss_conf->aid;
2401 wl->ps_poll_failures = 0;
2404 * use basic rates from AP, and determine lowest rate
2405 * to use with control frames.
2407 rates = bss_conf->basic_rates;
2408 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2410 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2412 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2414 ret = wl1271_acx_sta_rate_policies(wl);
2419 * with wl1271, we don't need to update the
2420 * beacon_int and dtim_period, because the firmware
2421 * updates it by itself when the first beacon is
2422 * received after a join.
2424 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2429 * Get a template for hardware connection maintenance
2431 dev_kfree_skb(wl->probereq);
2432 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2433 ieoffset = offsetof(struct ieee80211_mgmt,
2434 u.probe_req.variable);
2435 wl1271_ssid_set(wl, wl->probereq, ieoffset);
2437 /* enable the connection monitoring feature */
2438 ret = wl1271_acx_conn_monit_params(wl, true);
2442 /* If we want to go in PSM but we're not there yet */
2443 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2444 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2445 enum wl1271_cmd_ps_mode mode;
2447 mode = STATION_POWER_SAVE_MODE;
2448 ret = wl1271_ps_set_mode(wl, mode,
2455 /* use defaults when not associated */
2456 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2457 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2460 /* free probe-request template */
2461 dev_kfree_skb(wl->probereq);
2462 wl->probereq = NULL;
2464 /* re-enable dynamic ps - just in case */
2465 ieee80211_enable_dyn_ps(wl->vif);
2467 /* revert back to minimum rates for the current band */
2468 wl1271_set_band_rate(wl);
2469 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2470 ret = wl1271_acx_sta_rate_policies(wl);
2474 /* disable connection monitor features */
2475 ret = wl1271_acx_conn_monit_params(wl, false);
2477 /* Disable the keep-alive feature */
2478 ret = wl1271_acx_keep_alive_mode(wl, false);
2482 /* restore the bssid filter and go to dummy bssid */
2484 wl1271_dummy_join(wl);
2488 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2492 if (changed & BSS_CHANGED_ARP_FILTER) {
2493 __be32 addr = bss_conf->arp_addr_list[0];
2494 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2496 if (bss_conf->arp_addr_cnt == 1 &&
2497 bss_conf->arp_filter_enabled) {
2499 * The template should have been configured only upon
2500 * association. however, it seems that the correct ip
2501 * isn't being set (when sending), so we have to
2502 * reconfigure the template upon every ip change.
2504 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2506 wl1271_warning("build arp rsp failed: %d", ret);
2510 ret = wl1271_acx_arp_ip_filter(wl,
2511 ACX_ARP_FILTER_ARP_FILTERING,
2514 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
2521 ret = wl1271_join(wl, set_assoc);
2523 wl1271_warning("cmd join failed %d", ret);
2532 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2533 struct ieee80211_vif *vif,
2534 struct ieee80211_bss_conf *bss_conf,
2537 struct wl1271 *wl = hw->priv;
2538 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2541 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2544 mutex_lock(&wl->mutex);
2546 if (unlikely(wl->state == WL1271_STATE_OFF))
2549 ret = wl1271_ps_elp_wakeup(wl, false);
2554 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2556 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2558 wl1271_ps_elp_sleep(wl);
2561 mutex_unlock(&wl->mutex);
2564 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2565 const struct ieee80211_tx_queue_params *params)
2567 struct wl1271 *wl = hw->priv;
2571 mutex_lock(&wl->mutex);
2573 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2576 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2578 ps_scheme = CONF_PS_SCHEME_LEGACY;
2580 if (wl->state == WL1271_STATE_OFF) {
2582 * If the state is off, the parameters will be recorded and
2583 * configured on init. This happens in AP-mode.
2585 struct conf_tx_ac_category *conf_ac =
2586 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2587 struct conf_tx_tid *conf_tid =
2588 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2590 conf_ac->ac = wl1271_tx_get_queue(queue);
2591 conf_ac->cw_min = (u8)params->cw_min;
2592 conf_ac->cw_max = params->cw_max;
2593 conf_ac->aifsn = params->aifs;
2594 conf_ac->tx_op_limit = params->txop << 5;
2596 conf_tid->queue_id = wl1271_tx_get_queue(queue);
2597 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
2598 conf_tid->tsid = wl1271_tx_get_queue(queue);
2599 conf_tid->ps_scheme = ps_scheme;
2600 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
2601 conf_tid->apsd_conf[0] = 0;
2602 conf_tid->apsd_conf[1] = 0;
2604 ret = wl1271_ps_elp_wakeup(wl, false);
2609 * the txop is confed in units of 32us by the mac80211,
2612 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2613 params->cw_min, params->cw_max,
2614 params->aifs, params->txop << 5);
2618 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2619 CONF_CHANNEL_TYPE_EDCF,
2620 wl1271_tx_get_queue(queue),
2621 ps_scheme, CONF_ACK_POLICY_LEGACY,
2627 wl1271_ps_elp_sleep(wl);
2631 mutex_unlock(&wl->mutex);
2636 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2639 struct wl1271 *wl = hw->priv;
2640 u64 mactime = ULLONG_MAX;
2643 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2645 mutex_lock(&wl->mutex);
2647 if (unlikely(wl->state == WL1271_STATE_OFF))
2650 ret = wl1271_ps_elp_wakeup(wl, false);
2654 ret = wl1271_acx_tsf_info(wl, &mactime);
2659 wl1271_ps_elp_sleep(wl);
2662 mutex_unlock(&wl->mutex);
2666 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2667 struct survey_info *survey)
2669 struct wl1271 *wl = hw->priv;
2670 struct ieee80211_conf *conf = &hw->conf;
2675 survey->channel = conf->channel;
2676 survey->filled = SURVEY_INFO_NOISE_DBM;
2677 survey->noise = wl->noise;
2682 static int wl1271_allocate_sta(struct wl1271 *wl,
2683 struct ieee80211_sta *sta,
2686 struct wl1271_station *wl_sta;
2689 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
2690 if (id >= AP_MAX_STATIONS) {
2691 wl1271_warning("could not allocate HLID - too much stations");
2695 wl_sta = (struct wl1271_station *)sta->drv_priv;
2696 __set_bit(id, wl->ap_hlid_map);
2697 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
2698 *hlid = wl_sta->hlid;
2699 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
2703 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
2705 int id = hlid - WL1271_AP_STA_HLID_START;
2707 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2710 __clear_bit(id, wl->ap_hlid_map);
2711 memset(wl->links[hlid].addr, 0, ETH_ALEN);
2712 wl1271_tx_reset_link_queues(wl, hlid);
2713 __clear_bit(hlid, &wl->ap_ps_map);
2714 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
2717 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
2718 struct ieee80211_vif *vif,
2719 struct ieee80211_sta *sta)
2721 struct wl1271 *wl = hw->priv;
2725 mutex_lock(&wl->mutex);
2727 if (unlikely(wl->state == WL1271_STATE_OFF))
2730 if (wl->bss_type != BSS_TYPE_AP_BSS)
2733 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
2735 ret = wl1271_allocate_sta(wl, sta, &hlid);
2739 ret = wl1271_ps_elp_wakeup(wl, false);
2743 ret = wl1271_cmd_add_sta(wl, sta, hlid);
2748 wl1271_ps_elp_sleep(wl);
2752 wl1271_free_sta(wl, hlid);
2755 mutex_unlock(&wl->mutex);
2759 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
2760 struct ieee80211_vif *vif,
2761 struct ieee80211_sta *sta)
2763 struct wl1271 *wl = hw->priv;
2764 struct wl1271_station *wl_sta;
2767 mutex_lock(&wl->mutex);
2769 if (unlikely(wl->state == WL1271_STATE_OFF))
2772 if (wl->bss_type != BSS_TYPE_AP_BSS)
2775 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
2777 wl_sta = (struct wl1271_station *)sta->drv_priv;
2778 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
2779 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2782 ret = wl1271_ps_elp_wakeup(wl, false);
2786 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
2790 wl1271_free_sta(wl, wl_sta->hlid);
2793 wl1271_ps_elp_sleep(wl);
2796 mutex_unlock(&wl->mutex);
2800 int wl1271_op_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2801 enum ieee80211_ampdu_mlme_action action,
2802 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
2805 struct wl1271 *wl = hw->priv;
2808 mutex_lock(&wl->mutex);
2810 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2815 ret = wl1271_ps_elp_wakeup(wl, false);
2820 case IEEE80211_AMPDU_RX_START:
2821 if (wl->ba_support) {
2822 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
2825 wl->ba_rx_bitmap |= BIT(tid);
2831 case IEEE80211_AMPDU_RX_STOP:
2832 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
2834 wl->ba_rx_bitmap &= ~BIT(tid);
2838 * The BA initiator session management in FW independently.
2839 * Falling break here on purpose for all TX APDU commands.
2841 case IEEE80211_AMPDU_TX_START:
2842 case IEEE80211_AMPDU_TX_STOP:
2843 case IEEE80211_AMPDU_TX_OPERATIONAL:
2848 wl1271_error("Incorrect ampdu action id=%x\n", action);
2852 wl1271_ps_elp_sleep(wl);
2855 mutex_unlock(&wl->mutex);
2860 /* can't be const, mac80211 writes to this */
2861 static struct ieee80211_rate wl1271_rates[] = {
2863 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2864 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2866 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2867 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2868 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2870 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2871 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2872 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2874 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2875 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2876 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2878 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2879 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2881 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2882 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2884 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2885 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2887 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2888 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2890 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2891 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2893 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2894 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2896 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2897 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2899 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2900 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2903 /* can't be const, mac80211 writes to this */
2904 static struct ieee80211_channel wl1271_channels[] = {
2905 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2906 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2907 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2908 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2909 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2910 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2911 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2912 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2913 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2914 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2915 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2916 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2917 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2918 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
2921 /* mapping to indexes for wl1271_rates */
2922 static const u8 wl1271_rate_to_idx_2ghz[] = {
2923 /* MCS rates are used only with 11n */
2924 7, /* CONF_HW_RXTX_RATE_MCS7 */
2925 6, /* CONF_HW_RXTX_RATE_MCS6 */
2926 5, /* CONF_HW_RXTX_RATE_MCS5 */
2927 4, /* CONF_HW_RXTX_RATE_MCS4 */
2928 3, /* CONF_HW_RXTX_RATE_MCS3 */
2929 2, /* CONF_HW_RXTX_RATE_MCS2 */
2930 1, /* CONF_HW_RXTX_RATE_MCS1 */
2931 0, /* CONF_HW_RXTX_RATE_MCS0 */
2933 11, /* CONF_HW_RXTX_RATE_54 */
2934 10, /* CONF_HW_RXTX_RATE_48 */
2935 9, /* CONF_HW_RXTX_RATE_36 */
2936 8, /* CONF_HW_RXTX_RATE_24 */
2938 /* TI-specific rate */
2939 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2941 7, /* CONF_HW_RXTX_RATE_18 */
2942 6, /* CONF_HW_RXTX_RATE_12 */
2943 3, /* CONF_HW_RXTX_RATE_11 */
2944 5, /* CONF_HW_RXTX_RATE_9 */
2945 4, /* CONF_HW_RXTX_RATE_6 */
2946 2, /* CONF_HW_RXTX_RATE_5_5 */
2947 1, /* CONF_HW_RXTX_RATE_2 */
2948 0 /* CONF_HW_RXTX_RATE_1 */
2951 /* 11n STA capabilities */
2952 #define HW_RX_HIGHEST_RATE 72
2954 #ifdef CONFIG_WL12XX_HT
2955 #define WL12XX_HT_CAP { \
2956 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2957 .ht_supported = true, \
2958 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2959 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2961 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2962 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2963 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2967 #define WL12XX_HT_CAP { \
2968 .ht_supported = false, \
2972 /* can't be const, mac80211 writes to this */
2973 static struct ieee80211_supported_band wl1271_band_2ghz = {
2974 .channels = wl1271_channels,
2975 .n_channels = ARRAY_SIZE(wl1271_channels),
2976 .bitrates = wl1271_rates,
2977 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2978 .ht_cap = WL12XX_HT_CAP,
2981 /* 5 GHz data rates for WL1273 */
2982 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2984 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2985 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2987 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2988 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2990 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2991 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2993 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2994 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2996 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2997 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2999 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3000 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3002 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3003 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3005 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3006 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3009 /* 5 GHz band channels for WL1273 */
3010 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3011 { .hw_value = 7, .center_freq = 5035},
3012 { .hw_value = 8, .center_freq = 5040},
3013 { .hw_value = 9, .center_freq = 5045},
3014 { .hw_value = 11, .center_freq = 5055},
3015 { .hw_value = 12, .center_freq = 5060},
3016 { .hw_value = 16, .center_freq = 5080},
3017 { .hw_value = 34, .center_freq = 5170},
3018 { .hw_value = 36, .center_freq = 5180},
3019 { .hw_value = 38, .center_freq = 5190},
3020 { .hw_value = 40, .center_freq = 5200},
3021 { .hw_value = 42, .center_freq = 5210},
3022 { .hw_value = 44, .center_freq = 5220},
3023 { .hw_value = 46, .center_freq = 5230},
3024 { .hw_value = 48, .center_freq = 5240},
3025 { .hw_value = 52, .center_freq = 5260},
3026 { .hw_value = 56, .center_freq = 5280},
3027 { .hw_value = 60, .center_freq = 5300},
3028 { .hw_value = 64, .center_freq = 5320},
3029 { .hw_value = 100, .center_freq = 5500},
3030 { .hw_value = 104, .center_freq = 5520},
3031 { .hw_value = 108, .center_freq = 5540},
3032 { .hw_value = 112, .center_freq = 5560},
3033 { .hw_value = 116, .center_freq = 5580},
3034 { .hw_value = 120, .center_freq = 5600},
3035 { .hw_value = 124, .center_freq = 5620},
3036 { .hw_value = 128, .center_freq = 5640},
3037 { .hw_value = 132, .center_freq = 5660},
3038 { .hw_value = 136, .center_freq = 5680},
3039 { .hw_value = 140, .center_freq = 5700},
3040 { .hw_value = 149, .center_freq = 5745},
3041 { .hw_value = 153, .center_freq = 5765},
3042 { .hw_value = 157, .center_freq = 5785},
3043 { .hw_value = 161, .center_freq = 5805},
3044 { .hw_value = 165, .center_freq = 5825},
3047 /* mapping to indexes for wl1271_rates_5ghz */
3048 static const u8 wl1271_rate_to_idx_5ghz[] = {
3049 /* MCS rates are used only with 11n */
3050 7, /* CONF_HW_RXTX_RATE_MCS7 */
3051 6, /* CONF_HW_RXTX_RATE_MCS6 */
3052 5, /* CONF_HW_RXTX_RATE_MCS5 */
3053 4, /* CONF_HW_RXTX_RATE_MCS4 */
3054 3, /* CONF_HW_RXTX_RATE_MCS3 */
3055 2, /* CONF_HW_RXTX_RATE_MCS2 */
3056 1, /* CONF_HW_RXTX_RATE_MCS1 */
3057 0, /* CONF_HW_RXTX_RATE_MCS0 */
3059 7, /* CONF_HW_RXTX_RATE_54 */
3060 6, /* CONF_HW_RXTX_RATE_48 */
3061 5, /* CONF_HW_RXTX_RATE_36 */
3062 4, /* CONF_HW_RXTX_RATE_24 */
3064 /* TI-specific rate */
3065 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3067 3, /* CONF_HW_RXTX_RATE_18 */
3068 2, /* CONF_HW_RXTX_RATE_12 */
3069 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3070 1, /* CONF_HW_RXTX_RATE_9 */
3071 0, /* CONF_HW_RXTX_RATE_6 */
3072 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3073 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3074 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3077 static struct ieee80211_supported_band wl1271_band_5ghz = {
3078 .channels = wl1271_channels_5ghz,
3079 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3080 .bitrates = wl1271_rates_5ghz,
3081 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3082 .ht_cap = WL12XX_HT_CAP,
3085 static const u8 *wl1271_band_rate_to_idx[] = {
3086 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3087 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3090 static const struct ieee80211_ops wl1271_ops = {
3091 .start = wl1271_op_start,
3092 .stop = wl1271_op_stop,
3093 .add_interface = wl1271_op_add_interface,
3094 .remove_interface = wl1271_op_remove_interface,
3095 .config = wl1271_op_config,
3096 .prepare_multicast = wl1271_op_prepare_multicast,
3097 .configure_filter = wl1271_op_configure_filter,
3099 .set_key = wl1271_op_set_key,
3100 .hw_scan = wl1271_op_hw_scan,
3101 .bss_info_changed = wl1271_op_bss_info_changed,
3102 .set_frag_threshold = wl1271_op_set_frag_threshold,
3103 .set_rts_threshold = wl1271_op_set_rts_threshold,
3104 .conf_tx = wl1271_op_conf_tx,
3105 .get_tsf = wl1271_op_get_tsf,
3106 .get_survey = wl1271_op_get_survey,
3107 .sta_add = wl1271_op_sta_add,
3108 .sta_remove = wl1271_op_sta_remove,
3109 .ampdu_action = wl1271_op_ampdu_action,
3110 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3114 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3118 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3120 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3121 wl1271_error("Illegal RX rate from HW: %d", rate);
3125 idx = wl1271_band_rate_to_idx[band][rate];
3126 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3127 wl1271_error("Unsupported RX rate from HW: %d", rate);
3134 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3135 struct device_attribute *attr,
3138 struct wl1271 *wl = dev_get_drvdata(dev);
3143 mutex_lock(&wl->mutex);
3144 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3146 mutex_unlock(&wl->mutex);
3152 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3153 struct device_attribute *attr,
3154 const char *buf, size_t count)
3156 struct wl1271 *wl = dev_get_drvdata(dev);
3160 ret = strict_strtoul(buf, 10, &res);
3163 wl1271_warning("incorrect value written to bt_coex_mode");
3167 mutex_lock(&wl->mutex);
3171 if (res == wl->sg_enabled)
3174 wl->sg_enabled = res;
3176 if (wl->state == WL1271_STATE_OFF)
3179 ret = wl1271_ps_elp_wakeup(wl, false);
3183 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3184 wl1271_ps_elp_sleep(wl);
3187 mutex_unlock(&wl->mutex);
3191 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3192 wl1271_sysfs_show_bt_coex_state,
3193 wl1271_sysfs_store_bt_coex_state);
3195 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3196 struct device_attribute *attr,
3199 struct wl1271 *wl = dev_get_drvdata(dev);
3204 mutex_lock(&wl->mutex);
3205 if (wl->hw_pg_ver >= 0)
3206 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3208 len = snprintf(buf, len, "n/a\n");
3209 mutex_unlock(&wl->mutex);
3214 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3215 wl1271_sysfs_show_hw_pg_ver, NULL);
3217 int wl1271_register_hw(struct wl1271 *wl)
3221 if (wl->mac80211_registered)
3224 ret = wl1271_fetch_nvs(wl);
3226 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
3228 wl->mac_addr[0] = nvs_ptr[11];
3229 wl->mac_addr[1] = nvs_ptr[10];
3230 wl->mac_addr[2] = nvs_ptr[6];
3231 wl->mac_addr[3] = nvs_ptr[5];
3232 wl->mac_addr[4] = nvs_ptr[4];
3233 wl->mac_addr[5] = nvs_ptr[3];
3236 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3238 ret = ieee80211_register_hw(wl->hw);
3240 wl1271_error("unable to register mac80211 hw: %d", ret);
3244 wl->mac80211_registered = true;
3246 wl1271_debugfs_init(wl);
3248 register_netdevice_notifier(&wl1271_dev_notifier);
3250 wl1271_notice("loaded");
3254 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3256 void wl1271_unregister_hw(struct wl1271 *wl)
3258 if (wl->state == WL1271_STATE_PLT)
3259 __wl1271_plt_stop(wl);
3261 unregister_netdevice_notifier(&wl1271_dev_notifier);
3262 ieee80211_unregister_hw(wl->hw);
3263 wl->mac80211_registered = false;
3266 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3268 int wl1271_init_ieee80211(struct wl1271 *wl)
3270 static const u32 cipher_suites[] = {
3271 WLAN_CIPHER_SUITE_WEP40,
3272 WLAN_CIPHER_SUITE_WEP104,
3273 WLAN_CIPHER_SUITE_TKIP,
3274 WLAN_CIPHER_SUITE_CCMP,
3275 WL1271_CIPHER_SUITE_GEM,
3278 /* The tx descriptor buffer and the TKIP space. */
3279 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3280 sizeof(struct wl1271_tx_hw_descr);
3283 /* FIXME: find a proper value */
3284 wl->hw->channel_change_time = 10000;
3285 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3287 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3288 IEEE80211_HW_BEACON_FILTER |
3289 IEEE80211_HW_SUPPORTS_PS |
3290 IEEE80211_HW_SUPPORTS_UAPSD |
3291 IEEE80211_HW_HAS_RATE_CONTROL |
3292 IEEE80211_HW_CONNECTION_MONITOR |
3293 IEEE80211_HW_SUPPORTS_CQM_RSSI |
3294 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3295 IEEE80211_HW_AP_LINK_PS;
3297 wl->hw->wiphy->cipher_suites = cipher_suites;
3298 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3300 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3301 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3302 wl->hw->wiphy->max_scan_ssids = 1;
3304 * Maximum length of elements in scanning probe request templates
3305 * should be the maximum length possible for a template, without
3306 * the IEEE80211 header of the template
3308 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3309 sizeof(struct ieee80211_header);
3312 * We keep local copies of the band structs because we need to
3313 * modify them on a per-device basis.
3315 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3316 sizeof(wl1271_band_2ghz));
3317 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3318 sizeof(wl1271_band_5ghz));
3320 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3321 &wl->bands[IEEE80211_BAND_2GHZ];
3322 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3323 &wl->bands[IEEE80211_BAND_5GHZ];
3326 wl->hw->max_rates = 1;
3328 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3330 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3332 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3334 wl->hw->max_rx_aggregation_subframes = 8;
3338 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3340 #define WL1271_DEFAULT_CHANNEL 0
3342 struct ieee80211_hw *wl1271_alloc_hw(void)
3344 struct ieee80211_hw *hw;
3345 struct platform_device *plat_dev = NULL;
3350 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3352 wl1271_error("could not alloc ieee80211_hw");
3357 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3359 wl1271_error("could not allocate platform_device");
3361 goto err_plat_alloc;
3365 memset(wl, 0, sizeof(*wl));
3367 INIT_LIST_HEAD(&wl->list);
3370 wl->plat_dev = plat_dev;
3372 for (i = 0; i < NUM_TX_QUEUES; i++)
3373 skb_queue_head_init(&wl->tx_queue[i]);
3375 for (i = 0; i < NUM_TX_QUEUES; i++)
3376 for (j = 0; j < AP_MAX_LINKS; j++)
3377 skb_queue_head_init(&wl->links[j].tx_queue[i]);
3379 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3380 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3381 INIT_WORK(&wl->irq_work, wl1271_irq_work);
3382 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3383 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3384 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3385 wl->channel = WL1271_DEFAULT_CHANNEL;
3386 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3387 wl->default_key = 0;
3389 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3390 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3391 wl->psm_entry_retry = 0;
3392 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3393 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3394 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3395 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3396 wl->band = IEEE80211_BAND_2GHZ;
3399 wl->sg_enabled = true;
3401 wl->bss_type = MAX_BSS_TYPE;
3402 wl->set_bss_type = MAX_BSS_TYPE;
3403 wl->fw_bss_type = MAX_BSS_TYPE;
3404 wl->last_tx_hlid = 0;
3406 wl->ap_fw_ps_map = 0;
3408 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3409 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
3410 wl->tx_frames[i] = NULL;
3412 spin_lock_init(&wl->wl_lock);
3414 wl->state = WL1271_STATE_OFF;
3415 mutex_init(&wl->mutex);
3417 /* Apply default driver configuration. */
3418 wl1271_conf_init(wl);
3420 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3421 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3422 if (!wl->aggr_buf) {
3427 /* Register platform device */
3428 ret = platform_device_register(wl->plat_dev);
3430 wl1271_error("couldn't register platform device");
3433 dev_set_drvdata(&wl->plat_dev->dev, wl);
3435 /* Create sysfs file to control bt coex state */
3436 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3438 wl1271_error("failed to create sysfs file bt_coex_state");
3442 /* Create sysfs file to get HW PG version */
3443 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3445 wl1271_error("failed to create sysfs file hw_pg_ver");
3446 goto err_bt_coex_state;
3452 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3455 platform_device_unregister(wl->plat_dev);
3458 free_pages((unsigned long)wl->aggr_buf, order);
3461 wl1271_debugfs_exit(wl);
3465 ieee80211_free_hw(hw);
3469 return ERR_PTR(ret);
3471 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
3473 int wl1271_free_hw(struct wl1271 *wl)
3475 platform_device_unregister(wl->plat_dev);
3476 free_pages((unsigned long)wl->aggr_buf,
3477 get_order(WL1271_AGGR_BUFFER_SIZE));
3478 kfree(wl->plat_dev);
3480 wl1271_debugfs_exit(wl);
3487 kfree(wl->fw_status);
3488 kfree(wl->tx_res_if);
3490 ieee80211_free_hw(wl->hw);
3494 EXPORT_SYMBOL_GPL(wl1271_free_hw);
3496 u32 wl12xx_debug_level = DEBUG_NONE;
3497 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
3498 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
3499 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3501 MODULE_LICENSE("GPL");
3502 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
3503 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");