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_entry_nullfunc_retries = 3,
260 .psm_entry_hangover_period = 1,
261 .keep_alive_interval = 55000,
262 .max_listen_interval = 20,
269 .host_clk_settling_time = 5000,
270 .host_fast_wakeup_support = false
274 .avg_weight_rssi_beacon = 20,
275 .avg_weight_rssi_data = 10,
276 .avg_weight_snr_beacon = 20,
277 .avg_weight_snr_data = 10,
280 .min_dwell_time_active = 7500,
281 .max_dwell_time_active = 30000,
282 .min_dwell_time_passive = 100000,
283 .max_dwell_time_passive = 100000,
287 .tx_per_channel_power_compensation_2 = {
288 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
290 .tx_per_channel_power_compensation_5 = {
291 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
292 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
297 .tx_ba_win_size = 64,
298 .inactivity_timeout = 10000,
302 static void __wl1271_op_remove_interface(struct wl1271 *wl);
303 static void wl1271_free_ap_keys(struct wl1271 *wl);
306 static void wl1271_device_release(struct device *dev)
311 static struct platform_device wl1271_device = {
315 /* device model insists to have a release function */
317 .release = wl1271_device_release,
321 static LIST_HEAD(wl_list);
323 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
326 struct net_device *dev = arg;
327 struct wireless_dev *wdev;
329 struct ieee80211_hw *hw;
331 struct wl1271 *wl_temp;
334 /* Check that this notification is for us. */
335 if (what != NETDEV_CHANGE)
338 wdev = dev->ieee80211_ptr;
346 hw = wiphy_priv(wiphy);
351 list_for_each_entry(wl, &wl_list, list) {
358 mutex_lock(&wl->mutex);
360 if (wl->state == WL1271_STATE_OFF)
363 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
366 ret = wl1271_ps_elp_wakeup(wl, false);
370 if ((dev->operstate == IF_OPER_UP) &&
371 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
372 wl1271_cmd_set_sta_state(wl);
373 wl1271_info("Association completed.");
376 wl1271_ps_elp_sleep(wl);
379 mutex_unlock(&wl->mutex);
384 static int wl1271_reg_notify(struct wiphy *wiphy,
385 struct regulatory_request *request)
387 struct ieee80211_supported_band *band;
388 struct ieee80211_channel *ch;
391 band = wiphy->bands[IEEE80211_BAND_5GHZ];
392 for (i = 0; i < band->n_channels; i++) {
393 ch = &band->channels[i];
394 if (ch->flags & IEEE80211_CHAN_DISABLED)
397 if (ch->flags & IEEE80211_CHAN_RADAR)
398 ch->flags |= IEEE80211_CHAN_NO_IBSS |
399 IEEE80211_CHAN_PASSIVE_SCAN;
406 static void wl1271_conf_init(struct wl1271 *wl)
410 * This function applies the default configuration to the driver. This
411 * function is invoked upon driver load (spi probe.)
413 * The configuration is stored in a run-time structure in order to
414 * facilitate for run-time adjustment of any of the parameters. Making
415 * changes to the configuration structure will apply the new values on
416 * the next interface up (wl1271_op_start.)
419 /* apply driver default configuration */
420 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
424 static int wl1271_plt_init(struct wl1271 *wl)
426 struct conf_tx_ac_category *conf_ac;
427 struct conf_tx_tid *conf_tid;
430 ret = wl1271_cmd_general_parms(wl);
434 ret = wl1271_cmd_radio_parms(wl);
438 ret = wl1271_cmd_ext_radio_parms(wl);
442 ret = wl1271_sta_init_templates_config(wl);
446 ret = wl1271_acx_init_mem_config(wl);
450 /* PHY layer config */
451 ret = wl1271_init_phy_config(wl);
453 goto out_free_memmap;
455 ret = wl1271_acx_dco_itrim_params(wl);
457 goto out_free_memmap;
459 /* Initialize connection monitoring thresholds */
460 ret = wl1271_acx_conn_monit_params(wl, false);
462 goto out_free_memmap;
464 /* Bluetooth WLAN coexistence */
465 ret = wl1271_init_pta(wl);
467 goto out_free_memmap;
469 /* Energy detection */
470 ret = wl1271_init_energy_detection(wl);
472 goto out_free_memmap;
474 /* Default fragmentation threshold */
475 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
477 goto out_free_memmap;
479 /* Default TID/AC configuration */
480 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
481 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
482 conf_ac = &wl->conf.tx.ac_conf[i];
483 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
484 conf_ac->cw_max, conf_ac->aifsn,
485 conf_ac->tx_op_limit);
487 goto out_free_memmap;
489 conf_tid = &wl->conf.tx.tid_conf[i];
490 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
491 conf_tid->channel_type,
494 conf_tid->ack_policy,
495 conf_tid->apsd_conf[0],
496 conf_tid->apsd_conf[1]);
498 goto out_free_memmap;
501 /* Enable data path */
502 ret = wl1271_cmd_data_path(wl, 1);
504 goto out_free_memmap;
506 /* Configure for CAM power saving (ie. always active) */
507 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
509 goto out_free_memmap;
512 ret = wl1271_acx_pm_config(wl);
514 goto out_free_memmap;
519 kfree(wl->target_mem_map);
520 wl->target_mem_map = NULL;
525 static void wl1271_fw_status(struct wl1271 *wl,
526 struct wl1271_fw_status *status)
532 wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
534 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
535 "drv_rx_counter = %d, tx_results_counter = %d)",
537 status->fw_rx_counter,
538 status->drv_rx_counter,
539 status->tx_results_counter);
541 /* update number of available TX blocks */
542 for (i = 0; i < NUM_TX_QUEUES; i++) {
543 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
544 wl->tx_blocks_freed[i];
546 wl->tx_blocks_freed[i] =
547 le32_to_cpu(status->tx_released_blks[i]);
548 wl->tx_blocks_available += cnt;
552 /* if more blocks are available now, tx work can be scheduled */
554 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
556 /* update the host-chipset time offset */
558 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
559 (s64)le32_to_cpu(status->fw_localtime);
562 #define WL1271_IRQ_MAX_LOOPS 10
564 static void wl1271_irq_work(struct work_struct *work)
568 int loopcount = WL1271_IRQ_MAX_LOOPS;
571 container_of(work, struct wl1271, irq_work);
573 mutex_lock(&wl->mutex);
575 wl1271_debug(DEBUG_IRQ, "IRQ work");
577 if (unlikely(wl->state == WL1271_STATE_OFF))
580 ret = wl1271_ps_elp_wakeup(wl, true);
584 spin_lock_irqsave(&wl->wl_lock, flags);
585 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
586 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
587 spin_unlock_irqrestore(&wl->wl_lock, flags);
590 wl1271_fw_status(wl, wl->fw_status);
591 intr = le32_to_cpu(wl->fw_status->intr);
593 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
594 spin_lock_irqsave(&wl->wl_lock, flags);
598 intr &= WL1271_INTR_MASK;
600 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
601 wl1271_error("watchdog interrupt received! "
602 "starting recovery.");
603 ieee80211_queue_work(wl->hw, &wl->recovery_work);
605 /* restarting the chip. ignore any other interrupt. */
609 if (intr & WL1271_ACX_INTR_DATA) {
610 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
612 /* check for tx results */
613 if (wl->fw_status->tx_results_counter !=
614 (wl->tx_results_count & 0xff))
615 wl1271_tx_complete(wl);
617 /* Check if any tx blocks were freed */
618 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
619 wl->tx_queue_count) {
621 * In order to avoid starvation of the TX path,
622 * call the work function directly.
624 wl1271_tx_work_locked(wl);
627 wl1271_rx(wl, wl->fw_status);
630 if (intr & WL1271_ACX_INTR_EVENT_A) {
631 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
632 wl1271_event_handle(wl, 0);
635 if (intr & WL1271_ACX_INTR_EVENT_B) {
636 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
637 wl1271_event_handle(wl, 1);
640 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
641 wl1271_debug(DEBUG_IRQ,
642 "WL1271_ACX_INTR_INIT_COMPLETE");
644 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
645 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
647 spin_lock_irqsave(&wl->wl_lock, flags);
650 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
651 ieee80211_queue_work(wl->hw, &wl->irq_work);
653 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
654 spin_unlock_irqrestore(&wl->wl_lock, flags);
656 wl1271_ps_elp_sleep(wl);
659 mutex_unlock(&wl->mutex);
662 static int wl1271_fetch_firmware(struct wl1271 *wl)
664 const struct firmware *fw;
668 switch (wl->bss_type) {
669 case BSS_TYPE_AP_BSS:
670 fw_name = WL1271_AP_FW_NAME;
673 case BSS_TYPE_STA_BSS:
674 fw_name = WL1271_FW_NAME;
677 wl1271_error("no compatible firmware for bss_type %d",
682 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
684 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
687 wl1271_error("could not get firmware: %d", ret);
692 wl1271_error("firmware size is not multiple of 32 bits: %zu",
699 wl->fw_len = fw->size;
700 wl->fw = vmalloc(wl->fw_len);
703 wl1271_error("could not allocate memory for the firmware");
708 memcpy(wl->fw, fw->data, wl->fw_len);
709 wl->fw_bss_type = wl->bss_type;
713 release_firmware(fw);
718 static int wl1271_fetch_nvs(struct wl1271 *wl)
720 const struct firmware *fw;
723 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
726 wl1271_error("could not get nvs file: %d", ret);
730 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
733 wl1271_error("could not allocate memory for the nvs file");
738 wl->nvs_len = fw->size;
741 release_firmware(fw);
746 static void wl1271_recovery_work(struct work_struct *work)
749 container_of(work, struct wl1271, recovery_work);
751 mutex_lock(&wl->mutex);
753 if (wl->state != WL1271_STATE_ON)
756 wl1271_info("Hardware recovery in progress.");
758 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
759 ieee80211_connection_loss(wl->vif);
761 /* reboot the chipset */
762 __wl1271_op_remove_interface(wl);
763 ieee80211_restart_hw(wl->hw);
766 mutex_unlock(&wl->mutex);
769 static void wl1271_fw_wakeup(struct wl1271 *wl)
773 elp_reg = ELPCTRL_WAKE_UP;
774 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
777 static int wl1271_setup(struct wl1271 *wl)
779 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
783 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
784 if (!wl->tx_res_if) {
785 kfree(wl->fw_status);
792 static int wl1271_chip_wakeup(struct wl1271 *wl)
794 struct wl1271_partition_set partition;
797 msleep(WL1271_PRE_POWER_ON_SLEEP);
798 ret = wl1271_power_on(wl);
801 msleep(WL1271_POWER_ON_SLEEP);
805 /* We don't need a real memory partition here, because we only want
806 * to use the registers at this point. */
807 memset(&partition, 0, sizeof(partition));
808 partition.reg.start = REGISTERS_BASE;
809 partition.reg.size = REGISTERS_DOWN_SIZE;
810 wl1271_set_partition(wl, &partition);
812 /* ELP module wake up */
813 wl1271_fw_wakeup(wl);
815 /* whal_FwCtrl_BootSm() */
817 /* 0. read chip id from CHIP_ID */
818 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
820 /* 1. check if chip id is valid */
822 switch (wl->chip.id) {
823 case CHIP_ID_1271_PG10:
824 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
827 ret = wl1271_setup(wl);
831 case CHIP_ID_1271_PG20:
832 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
835 ret = wl1271_setup(wl);
840 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
845 /* Make sure the firmware type matches the BSS type */
846 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
847 ret = wl1271_fetch_firmware(wl);
852 /* No NVS from netlink, try to get it from the filesystem */
853 if (wl->nvs == NULL) {
854 ret = wl1271_fetch_nvs(wl);
863 int wl1271_plt_start(struct wl1271 *wl)
865 int retries = WL1271_BOOT_RETRIES;
868 mutex_lock(&wl->mutex);
870 wl1271_notice("power up");
872 if (wl->state != WL1271_STATE_OFF) {
873 wl1271_error("cannot go into PLT state because not "
874 "in off state: %d", wl->state);
879 wl->bss_type = BSS_TYPE_STA_BSS;
883 ret = wl1271_chip_wakeup(wl);
887 ret = wl1271_boot(wl);
891 ret = wl1271_plt_init(wl);
895 wl->state = WL1271_STATE_PLT;
896 wl1271_notice("firmware booted in PLT mode (%s)",
897 wl->chip.fw_ver_str);
901 wl1271_disable_interrupts(wl);
902 mutex_unlock(&wl->mutex);
903 /* Unlocking the mutex in the middle of handling is
904 inherently unsafe. In this case we deem it safe to do,
905 because we need to let any possibly pending IRQ out of
906 the system (and while we are WL1271_STATE_OFF the IRQ
907 work function will not do anything.) Also, any other
908 possible concurrent operations will fail due to the
909 current state, hence the wl1271 struct should be safe. */
910 cancel_work_sync(&wl->irq_work);
911 mutex_lock(&wl->mutex);
913 wl1271_power_off(wl);
916 wl1271_error("firmware boot in PLT mode failed despite %d retries",
917 WL1271_BOOT_RETRIES);
919 mutex_unlock(&wl->mutex);
924 int __wl1271_plt_stop(struct wl1271 *wl)
928 wl1271_notice("power down");
930 if (wl->state != WL1271_STATE_PLT) {
931 wl1271_error("cannot power down because not in PLT "
932 "state: %d", wl->state);
937 wl1271_disable_interrupts(wl);
938 wl1271_power_off(wl);
940 wl->state = WL1271_STATE_OFF;
943 mutex_unlock(&wl->mutex);
944 cancel_work_sync(&wl->irq_work);
945 cancel_work_sync(&wl->recovery_work);
946 mutex_lock(&wl->mutex);
951 int wl1271_plt_stop(struct wl1271 *wl)
955 mutex_lock(&wl->mutex);
956 ret = __wl1271_plt_stop(wl);
957 mutex_unlock(&wl->mutex);
961 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
963 struct wl1271 *wl = hw->priv;
964 struct ieee80211_conf *conf = &hw->conf;
965 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
966 struct ieee80211_sta *sta = txinfo->control.sta;
971 * peek into the rates configured in the STA entry.
972 * The rates set after connection stage, The first block only BG sets:
973 * the compare is for bit 0-16 of sta_rate_set. The second block add
974 * HT rates in case of HT supported.
976 spin_lock_irqsave(&wl->wl_lock, flags);
978 (sta->supp_rates[conf->channel->band] !=
979 (wl->sta_rate_set & HW_BG_RATES_MASK)) &&
980 wl->bss_type != BSS_TYPE_AP_BSS) {
981 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
982 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
985 #ifdef CONFIG_WL12XX_HT
987 sta->ht_cap.ht_supported &&
988 ((wl->sta_rate_set >> HW_HT_RATES_OFFSET) !=
989 sta->ht_cap.mcs.rx_mask[0])) {
990 /* Clean MCS bits before setting them */
991 wl->sta_rate_set &= HW_BG_RATES_MASK;
993 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
994 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
997 wl->tx_queue_count++;
998 spin_unlock_irqrestore(&wl->wl_lock, flags);
1000 /* queue the packet */
1001 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1002 skb_queue_tail(&wl->tx_queue[q], skb);
1005 * The chip specific setup must run before the first TX packet -
1006 * before that, the tx_work will not be initialized!
1009 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1010 ieee80211_queue_work(wl->hw, &wl->tx_work);
1013 * The workqueue is slow to process the tx_queue and we need stop
1014 * the queue here, otherwise the queue will get too long.
1016 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1017 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1019 spin_lock_irqsave(&wl->wl_lock, flags);
1020 ieee80211_stop_queues(wl->hw);
1021 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1022 spin_unlock_irqrestore(&wl->wl_lock, flags);
1025 return NETDEV_TX_OK;
1028 static struct notifier_block wl1271_dev_notifier = {
1029 .notifier_call = wl1271_dev_notify,
1032 static int wl1271_op_start(struct ieee80211_hw *hw)
1034 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1037 * We have to delay the booting of the hardware because
1038 * we need to know the local MAC address before downloading and
1039 * initializing the firmware. The MAC address cannot be changed
1040 * after boot, and without the proper MAC address, the firmware
1041 * will not function properly.
1043 * The MAC address is first known when the corresponding interface
1044 * is added. That is where we will initialize the hardware.
1046 * In addition, we currently have different firmwares for AP and managed
1047 * operation. We will know which to boot according to interface type.
1053 static void wl1271_op_stop(struct ieee80211_hw *hw)
1055 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1058 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1059 struct ieee80211_vif *vif)
1061 struct wl1271 *wl = hw->priv;
1062 struct wiphy *wiphy = hw->wiphy;
1063 int retries = WL1271_BOOT_RETRIES;
1065 bool booted = false;
1067 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1068 vif->type, vif->addr);
1070 mutex_lock(&wl->mutex);
1072 wl1271_debug(DEBUG_MAC80211,
1073 "multiple vifs are not supported yet");
1078 switch (vif->type) {
1079 case NL80211_IFTYPE_STATION:
1080 wl->bss_type = BSS_TYPE_STA_BSS;
1081 wl->set_bss_type = BSS_TYPE_STA_BSS;
1083 case NL80211_IFTYPE_ADHOC:
1084 wl->bss_type = BSS_TYPE_IBSS;
1085 wl->set_bss_type = BSS_TYPE_STA_BSS;
1087 case NL80211_IFTYPE_AP:
1088 wl->bss_type = BSS_TYPE_AP_BSS;
1095 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1097 if (wl->state != WL1271_STATE_OFF) {
1098 wl1271_error("cannot start because not in off state: %d",
1106 ret = wl1271_chip_wakeup(wl);
1110 ret = wl1271_boot(wl);
1114 ret = wl1271_hw_init(wl);
1122 wl1271_disable_interrupts(wl);
1123 mutex_unlock(&wl->mutex);
1124 /* Unlocking the mutex in the middle of handling is
1125 inherently unsafe. In this case we deem it safe to do,
1126 because we need to let any possibly pending IRQ out of
1127 the system (and while we are WL1271_STATE_OFF the IRQ
1128 work function will not do anything.) Also, any other
1129 possible concurrent operations will fail due to the
1130 current state, hence the wl1271 struct should be safe. */
1131 cancel_work_sync(&wl->irq_work);
1132 mutex_lock(&wl->mutex);
1134 wl1271_power_off(wl);
1138 wl1271_error("firmware boot failed despite %d retries",
1139 WL1271_BOOT_RETRIES);
1144 wl->state = WL1271_STATE_ON;
1145 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1147 /* update hw/fw version info in wiphy struct */
1148 wiphy->hw_version = wl->chip.id;
1149 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1150 sizeof(wiphy->fw_version));
1153 * Now we know if 11a is supported (info from the NVS), so disable
1154 * 11a channels if not supported
1156 if (!wl->enable_11a)
1157 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1159 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1160 wl->enable_11a ? "" : "not ");
1163 mutex_unlock(&wl->mutex);
1166 list_add(&wl->list, &wl_list);
1171 static void __wl1271_op_remove_interface(struct wl1271 *wl)
1175 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1177 wl1271_info("down");
1179 list_del(&wl->list);
1181 WARN_ON(wl->state != WL1271_STATE_ON);
1183 /* enable dyn ps just in case (if left on due to fw crash etc) */
1184 if (wl->bss_type == BSS_TYPE_STA_BSS)
1185 ieee80211_enable_dyn_ps(wl->vif);
1187 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1188 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1189 kfree(wl->scan.scanned_ch);
1190 wl->scan.scanned_ch = NULL;
1191 wl->scan.req = NULL;
1192 ieee80211_scan_completed(wl->hw, true);
1195 wl->state = WL1271_STATE_OFF;
1197 wl1271_disable_interrupts(wl);
1199 mutex_unlock(&wl->mutex);
1201 cancel_delayed_work_sync(&wl->scan_complete_work);
1202 cancel_work_sync(&wl->irq_work);
1203 cancel_work_sync(&wl->tx_work);
1204 cancel_delayed_work_sync(&wl->pspoll_work);
1205 cancel_delayed_work_sync(&wl->elp_work);
1207 mutex_lock(&wl->mutex);
1209 /* let's notify MAC80211 about the remaining pending TX frames */
1210 wl1271_tx_reset(wl);
1211 wl1271_power_off(wl);
1213 memset(wl->bssid, 0, ETH_ALEN);
1214 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1216 wl->bss_type = MAX_BSS_TYPE;
1217 wl->set_bss_type = MAX_BSS_TYPE;
1218 wl->band = IEEE80211_BAND_2GHZ;
1221 wl->psm_entry_retry = 0;
1222 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1223 wl->tx_blocks_available = 0;
1224 wl->tx_results_count = 0;
1225 wl->tx_packets_count = 0;
1226 wl->tx_security_last_seq = 0;
1227 wl->tx_security_seq = 0;
1228 wl->time_offset = 0;
1229 wl->session_counter = 0;
1230 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1231 wl->sta_rate_set = 0;
1235 wl1271_free_ap_keys(wl);
1236 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1238 for (i = 0; i < NUM_TX_QUEUES; i++)
1239 wl->tx_blocks_freed[i] = 0;
1241 wl1271_debugfs_reset(wl);
1243 kfree(wl->fw_status);
1244 wl->fw_status = NULL;
1245 kfree(wl->tx_res_if);
1246 wl->tx_res_if = NULL;
1247 kfree(wl->target_mem_map);
1248 wl->target_mem_map = NULL;
1251 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1252 struct ieee80211_vif *vif)
1254 struct wl1271 *wl = hw->priv;
1256 mutex_lock(&wl->mutex);
1258 * wl->vif can be null here if someone shuts down the interface
1259 * just when hardware recovery has been started.
1262 WARN_ON(wl->vif != vif);
1263 __wl1271_op_remove_interface(wl);
1266 mutex_unlock(&wl->mutex);
1267 cancel_work_sync(&wl->recovery_work);
1270 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1272 wl1271_set_default_filters(wl);
1274 /* combine requested filters with current filter config */
1275 filters = wl->filters | filters;
1277 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1279 if (filters & FIF_PROMISC_IN_BSS) {
1280 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1281 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1282 wl->rx_config |= CFG_BSSID_FILTER_EN;
1284 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1285 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1286 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1287 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1289 if (filters & FIF_OTHER_BSS) {
1290 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1291 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1293 if (filters & FIF_CONTROL) {
1294 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1295 wl->rx_filter |= CFG_RX_CTL_EN;
1297 if (filters & FIF_FCSFAIL) {
1298 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1299 wl->rx_filter |= CFG_RX_FCS_ERROR;
1303 static int wl1271_dummy_join(struct wl1271 *wl)
1306 /* we need to use a dummy BSSID for now */
1307 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1310 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1312 /* pass through frames from all BSS */
1313 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1315 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1319 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1325 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1330 * One of the side effects of the JOIN command is that is clears
1331 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1332 * to a WPA/WPA2 access point will therefore kill the data-path.
1333 * Currently there is no supported scenario for JOIN during
1334 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1335 * must be handled somehow.
1338 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1339 wl1271_info("JOIN while associated.");
1342 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1344 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1348 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1350 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1354 * The join command disable the keep-alive mode, shut down its process,
1355 * and also clear the template config, so we need to reset it all after
1356 * the join. The acx_aid starts the keep-alive process, and the order
1357 * of the commands below is relevant.
1359 ret = wl1271_acx_keep_alive_mode(wl, true);
1363 ret = wl1271_acx_aid(wl, wl->aid);
1367 ret = wl1271_cmd_build_klv_null_data(wl);
1371 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1372 ACX_KEEP_ALIVE_TPL_VALID);
1380 static int wl1271_unjoin(struct wl1271 *wl)
1384 /* to stop listening to a channel, we disconnect */
1385 ret = wl1271_cmd_disconnect(wl);
1389 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1390 memset(wl->bssid, 0, ETH_ALEN);
1392 /* stop filterting packets based on bssid */
1393 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1399 static void wl1271_set_band_rate(struct wl1271 *wl)
1401 if (wl->band == IEEE80211_BAND_2GHZ)
1402 wl->basic_rate_set = wl->conf.tx.basic_rate;
1404 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1407 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1412 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1413 ret = wl1271_unjoin(wl);
1417 wl->rate_set = wl1271_tx_min_rate_get(wl);
1418 wl->sta_rate_set = 0;
1419 ret = wl1271_acx_sta_rate_policies(wl);
1422 ret = wl1271_acx_keep_alive_config(
1423 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1424 ACX_KEEP_ALIVE_TPL_INVALID);
1427 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1429 /* increment the session counter */
1430 wl->session_counter++;
1431 if (wl->session_counter >= SESSION_COUNTER_MAX)
1432 wl->session_counter = 0;
1433 ret = wl1271_dummy_join(wl);
1436 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1443 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1445 struct wl1271 *wl = hw->priv;
1446 struct ieee80211_conf *conf = &hw->conf;
1447 int channel, ret = 0;
1450 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1452 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1455 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1457 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1461 * mac80211 will go to idle nearly immediately after transmitting some
1462 * frames, such as the deauth. To make sure those frames reach the air,
1463 * wait here until the TX queue is fully flushed.
1465 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1466 (conf->flags & IEEE80211_CONF_IDLE))
1467 wl1271_tx_flush(wl);
1469 mutex_lock(&wl->mutex);
1471 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1476 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1478 ret = wl1271_ps_elp_wakeup(wl, false);
1482 /* if the channel changes while joined, join again */
1483 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1484 ((wl->band != conf->channel->band) ||
1485 (wl->channel != channel))) {
1486 wl->band = conf->channel->band;
1487 wl->channel = channel;
1491 * FIXME: the mac80211 should really provide a fixed
1492 * rate to use here. for now, just use the smallest
1493 * possible rate for the band as a fixed rate for
1494 * association frames and other control messages.
1496 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1497 wl1271_set_band_rate(wl);
1499 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1500 ret = wl1271_acx_sta_rate_policies(wl);
1502 wl1271_warning("rate policy for channel "
1505 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1506 ret = wl1271_join(wl, false);
1508 wl1271_warning("cmd join on channel "
1514 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1515 ret = wl1271_sta_handle_idle(wl,
1516 conf->flags & IEEE80211_CONF_IDLE);
1518 wl1271_warning("idle mode change failed %d", ret);
1522 * if mac80211 changes the PSM mode, make sure the mode is not
1523 * incorrectly changed after the pspoll failure active window.
1525 if (changed & IEEE80211_CONF_CHANGE_PS)
1526 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1528 if (conf->flags & IEEE80211_CONF_PS &&
1529 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1530 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1533 * We enter PSM only if we're already associated.
1534 * If we're not, we'll enter it when joining an SSID,
1535 * through the bss_info_changed() hook.
1537 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1538 wl1271_debug(DEBUG_PSM, "psm enabled");
1539 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1540 wl->basic_rate, true);
1542 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1543 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1544 wl1271_debug(DEBUG_PSM, "psm disabled");
1546 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1548 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1549 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1550 wl->basic_rate, true);
1553 if (conf->power_level != wl->power_level) {
1554 ret = wl1271_acx_tx_power(wl, conf->power_level);
1558 wl->power_level = conf->power_level;
1562 wl1271_ps_elp_sleep(wl);
1565 mutex_unlock(&wl->mutex);
1570 struct wl1271_filter_params {
1573 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1576 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1577 struct netdev_hw_addr_list *mc_list)
1579 struct wl1271_filter_params *fp;
1580 struct netdev_hw_addr *ha;
1581 struct wl1271 *wl = hw->priv;
1583 if (unlikely(wl->state == WL1271_STATE_OFF))
1586 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1588 wl1271_error("Out of memory setting filters.");
1592 /* update multicast filtering parameters */
1593 fp->mc_list_length = 0;
1594 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1595 fp->enabled = false;
1598 netdev_hw_addr_list_for_each(ha, mc_list) {
1599 memcpy(fp->mc_list[fp->mc_list_length],
1600 ha->addr, ETH_ALEN);
1601 fp->mc_list_length++;
1605 return (u64)(unsigned long)fp;
1608 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1611 FIF_BCN_PRBRESP_PROMISC | \
1615 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1616 unsigned int changed,
1617 unsigned int *total, u64 multicast)
1619 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1620 struct wl1271 *wl = hw->priv;
1623 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
1624 " total %x", changed, *total);
1626 mutex_lock(&wl->mutex);
1628 *total &= WL1271_SUPPORTED_FILTERS;
1629 changed &= WL1271_SUPPORTED_FILTERS;
1631 if (unlikely(wl->state == WL1271_STATE_OFF))
1634 ret = wl1271_ps_elp_wakeup(wl, false);
1638 if (wl->bss_type != BSS_TYPE_AP_BSS) {
1639 if (*total & FIF_ALLMULTI)
1640 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1642 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1644 fp->mc_list_length);
1649 /* determine, whether supported filter values have changed */
1653 /* configure filters */
1654 wl->filters = *total;
1655 wl1271_configure_filters(wl, 0);
1657 /* apply configured filters */
1658 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1663 wl1271_ps_elp_sleep(wl);
1666 mutex_unlock(&wl->mutex);
1670 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
1671 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1674 struct wl1271_ap_key *ap_key;
1677 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
1679 if (key_size > MAX_KEY_SIZE)
1683 * Find next free entry in ap_keys. Also check we are not replacing
1686 for (i = 0; i < MAX_NUM_KEYS; i++) {
1687 if (wl->recorded_ap_keys[i] == NULL)
1690 if (wl->recorded_ap_keys[i]->id == id) {
1691 wl1271_warning("trying to record key replacement");
1696 if (i == MAX_NUM_KEYS)
1699 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
1704 ap_key->key_type = key_type;
1705 ap_key->key_size = key_size;
1706 memcpy(ap_key->key, key, key_size);
1707 ap_key->hlid = hlid;
1708 ap_key->tx_seq_32 = tx_seq_32;
1709 ap_key->tx_seq_16 = tx_seq_16;
1711 wl->recorded_ap_keys[i] = ap_key;
1715 static void wl1271_free_ap_keys(struct wl1271 *wl)
1719 for (i = 0; i < MAX_NUM_KEYS; i++) {
1720 kfree(wl->recorded_ap_keys[i]);
1721 wl->recorded_ap_keys[i] = NULL;
1725 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
1728 struct wl1271_ap_key *key;
1729 bool wep_key_added = false;
1731 for (i = 0; i < MAX_NUM_KEYS; i++) {
1732 if (wl->recorded_ap_keys[i] == NULL)
1735 key = wl->recorded_ap_keys[i];
1736 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
1737 key->id, key->key_type,
1738 key->key_size, key->key,
1739 key->hlid, key->tx_seq_32,
1744 if (key->key_type == KEY_WEP)
1745 wep_key_added = true;
1748 if (wep_key_added) {
1749 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
1755 wl1271_free_ap_keys(wl);
1759 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
1760 u8 key_size, const u8 *key, u32 tx_seq_32,
1761 u16 tx_seq_16, struct ieee80211_sta *sta)
1764 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1767 struct wl1271_station *wl_sta;
1771 wl_sta = (struct wl1271_station *)sta->drv_priv;
1772 hlid = wl_sta->hlid;
1774 hlid = WL1271_AP_BROADCAST_HLID;
1777 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
1779 * We do not support removing keys after AP shutdown.
1780 * Pretend we do to make mac80211 happy.
1782 if (action != KEY_ADD_OR_REPLACE)
1785 ret = wl1271_record_ap_key(wl, id,
1787 key, hlid, tx_seq_32,
1790 ret = wl1271_cmd_set_ap_key(wl, action,
1791 id, key_type, key_size,
1792 key, hlid, tx_seq_32,
1800 static const u8 bcast_addr[ETH_ALEN] = {
1801 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
1804 addr = sta ? sta->addr : bcast_addr;
1806 if (is_zero_ether_addr(addr)) {
1807 /* We dont support TX only encryption */
1811 /* The wl1271 does not allow to remove unicast keys - they
1812 will be cleared automatically on next CMD_JOIN. Ignore the
1813 request silently, as we dont want the mac80211 to emit
1814 an error message. */
1815 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
1818 ret = wl1271_cmd_set_sta_key(wl, action,
1819 id, key_type, key_size,
1820 key, addr, tx_seq_32,
1825 /* the default WEP key needs to be configured at least once */
1826 if (key_type == KEY_WEP) {
1827 ret = wl1271_cmd_set_sta_default_wep_key(wl,
1837 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1838 struct ieee80211_vif *vif,
1839 struct ieee80211_sta *sta,
1840 struct ieee80211_key_conf *key_conf)
1842 struct wl1271 *wl = hw->priv;
1848 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1850 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
1851 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1852 key_conf->cipher, key_conf->keyidx,
1853 key_conf->keylen, key_conf->flags);
1854 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1856 mutex_lock(&wl->mutex);
1858 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1863 ret = wl1271_ps_elp_wakeup(wl, false);
1867 switch (key_conf->cipher) {
1868 case WLAN_CIPHER_SUITE_WEP40:
1869 case WLAN_CIPHER_SUITE_WEP104:
1872 key_conf->hw_key_idx = key_conf->keyidx;
1874 case WLAN_CIPHER_SUITE_TKIP:
1875 key_type = KEY_TKIP;
1877 key_conf->hw_key_idx = key_conf->keyidx;
1878 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1879 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1881 case WLAN_CIPHER_SUITE_CCMP:
1884 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1885 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1886 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1888 case WL1271_CIPHER_SUITE_GEM:
1890 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1891 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1894 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
1902 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
1903 key_conf->keyidx, key_type,
1904 key_conf->keylen, key_conf->key,
1905 tx_seq_32, tx_seq_16, sta);
1907 wl1271_error("Could not add or replace key");
1913 ret = wl1271_set_key(wl, KEY_REMOVE,
1914 key_conf->keyidx, key_type,
1915 key_conf->keylen, key_conf->key,
1918 wl1271_error("Could not remove key");
1924 wl1271_error("Unsupported key cmd 0x%x", cmd);
1930 wl1271_ps_elp_sleep(wl);
1933 mutex_unlock(&wl->mutex);
1938 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1939 struct ieee80211_vif *vif,
1940 struct cfg80211_scan_request *req)
1942 struct wl1271 *wl = hw->priv;
1947 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1950 ssid = req->ssids[0].ssid;
1951 len = req->ssids[0].ssid_len;
1954 mutex_lock(&wl->mutex);
1956 if (wl->state == WL1271_STATE_OFF) {
1958 * We cannot return -EBUSY here because cfg80211 will expect
1959 * a call to ieee80211_scan_completed if we do - in this case
1960 * there won't be any call.
1966 ret = wl1271_ps_elp_wakeup(wl, false);
1970 ret = wl1271_scan(hw->priv, ssid, len, req);
1972 wl1271_ps_elp_sleep(wl);
1975 mutex_unlock(&wl->mutex);
1980 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1982 struct wl1271 *wl = hw->priv;
1985 mutex_lock(&wl->mutex);
1987 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1992 ret = wl1271_ps_elp_wakeup(wl, false);
1996 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1998 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2000 wl1271_ps_elp_sleep(wl);
2003 mutex_unlock(&wl->mutex);
2008 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2010 struct wl1271 *wl = hw->priv;
2013 mutex_lock(&wl->mutex);
2015 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2020 ret = wl1271_ps_elp_wakeup(wl, false);
2024 ret = wl1271_acx_rts_threshold(wl, (u16) value);
2026 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2028 wl1271_ps_elp_sleep(wl);
2031 mutex_unlock(&wl->mutex);
2036 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2039 u8 *ptr = skb->data + offset;
2041 /* find the location of the ssid in the beacon */
2042 while (ptr < skb->data + skb->len) {
2043 if (ptr[0] == WLAN_EID_SSID) {
2044 wl->ssid_len = ptr[1];
2045 memcpy(wl->ssid, ptr+2, wl->ssid_len);
2048 ptr += (ptr[1] + 2);
2051 wl1271_error("No SSID in IEs!\n");
2055 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2056 struct ieee80211_bss_conf *bss_conf,
2061 if (changed & BSS_CHANGED_ERP_SLOT) {
2062 if (bss_conf->use_short_slot)
2063 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2065 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2067 wl1271_warning("Set slot time failed %d", ret);
2072 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2073 if (bss_conf->use_short_preamble)
2074 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2076 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2079 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2080 if (bss_conf->use_cts_prot)
2081 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2083 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2085 wl1271_warning("Set ctsprotect failed %d", ret);
2094 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2095 struct ieee80211_vif *vif,
2096 struct ieee80211_bss_conf *bss_conf,
2099 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2102 if ((changed & BSS_CHANGED_BEACON_INT)) {
2103 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2104 bss_conf->beacon_int);
2106 wl->beacon_int = bss_conf->beacon_int;
2109 if ((changed & BSS_CHANGED_BEACON)) {
2110 struct ieee80211_hdr *hdr;
2111 int ieoffset = offsetof(struct ieee80211_mgmt,
2113 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2119 wl1271_debug(DEBUG_MASTER, "beacon updated");
2121 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2123 dev_kfree_skb(beacon);
2126 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2128 ret = wl1271_cmd_template_set(wl, tmpl_id,
2131 wl1271_tx_min_rate_get(wl));
2133 dev_kfree_skb(beacon);
2137 hdr = (struct ieee80211_hdr *) beacon->data;
2138 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2139 IEEE80211_STYPE_PROBE_RESP);
2141 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2142 CMD_TEMPL_PROBE_RESPONSE;
2143 ret = wl1271_cmd_template_set(wl,
2147 wl1271_tx_min_rate_get(wl));
2148 dev_kfree_skb(beacon);
2157 /* AP mode changes */
2158 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2159 struct ieee80211_vif *vif,
2160 struct ieee80211_bss_conf *bss_conf,
2165 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2166 u32 rates = bss_conf->basic_rates;
2167 struct conf_tx_rate_class mgmt_rc;
2169 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2170 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2171 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
2172 wl->basic_rate_set);
2174 /* update the AP management rate policy with the new rates */
2175 mgmt_rc.enabled_rates = wl->basic_rate_set;
2176 mgmt_rc.long_retry_limit = 10;
2177 mgmt_rc.short_retry_limit = 10;
2179 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
2180 ACX_TX_AP_MODE_MGMT_RATE);
2182 wl1271_error("AP mgmt policy change failed %d", ret);
2187 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2191 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2192 if (bss_conf->enable_beacon) {
2193 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2194 ret = wl1271_cmd_start_bss(wl);
2198 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2199 wl1271_debug(DEBUG_AP, "started AP");
2201 ret = wl1271_ap_init_hwenc(wl);
2206 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2207 ret = wl1271_cmd_stop_bss(wl);
2211 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2212 wl1271_debug(DEBUG_AP, "stopped AP");
2217 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2224 /* STA/IBSS mode changes */
2225 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2226 struct ieee80211_vif *vif,
2227 struct ieee80211_bss_conf *bss_conf,
2230 bool do_join = false, set_assoc = false;
2231 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2233 struct ieee80211_sta *sta;
2236 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2242 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2245 /* Need to update the SSID (for filtering etc) */
2246 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2249 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2250 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2251 bss_conf->enable_beacon ? "enabled" : "disabled");
2253 if (bss_conf->enable_beacon)
2254 wl->set_bss_type = BSS_TYPE_IBSS;
2256 wl->set_bss_type = BSS_TYPE_STA_BSS;
2260 if ((changed & BSS_CHANGED_CQM)) {
2261 bool enable = false;
2262 if (bss_conf->cqm_rssi_thold)
2264 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2265 bss_conf->cqm_rssi_thold,
2266 bss_conf->cqm_rssi_hyst);
2269 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2272 if ((changed & BSS_CHANGED_BSSID) &&
2274 * Now we know the correct bssid, so we send a new join command
2275 * and enable the BSSID filter
2277 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2278 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2280 if (!is_zero_ether_addr(wl->bssid)) {
2281 ret = wl1271_cmd_build_null_data(wl);
2285 ret = wl1271_build_qos_null_data(wl);
2289 /* filter out all packets not from this BSSID */
2290 wl1271_configure_filters(wl, 0);
2292 /* Need to update the BSSID (for filtering etc) */
2297 if ((changed & BSS_CHANGED_ASSOC)) {
2298 if (bss_conf->assoc) {
2301 wl->aid = bss_conf->aid;
2304 wl->ps_poll_failures = 0;
2307 * use basic rates from AP, and determine lowest rate
2308 * to use with control frames.
2310 rates = bss_conf->basic_rates;
2311 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2313 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2314 ret = wl1271_acx_sta_rate_policies(wl);
2319 * with wl1271, we don't need to update the
2320 * beacon_int and dtim_period, because the firmware
2321 * updates it by itself when the first beacon is
2322 * received after a join.
2324 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2329 * Get a template for hardware connection maintenance
2331 dev_kfree_skb(wl->probereq);
2332 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2333 ieoffset = offsetof(struct ieee80211_mgmt,
2334 u.probe_req.variable);
2335 wl1271_ssid_set(wl, wl->probereq, ieoffset);
2337 /* enable the connection monitoring feature */
2338 ret = wl1271_acx_conn_monit_params(wl, true);
2342 /* If we want to go in PSM but we're not there yet */
2343 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2344 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2345 enum wl1271_cmd_ps_mode mode;
2347 mode = STATION_POWER_SAVE_MODE;
2348 ret = wl1271_ps_set_mode(wl, mode,
2355 /* use defaults when not associated */
2356 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2357 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2360 /* free probe-request template */
2361 dev_kfree_skb(wl->probereq);
2362 wl->probereq = NULL;
2364 /* re-enable dynamic ps - just in case */
2365 ieee80211_enable_dyn_ps(wl->vif);
2367 /* revert back to minimum rates for the current band */
2368 wl1271_set_band_rate(wl);
2369 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2370 ret = wl1271_acx_sta_rate_policies(wl);
2374 /* disable connection monitor features */
2375 ret = wl1271_acx_conn_monit_params(wl, false);
2377 /* Disable the keep-alive feature */
2378 ret = wl1271_acx_keep_alive_mode(wl, false);
2382 /* restore the bssid filter and go to dummy bssid */
2384 wl1271_dummy_join(wl);
2388 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2393 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2395 /* handle new association with HT and HT information change */
2396 if ((changed & BSS_CHANGED_HT) &&
2397 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2398 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap,
2401 wl1271_warning("Set ht cap true failed %d",
2406 ret = wl1271_acx_set_ht_information(wl,
2407 bss_conf->ht_operation_mode);
2409 wl1271_warning("Set ht information failed %d",
2415 /* handle new association without HT and disassociation */
2416 else if (changed & BSS_CHANGED_ASSOC) {
2417 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap,
2420 wl1271_warning("Set ht cap false failed %d",
2429 if (changed & BSS_CHANGED_ARP_FILTER) {
2430 __be32 addr = bss_conf->arp_addr_list[0];
2431 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2433 if (bss_conf->arp_addr_cnt == 1 &&
2434 bss_conf->arp_filter_enabled) {
2436 * The template should have been configured only upon
2437 * association. however, it seems that the correct ip
2438 * isn't being set (when sending), so we have to
2439 * reconfigure the template upon every ip change.
2441 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2443 wl1271_warning("build arp rsp failed: %d", ret);
2447 ret = wl1271_acx_arp_ip_filter(wl,
2448 ACX_ARP_FILTER_ARP_FILTERING,
2451 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
2458 ret = wl1271_join(wl, set_assoc);
2460 wl1271_warning("cmd join failed %d", ret);
2469 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2470 struct ieee80211_vif *vif,
2471 struct ieee80211_bss_conf *bss_conf,
2474 struct wl1271 *wl = hw->priv;
2475 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2478 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2481 mutex_lock(&wl->mutex);
2483 if (unlikely(wl->state == WL1271_STATE_OFF))
2486 ret = wl1271_ps_elp_wakeup(wl, false);
2491 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2493 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2495 wl1271_ps_elp_sleep(wl);
2498 mutex_unlock(&wl->mutex);
2501 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2502 const struct ieee80211_tx_queue_params *params)
2504 struct wl1271 *wl = hw->priv;
2508 mutex_lock(&wl->mutex);
2510 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2513 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2515 ps_scheme = CONF_PS_SCHEME_LEGACY;
2517 if (wl->state == WL1271_STATE_OFF) {
2519 * If the state is off, the parameters will be recorded and
2520 * configured on init. This happens in AP-mode.
2522 struct conf_tx_ac_category *conf_ac =
2523 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2524 struct conf_tx_tid *conf_tid =
2525 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2527 conf_ac->ac = wl1271_tx_get_queue(queue);
2528 conf_ac->cw_min = (u8)params->cw_min;
2529 conf_ac->cw_max = params->cw_max;
2530 conf_ac->aifsn = params->aifs;
2531 conf_ac->tx_op_limit = params->txop << 5;
2533 conf_tid->queue_id = wl1271_tx_get_queue(queue);
2534 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
2535 conf_tid->tsid = wl1271_tx_get_queue(queue);
2536 conf_tid->ps_scheme = ps_scheme;
2537 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
2538 conf_tid->apsd_conf[0] = 0;
2539 conf_tid->apsd_conf[1] = 0;
2541 ret = wl1271_ps_elp_wakeup(wl, false);
2546 * the txop is confed in units of 32us by the mac80211,
2549 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2550 params->cw_min, params->cw_max,
2551 params->aifs, params->txop << 5);
2555 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2556 CONF_CHANNEL_TYPE_EDCF,
2557 wl1271_tx_get_queue(queue),
2558 ps_scheme, CONF_ACK_POLICY_LEGACY,
2564 wl1271_ps_elp_sleep(wl);
2568 mutex_unlock(&wl->mutex);
2573 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2576 struct wl1271 *wl = hw->priv;
2577 u64 mactime = ULLONG_MAX;
2580 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2582 mutex_lock(&wl->mutex);
2584 if (unlikely(wl->state == WL1271_STATE_OFF))
2587 ret = wl1271_ps_elp_wakeup(wl, false);
2591 ret = wl1271_acx_tsf_info(wl, &mactime);
2596 wl1271_ps_elp_sleep(wl);
2599 mutex_unlock(&wl->mutex);
2603 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2604 struct survey_info *survey)
2606 struct wl1271 *wl = hw->priv;
2607 struct ieee80211_conf *conf = &hw->conf;
2612 survey->channel = conf->channel;
2613 survey->filled = SURVEY_INFO_NOISE_DBM;
2614 survey->noise = wl->noise;
2619 static int wl1271_allocate_hlid(struct wl1271 *wl,
2620 struct ieee80211_sta *sta,
2623 struct wl1271_station *wl_sta;
2626 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
2627 if (id >= AP_MAX_STATIONS) {
2628 wl1271_warning("could not allocate HLID - too much stations");
2632 wl_sta = (struct wl1271_station *)sta->drv_priv;
2634 __set_bit(id, wl->ap_hlid_map);
2635 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
2636 *hlid = wl_sta->hlid;
2640 static void wl1271_free_hlid(struct wl1271 *wl, u8 hlid)
2642 int id = hlid - WL1271_AP_STA_HLID_START;
2644 __clear_bit(id, wl->ap_hlid_map);
2647 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
2648 struct ieee80211_vif *vif,
2649 struct ieee80211_sta *sta)
2651 struct wl1271 *wl = hw->priv;
2655 mutex_lock(&wl->mutex);
2657 if (unlikely(wl->state == WL1271_STATE_OFF))
2660 if (wl->bss_type != BSS_TYPE_AP_BSS)
2663 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
2665 ret = wl1271_allocate_hlid(wl, sta, &hlid);
2669 ret = wl1271_ps_elp_wakeup(wl, false);
2673 ret = wl1271_cmd_add_sta(wl, sta, hlid);
2678 wl1271_ps_elp_sleep(wl);
2681 mutex_unlock(&wl->mutex);
2685 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
2686 struct ieee80211_vif *vif,
2687 struct ieee80211_sta *sta)
2689 struct wl1271 *wl = hw->priv;
2690 struct wl1271_station *wl_sta;
2693 mutex_lock(&wl->mutex);
2695 if (unlikely(wl->state == WL1271_STATE_OFF))
2698 if (wl->bss_type != BSS_TYPE_AP_BSS)
2701 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
2703 wl_sta = (struct wl1271_station *)sta->drv_priv;
2704 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
2705 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2708 ret = wl1271_ps_elp_wakeup(wl, false);
2712 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
2716 wl1271_free_hlid(wl, wl_sta->hlid);
2719 wl1271_ps_elp_sleep(wl);
2722 mutex_unlock(&wl->mutex);
2726 int wl1271_op_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2727 enum ieee80211_ampdu_mlme_action action,
2728 struct ieee80211_sta *sta, u16 tid, u16 *ssn)
2730 struct wl1271 *wl = hw->priv;
2733 mutex_lock(&wl->mutex);
2735 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2740 ret = wl1271_ps_elp_wakeup(wl, false);
2745 case IEEE80211_AMPDU_RX_START:
2746 if (wl->ba_support) {
2747 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
2750 wl->ba_rx_bitmap |= BIT(tid);
2756 case IEEE80211_AMPDU_RX_STOP:
2757 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
2759 wl->ba_rx_bitmap &= ~BIT(tid);
2763 * The BA initiator session management in FW independently.
2764 * Falling break here on purpose for all TX APDU commands.
2766 case IEEE80211_AMPDU_TX_START:
2767 case IEEE80211_AMPDU_TX_STOP:
2768 case IEEE80211_AMPDU_TX_OPERATIONAL:
2773 wl1271_error("Incorrect ampdu action id=%x\n", action);
2777 wl1271_ps_elp_sleep(wl);
2780 mutex_unlock(&wl->mutex);
2785 /* can't be const, mac80211 writes to this */
2786 static struct ieee80211_rate wl1271_rates[] = {
2788 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2789 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
2791 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2792 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
2793 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2795 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2796 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
2797 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2799 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2800 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
2801 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2803 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2804 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2806 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2807 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2809 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2810 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2812 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2813 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2815 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2816 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2818 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2819 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2821 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2822 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2824 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2825 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2828 /* can't be const, mac80211 writes to this */
2829 static struct ieee80211_channel wl1271_channels[] = {
2830 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
2831 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
2832 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2833 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2834 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
2835 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
2836 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2837 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2838 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
2839 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
2840 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2841 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2842 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
2843 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
2846 /* mapping to indexes for wl1271_rates */
2847 static const u8 wl1271_rate_to_idx_2ghz[] = {
2848 /* MCS rates are used only with 11n */
2849 7, /* CONF_HW_RXTX_RATE_MCS7 */
2850 6, /* CONF_HW_RXTX_RATE_MCS6 */
2851 5, /* CONF_HW_RXTX_RATE_MCS5 */
2852 4, /* CONF_HW_RXTX_RATE_MCS4 */
2853 3, /* CONF_HW_RXTX_RATE_MCS3 */
2854 2, /* CONF_HW_RXTX_RATE_MCS2 */
2855 1, /* CONF_HW_RXTX_RATE_MCS1 */
2856 0, /* CONF_HW_RXTX_RATE_MCS0 */
2858 11, /* CONF_HW_RXTX_RATE_54 */
2859 10, /* CONF_HW_RXTX_RATE_48 */
2860 9, /* CONF_HW_RXTX_RATE_36 */
2861 8, /* CONF_HW_RXTX_RATE_24 */
2863 /* TI-specific rate */
2864 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2866 7, /* CONF_HW_RXTX_RATE_18 */
2867 6, /* CONF_HW_RXTX_RATE_12 */
2868 3, /* CONF_HW_RXTX_RATE_11 */
2869 5, /* CONF_HW_RXTX_RATE_9 */
2870 4, /* CONF_HW_RXTX_RATE_6 */
2871 2, /* CONF_HW_RXTX_RATE_5_5 */
2872 1, /* CONF_HW_RXTX_RATE_2 */
2873 0 /* CONF_HW_RXTX_RATE_1 */
2876 /* 11n STA capabilities */
2877 #define HW_RX_HIGHEST_RATE 72
2879 #ifdef CONFIG_WL12XX_HT
2880 #define WL12XX_HT_CAP { \
2881 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2882 .ht_supported = true, \
2883 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2884 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2886 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2887 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2888 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2892 #define WL12XX_HT_CAP { \
2893 .ht_supported = false, \
2897 /* can't be const, mac80211 writes to this */
2898 static struct ieee80211_supported_band wl1271_band_2ghz = {
2899 .channels = wl1271_channels,
2900 .n_channels = ARRAY_SIZE(wl1271_channels),
2901 .bitrates = wl1271_rates,
2902 .n_bitrates = ARRAY_SIZE(wl1271_rates),
2903 .ht_cap = WL12XX_HT_CAP,
2906 /* 5 GHz data rates for WL1273 */
2907 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2909 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2910 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2912 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2913 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2915 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2916 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2918 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2919 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2921 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2922 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2924 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2925 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2927 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2928 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2930 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2931 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2934 /* 5 GHz band channels for WL1273 */
2935 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2936 { .hw_value = 7, .center_freq = 5035},
2937 { .hw_value = 8, .center_freq = 5040},
2938 { .hw_value = 9, .center_freq = 5045},
2939 { .hw_value = 11, .center_freq = 5055},
2940 { .hw_value = 12, .center_freq = 5060},
2941 { .hw_value = 16, .center_freq = 5080},
2942 { .hw_value = 34, .center_freq = 5170},
2943 { .hw_value = 36, .center_freq = 5180},
2944 { .hw_value = 38, .center_freq = 5190},
2945 { .hw_value = 40, .center_freq = 5200},
2946 { .hw_value = 42, .center_freq = 5210},
2947 { .hw_value = 44, .center_freq = 5220},
2948 { .hw_value = 46, .center_freq = 5230},
2949 { .hw_value = 48, .center_freq = 5240},
2950 { .hw_value = 52, .center_freq = 5260},
2951 { .hw_value = 56, .center_freq = 5280},
2952 { .hw_value = 60, .center_freq = 5300},
2953 { .hw_value = 64, .center_freq = 5320},
2954 { .hw_value = 100, .center_freq = 5500},
2955 { .hw_value = 104, .center_freq = 5520},
2956 { .hw_value = 108, .center_freq = 5540},
2957 { .hw_value = 112, .center_freq = 5560},
2958 { .hw_value = 116, .center_freq = 5580},
2959 { .hw_value = 120, .center_freq = 5600},
2960 { .hw_value = 124, .center_freq = 5620},
2961 { .hw_value = 128, .center_freq = 5640},
2962 { .hw_value = 132, .center_freq = 5660},
2963 { .hw_value = 136, .center_freq = 5680},
2964 { .hw_value = 140, .center_freq = 5700},
2965 { .hw_value = 149, .center_freq = 5745},
2966 { .hw_value = 153, .center_freq = 5765},
2967 { .hw_value = 157, .center_freq = 5785},
2968 { .hw_value = 161, .center_freq = 5805},
2969 { .hw_value = 165, .center_freq = 5825},
2972 /* mapping to indexes for wl1271_rates_5ghz */
2973 static const u8 wl1271_rate_to_idx_5ghz[] = {
2974 /* MCS rates are used only with 11n */
2975 7, /* CONF_HW_RXTX_RATE_MCS7 */
2976 6, /* CONF_HW_RXTX_RATE_MCS6 */
2977 5, /* CONF_HW_RXTX_RATE_MCS5 */
2978 4, /* CONF_HW_RXTX_RATE_MCS4 */
2979 3, /* CONF_HW_RXTX_RATE_MCS3 */
2980 2, /* CONF_HW_RXTX_RATE_MCS2 */
2981 1, /* CONF_HW_RXTX_RATE_MCS1 */
2982 0, /* CONF_HW_RXTX_RATE_MCS0 */
2984 7, /* CONF_HW_RXTX_RATE_54 */
2985 6, /* CONF_HW_RXTX_RATE_48 */
2986 5, /* CONF_HW_RXTX_RATE_36 */
2987 4, /* CONF_HW_RXTX_RATE_24 */
2989 /* TI-specific rate */
2990 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2992 3, /* CONF_HW_RXTX_RATE_18 */
2993 2, /* CONF_HW_RXTX_RATE_12 */
2994 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2995 1, /* CONF_HW_RXTX_RATE_9 */
2996 0, /* CONF_HW_RXTX_RATE_6 */
2997 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
2998 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
2999 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3002 static struct ieee80211_supported_band wl1271_band_5ghz = {
3003 .channels = wl1271_channels_5ghz,
3004 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3005 .bitrates = wl1271_rates_5ghz,
3006 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3007 .ht_cap = WL12XX_HT_CAP,
3010 static const u8 *wl1271_band_rate_to_idx[] = {
3011 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3012 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3015 static const struct ieee80211_ops wl1271_ops = {
3016 .start = wl1271_op_start,
3017 .stop = wl1271_op_stop,
3018 .add_interface = wl1271_op_add_interface,
3019 .remove_interface = wl1271_op_remove_interface,
3020 .config = wl1271_op_config,
3021 .prepare_multicast = wl1271_op_prepare_multicast,
3022 .configure_filter = wl1271_op_configure_filter,
3024 .set_key = wl1271_op_set_key,
3025 .hw_scan = wl1271_op_hw_scan,
3026 .bss_info_changed = wl1271_op_bss_info_changed,
3027 .set_frag_threshold = wl1271_op_set_frag_threshold,
3028 .set_rts_threshold = wl1271_op_set_rts_threshold,
3029 .conf_tx = wl1271_op_conf_tx,
3030 .get_tsf = wl1271_op_get_tsf,
3031 .get_survey = wl1271_op_get_survey,
3032 .sta_add = wl1271_op_sta_add,
3033 .sta_remove = wl1271_op_sta_remove,
3034 .ampdu_action = wl1271_op_ampdu_action,
3035 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3039 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3043 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3045 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3046 wl1271_error("Illegal RX rate from HW: %d", rate);
3050 idx = wl1271_band_rate_to_idx[band][rate];
3051 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3052 wl1271_error("Unsupported RX rate from HW: %d", rate);
3059 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3060 struct device_attribute *attr,
3063 struct wl1271 *wl = dev_get_drvdata(dev);
3068 mutex_lock(&wl->mutex);
3069 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3071 mutex_unlock(&wl->mutex);
3077 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3078 struct device_attribute *attr,
3079 const char *buf, size_t count)
3081 struct wl1271 *wl = dev_get_drvdata(dev);
3085 ret = strict_strtoul(buf, 10, &res);
3088 wl1271_warning("incorrect value written to bt_coex_mode");
3092 mutex_lock(&wl->mutex);
3096 if (res == wl->sg_enabled)
3099 wl->sg_enabled = res;
3101 if (wl->state == WL1271_STATE_OFF)
3104 ret = wl1271_ps_elp_wakeup(wl, false);
3108 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3109 wl1271_ps_elp_sleep(wl);
3112 mutex_unlock(&wl->mutex);
3116 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3117 wl1271_sysfs_show_bt_coex_state,
3118 wl1271_sysfs_store_bt_coex_state);
3120 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3121 struct device_attribute *attr,
3124 struct wl1271 *wl = dev_get_drvdata(dev);
3129 mutex_lock(&wl->mutex);
3130 if (wl->hw_pg_ver >= 0)
3131 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3133 len = snprintf(buf, len, "n/a\n");
3134 mutex_unlock(&wl->mutex);
3139 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3140 wl1271_sysfs_show_hw_pg_ver, NULL);
3142 int wl1271_register_hw(struct wl1271 *wl)
3146 if (wl->mac80211_registered)
3149 ret = wl1271_fetch_nvs(wl);
3151 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
3153 wl->mac_addr[0] = nvs_ptr[11];
3154 wl->mac_addr[1] = nvs_ptr[10];
3155 wl->mac_addr[2] = nvs_ptr[6];
3156 wl->mac_addr[3] = nvs_ptr[5];
3157 wl->mac_addr[4] = nvs_ptr[4];
3158 wl->mac_addr[5] = nvs_ptr[3];
3161 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3163 ret = ieee80211_register_hw(wl->hw);
3165 wl1271_error("unable to register mac80211 hw: %d", ret);
3169 wl->mac80211_registered = true;
3171 wl1271_debugfs_init(wl);
3173 register_netdevice_notifier(&wl1271_dev_notifier);
3175 wl1271_notice("loaded");
3179 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3181 void wl1271_unregister_hw(struct wl1271 *wl)
3183 if (wl->state == WL1271_STATE_PLT)
3184 __wl1271_plt_stop(wl);
3186 unregister_netdevice_notifier(&wl1271_dev_notifier);
3187 ieee80211_unregister_hw(wl->hw);
3188 wl->mac80211_registered = false;
3191 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3193 int wl1271_init_ieee80211(struct wl1271 *wl)
3195 static const u32 cipher_suites[] = {
3196 WLAN_CIPHER_SUITE_WEP40,
3197 WLAN_CIPHER_SUITE_WEP104,
3198 WLAN_CIPHER_SUITE_TKIP,
3199 WLAN_CIPHER_SUITE_CCMP,
3200 WL1271_CIPHER_SUITE_GEM,
3203 /* The tx descriptor buffer and the TKIP space. */
3204 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3205 sizeof(struct wl1271_tx_hw_descr);
3208 /* FIXME: find a proper value */
3209 wl->hw->channel_change_time = 10000;
3210 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3212 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3213 IEEE80211_HW_BEACON_FILTER |
3214 IEEE80211_HW_SUPPORTS_PS |
3215 IEEE80211_HW_SUPPORTS_UAPSD |
3216 IEEE80211_HW_HAS_RATE_CONTROL |
3217 IEEE80211_HW_CONNECTION_MONITOR |
3218 IEEE80211_HW_SUPPORTS_CQM_RSSI;
3220 wl->hw->wiphy->cipher_suites = cipher_suites;
3221 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3223 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3224 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3225 wl->hw->wiphy->max_scan_ssids = 1;
3227 * Maximum length of elements in scanning probe request templates
3228 * should be the maximum length possible for a template, without
3229 * the IEEE80211 header of the template
3231 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3232 sizeof(struct ieee80211_header);
3235 * We keep local copies of the band structs because we need to
3236 * modify them on a per-device basis.
3238 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3239 sizeof(wl1271_band_2ghz));
3240 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3241 sizeof(wl1271_band_5ghz));
3243 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3244 &wl->bands[IEEE80211_BAND_2GHZ];
3245 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3246 &wl->bands[IEEE80211_BAND_5GHZ];
3249 wl->hw->max_rates = 1;
3251 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3253 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3255 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3257 wl->hw->max_rx_aggregation_subframes = 8;
3261 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3263 #define WL1271_DEFAULT_CHANNEL 0
3265 struct ieee80211_hw *wl1271_alloc_hw(void)
3267 struct ieee80211_hw *hw;
3268 struct platform_device *plat_dev = NULL;
3273 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3275 wl1271_error("could not alloc ieee80211_hw");
3280 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3282 wl1271_error("could not allocate platform_device");
3284 goto err_plat_alloc;
3288 memset(wl, 0, sizeof(*wl));
3290 INIT_LIST_HEAD(&wl->list);
3293 wl->plat_dev = plat_dev;
3295 for (i = 0; i < NUM_TX_QUEUES; i++)
3296 skb_queue_head_init(&wl->tx_queue[i]);
3298 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3299 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3300 INIT_WORK(&wl->irq_work, wl1271_irq_work);
3301 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3302 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3303 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3304 wl->channel = WL1271_DEFAULT_CHANNEL;
3305 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3306 wl->default_key = 0;
3308 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3309 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3310 wl->psm_entry_retry = 0;
3311 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3312 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3313 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3314 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3315 wl->sta_rate_set = 0;
3316 wl->band = IEEE80211_BAND_2GHZ;
3319 wl->sg_enabled = true;
3321 wl->bss_type = MAX_BSS_TYPE;
3322 wl->set_bss_type = MAX_BSS_TYPE;
3323 wl->fw_bss_type = MAX_BSS_TYPE;
3325 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3326 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
3327 wl->tx_frames[i] = NULL;
3329 spin_lock_init(&wl->wl_lock);
3331 wl->state = WL1271_STATE_OFF;
3332 mutex_init(&wl->mutex);
3334 /* Apply default driver configuration. */
3335 wl1271_conf_init(wl);
3337 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3338 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3339 if (!wl->aggr_buf) {
3344 /* Register platform device */
3345 ret = platform_device_register(wl->plat_dev);
3347 wl1271_error("couldn't register platform device");
3350 dev_set_drvdata(&wl->plat_dev->dev, wl);
3352 /* Create sysfs file to control bt coex state */
3353 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3355 wl1271_error("failed to create sysfs file bt_coex_state");
3359 /* Create sysfs file to get HW PG version */
3360 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3362 wl1271_error("failed to create sysfs file hw_pg_ver");
3363 goto err_bt_coex_state;
3369 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3372 platform_device_unregister(wl->plat_dev);
3375 free_pages((unsigned long)wl->aggr_buf, order);
3378 wl1271_debugfs_exit(wl);
3382 ieee80211_free_hw(hw);
3386 return ERR_PTR(ret);
3388 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
3390 int wl1271_free_hw(struct wl1271 *wl)
3392 platform_device_unregister(wl->plat_dev);
3393 free_pages((unsigned long)wl->aggr_buf,
3394 get_order(WL1271_AGGR_BUFFER_SIZE));
3395 kfree(wl->plat_dev);
3397 wl1271_debugfs_exit(wl);
3404 kfree(wl->fw_status);
3405 kfree(wl->tx_res_if);
3407 ieee80211_free_hw(wl->hw);
3411 EXPORT_SYMBOL_GPL(wl1271_free_hw);
3413 u32 wl12xx_debug_level = DEBUG_NONE;
3414 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
3415 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
3416 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3418 MODULE_LICENSE("GPL");
3419 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
3420 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");