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>
38 #include "wl12xx_80211.h"
39 #include "wl1271_reg.h"
40 #include "wl1271_spi.h"
41 #include "wl1271_io.h"
42 #include "wl1271_event.h"
43 #include "wl1271_tx.h"
44 #include "wl1271_rx.h"
45 #include "wl1271_ps.h"
46 #include "wl1271_init.h"
47 #include "wl1271_debugfs.h"
48 #include "wl1271_cmd.h"
49 #include "wl1271_boot.h"
50 #include "wl1271_testmode.h"
52 #define WL1271_BOOT_RETRIES 3
54 static struct conf_drv_settings default_conf = {
56 .per_threshold = 7500,
57 .max_scan_compensation_time = 120000,
58 .nfs_sample_interval = 400,
61 .probe_req_compensation = 170,
62 .scan_window_compensation = 50,
64 .beacon_miss_threshold = 60,
65 .rate_adaptation_threshold = CONF_HW_BIT_RATE_12MBPS,
66 .rate_adaptation_snr = 0
69 .rx_msdu_life_time = 512000,
70 .packet_detection_threshold = 0,
71 .ps_poll_timeout = 15,
73 .rts_threshold = 2347,
74 .rx_cca_threshold = 0,
75 .irq_blk_threshold = 0xFFFF,
76 .irq_pkt_threshold = 0,
78 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
81 .tx_energy_detection = 0,
83 .enabled_rates = CONF_HW_BIT_RATE_1MBPS |
84 CONF_HW_BIT_RATE_2MBPS,
85 .short_retry_limit = 10,
86 .long_retry_limit = 10,
109 .aifsn = CONF_TX_AIFS_PIFS,
116 .aifsn = CONF_TX_AIFS_PIFS,
124 .channel_type = CONF_CHANNEL_TYPE_DCF,
125 .tsid = CONF_TX_AC_BE,
126 .ps_scheme = CONF_PS_SCHEME_LEGACY,
127 .ack_policy = CONF_ACK_POLICY_LEGACY,
132 .channel_type = CONF_CHANNEL_TYPE_DCF,
133 .tsid = CONF_TX_AC_BE,
134 .ps_scheme = CONF_PS_SCHEME_LEGACY,
135 .ack_policy = CONF_ACK_POLICY_LEGACY,
140 .channel_type = CONF_CHANNEL_TYPE_DCF,
141 .tsid = CONF_TX_AC_BE,
142 .ps_scheme = CONF_PS_SCHEME_LEGACY,
143 .ack_policy = CONF_ACK_POLICY_LEGACY,
148 .channel_type = CONF_CHANNEL_TYPE_DCF,
149 .tsid = CONF_TX_AC_BE,
150 .ps_scheme = CONF_PS_SCHEME_LEGACY,
151 .ack_policy = CONF_ACK_POLICY_LEGACY,
156 .channel_type = CONF_CHANNEL_TYPE_DCF,
157 .tsid = CONF_TX_AC_BE,
158 .ps_scheme = CONF_PS_SCHEME_LEGACY,
159 .ack_policy = CONF_ACK_POLICY_LEGACY,
164 .channel_type = CONF_CHANNEL_TYPE_DCF,
165 .tsid = CONF_TX_AC_BE,
166 .ps_scheme = CONF_PS_SCHEME_LEGACY,
167 .ack_policy = CONF_ACK_POLICY_LEGACY,
172 .channel_type = CONF_CHANNEL_TYPE_DCF,
173 .tsid = CONF_TX_AC_BE,
174 .ps_scheme = CONF_PS_SCHEME_LEGACY,
175 .ack_policy = CONF_ACK_POLICY_LEGACY,
179 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
180 .tx_compl_timeout = 700,
181 .tx_compl_threshold = 4
184 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
185 .listen_interval = 0,
186 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
187 .bcn_filt_ie_count = 1,
190 .ie = WLAN_EID_CHANNEL_SWITCH,
191 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
194 .synch_fail_thold = 10,
195 .bss_lose_timeout = 100,
196 .beacon_rx_timeout = 10000,
197 .broadcast_timeout = 20000,
198 .rx_broadcast_in_ps = 1,
199 .ps_poll_threshold = 20,
200 .sig_trigger_count = 2,
205 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
206 .type = CONF_TRIG_EVENT_TYPE_EDGE,
207 .direction = CONF_TRIG_EVENT_DIR_LOW,
215 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
216 .type = CONF_TRIG_EVENT_TYPE_EDGE,
217 .direction = CONF_TRIG_EVENT_DIR_HIGH,
224 .rssi_bcn_avg_weight = 10,
225 .rssi_pkt_avg_weight = 10,
226 .snr_bcn_avg_weight = 10,
227 .snr_pkt_avg_weight = 10
229 .bet_enable = CONF_BET_MODE_ENABLE,
230 .bet_max_consecutive = 10,
231 .psm_entry_retries = 3
243 .host_clk_settling_time = 5000,
244 .host_fast_wakeup_support = false
248 static LIST_HEAD(wl_list);
250 static void wl1271_conf_init(struct wl1271 *wl)
254 * This function applies the default configuration to the driver. This
255 * function is invoked upon driver load (spi probe.)
257 * The configuration is stored in a run-time structure in order to
258 * facilitate for run-time adjustment of any of the parameters. Making
259 * changes to the configuration structure will apply the new values on
260 * the next interface up (wl1271_op_start.)
263 /* apply driver default configuration */
264 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
268 static int wl1271_plt_init(struct wl1271 *wl)
270 struct conf_tx_ac_category *conf_ac;
271 struct conf_tx_tid *conf_tid;
274 ret = wl1271_cmd_general_parms(wl);
278 ret = wl1271_cmd_radio_parms(wl);
282 ret = wl1271_init_templates_config(wl);
286 ret = wl1271_acx_init_mem_config(wl);
290 /* PHY layer config */
291 ret = wl1271_init_phy_config(wl);
293 goto out_free_memmap;
295 ret = wl1271_acx_dco_itrim_params(wl);
297 goto out_free_memmap;
299 /* Initialize connection monitoring thresholds */
300 ret = wl1271_acx_conn_monit_params(wl);
302 goto out_free_memmap;
304 /* Bluetooth WLAN coexistence */
305 ret = wl1271_init_pta(wl);
307 goto out_free_memmap;
309 /* Energy detection */
310 ret = wl1271_init_energy_detection(wl);
312 goto out_free_memmap;
314 /* Default fragmentation threshold */
315 ret = wl1271_acx_frag_threshold(wl);
317 goto out_free_memmap;
319 /* Default TID configuration */
320 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
321 conf_tid = &wl->conf.tx.tid_conf[i];
322 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
323 conf_tid->channel_type,
326 conf_tid->ack_policy,
327 conf_tid->apsd_conf[0],
328 conf_tid->apsd_conf[1]);
330 goto out_free_memmap;
333 /* Default AC configuration */
334 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
335 conf_ac = &wl->conf.tx.ac_conf[i];
336 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
337 conf_ac->cw_max, conf_ac->aifsn,
338 conf_ac->tx_op_limit);
340 goto out_free_memmap;
343 /* Enable data path */
344 ret = wl1271_cmd_data_path(wl, 1);
346 goto out_free_memmap;
348 /* Configure for CAM power saving (ie. always active) */
349 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
351 goto out_free_memmap;
354 ret = wl1271_acx_pm_config(wl);
356 goto out_free_memmap;
361 kfree(wl->target_mem_map);
362 wl->target_mem_map = NULL;
367 static void wl1271_disable_interrupts(struct wl1271 *wl)
369 disable_irq(wl->irq);
372 static void wl1271_power_off(struct wl1271 *wl)
374 wl->set_power(false);
375 clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
378 static void wl1271_power_on(struct wl1271 *wl)
381 set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
384 static void wl1271_fw_status(struct wl1271 *wl,
385 struct wl1271_fw_status *status)
390 wl1271_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
392 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
393 "drv_rx_counter = %d, tx_results_counter = %d)",
395 status->fw_rx_counter,
396 status->drv_rx_counter,
397 status->tx_results_counter);
399 /* update number of available TX blocks */
400 for (i = 0; i < NUM_TX_QUEUES; i++) {
401 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
402 wl->tx_blocks_freed[i];
404 wl->tx_blocks_freed[i] =
405 le32_to_cpu(status->tx_released_blks[i]);
406 wl->tx_blocks_available += cnt;
410 /* if more blocks are available now, schedule some tx work */
411 if (total && !skb_queue_empty(&wl->tx_queue))
412 ieee80211_queue_work(wl->hw, &wl->tx_work);
414 /* update the host-chipset time offset */
415 wl->time_offset = jiffies_to_usecs(jiffies) -
416 le32_to_cpu(status->fw_localtime);
419 static void wl1271_irq_work(struct work_struct *work)
424 container_of(work, struct wl1271, irq_work);
426 mutex_lock(&wl->mutex);
428 wl1271_debug(DEBUG_IRQ, "IRQ work");
430 if (wl->state == WL1271_STATE_OFF)
433 ret = wl1271_ps_elp_wakeup(wl, true);
437 wl1271_write32(wl, ACX_REG_INTERRUPT_MASK, WL1271_ACX_INTR_ALL);
439 wl1271_fw_status(wl, wl->fw_status);
440 intr = le32_to_cpu(wl->fw_status->intr);
442 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
446 intr &= WL1271_INTR_MASK;
448 if (intr & WL1271_ACX_INTR_EVENT_A) {
449 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
450 wl1271_event_handle(wl, 0);
453 if (intr & WL1271_ACX_INTR_EVENT_B) {
454 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
455 wl1271_event_handle(wl, 1);
458 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
459 wl1271_debug(DEBUG_IRQ,
460 "WL1271_ACX_INTR_INIT_COMPLETE");
462 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
463 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
465 if (intr & WL1271_ACX_INTR_DATA) {
466 u8 tx_res_cnt = wl->fw_status->tx_results_counter -
467 wl->tx_results_count;
469 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
471 /* check for tx results */
473 wl1271_tx_complete(wl, tx_res_cnt);
475 wl1271_rx(wl, wl->fw_status);
479 wl1271_write32(wl, ACX_REG_INTERRUPT_MASK,
480 WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK));
481 wl1271_ps_elp_sleep(wl);
484 mutex_unlock(&wl->mutex);
487 static irqreturn_t wl1271_irq(int irq, void *cookie)
492 wl1271_debug(DEBUG_IRQ, "IRQ");
496 /* complete the ELP completion */
497 spin_lock_irqsave(&wl->wl_lock, flags);
499 complete(wl->elp_compl);
500 wl->elp_compl = NULL;
503 ieee80211_queue_work(wl->hw, &wl->irq_work);
504 spin_unlock_irqrestore(&wl->wl_lock, flags);
509 static int wl1271_fetch_firmware(struct wl1271 *wl)
511 const struct firmware *fw;
514 ret = request_firmware(&fw, WL1271_FW_NAME, &wl->spi->dev);
517 wl1271_error("could not get firmware: %d", ret);
522 wl1271_error("firmware size is not multiple of 32 bits: %zu",
528 wl->fw_len = fw->size;
529 wl->fw = vmalloc(wl->fw_len);
532 wl1271_error("could not allocate memory for the firmware");
537 memcpy(wl->fw, fw->data, wl->fw_len);
542 release_firmware(fw);
547 static int wl1271_update_mac_addr(struct wl1271 *wl)
550 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
552 /* get mac address from the NVS */
553 wl->mac_addr[0] = nvs_ptr[11];
554 wl->mac_addr[1] = nvs_ptr[10];
555 wl->mac_addr[2] = nvs_ptr[6];
556 wl->mac_addr[3] = nvs_ptr[5];
557 wl->mac_addr[4] = nvs_ptr[4];
558 wl->mac_addr[5] = nvs_ptr[3];
560 /* FIXME: if it is a zero-address, we should bail out. Now, instead,
561 we randomize an address */
562 if (is_zero_ether_addr(wl->mac_addr)) {
563 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
564 memcpy(wl->mac_addr, nokia_oui, 3);
565 get_random_bytes(wl->mac_addr + 3, 3);
567 /* update this address to the NVS */
568 nvs_ptr[11] = wl->mac_addr[0];
569 nvs_ptr[10] = wl->mac_addr[1];
570 nvs_ptr[6] = wl->mac_addr[2];
571 nvs_ptr[5] = wl->mac_addr[3];
572 nvs_ptr[4] = wl->mac_addr[4];
573 nvs_ptr[3] = wl->mac_addr[5];
576 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
581 static int wl1271_fetch_nvs(struct wl1271 *wl)
583 const struct firmware *fw;
586 ret = request_firmware(&fw, WL1271_NVS_NAME, &wl->spi->dev);
589 wl1271_error("could not get nvs file: %d", ret);
593 if (fw->size != sizeof(struct wl1271_nvs_file)) {
594 wl1271_error("nvs size is not as expected: %zu != %zu",
595 fw->size, sizeof(struct wl1271_nvs_file));
600 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
603 wl1271_error("could not allocate memory for the nvs file");
608 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
610 ret = wl1271_update_mac_addr(wl);
613 release_firmware(fw);
618 static void wl1271_fw_wakeup(struct wl1271 *wl)
622 elp_reg = ELPCTRL_WAKE_UP;
623 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
626 static int wl1271_setup(struct wl1271 *wl)
628 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
632 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
633 if (!wl->tx_res_if) {
634 kfree(wl->fw_status);
638 INIT_WORK(&wl->irq_work, wl1271_irq_work);
639 INIT_WORK(&wl->tx_work, wl1271_tx_work);
643 static int wl1271_chip_wakeup(struct wl1271 *wl)
645 struct wl1271_partition_set partition;
648 msleep(WL1271_PRE_POWER_ON_SLEEP);
650 msleep(WL1271_POWER_ON_SLEEP);
654 /* We don't need a real memory partition here, because we only want
655 * to use the registers at this point. */
656 memset(&partition, 0, sizeof(partition));
657 partition.reg.start = REGISTERS_BASE;
658 partition.reg.size = REGISTERS_DOWN_SIZE;
659 wl1271_set_partition(wl, &partition);
661 /* ELP module wake up */
662 wl1271_fw_wakeup(wl);
664 /* whal_FwCtrl_BootSm() */
666 /* 0. read chip id from CHIP_ID */
667 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
669 /* 1. check if chip id is valid */
671 switch (wl->chip.id) {
672 case CHIP_ID_1271_PG10:
673 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
676 ret = wl1271_setup(wl);
680 case CHIP_ID_1271_PG20:
681 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
684 ret = wl1271_setup(wl);
689 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
694 if (wl->fw == NULL) {
695 ret = wl1271_fetch_firmware(wl);
700 /* No NVS from netlink, try to get it from the filesystem */
701 if (wl->nvs == NULL) {
702 ret = wl1271_fetch_nvs(wl);
711 int wl1271_plt_start(struct wl1271 *wl)
713 int retries = WL1271_BOOT_RETRIES;
716 mutex_lock(&wl->mutex);
718 wl1271_notice("power up");
720 if (wl->state != WL1271_STATE_OFF) {
721 wl1271_error("cannot go into PLT state because not "
722 "in off state: %d", wl->state);
729 ret = wl1271_chip_wakeup(wl);
733 ret = wl1271_boot(wl);
737 ret = wl1271_plt_init(wl);
741 wl->state = WL1271_STATE_PLT;
742 wl1271_notice("firmware booted in PLT mode (%s)",
747 wl1271_disable_interrupts(wl);
748 mutex_unlock(&wl->mutex);
749 /* Unlocking the mutex in the middle of handling is
750 inherently unsafe. In this case we deem it safe to do,
751 because we need to let any possibly pending IRQ out of
752 the system (and while we are WL1271_STATE_OFF the IRQ
753 work function will not do anything.) Also, any other
754 possible concurrent operations will fail due to the
755 current state, hence the wl1271 struct should be safe. */
756 cancel_work_sync(&wl->irq_work);
757 mutex_lock(&wl->mutex);
759 wl1271_power_off(wl);
762 wl1271_error("firmware boot in PLT mode failed despite %d retries",
763 WL1271_BOOT_RETRIES);
765 mutex_unlock(&wl->mutex);
770 int wl1271_plt_stop(struct wl1271 *wl)
774 mutex_lock(&wl->mutex);
776 wl1271_notice("power down");
778 if (wl->state != WL1271_STATE_PLT) {
779 wl1271_error("cannot power down because not in PLT "
780 "state: %d", wl->state);
785 wl1271_disable_interrupts(wl);
786 wl1271_power_off(wl);
788 wl->state = WL1271_STATE_OFF;
792 mutex_unlock(&wl->mutex);
798 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
800 struct wl1271 *wl = hw->priv;
801 struct ieee80211_conf *conf = &hw->conf;
802 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
803 struct ieee80211_sta *sta = txinfo->control.sta;
806 /* peek into the rates configured in the STA entry */
807 spin_lock_irqsave(&wl->wl_lock, flags);
808 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
809 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
810 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
812 spin_unlock_irqrestore(&wl->wl_lock, flags);
814 /* queue the packet */
815 skb_queue_tail(&wl->tx_queue, skb);
818 * The chip specific setup must run before the first TX packet -
819 * before that, the tx_work will not be initialized!
822 ieee80211_queue_work(wl->hw, &wl->tx_work);
825 * The workqueue is slow to process the tx_queue and we need stop
826 * the queue here, otherwise the queue will get too long.
828 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_MAX_LENGTH) {
829 ieee80211_stop_queues(wl->hw);
832 * FIXME: this is racy, the variable is not properly
833 * protected. Maybe fix this by removing the stupid
834 * variable altogether and checking the real queue state?
836 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
842 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
845 struct net_device *dev;
846 struct wireless_dev *wdev;
848 struct ieee80211_hw *hw;
850 struct wl1271 *wl_temp;
851 struct in_device *idev;
852 struct in_ifaddr *ifa = arg;
855 /* FIXME: this ugly function should probably be implemented in the
856 * mac80211, and here should only be a simple callback handling actual
857 * setting of the filters. Now we need to dig up references to
858 * various structures to gain access to what we need.
859 * Also, because of this, there is no "initial" setting of the filter
860 * in "op_start", because we don't want to dig up struct net_device
861 * there - the filter will be set upon first change of the interface
864 dev = ifa->ifa_dev->dev;
866 wdev = dev->ieee80211_ptr;
874 hw = wiphy_priv(wiphy);
878 /* Check that the interface is one supported by this driver. */
880 list_for_each_entry(wl, &wl_list, list) {
887 /* Get the interface IP address for the device. "ifa" will become
889 - there is no IPV4 protocol address configured
890 - there are multiple (virtual) IPV4 addresses configured
891 When "ifa" is NULL, filtering will be disabled.
896 ifa = idev->ifa_list;
898 if (ifa && ifa->ifa_next)
901 mutex_lock(&wl->mutex);
903 if (wl->state == WL1271_STATE_OFF)
906 ret = wl1271_ps_elp_wakeup(wl, false);
910 ret = wl1271_acx_arp_ip_filter(wl, true,
911 (u8 *)&ifa->ifa_address,
914 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
916 wl1271_ps_elp_sleep(wl);
919 mutex_unlock(&wl->mutex);
924 static struct notifier_block wl1271_dev_notifier = {
925 .notifier_call = wl1271_dev_notify,
929 static int wl1271_op_start(struct ieee80211_hw *hw)
931 struct wl1271 *wl = hw->priv;
932 int retries = WL1271_BOOT_RETRIES;
935 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
937 mutex_lock(&wl->mutex);
939 if (wl->state != WL1271_STATE_OFF) {
940 wl1271_error("cannot start because not in off state: %d",
948 ret = wl1271_chip_wakeup(wl);
952 ret = wl1271_boot(wl);
956 ret = wl1271_hw_init(wl);
960 wl->state = WL1271_STATE_ON;
961 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
965 wl1271_disable_interrupts(wl);
966 mutex_unlock(&wl->mutex);
967 /* Unlocking the mutex in the middle of handling is
968 inherently unsafe. In this case we deem it safe to do,
969 because we need to let any possibly pending IRQ out of
970 the system (and while we are WL1271_STATE_OFF the IRQ
971 work function will not do anything.) Also, any other
972 possible concurrent operations will fail due to the
973 current state, hence the wl1271 struct should be safe. */
974 cancel_work_sync(&wl->irq_work);
975 mutex_lock(&wl->mutex);
977 wl1271_power_off(wl);
980 wl1271_error("firmware boot failed despite %d retries",
981 WL1271_BOOT_RETRIES);
983 mutex_unlock(&wl->mutex);
986 list_add(&wl->list, &wl_list);
987 register_inetaddr_notifier(&wl1271_dev_notifier);
993 static void wl1271_op_stop(struct ieee80211_hw *hw)
995 struct wl1271 *wl = hw->priv;
1000 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1002 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1003 list_del(&wl->list);
1005 mutex_lock(&wl->mutex);
1007 WARN_ON(wl->state != WL1271_STATE_ON);
1009 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1010 mutex_unlock(&wl->mutex);
1011 ieee80211_scan_completed(wl->hw, true);
1012 mutex_lock(&wl->mutex);
1015 wl->state = WL1271_STATE_OFF;
1017 wl1271_disable_interrupts(wl);
1019 mutex_unlock(&wl->mutex);
1021 cancel_work_sync(&wl->irq_work);
1022 cancel_work_sync(&wl->tx_work);
1024 mutex_lock(&wl->mutex);
1026 /* let's notify MAC80211 about the remaining pending TX frames */
1027 wl1271_tx_flush(wl);
1028 wl1271_power_off(wl);
1030 memset(wl->bssid, 0, ETH_ALEN);
1031 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1033 wl->bss_type = MAX_BSS_TYPE;
1034 wl->band = IEEE80211_BAND_2GHZ;
1037 wl->psm_entry_retry = 0;
1038 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1039 wl->tx_blocks_available = 0;
1040 wl->tx_results_count = 0;
1041 wl->tx_packets_count = 0;
1042 wl->tx_security_last_seq = 0;
1043 wl->tx_security_seq_16 = 0;
1044 wl->tx_security_seq_32 = 0;
1045 wl->time_offset = 0;
1046 wl->session_counter = 0;
1047 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1048 wl->sta_rate_set = 0;
1051 for (i = 0; i < NUM_TX_QUEUES; i++)
1052 wl->tx_blocks_freed[i] = 0;
1054 wl1271_debugfs_reset(wl);
1055 mutex_unlock(&wl->mutex);
1058 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1059 struct ieee80211_vif *vif)
1061 struct wl1271 *wl = hw->priv;
1064 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1065 vif->type, vif->addr);
1067 mutex_lock(&wl->mutex);
1075 switch (vif->type) {
1076 case NL80211_IFTYPE_STATION:
1077 wl->bss_type = BSS_TYPE_STA_BSS;
1079 case NL80211_IFTYPE_ADHOC:
1080 wl->bss_type = BSS_TYPE_IBSS;
1087 /* FIXME: what if conf->mac_addr changes? */
1090 mutex_unlock(&wl->mutex);
1094 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1095 struct ieee80211_vif *vif)
1097 struct wl1271 *wl = hw->priv;
1099 mutex_lock(&wl->mutex);
1100 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1102 mutex_unlock(&wl->mutex);
1106 static int wl1271_op_config_interface(struct ieee80211_hw *hw,
1107 struct ieee80211_vif *vif,
1108 struct ieee80211_if_conf *conf)
1110 struct wl1271 *wl = hw->priv;
1111 struct sk_buff *beacon;
1114 wl1271_debug(DEBUG_MAC80211, "mac80211 config_interface bssid %pM",
1116 wl1271_dump_ascii(DEBUG_MAC80211, "ssid: ", conf->ssid,
1119 mutex_lock(&wl->mutex);
1121 ret = wl1271_ps_elp_wakeup(wl, false);
1125 if (memcmp(wl->bssid, conf->bssid, ETH_ALEN)) {
1126 wl1271_debug(DEBUG_MAC80211, "bssid changed");
1128 memcpy(wl->bssid, conf->bssid, ETH_ALEN);
1130 ret = wl1271_cmd_join(wl);
1134 ret = wl1271_cmd_build_null_data(wl);
1139 wl->ssid_len = conf->ssid_len;
1141 memcpy(wl->ssid, conf->ssid, wl->ssid_len);
1143 if (conf->changed & IEEE80211_IFCC_BEACON) {
1144 beacon = ieee80211_beacon_get(hw, vif);
1145 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1146 beacon->data, beacon->len);
1149 dev_kfree_skb(beacon);
1153 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE,
1154 beacon->data, beacon->len);
1156 dev_kfree_skb(beacon);
1163 wl1271_ps_elp_sleep(wl);
1166 mutex_unlock(&wl->mutex);
1172 static int wl1271_join_channel(struct wl1271 *wl, int channel)
1175 /* we need to use a dummy BSSID for now */
1176 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1179 /* the dummy join is not required for ad-hoc */
1180 if (wl->bss_type == BSS_TYPE_IBSS)
1183 /* disable mac filter, so we hear everything */
1184 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1186 wl->channel = channel;
1187 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1189 ret = wl1271_cmd_join(wl);
1193 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1199 static int wl1271_unjoin_channel(struct wl1271 *wl)
1203 /* to stop listening to a channel, we disconnect */
1204 ret = wl1271_cmd_disconnect(wl);
1208 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1210 memset(wl->bssid, 0, ETH_ALEN);
1211 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1217 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1219 struct wl1271 *wl = hw->priv;
1220 struct ieee80211_conf *conf = &hw->conf;
1221 int channel, ret = 0;
1223 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1225 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1227 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1229 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1231 mutex_lock(&wl->mutex);
1233 wl->band = conf->channel->band;
1235 ret = wl1271_ps_elp_wakeup(wl, false);
1239 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1240 if (conf->flags & IEEE80211_CONF_IDLE &&
1241 test_bit(WL1271_FLAG_JOINED, &wl->flags))
1242 wl1271_unjoin_channel(wl);
1243 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1244 wl1271_join_channel(wl, channel);
1246 if (conf->flags & IEEE80211_CONF_IDLE) {
1247 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1248 wl->sta_rate_set = 0;
1249 wl1271_acx_rate_policies(wl);
1253 /* if the channel changes while joined, join again */
1254 if (channel != wl->channel &&
1255 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1256 wl->channel = channel;
1257 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
1258 ret = wl1271_cmd_join(wl);
1260 wl1271_warning("cmd join to update channel failed %d",
1263 wl->channel = channel;
1265 if (conf->flags & IEEE80211_CONF_PS &&
1266 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1267 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1270 * We enter PSM only if we're already associated.
1271 * If we're not, we'll enter it when joining an SSID,
1272 * through the bss_info_changed() hook.
1274 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1275 wl1271_info("psm enabled");
1276 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1279 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1280 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1281 wl1271_info("psm disabled");
1283 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1285 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1286 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1290 if (conf->power_level != wl->power_level) {
1291 ret = wl1271_acx_tx_power(wl, conf->power_level);
1295 wl->power_level = conf->power_level;
1299 wl1271_ps_elp_sleep(wl);
1302 mutex_unlock(&wl->mutex);
1307 struct wl1271_filter_params {
1310 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1313 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1314 struct dev_addr_list *mc_list)
1316 struct wl1271_filter_params *fp;
1319 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1321 wl1271_error("Out of memory setting filters.");
1325 /* update multicast filtering parameters */
1327 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1329 fp->enabled = false;
1332 fp->mc_list_length = 0;
1333 for (i = 0; i < mc_count; i++) {
1334 if (mc_list->da_addrlen == ETH_ALEN) {
1335 memcpy(fp->mc_list[fp->mc_list_length],
1336 mc_list->da_addr, ETH_ALEN);
1337 fp->mc_list_length++;
1339 wl1271_warning("Unknown mc address length.");
1340 mc_list = mc_list->next;
1343 return (u64)(unsigned long)fp;
1346 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1349 FIF_BCN_PRBRESP_PROMISC | \
1353 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1354 unsigned int changed,
1355 unsigned int *total, u64 multicast)
1357 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1358 struct wl1271 *wl = hw->priv;
1361 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1363 mutex_lock(&wl->mutex);
1365 if (wl->state == WL1271_STATE_OFF)
1368 ret = wl1271_ps_elp_wakeup(wl, false);
1372 *total &= WL1271_SUPPORTED_FILTERS;
1373 changed &= WL1271_SUPPORTED_FILTERS;
1375 if (*total & FIF_ALLMULTI)
1376 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1378 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1380 fp->mc_list_length);
1386 /* FIXME: We still need to set our filters properly */
1388 /* determine, whether supported filter values have changed */
1392 /* apply configured filters */
1393 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1398 wl1271_ps_elp_sleep(wl);
1401 mutex_unlock(&wl->mutex);
1404 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1405 struct ieee80211_vif *vif,
1406 struct ieee80211_sta *sta,
1407 struct ieee80211_key_conf *key_conf)
1409 struct wl1271 *wl = hw->priv;
1416 static const u8 bcast_addr[ETH_ALEN] =
1417 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1419 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1421 addr = sta ? sta->addr : bcast_addr;
1423 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1424 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1425 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1426 key_conf->alg, key_conf->keyidx,
1427 key_conf->keylen, key_conf->flags);
1428 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1430 if (is_zero_ether_addr(addr)) {
1431 /* We dont support TX only encryption */
1436 mutex_lock(&wl->mutex);
1438 ret = wl1271_ps_elp_wakeup(wl, false);
1442 switch (key_conf->alg) {
1446 key_conf->hw_key_idx = key_conf->keyidx;
1449 key_type = KEY_TKIP;
1451 key_conf->hw_key_idx = key_conf->keyidx;
1452 tx_seq_32 = wl->tx_security_seq_32;
1453 tx_seq_16 = wl->tx_security_seq_16;
1458 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1459 tx_seq_32 = wl->tx_security_seq_32;
1460 tx_seq_16 = wl->tx_security_seq_16;
1463 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1471 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1472 key_conf->keyidx, key_type,
1473 key_conf->keylen, key_conf->key,
1474 addr, tx_seq_32, tx_seq_16);
1476 wl1271_error("Could not add or replace key");
1480 /* the default WEP key needs to be configured at least once */
1481 if (key_type == KEY_WEP) {
1482 ret = wl1271_cmd_set_default_wep_key(wl,
1490 /* The wl1271 does not allow to remove unicast keys - they
1491 will be cleared automatically on next CMD_JOIN. Ignore the
1492 request silently, as we dont want the mac80211 to emit
1493 an error message. */
1494 if (!is_broadcast_ether_addr(addr))
1497 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1498 key_conf->keyidx, key_type,
1499 key_conf->keylen, key_conf->key,
1502 wl1271_error("Could not remove key");
1508 wl1271_error("Unsupported key cmd 0x%x", cmd);
1516 wl1271_ps_elp_sleep(wl);
1519 mutex_unlock(&wl->mutex);
1525 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1526 struct cfg80211_scan_request *req)
1528 struct wl1271 *wl = hw->priv;
1533 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1536 ssid = req->ssids[0].ssid;
1537 len = req->ssids[0].ssid_len;
1540 mutex_lock(&wl->mutex);
1542 ret = wl1271_ps_elp_wakeup(wl, false);
1546 if (wl1271_11a_enabled())
1547 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1548 WL1271_SCAN_BAND_DUAL, 3);
1550 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1551 WL1271_SCAN_BAND_2_4_GHZ, 3);
1553 wl1271_ps_elp_sleep(wl);
1556 mutex_unlock(&wl->mutex);
1561 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1563 struct wl1271 *wl = hw->priv;
1566 mutex_lock(&wl->mutex);
1568 ret = wl1271_ps_elp_wakeup(wl, false);
1572 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1574 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1576 wl1271_ps_elp_sleep(wl);
1579 mutex_unlock(&wl->mutex);
1584 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1586 u8 *ptr = beacon->data +
1587 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1589 /* find the location of the ssid in the beacon */
1590 while (ptr < beacon->data + beacon->len) {
1591 if (ptr[0] == WLAN_EID_SSID) {
1592 wl->ssid_len = ptr[1];
1593 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1598 wl1271_error("ad-hoc beacon template has no SSID!\n");
1601 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1602 struct ieee80211_vif *vif,
1603 struct ieee80211_bss_conf *bss_conf,
1606 enum wl1271_cmd_ps_mode mode;
1607 struct wl1271 *wl = hw->priv;
1608 bool do_join = false;
1611 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1613 mutex_lock(&wl->mutex);
1615 ret = wl1271_ps_elp_wakeup(wl, false);
1619 if (wl->bss_type == BSS_TYPE_IBSS) {
1620 /* FIXME: This implements rudimentary ad-hoc support -
1621 proper templates are on the wish list and notification
1622 on when they change. This patch will update the templates
1623 on every call to this function. */
1624 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1627 struct ieee80211_hdr *hdr;
1629 wl1271_ssid_set(wl, beacon);
1630 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1635 dev_kfree_skb(beacon);
1639 hdr = (struct ieee80211_hdr *) beacon->data;
1640 hdr->frame_control = cpu_to_le16(
1641 IEEE80211_FTYPE_MGMT |
1642 IEEE80211_STYPE_PROBE_RESP);
1644 ret = wl1271_cmd_template_set(wl,
1645 CMD_TEMPL_PROBE_RESPONSE,
1648 dev_kfree_skb(beacon);
1652 /* Need to update the SSID (for filtering etc) */
1657 if ((changed & BSS_CHANGED_BSSID) &&
1659 * Now we know the correct bssid, so we send a new join command
1660 * and enable the BSSID filter
1662 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1663 wl->rx_config |= CFG_BSSID_FILTER_EN;
1664 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1665 ret = wl1271_cmd_build_null_data(wl);
1667 wl1271_warning("cmd buld null data failed %d",
1672 /* Need to update the BSSID (for filtering etc) */
1676 if (changed & BSS_CHANGED_ASSOC) {
1677 if (bss_conf->assoc) {
1678 wl->aid = bss_conf->aid;
1679 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1682 * with wl1271, we don't need to update the
1683 * beacon_int and dtim_period, because the firmware
1684 * updates it by itself when the first beacon is
1685 * received after a join.
1687 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1691 ret = wl1271_acx_aid(wl, wl->aid);
1695 /* If we want to go in PSM but we're not there yet */
1696 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1697 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1698 mode = STATION_POWER_SAVE_MODE;
1699 ret = wl1271_ps_set_mode(wl, mode, true);
1704 /* use defaults when not associated */
1705 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1711 if (changed & BSS_CHANGED_ERP_SLOT) {
1712 if (bss_conf->use_short_slot)
1713 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1715 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1717 wl1271_warning("Set slot time failed %d", ret);
1722 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1723 if (bss_conf->use_short_preamble)
1724 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1726 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1729 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1730 if (bss_conf->use_cts_prot)
1731 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1733 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1735 wl1271_warning("Set ctsprotect failed %d", ret);
1741 ret = wl1271_cmd_join(wl);
1743 wl1271_warning("cmd join failed %d", ret);
1746 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1750 wl1271_ps_elp_sleep(wl);
1753 mutex_unlock(&wl->mutex);
1756 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1757 const struct ieee80211_tx_queue_params *params)
1759 struct wl1271 *wl = hw->priv;
1762 mutex_lock(&wl->mutex);
1764 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1766 ret = wl1271_ps_elp_wakeup(wl, false);
1770 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1771 params->cw_min, params->cw_max,
1772 params->aifs, params->txop);
1776 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1777 CONF_CHANNEL_TYPE_EDCF,
1778 wl1271_tx_get_queue(queue),
1779 CONF_PS_SCHEME_LEGACY_PSPOLL,
1780 CONF_ACK_POLICY_LEGACY, 0, 0);
1785 wl1271_ps_elp_sleep(wl);
1788 mutex_unlock(&wl->mutex);
1794 /* can't be const, mac80211 writes to this */
1795 static struct ieee80211_rate wl1271_rates[] = {
1797 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1798 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1800 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1801 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1802 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1804 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1805 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1806 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1808 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1809 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1810 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1812 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1813 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1815 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1816 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1818 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1819 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1821 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1822 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1824 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1825 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1827 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1828 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1830 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1831 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1833 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1834 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1837 /* can't be const, mac80211 writes to this */
1838 static struct ieee80211_channel wl1271_channels[] = {
1839 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1840 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1841 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1842 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1843 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1844 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1845 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1846 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1847 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1848 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1849 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1850 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1851 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1854 /* can't be const, mac80211 writes to this */
1855 static struct ieee80211_supported_band wl1271_band_2ghz = {
1856 .channels = wl1271_channels,
1857 .n_channels = ARRAY_SIZE(wl1271_channels),
1858 .bitrates = wl1271_rates,
1859 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1862 /* 5 GHz data rates for WL1273 */
1863 static struct ieee80211_rate wl1271_rates_5ghz[] = {
1865 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1866 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1868 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1869 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1871 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1872 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1874 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1875 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1877 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1878 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1880 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1881 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1883 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1884 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1886 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1887 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1890 /* 5 GHz band channels for WL1273 */
1891 static struct ieee80211_channel wl1271_channels_5ghz[] = {
1892 { .hw_value = 183, .center_freq = 4915},
1893 { .hw_value = 184, .center_freq = 4920},
1894 { .hw_value = 185, .center_freq = 4925},
1895 { .hw_value = 187, .center_freq = 4935},
1896 { .hw_value = 188, .center_freq = 4940},
1897 { .hw_value = 189, .center_freq = 4945},
1898 { .hw_value = 192, .center_freq = 4960},
1899 { .hw_value = 196, .center_freq = 4980},
1900 { .hw_value = 7, .center_freq = 5035},
1901 { .hw_value = 8, .center_freq = 5040},
1902 { .hw_value = 9, .center_freq = 5045},
1903 { .hw_value = 11, .center_freq = 5055},
1904 { .hw_value = 12, .center_freq = 5060},
1905 { .hw_value = 16, .center_freq = 5080},
1906 { .hw_value = 34, .center_freq = 5170},
1907 { .hw_value = 36, .center_freq = 5180},
1908 { .hw_value = 38, .center_freq = 5190},
1909 { .hw_value = 40, .center_freq = 5200},
1910 { .hw_value = 42, .center_freq = 5210},
1911 { .hw_value = 44, .center_freq = 5220},
1912 { .hw_value = 46, .center_freq = 5230},
1913 { .hw_value = 48, .center_freq = 5240},
1914 { .hw_value = 52, .center_freq = 5260},
1915 { .hw_value = 56, .center_freq = 5280},
1916 { .hw_value = 60, .center_freq = 5300},
1917 { .hw_value = 64, .center_freq = 5320},
1918 { .hw_value = 100, .center_freq = 5500},
1919 { .hw_value = 104, .center_freq = 5520},
1920 { .hw_value = 108, .center_freq = 5540},
1921 { .hw_value = 112, .center_freq = 5560},
1922 { .hw_value = 116, .center_freq = 5580},
1923 { .hw_value = 120, .center_freq = 5600},
1924 { .hw_value = 124, .center_freq = 5620},
1925 { .hw_value = 128, .center_freq = 5640},
1926 { .hw_value = 132, .center_freq = 5660},
1927 { .hw_value = 136, .center_freq = 5680},
1928 { .hw_value = 140, .center_freq = 5700},
1929 { .hw_value = 149, .center_freq = 5745},
1930 { .hw_value = 153, .center_freq = 5765},
1931 { .hw_value = 157, .center_freq = 5785},
1932 { .hw_value = 161, .center_freq = 5805},
1933 { .hw_value = 165, .center_freq = 5825},
1937 static struct ieee80211_supported_band wl1271_band_5ghz = {
1938 .channels = wl1271_channels_5ghz,
1939 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1940 .bitrates = wl1271_rates_5ghz,
1941 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1944 static const struct ieee80211_ops wl1271_ops = {
1945 .start = wl1271_op_start,
1946 .stop = wl1271_op_stop,
1947 .add_interface = wl1271_op_add_interface,
1948 .remove_interface = wl1271_op_remove_interface,
1949 .config = wl1271_op_config,
1950 /* .config_interface = wl1271_op_config_interface, */
1951 .prepare_multicast = wl1271_op_prepare_multicast,
1952 .configure_filter = wl1271_op_configure_filter,
1954 .set_key = wl1271_op_set_key,
1955 .hw_scan = wl1271_op_hw_scan,
1956 .bss_info_changed = wl1271_op_bss_info_changed,
1957 .set_rts_threshold = wl1271_op_set_rts_threshold,
1958 .conf_tx = wl1271_op_conf_tx,
1959 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
1962 static int wl1271_register_hw(struct wl1271 *wl)
1966 if (wl->mac80211_registered)
1969 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1971 ret = ieee80211_register_hw(wl->hw);
1973 wl1271_error("unable to register mac80211 hw: %d", ret);
1977 wl->mac80211_registered = true;
1979 wl1271_notice("loaded");
1984 static int wl1271_init_ieee80211(struct wl1271 *wl)
1986 /* The tx descriptor buffer and the TKIP space. */
1987 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1988 sizeof(struct wl1271_tx_hw_descr);
1991 /* FIXME: find a proper value */
1992 wl->hw->channel_change_time = 10000;
1994 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1995 IEEE80211_HW_NOISE_DBM |
1996 IEEE80211_HW_BEACON_FILTER |
1997 IEEE80211_HW_SUPPORTS_PS;
1999 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2000 BIT(NL80211_IFTYPE_ADHOC);
2001 wl->hw->wiphy->max_scan_ssids = 1;
2002 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2004 if (wl1271_11a_enabled())
2005 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2007 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
2012 static void wl1271_device_release(struct device *dev)
2017 static struct platform_device wl1271_device = {
2021 /* device model insists to have a release function */
2023 .release = wl1271_device_release,
2027 #define WL1271_DEFAULT_CHANNEL 0
2029 static struct ieee80211_hw *wl1271_alloc_hw(void)
2031 struct ieee80211_hw *hw;
2035 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2037 wl1271_error("could not alloc ieee80211_hw");
2038 return ERR_PTR(-ENOMEM);
2042 memset(wl, 0, sizeof(*wl));
2044 INIT_LIST_HEAD(&wl->list);
2048 skb_queue_head_init(&wl->tx_queue);
2050 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2051 wl->channel = WL1271_DEFAULT_CHANNEL;
2052 wl->default_key = 0;
2054 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2055 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2056 wl->psm_entry_retry = 0;
2057 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2058 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2059 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2060 wl->sta_rate_set = 0;
2061 wl->band = IEEE80211_BAND_2GHZ;
2065 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2066 wl->tx_frames[i] = NULL;
2068 spin_lock_init(&wl->wl_lock);
2070 wl->state = WL1271_STATE_OFF;
2071 mutex_init(&wl->mutex);
2073 /* Apply default driver configuration. */
2074 wl1271_conf_init(wl);
2079 int wl1271_free_hw(struct wl1271 *wl)
2081 ieee80211_unregister_hw(wl->hw);
2083 wl1271_debugfs_exit(wl);
2085 kfree(wl->target_mem_map);
2091 kfree(wl->fw_status);
2092 kfree(wl->tx_res_if);
2094 ieee80211_free_hw(wl->hw);
2099 static int __devinit wl1271_probe(struct spi_device *spi)
2101 struct wl12xx_platform_data *pdata;
2102 struct ieee80211_hw *hw;
2106 pdata = spi->dev.platform_data;
2108 wl1271_error("no platform data");
2112 hw = wl1271_alloc_hw();
2118 dev_set_drvdata(&spi->dev, wl);
2121 /* This is the only SPI value that we need to set here, the rest
2122 * comes from the board-peripherals file */
2123 spi->bits_per_word = 32;
2125 ret = spi_setup(spi);
2127 wl1271_error("spi_setup failed");
2131 wl->set_power = pdata->set_power;
2132 if (!wl->set_power) {
2133 wl1271_error("set power function missing in platform data");
2140 wl1271_error("irq missing in platform data");
2145 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
2147 wl1271_error("request_irq() failed: %d", ret);
2151 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
2153 disable_irq(wl->irq);
2155 ret = platform_device_register(&wl1271_device);
2157 wl1271_error("couldn't register platform device");
2160 dev_set_drvdata(&wl1271_device.dev, wl);
2162 ret = wl1271_init_ieee80211(wl);
2166 ret = wl1271_register_hw(wl);
2170 wl1271_debugfs_init(wl);
2172 wl1271_notice("initialized");
2177 platform_device_unregister(&wl1271_device);
2180 free_irq(wl->irq, wl);
2183 ieee80211_free_hw(hw);
2188 static int __devexit wl1271_remove(struct spi_device *spi)
2190 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
2192 platform_device_unregister(&wl1271_device);
2193 free_irq(wl->irq, wl);
2201 static struct spi_driver wl1271_spi_driver = {
2204 .bus = &spi_bus_type,
2205 .owner = THIS_MODULE,
2208 .probe = wl1271_probe,
2209 .remove = __devexit_p(wl1271_remove),
2212 static int __init wl1271_init(void)
2216 ret = spi_register_driver(&wl1271_spi_driver);
2218 wl1271_error("failed to register spi driver: %d", ret);
2226 static void __exit wl1271_exit(void)
2228 spi_unregister_driver(&wl1271_spi_driver);
2230 wl1271_notice("unloaded");
2233 module_init(wl1271_init);
2234 module_exit(wl1271_exit);
2236 MODULE_LICENSE("GPL");
2237 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2238 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2239 MODULE_FIRMWARE(WL1271_FW_NAME);