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/platform_device.h>
26 #include <linux/interrupt.h>
27 #include <linux/firmware.h>
28 #include <linux/delay.h>
29 #include <linux/irq.h>
30 #include <linux/spi/spi.h>
31 #include <linux/crc32.h>
32 #include <linux/etherdevice.h>
33 #include <linux/vmalloc.h>
34 #include <linux/spi/wl12xx.h>
35 #include <linux/inetdevice.h>
36 #include <linux/slab.h>
39 #include "wl12xx_80211.h"
40 #include "wl1271_reg.h"
41 #include "wl1271_spi.h"
42 #include "wl1271_io.h"
43 #include "wl1271_event.h"
44 #include "wl1271_tx.h"
45 #include "wl1271_rx.h"
46 #include "wl1271_ps.h"
47 #include "wl1271_init.h"
48 #include "wl1271_debugfs.h"
49 #include "wl1271_cmd.h"
50 #include "wl1271_boot.h"
51 #include "wl1271_testmode.h"
53 #define WL1271_BOOT_RETRIES 3
55 static struct conf_drv_settings default_conf = {
57 .per_threshold = 7500,
58 .max_scan_compensation_time = 120000,
59 .nfs_sample_interval = 400,
62 .probe_req_compensation = 170,
63 .scan_window_compensation = 50,
65 .beacon_miss_threshold = 60,
66 .rate_adaptation_threshold = CONF_HW_BIT_RATE_12MBPS,
67 .rate_adaptation_snr = 0
70 .rx_msdu_life_time = 512000,
71 .packet_detection_threshold = 0,
72 .ps_poll_timeout = 15,
74 .rts_threshold = 2347,
75 .rx_cca_threshold = 0,
76 .irq_blk_threshold = 0xFFFF,
77 .irq_pkt_threshold = 0,
79 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
82 .tx_energy_detection = 0,
84 .enabled_rates = CONF_HW_BIT_RATE_1MBPS |
85 CONF_HW_BIT_RATE_2MBPS,
86 .short_retry_limit = 10,
87 .long_retry_limit = 10,
110 .aifsn = CONF_TX_AIFS_PIFS,
117 .aifsn = CONF_TX_AIFS_PIFS,
125 .channel_type = CONF_CHANNEL_TYPE_DCF,
126 .tsid = CONF_TX_AC_BE,
127 .ps_scheme = CONF_PS_SCHEME_LEGACY,
128 .ack_policy = CONF_ACK_POLICY_LEGACY,
133 .channel_type = CONF_CHANNEL_TYPE_DCF,
134 .tsid = CONF_TX_AC_BE,
135 .ps_scheme = CONF_PS_SCHEME_LEGACY,
136 .ack_policy = CONF_ACK_POLICY_LEGACY,
141 .channel_type = CONF_CHANNEL_TYPE_DCF,
142 .tsid = CONF_TX_AC_BE,
143 .ps_scheme = CONF_PS_SCHEME_LEGACY,
144 .ack_policy = CONF_ACK_POLICY_LEGACY,
149 .channel_type = CONF_CHANNEL_TYPE_DCF,
150 .tsid = CONF_TX_AC_BE,
151 .ps_scheme = CONF_PS_SCHEME_LEGACY,
152 .ack_policy = CONF_ACK_POLICY_LEGACY,
157 .channel_type = CONF_CHANNEL_TYPE_DCF,
158 .tsid = CONF_TX_AC_BE,
159 .ps_scheme = CONF_PS_SCHEME_LEGACY,
160 .ack_policy = CONF_ACK_POLICY_LEGACY,
165 .channel_type = CONF_CHANNEL_TYPE_DCF,
166 .tsid = CONF_TX_AC_BE,
167 .ps_scheme = CONF_PS_SCHEME_LEGACY,
168 .ack_policy = CONF_ACK_POLICY_LEGACY,
173 .channel_type = CONF_CHANNEL_TYPE_DCF,
174 .tsid = CONF_TX_AC_BE,
175 .ps_scheme = CONF_PS_SCHEME_LEGACY,
176 .ack_policy = CONF_ACK_POLICY_LEGACY,
180 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
181 .tx_compl_timeout = 700,
182 .tx_compl_threshold = 4
185 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
186 .listen_interval = 0,
187 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
188 .bcn_filt_ie_count = 1,
191 .ie = WLAN_EID_CHANNEL_SWITCH,
192 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
195 .synch_fail_thold = 10,
196 .bss_lose_timeout = 100,
197 .beacon_rx_timeout = 10000,
198 .broadcast_timeout = 20000,
199 .rx_broadcast_in_ps = 1,
200 .ps_poll_threshold = 20,
201 .sig_trigger_count = 2,
206 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
207 .type = CONF_TRIG_EVENT_TYPE_EDGE,
208 .direction = CONF_TRIG_EVENT_DIR_LOW,
216 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
217 .type = CONF_TRIG_EVENT_TYPE_EDGE,
218 .direction = CONF_TRIG_EVENT_DIR_HIGH,
225 .rssi_bcn_avg_weight = 10,
226 .rssi_pkt_avg_weight = 10,
227 .snr_bcn_avg_weight = 10,
228 .snr_pkt_avg_weight = 10
230 .bet_enable = CONF_BET_MODE_ENABLE,
231 .bet_max_consecutive = 10,
232 .psm_entry_retries = 3
244 .host_clk_settling_time = 5000,
245 .host_fast_wakeup_support = false
249 static LIST_HEAD(wl_list);
251 static void wl1271_conf_init(struct wl1271 *wl)
255 * This function applies the default configuration to the driver. This
256 * function is invoked upon driver load (spi probe.)
258 * The configuration is stored in a run-time structure in order to
259 * facilitate for run-time adjustment of any of the parameters. Making
260 * changes to the configuration structure will apply the new values on
261 * the next interface up (wl1271_op_start.)
264 /* apply driver default configuration */
265 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
269 static int wl1271_plt_init(struct wl1271 *wl)
271 struct conf_tx_ac_category *conf_ac;
272 struct conf_tx_tid *conf_tid;
275 ret = wl1271_cmd_general_parms(wl);
279 ret = wl1271_cmd_radio_parms(wl);
283 ret = wl1271_init_templates_config(wl);
287 ret = wl1271_acx_init_mem_config(wl);
291 /* PHY layer config */
292 ret = wl1271_init_phy_config(wl);
294 goto out_free_memmap;
296 ret = wl1271_acx_dco_itrim_params(wl);
298 goto out_free_memmap;
300 /* Initialize connection monitoring thresholds */
301 ret = wl1271_acx_conn_monit_params(wl);
303 goto out_free_memmap;
305 /* Bluetooth WLAN coexistence */
306 ret = wl1271_init_pta(wl);
308 goto out_free_memmap;
310 /* Energy detection */
311 ret = wl1271_init_energy_detection(wl);
313 goto out_free_memmap;
315 /* Default fragmentation threshold */
316 ret = wl1271_acx_frag_threshold(wl);
318 goto out_free_memmap;
320 /* Default TID configuration */
321 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
322 conf_tid = &wl->conf.tx.tid_conf[i];
323 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
324 conf_tid->channel_type,
327 conf_tid->ack_policy,
328 conf_tid->apsd_conf[0],
329 conf_tid->apsd_conf[1]);
331 goto out_free_memmap;
334 /* Default AC configuration */
335 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
336 conf_ac = &wl->conf.tx.ac_conf[i];
337 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
338 conf_ac->cw_max, conf_ac->aifsn,
339 conf_ac->tx_op_limit);
341 goto out_free_memmap;
344 /* Enable data path */
345 ret = wl1271_cmd_data_path(wl, 1);
347 goto out_free_memmap;
349 /* Configure for CAM power saving (ie. always active) */
350 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
352 goto out_free_memmap;
355 ret = wl1271_acx_pm_config(wl);
357 goto out_free_memmap;
362 kfree(wl->target_mem_map);
363 wl->target_mem_map = NULL;
368 static void wl1271_disable_interrupts(struct wl1271 *wl)
370 disable_irq(wl->irq);
373 static void wl1271_power_off(struct wl1271 *wl)
375 wl->set_power(false);
376 clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
379 static void wl1271_power_on(struct wl1271 *wl)
382 set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
385 static void wl1271_fw_status(struct wl1271 *wl,
386 struct wl1271_fw_status *status)
391 wl1271_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
393 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
394 "drv_rx_counter = %d, tx_results_counter = %d)",
396 status->fw_rx_counter,
397 status->drv_rx_counter,
398 status->tx_results_counter);
400 /* update number of available TX blocks */
401 for (i = 0; i < NUM_TX_QUEUES; i++) {
402 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
403 wl->tx_blocks_freed[i];
405 wl->tx_blocks_freed[i] =
406 le32_to_cpu(status->tx_released_blks[i]);
407 wl->tx_blocks_available += cnt;
411 /* if more blocks are available now, schedule some tx work */
412 if (total && !skb_queue_empty(&wl->tx_queue))
413 ieee80211_queue_work(wl->hw, &wl->tx_work);
415 /* update the host-chipset time offset */
416 wl->time_offset = jiffies_to_usecs(jiffies) -
417 le32_to_cpu(status->fw_localtime);
420 static void wl1271_irq_work(struct work_struct *work)
425 container_of(work, struct wl1271, irq_work);
427 mutex_lock(&wl->mutex);
429 wl1271_debug(DEBUG_IRQ, "IRQ work");
431 if (wl->state == WL1271_STATE_OFF)
434 ret = wl1271_ps_elp_wakeup(wl, true);
438 wl1271_write32(wl, ACX_REG_INTERRUPT_MASK, WL1271_ACX_INTR_ALL);
440 wl1271_fw_status(wl, wl->fw_status);
441 intr = le32_to_cpu(wl->fw_status->intr);
443 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
447 intr &= WL1271_INTR_MASK;
449 if (intr & WL1271_ACX_INTR_EVENT_A) {
450 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
451 wl1271_event_handle(wl, 0);
454 if (intr & WL1271_ACX_INTR_EVENT_B) {
455 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
456 wl1271_event_handle(wl, 1);
459 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
460 wl1271_debug(DEBUG_IRQ,
461 "WL1271_ACX_INTR_INIT_COMPLETE");
463 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
464 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
466 if (intr & WL1271_ACX_INTR_DATA) {
467 u8 tx_res_cnt = wl->fw_status->tx_results_counter -
468 wl->tx_results_count;
470 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
472 /* check for tx results */
474 wl1271_tx_complete(wl, tx_res_cnt);
476 wl1271_rx(wl, wl->fw_status);
480 wl1271_write32(wl, ACX_REG_INTERRUPT_MASK,
481 WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK));
482 wl1271_ps_elp_sleep(wl);
485 mutex_unlock(&wl->mutex);
488 static irqreturn_t wl1271_irq(int irq, void *cookie)
493 wl1271_debug(DEBUG_IRQ, "IRQ");
497 /* complete the ELP completion */
498 spin_lock_irqsave(&wl->wl_lock, flags);
500 complete(wl->elp_compl);
501 wl->elp_compl = NULL;
504 ieee80211_queue_work(wl->hw, &wl->irq_work);
505 spin_unlock_irqrestore(&wl->wl_lock, flags);
510 static int wl1271_fetch_firmware(struct wl1271 *wl)
512 const struct firmware *fw;
515 ret = request_firmware(&fw, WL1271_FW_NAME, &wl->spi->dev);
518 wl1271_error("could not get firmware: %d", ret);
523 wl1271_error("firmware size is not multiple of 32 bits: %zu",
529 wl->fw_len = fw->size;
530 wl->fw = vmalloc(wl->fw_len);
533 wl1271_error("could not allocate memory for the firmware");
538 memcpy(wl->fw, fw->data, wl->fw_len);
543 release_firmware(fw);
548 static int wl1271_update_mac_addr(struct wl1271 *wl)
551 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
553 /* get mac address from the NVS */
554 wl->mac_addr[0] = nvs_ptr[11];
555 wl->mac_addr[1] = nvs_ptr[10];
556 wl->mac_addr[2] = nvs_ptr[6];
557 wl->mac_addr[3] = nvs_ptr[5];
558 wl->mac_addr[4] = nvs_ptr[4];
559 wl->mac_addr[5] = nvs_ptr[3];
561 /* FIXME: if it is a zero-address, we should bail out. Now, instead,
562 we randomize an address */
563 if (is_zero_ether_addr(wl->mac_addr)) {
564 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
565 memcpy(wl->mac_addr, nokia_oui, 3);
566 get_random_bytes(wl->mac_addr + 3, 3);
568 /* update this address to the NVS */
569 nvs_ptr[11] = wl->mac_addr[0];
570 nvs_ptr[10] = wl->mac_addr[1];
571 nvs_ptr[6] = wl->mac_addr[2];
572 nvs_ptr[5] = wl->mac_addr[3];
573 nvs_ptr[4] = wl->mac_addr[4];
574 nvs_ptr[3] = wl->mac_addr[5];
577 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
582 static int wl1271_fetch_nvs(struct wl1271 *wl)
584 const struct firmware *fw;
587 ret = request_firmware(&fw, WL1271_NVS_NAME, &wl->spi->dev);
590 wl1271_error("could not get nvs file: %d", ret);
594 if (fw->size != sizeof(struct wl1271_nvs_file)) {
595 wl1271_error("nvs size is not as expected: %zu != %zu",
596 fw->size, sizeof(struct wl1271_nvs_file));
601 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
604 wl1271_error("could not allocate memory for the nvs file");
609 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
611 ret = wl1271_update_mac_addr(wl);
614 release_firmware(fw);
619 static void wl1271_fw_wakeup(struct wl1271 *wl)
623 elp_reg = ELPCTRL_WAKE_UP;
624 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
627 static int wl1271_setup(struct wl1271 *wl)
629 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
633 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
634 if (!wl->tx_res_if) {
635 kfree(wl->fw_status);
639 INIT_WORK(&wl->irq_work, wl1271_irq_work);
640 INIT_WORK(&wl->tx_work, wl1271_tx_work);
644 static int wl1271_chip_wakeup(struct wl1271 *wl)
646 struct wl1271_partition_set partition;
649 msleep(WL1271_PRE_POWER_ON_SLEEP);
651 msleep(WL1271_POWER_ON_SLEEP);
655 /* We don't need a real memory partition here, because we only want
656 * to use the registers at this point. */
657 memset(&partition, 0, sizeof(partition));
658 partition.reg.start = REGISTERS_BASE;
659 partition.reg.size = REGISTERS_DOWN_SIZE;
660 wl1271_set_partition(wl, &partition);
662 /* ELP module wake up */
663 wl1271_fw_wakeup(wl);
665 /* whal_FwCtrl_BootSm() */
667 /* 0. read chip id from CHIP_ID */
668 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
670 /* 1. check if chip id is valid */
672 switch (wl->chip.id) {
673 case CHIP_ID_1271_PG10:
674 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
677 ret = wl1271_setup(wl);
681 case CHIP_ID_1271_PG20:
682 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
685 ret = wl1271_setup(wl);
690 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
695 if (wl->fw == NULL) {
696 ret = wl1271_fetch_firmware(wl);
701 /* No NVS from netlink, try to get it from the filesystem */
702 if (wl->nvs == NULL) {
703 ret = wl1271_fetch_nvs(wl);
712 int wl1271_plt_start(struct wl1271 *wl)
714 int retries = WL1271_BOOT_RETRIES;
717 mutex_lock(&wl->mutex);
719 wl1271_notice("power up");
721 if (wl->state != WL1271_STATE_OFF) {
722 wl1271_error("cannot go into PLT state because not "
723 "in off state: %d", wl->state);
730 ret = wl1271_chip_wakeup(wl);
734 ret = wl1271_boot(wl);
738 ret = wl1271_plt_init(wl);
742 wl->state = WL1271_STATE_PLT;
743 wl1271_notice("firmware booted in PLT mode (%s)",
748 wl1271_disable_interrupts(wl);
749 mutex_unlock(&wl->mutex);
750 /* Unlocking the mutex in the middle of handling is
751 inherently unsafe. In this case we deem it safe to do,
752 because we need to let any possibly pending IRQ out of
753 the system (and while we are WL1271_STATE_OFF the IRQ
754 work function will not do anything.) Also, any other
755 possible concurrent operations will fail due to the
756 current state, hence the wl1271 struct should be safe. */
757 cancel_work_sync(&wl->irq_work);
758 mutex_lock(&wl->mutex);
760 wl1271_power_off(wl);
763 wl1271_error("firmware boot in PLT mode failed despite %d retries",
764 WL1271_BOOT_RETRIES);
766 mutex_unlock(&wl->mutex);
771 int wl1271_plt_stop(struct wl1271 *wl)
775 mutex_lock(&wl->mutex);
777 wl1271_notice("power down");
779 if (wl->state != WL1271_STATE_PLT) {
780 wl1271_error("cannot power down because not in PLT "
781 "state: %d", wl->state);
786 wl1271_disable_interrupts(wl);
787 wl1271_power_off(wl);
789 wl->state = WL1271_STATE_OFF;
793 mutex_unlock(&wl->mutex);
799 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
801 struct wl1271 *wl = hw->priv;
802 struct ieee80211_conf *conf = &hw->conf;
803 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
804 struct ieee80211_sta *sta = txinfo->control.sta;
807 /* peek into the rates configured in the STA entry */
808 spin_lock_irqsave(&wl->wl_lock, flags);
809 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
810 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
811 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
813 spin_unlock_irqrestore(&wl->wl_lock, flags);
815 /* queue the packet */
816 skb_queue_tail(&wl->tx_queue, skb);
819 * The chip specific setup must run before the first TX packet -
820 * before that, the tx_work will not be initialized!
823 ieee80211_queue_work(wl->hw, &wl->tx_work);
826 * The workqueue is slow to process the tx_queue and we need stop
827 * the queue here, otherwise the queue will get too long.
829 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_MAX_LENGTH) {
830 ieee80211_stop_queues(wl->hw);
833 * FIXME: this is racy, the variable is not properly
834 * protected. Maybe fix this by removing the stupid
835 * variable altogether and checking the real queue state?
837 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
843 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
846 struct net_device *dev;
847 struct wireless_dev *wdev;
849 struct ieee80211_hw *hw;
851 struct wl1271 *wl_temp;
852 struct in_device *idev;
853 struct in_ifaddr *ifa = arg;
856 /* FIXME: this ugly function should probably be implemented in the
857 * mac80211, and here should only be a simple callback handling actual
858 * setting of the filters. Now we need to dig up references to
859 * various structures to gain access to what we need.
860 * Also, because of this, there is no "initial" setting of the filter
861 * in "op_start", because we don't want to dig up struct net_device
862 * there - the filter will be set upon first change of the interface
865 dev = ifa->ifa_dev->dev;
867 wdev = dev->ieee80211_ptr;
875 hw = wiphy_priv(wiphy);
879 /* Check that the interface is one supported by this driver. */
881 list_for_each_entry(wl, &wl_list, list) {
888 /* Get the interface IP address for the device. "ifa" will become
890 - there is no IPV4 protocol address configured
891 - there are multiple (virtual) IPV4 addresses configured
892 When "ifa" is NULL, filtering will be disabled.
897 ifa = idev->ifa_list;
899 if (ifa && ifa->ifa_next)
902 mutex_lock(&wl->mutex);
904 if (wl->state == WL1271_STATE_OFF)
907 ret = wl1271_ps_elp_wakeup(wl, false);
911 ret = wl1271_acx_arp_ip_filter(wl, true,
912 (u8 *)&ifa->ifa_address,
915 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
917 wl1271_ps_elp_sleep(wl);
920 mutex_unlock(&wl->mutex);
925 static struct notifier_block wl1271_dev_notifier = {
926 .notifier_call = wl1271_dev_notify,
930 static int wl1271_op_start(struct ieee80211_hw *hw)
932 struct wl1271 *wl = hw->priv;
933 int retries = WL1271_BOOT_RETRIES;
936 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
938 mutex_lock(&wl->mutex);
940 if (wl->state != WL1271_STATE_OFF) {
941 wl1271_error("cannot start because not in off state: %d",
949 ret = wl1271_chip_wakeup(wl);
953 ret = wl1271_boot(wl);
957 ret = wl1271_hw_init(wl);
961 wl->state = WL1271_STATE_ON;
962 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
966 wl1271_disable_interrupts(wl);
967 mutex_unlock(&wl->mutex);
968 /* Unlocking the mutex in the middle of handling is
969 inherently unsafe. In this case we deem it safe to do,
970 because we need to let any possibly pending IRQ out of
971 the system (and while we are WL1271_STATE_OFF the IRQ
972 work function will not do anything.) Also, any other
973 possible concurrent operations will fail due to the
974 current state, hence the wl1271 struct should be safe. */
975 cancel_work_sync(&wl->irq_work);
976 mutex_lock(&wl->mutex);
978 wl1271_power_off(wl);
981 wl1271_error("firmware boot failed despite %d retries",
982 WL1271_BOOT_RETRIES);
984 mutex_unlock(&wl->mutex);
987 list_add(&wl->list, &wl_list);
988 register_inetaddr_notifier(&wl1271_dev_notifier);
994 static void wl1271_op_stop(struct ieee80211_hw *hw)
996 struct wl1271 *wl = hw->priv;
1001 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1003 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1004 list_del(&wl->list);
1006 mutex_lock(&wl->mutex);
1008 WARN_ON(wl->state != WL1271_STATE_ON);
1010 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1011 mutex_unlock(&wl->mutex);
1012 ieee80211_scan_completed(wl->hw, true);
1013 mutex_lock(&wl->mutex);
1016 wl->state = WL1271_STATE_OFF;
1018 wl1271_disable_interrupts(wl);
1020 mutex_unlock(&wl->mutex);
1022 cancel_work_sync(&wl->irq_work);
1023 cancel_work_sync(&wl->tx_work);
1025 mutex_lock(&wl->mutex);
1027 /* let's notify MAC80211 about the remaining pending TX frames */
1028 wl1271_tx_flush(wl);
1029 wl1271_power_off(wl);
1031 memset(wl->bssid, 0, ETH_ALEN);
1032 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1034 wl->bss_type = MAX_BSS_TYPE;
1035 wl->band = IEEE80211_BAND_2GHZ;
1038 wl->psm_entry_retry = 0;
1039 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1040 wl->tx_blocks_available = 0;
1041 wl->tx_results_count = 0;
1042 wl->tx_packets_count = 0;
1043 wl->tx_security_last_seq = 0;
1044 wl->tx_security_seq_16 = 0;
1045 wl->tx_security_seq_32 = 0;
1046 wl->time_offset = 0;
1047 wl->session_counter = 0;
1048 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1049 wl->sta_rate_set = 0;
1052 for (i = 0; i < NUM_TX_QUEUES; i++)
1053 wl->tx_blocks_freed[i] = 0;
1055 wl1271_debugfs_reset(wl);
1056 mutex_unlock(&wl->mutex);
1059 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1060 struct ieee80211_vif *vif)
1062 struct wl1271 *wl = hw->priv;
1065 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1066 vif->type, vif->addr);
1068 mutex_lock(&wl->mutex);
1076 switch (vif->type) {
1077 case NL80211_IFTYPE_STATION:
1078 wl->bss_type = BSS_TYPE_STA_BSS;
1080 case NL80211_IFTYPE_ADHOC:
1081 wl->bss_type = BSS_TYPE_IBSS;
1088 /* FIXME: what if conf->mac_addr changes? */
1091 mutex_unlock(&wl->mutex);
1095 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1096 struct ieee80211_vif *vif)
1098 struct wl1271 *wl = hw->priv;
1100 mutex_lock(&wl->mutex);
1101 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1103 mutex_unlock(&wl->mutex);
1107 static int wl1271_op_config_interface(struct ieee80211_hw *hw,
1108 struct ieee80211_vif *vif,
1109 struct ieee80211_if_conf *conf)
1111 struct wl1271 *wl = hw->priv;
1112 struct sk_buff *beacon;
1115 wl1271_debug(DEBUG_MAC80211, "mac80211 config_interface bssid %pM",
1117 wl1271_dump_ascii(DEBUG_MAC80211, "ssid: ", conf->ssid,
1120 mutex_lock(&wl->mutex);
1122 ret = wl1271_ps_elp_wakeup(wl, false);
1126 if (memcmp(wl->bssid, conf->bssid, ETH_ALEN)) {
1127 wl1271_debug(DEBUG_MAC80211, "bssid changed");
1129 memcpy(wl->bssid, conf->bssid, ETH_ALEN);
1131 ret = wl1271_cmd_join(wl);
1135 ret = wl1271_cmd_build_null_data(wl);
1140 wl->ssid_len = conf->ssid_len;
1142 memcpy(wl->ssid, conf->ssid, wl->ssid_len);
1144 if (conf->changed & IEEE80211_IFCC_BEACON) {
1145 beacon = ieee80211_beacon_get(hw, vif);
1146 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1147 beacon->data, beacon->len);
1150 dev_kfree_skb(beacon);
1154 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE,
1155 beacon->data, beacon->len);
1157 dev_kfree_skb(beacon);
1164 wl1271_ps_elp_sleep(wl);
1167 mutex_unlock(&wl->mutex);
1173 static int wl1271_join_channel(struct wl1271 *wl, int channel)
1176 /* we need to use a dummy BSSID for now */
1177 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1180 /* the dummy join is not required for ad-hoc */
1181 if (wl->bss_type == BSS_TYPE_IBSS)
1184 /* disable mac filter, so we hear everything */
1185 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1187 wl->channel = channel;
1188 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1190 ret = wl1271_cmd_join(wl);
1194 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1200 static int wl1271_unjoin_channel(struct wl1271 *wl)
1204 /* to stop listening to a channel, we disconnect */
1205 ret = wl1271_cmd_disconnect(wl);
1209 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1211 memset(wl->bssid, 0, ETH_ALEN);
1212 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1218 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1220 struct wl1271 *wl = hw->priv;
1221 struct ieee80211_conf *conf = &hw->conf;
1222 int channel, ret = 0;
1224 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1226 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1228 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1230 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1232 mutex_lock(&wl->mutex);
1234 wl->band = conf->channel->band;
1236 ret = wl1271_ps_elp_wakeup(wl, false);
1240 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1241 if (conf->flags & IEEE80211_CONF_IDLE &&
1242 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1243 wl1271_unjoin_channel(wl);
1244 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1245 wl1271_join_channel(wl, channel);
1247 if (conf->flags & IEEE80211_CONF_IDLE) {
1248 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1249 wl->sta_rate_set = 0;
1250 wl1271_acx_rate_policies(wl);
1254 /* if the channel changes while joined, join again */
1255 if (channel != wl->channel &&
1256 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1257 wl->channel = channel;
1258 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
1259 ret = wl1271_cmd_join(wl);
1261 wl1271_warning("cmd join to update channel failed %d",
1264 wl->channel = channel;
1266 if (conf->flags & IEEE80211_CONF_PS &&
1267 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1268 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1271 * We enter PSM only if we're already associated.
1272 * If we're not, we'll enter it when joining an SSID,
1273 * through the bss_info_changed() hook.
1275 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1276 wl1271_info("psm enabled");
1277 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1280 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1281 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1282 wl1271_info("psm disabled");
1284 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1286 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1287 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1291 if (conf->power_level != wl->power_level) {
1292 ret = wl1271_acx_tx_power(wl, conf->power_level);
1296 wl->power_level = conf->power_level;
1300 wl1271_ps_elp_sleep(wl);
1303 mutex_unlock(&wl->mutex);
1308 struct wl1271_filter_params {
1311 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1314 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1315 struct dev_addr_list *mc_list)
1317 struct wl1271_filter_params *fp;
1320 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1322 wl1271_error("Out of memory setting filters.");
1326 /* update multicast filtering parameters */
1328 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1330 fp->enabled = false;
1333 fp->mc_list_length = 0;
1334 for (i = 0; i < mc_count; i++) {
1335 if (mc_list->da_addrlen == ETH_ALEN) {
1336 memcpy(fp->mc_list[fp->mc_list_length],
1337 mc_list->da_addr, ETH_ALEN);
1338 fp->mc_list_length++;
1340 wl1271_warning("Unknown mc address length.");
1341 mc_list = mc_list->next;
1344 return (u64)(unsigned long)fp;
1347 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1350 FIF_BCN_PRBRESP_PROMISC | \
1354 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1355 unsigned int changed,
1356 unsigned int *total, u64 multicast)
1358 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1359 struct wl1271 *wl = hw->priv;
1362 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1364 mutex_lock(&wl->mutex);
1366 if (wl->state == WL1271_STATE_OFF)
1369 ret = wl1271_ps_elp_wakeup(wl, false);
1373 *total &= WL1271_SUPPORTED_FILTERS;
1374 changed &= WL1271_SUPPORTED_FILTERS;
1376 if (*total & FIF_ALLMULTI)
1377 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1379 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1381 fp->mc_list_length);
1387 /* FIXME: We still need to set our filters properly */
1389 /* determine, whether supported filter values have changed */
1393 /* apply configured filters */
1394 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1399 wl1271_ps_elp_sleep(wl);
1402 mutex_unlock(&wl->mutex);
1405 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1406 struct ieee80211_vif *vif,
1407 struct ieee80211_sta *sta,
1408 struct ieee80211_key_conf *key_conf)
1410 struct wl1271 *wl = hw->priv;
1417 static const u8 bcast_addr[ETH_ALEN] =
1418 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1420 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1422 addr = sta ? sta->addr : bcast_addr;
1424 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1425 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1426 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1427 key_conf->alg, key_conf->keyidx,
1428 key_conf->keylen, key_conf->flags);
1429 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1431 if (is_zero_ether_addr(addr)) {
1432 /* We dont support TX only encryption */
1437 mutex_lock(&wl->mutex);
1439 ret = wl1271_ps_elp_wakeup(wl, false);
1443 switch (key_conf->alg) {
1447 key_conf->hw_key_idx = key_conf->keyidx;
1450 key_type = KEY_TKIP;
1452 key_conf->hw_key_idx = key_conf->keyidx;
1453 tx_seq_32 = wl->tx_security_seq_32;
1454 tx_seq_16 = wl->tx_security_seq_16;
1459 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1460 tx_seq_32 = wl->tx_security_seq_32;
1461 tx_seq_16 = wl->tx_security_seq_16;
1464 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1472 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1473 key_conf->keyidx, key_type,
1474 key_conf->keylen, key_conf->key,
1475 addr, tx_seq_32, tx_seq_16);
1477 wl1271_error("Could not add or replace key");
1481 /* the default WEP key needs to be configured at least once */
1482 if (key_type == KEY_WEP) {
1483 ret = wl1271_cmd_set_default_wep_key(wl,
1491 /* The wl1271 does not allow to remove unicast keys - they
1492 will be cleared automatically on next CMD_JOIN. Ignore the
1493 request silently, as we dont want the mac80211 to emit
1494 an error message. */
1495 if (!is_broadcast_ether_addr(addr))
1498 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1499 key_conf->keyidx, key_type,
1500 key_conf->keylen, key_conf->key,
1503 wl1271_error("Could not remove key");
1509 wl1271_error("Unsupported key cmd 0x%x", cmd);
1517 wl1271_ps_elp_sleep(wl);
1520 mutex_unlock(&wl->mutex);
1526 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1527 struct cfg80211_scan_request *req)
1529 struct wl1271 *wl = hw->priv;
1534 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1537 ssid = req->ssids[0].ssid;
1538 len = req->ssids[0].ssid_len;
1541 mutex_lock(&wl->mutex);
1543 ret = wl1271_ps_elp_wakeup(wl, false);
1547 if (wl1271_11a_enabled())
1548 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1549 WL1271_SCAN_BAND_DUAL, 3);
1551 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1552 WL1271_SCAN_BAND_2_4_GHZ, 3);
1554 wl1271_ps_elp_sleep(wl);
1557 mutex_unlock(&wl->mutex);
1562 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1564 struct wl1271 *wl = hw->priv;
1567 mutex_lock(&wl->mutex);
1569 ret = wl1271_ps_elp_wakeup(wl, false);
1573 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1575 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1577 wl1271_ps_elp_sleep(wl);
1580 mutex_unlock(&wl->mutex);
1585 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1587 u8 *ptr = beacon->data +
1588 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1590 /* find the location of the ssid in the beacon */
1591 while (ptr < beacon->data + beacon->len) {
1592 if (ptr[0] == WLAN_EID_SSID) {
1593 wl->ssid_len = ptr[1];
1594 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1599 wl1271_error("ad-hoc beacon template has no SSID!\n");
1602 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1603 struct ieee80211_vif *vif,
1604 struct ieee80211_bss_conf *bss_conf,
1607 enum wl1271_cmd_ps_mode mode;
1608 struct wl1271 *wl = hw->priv;
1609 bool do_join = false;
1612 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1614 mutex_lock(&wl->mutex);
1616 ret = wl1271_ps_elp_wakeup(wl, false);
1620 if (wl->bss_type == BSS_TYPE_IBSS) {
1621 /* FIXME: This implements rudimentary ad-hoc support -
1622 proper templates are on the wish list and notification
1623 on when they change. This patch will update the templates
1624 on every call to this function. */
1625 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1628 struct ieee80211_hdr *hdr;
1630 wl1271_ssid_set(wl, beacon);
1631 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1636 dev_kfree_skb(beacon);
1640 hdr = (struct ieee80211_hdr *) beacon->data;
1641 hdr->frame_control = cpu_to_le16(
1642 IEEE80211_FTYPE_MGMT |
1643 IEEE80211_STYPE_PROBE_RESP);
1645 ret = wl1271_cmd_template_set(wl,
1646 CMD_TEMPL_PROBE_RESPONSE,
1649 dev_kfree_skb(beacon);
1653 /* Need to update the SSID (for filtering etc) */
1658 if ((changed & BSS_CHANGED_BSSID) &&
1660 * Now we know the correct bssid, so we send a new join command
1661 * and enable the BSSID filter
1663 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1664 wl->rx_config |= CFG_BSSID_FILTER_EN;
1665 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1666 ret = wl1271_cmd_build_null_data(wl);
1668 wl1271_warning("cmd buld null data failed %d",
1673 /* Need to update the BSSID (for filtering etc) */
1677 if (changed & BSS_CHANGED_ASSOC) {
1678 if (bss_conf->assoc) {
1679 wl->aid = bss_conf->aid;
1680 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1683 * with wl1271, we don't need to update the
1684 * beacon_int and dtim_period, because the firmware
1685 * updates it by itself when the first beacon is
1686 * received after a join.
1688 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1692 ret = wl1271_acx_aid(wl, wl->aid);
1696 /* If we want to go in PSM but we're not there yet */
1697 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1698 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1699 mode = STATION_POWER_SAVE_MODE;
1700 ret = wl1271_ps_set_mode(wl, mode, true);
1705 /* use defaults when not associated */
1706 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1712 if (changed & BSS_CHANGED_ERP_SLOT) {
1713 if (bss_conf->use_short_slot)
1714 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1716 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1718 wl1271_warning("Set slot time failed %d", ret);
1723 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1724 if (bss_conf->use_short_preamble)
1725 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1727 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1730 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1731 if (bss_conf->use_cts_prot)
1732 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1734 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1736 wl1271_warning("Set ctsprotect failed %d", ret);
1742 ret = wl1271_cmd_join(wl);
1744 wl1271_warning("cmd join failed %d", ret);
1747 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1751 wl1271_ps_elp_sleep(wl);
1754 mutex_unlock(&wl->mutex);
1757 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1758 const struct ieee80211_tx_queue_params *params)
1760 struct wl1271 *wl = hw->priv;
1763 mutex_lock(&wl->mutex);
1765 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1767 ret = wl1271_ps_elp_wakeup(wl, false);
1771 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1772 params->cw_min, params->cw_max,
1773 params->aifs, params->txop);
1777 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1778 CONF_CHANNEL_TYPE_EDCF,
1779 wl1271_tx_get_queue(queue),
1780 CONF_PS_SCHEME_LEGACY_PSPOLL,
1781 CONF_ACK_POLICY_LEGACY, 0, 0);
1786 wl1271_ps_elp_sleep(wl);
1789 mutex_unlock(&wl->mutex);
1795 /* can't be const, mac80211 writes to this */
1796 static struct ieee80211_rate wl1271_rates[] = {
1798 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1799 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1801 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1802 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1803 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1805 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1806 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1807 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1809 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1810 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1811 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1813 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1814 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1816 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1817 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1819 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1820 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1822 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1823 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1825 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1826 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1828 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1829 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1831 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1832 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1834 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1835 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1838 /* can't be const, mac80211 writes to this */
1839 static struct ieee80211_channel wl1271_channels[] = {
1840 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1841 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1842 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1843 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1844 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1845 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1846 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1847 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1848 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1849 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1850 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1851 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1852 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1855 /* can't be const, mac80211 writes to this */
1856 static struct ieee80211_supported_band wl1271_band_2ghz = {
1857 .channels = wl1271_channels,
1858 .n_channels = ARRAY_SIZE(wl1271_channels),
1859 .bitrates = wl1271_rates,
1860 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1863 /* 5 GHz data rates for WL1273 */
1864 static struct ieee80211_rate wl1271_rates_5ghz[] = {
1866 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1867 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1869 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1870 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1872 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1873 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1875 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1876 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1878 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1879 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1881 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1882 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1884 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1885 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1887 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1888 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1891 /* 5 GHz band channels for WL1273 */
1892 static struct ieee80211_channel wl1271_channels_5ghz[] = {
1893 { .hw_value = 183, .center_freq = 4915},
1894 { .hw_value = 184, .center_freq = 4920},
1895 { .hw_value = 185, .center_freq = 4925},
1896 { .hw_value = 187, .center_freq = 4935},
1897 { .hw_value = 188, .center_freq = 4940},
1898 { .hw_value = 189, .center_freq = 4945},
1899 { .hw_value = 192, .center_freq = 4960},
1900 { .hw_value = 196, .center_freq = 4980},
1901 { .hw_value = 7, .center_freq = 5035},
1902 { .hw_value = 8, .center_freq = 5040},
1903 { .hw_value = 9, .center_freq = 5045},
1904 { .hw_value = 11, .center_freq = 5055},
1905 { .hw_value = 12, .center_freq = 5060},
1906 { .hw_value = 16, .center_freq = 5080},
1907 { .hw_value = 34, .center_freq = 5170},
1908 { .hw_value = 36, .center_freq = 5180},
1909 { .hw_value = 38, .center_freq = 5190},
1910 { .hw_value = 40, .center_freq = 5200},
1911 { .hw_value = 42, .center_freq = 5210},
1912 { .hw_value = 44, .center_freq = 5220},
1913 { .hw_value = 46, .center_freq = 5230},
1914 { .hw_value = 48, .center_freq = 5240},
1915 { .hw_value = 52, .center_freq = 5260},
1916 { .hw_value = 56, .center_freq = 5280},
1917 { .hw_value = 60, .center_freq = 5300},
1918 { .hw_value = 64, .center_freq = 5320},
1919 { .hw_value = 100, .center_freq = 5500},
1920 { .hw_value = 104, .center_freq = 5520},
1921 { .hw_value = 108, .center_freq = 5540},
1922 { .hw_value = 112, .center_freq = 5560},
1923 { .hw_value = 116, .center_freq = 5580},
1924 { .hw_value = 120, .center_freq = 5600},
1925 { .hw_value = 124, .center_freq = 5620},
1926 { .hw_value = 128, .center_freq = 5640},
1927 { .hw_value = 132, .center_freq = 5660},
1928 { .hw_value = 136, .center_freq = 5680},
1929 { .hw_value = 140, .center_freq = 5700},
1930 { .hw_value = 149, .center_freq = 5745},
1931 { .hw_value = 153, .center_freq = 5765},
1932 { .hw_value = 157, .center_freq = 5785},
1933 { .hw_value = 161, .center_freq = 5805},
1934 { .hw_value = 165, .center_freq = 5825},
1938 static struct ieee80211_supported_band wl1271_band_5ghz = {
1939 .channels = wl1271_channels_5ghz,
1940 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1941 .bitrates = wl1271_rates_5ghz,
1942 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1945 static const struct ieee80211_ops wl1271_ops = {
1946 .start = wl1271_op_start,
1947 .stop = wl1271_op_stop,
1948 .add_interface = wl1271_op_add_interface,
1949 .remove_interface = wl1271_op_remove_interface,
1950 .config = wl1271_op_config,
1951 /* .config_interface = wl1271_op_config_interface, */
1952 .prepare_multicast = wl1271_op_prepare_multicast,
1953 .configure_filter = wl1271_op_configure_filter,
1955 .set_key = wl1271_op_set_key,
1956 .hw_scan = wl1271_op_hw_scan,
1957 .bss_info_changed = wl1271_op_bss_info_changed,
1958 .set_rts_threshold = wl1271_op_set_rts_threshold,
1959 .conf_tx = wl1271_op_conf_tx,
1960 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
1963 static int wl1271_register_hw(struct wl1271 *wl)
1967 if (wl->mac80211_registered)
1970 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1972 ret = ieee80211_register_hw(wl->hw);
1974 wl1271_error("unable to register mac80211 hw: %d", ret);
1978 wl->mac80211_registered = true;
1980 wl1271_notice("loaded");
1985 static int wl1271_init_ieee80211(struct wl1271 *wl)
1987 /* The tx descriptor buffer and the TKIP space. */
1988 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1989 sizeof(struct wl1271_tx_hw_descr);
1992 /* FIXME: find a proper value */
1993 wl->hw->channel_change_time = 10000;
1995 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1996 IEEE80211_HW_NOISE_DBM |
1997 IEEE80211_HW_BEACON_FILTER |
1998 IEEE80211_HW_SUPPORTS_PS;
2000 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2001 BIT(NL80211_IFTYPE_ADHOC);
2002 wl->hw->wiphy->max_scan_ssids = 1;
2003 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2005 if (wl1271_11a_enabled())
2006 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2008 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
2013 static void wl1271_device_release(struct device *dev)
2018 static struct platform_device wl1271_device = {
2022 /* device model insists to have a release function */
2024 .release = wl1271_device_release,
2028 #define WL1271_DEFAULT_CHANNEL 0
2030 static struct ieee80211_hw *wl1271_alloc_hw(void)
2032 struct ieee80211_hw *hw;
2036 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2038 wl1271_error("could not alloc ieee80211_hw");
2039 return ERR_PTR(-ENOMEM);
2043 memset(wl, 0, sizeof(*wl));
2045 INIT_LIST_HEAD(&wl->list);
2049 skb_queue_head_init(&wl->tx_queue);
2051 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2052 wl->channel = WL1271_DEFAULT_CHANNEL;
2053 wl->default_key = 0;
2055 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2056 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2057 wl->psm_entry_retry = 0;
2058 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2059 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2060 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2061 wl->sta_rate_set = 0;
2062 wl->band = IEEE80211_BAND_2GHZ;
2066 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2067 wl->tx_frames[i] = NULL;
2069 spin_lock_init(&wl->wl_lock);
2071 wl->state = WL1271_STATE_OFF;
2072 mutex_init(&wl->mutex);
2074 /* Apply default driver configuration. */
2075 wl1271_conf_init(wl);
2080 int wl1271_free_hw(struct wl1271 *wl)
2082 ieee80211_unregister_hw(wl->hw);
2084 wl1271_debugfs_exit(wl);
2086 kfree(wl->target_mem_map);
2092 kfree(wl->fw_status);
2093 kfree(wl->tx_res_if);
2095 ieee80211_free_hw(wl->hw);
2100 static int __devinit wl1271_probe(struct spi_device *spi)
2102 struct wl12xx_platform_data *pdata;
2103 struct ieee80211_hw *hw;
2107 pdata = spi->dev.platform_data;
2109 wl1271_error("no platform data");
2113 hw = wl1271_alloc_hw();
2119 dev_set_drvdata(&spi->dev, wl);
2122 /* This is the only SPI value that we need to set here, the rest
2123 * comes from the board-peripherals file */
2124 spi->bits_per_word = 32;
2126 ret = spi_setup(spi);
2128 wl1271_error("spi_setup failed");
2132 wl->set_power = pdata->set_power;
2133 if (!wl->set_power) {
2134 wl1271_error("set power function missing in platform data");
2141 wl1271_error("irq missing in platform data");
2146 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
2148 wl1271_error("request_irq() failed: %d", ret);
2152 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
2154 disable_irq(wl->irq);
2156 ret = platform_device_register(&wl1271_device);
2158 wl1271_error("couldn't register platform device");
2161 dev_set_drvdata(&wl1271_device.dev, wl);
2163 ret = wl1271_init_ieee80211(wl);
2167 ret = wl1271_register_hw(wl);
2171 wl1271_debugfs_init(wl);
2173 wl1271_notice("initialized");
2178 platform_device_unregister(&wl1271_device);
2181 free_irq(wl->irq, wl);
2184 ieee80211_free_hw(hw);
2189 static int __devexit wl1271_remove(struct spi_device *spi)
2191 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
2193 platform_device_unregister(&wl1271_device);
2194 free_irq(wl->irq, wl);
2202 static struct spi_driver wl1271_spi_driver = {
2205 .bus = &spi_bus_type,
2206 .owner = THIS_MODULE,
2209 .probe = wl1271_probe,
2210 .remove = __devexit_p(wl1271_remove),
2213 static int __init wl1271_init(void)
2217 ret = spi_register_driver(&wl1271_spi_driver);
2219 wl1271_error("failed to register spi driver: %d", ret);
2227 static void __exit wl1271_exit(void)
2229 spi_unregister_driver(&wl1271_spi_driver);
2231 wl1271_notice("unloaded");
2234 module_init(wl1271_init);
2235 module_exit(wl1271_exit);
2237 MODULE_LICENSE("GPL");
2238 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2239 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2240 MODULE_FIRMWARE(WL1271_FW_NAME);