2 * This file is part of wl1271
4 * Copyright (C) 2008-2009 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>
37 #include "wl12xx_80211.h"
38 #include "wl1271_reg.h"
39 #include "wl1271_spi.h"
40 #include "wl1271_event.h"
41 #include "wl1271_tx.h"
42 #include "wl1271_rx.h"
43 #include "wl1271_ps.h"
44 #include "wl1271_init.h"
45 #include "wl1271_debugfs.h"
46 #include "wl1271_cmd.h"
47 #include "wl1271_boot.h"
49 static int wl1271_plt_init(struct wl1271
*wl
)
53 ret
= wl1271_acx_init_mem_config(wl
);
57 ret
= wl1271_cmd_data_path(wl
, wl
->channel
, 1);
64 static void wl1271_disable_interrupts(struct wl1271
*wl
)
69 static void wl1271_power_off(struct wl1271
*wl
)
74 static void wl1271_power_on(struct wl1271
*wl
)
79 static void wl1271_fw_status(struct wl1271
*wl
,
80 struct wl1271_fw_status
*status
)
85 wl1271_spi_reg_read(wl
, FW_STATUS_ADDR
, status
,
86 sizeof(*status
), false);
88 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
89 "drv_rx_counter = %d, tx_results_counter = %d)",
91 status
->fw_rx_counter
,
92 status
->drv_rx_counter
,
93 status
->tx_results_counter
);
95 /* update number of available TX blocks */
96 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
97 u32 cnt
= status
->tx_released_blks
[i
] - wl
->tx_blocks_freed
[i
];
98 wl
->tx_blocks_freed
[i
] = status
->tx_released_blks
[i
];
99 wl
->tx_blocks_available
+= cnt
;
103 /* if more blocks are available now, schedule some tx work */
104 if (total
&& !skb_queue_empty(&wl
->tx_queue
))
105 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
107 /* update the host-chipset time offset */
108 wl
->time_offset
= jiffies_to_usecs(jiffies
) - status
->fw_localtime
;
111 static void wl1271_irq_work(struct work_struct
*work
)
116 container_of(work
, struct wl1271
, irq_work
);
118 mutex_lock(&wl
->mutex
);
120 wl1271_debug(DEBUG_IRQ
, "IRQ work");
122 if (wl
->state
== WL1271_STATE_OFF
)
125 ret
= wl1271_ps_elp_wakeup(wl
, true);
129 wl1271_reg_write32(wl
, ACX_REG_INTERRUPT_MASK
, WL1271_ACX_INTR_ALL
);
131 wl1271_fw_status(wl
, wl
->fw_status
);
132 intr
= wl
->fw_status
->intr
;
134 wl1271_debug(DEBUG_IRQ
, "Zero interrupt received.");
138 intr
&= WL1271_INTR_MASK
;
140 if (intr
& (WL1271_ACX_INTR_EVENT_A
|
141 WL1271_ACX_INTR_EVENT_B
)) {
142 wl1271_debug(DEBUG_IRQ
,
143 "WL1271_ACX_INTR_EVENT (0x%x)", intr
);
144 if (intr
& WL1271_ACX_INTR_EVENT_A
)
145 wl1271_event_handle(wl
, 0);
147 wl1271_event_handle(wl
, 1);
150 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
151 wl1271_debug(DEBUG_IRQ
,
152 "WL1271_ACX_INTR_INIT_COMPLETE");
154 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
155 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
157 if (intr
& WL1271_ACX_INTR_DATA
) {
158 u8 tx_res_cnt
= wl
->fw_status
->tx_results_counter
-
159 wl
->tx_results_count
;
161 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
163 /* check for tx results */
165 wl1271_tx_complete(wl
, tx_res_cnt
);
167 wl1271_rx(wl
, wl
->fw_status
);
171 wl1271_reg_write32(wl
, ACX_REG_INTERRUPT_MASK
,
172 WL1271_ACX_INTR_ALL
& ~(WL1271_INTR_MASK
));
173 wl1271_ps_elp_sleep(wl
);
176 mutex_unlock(&wl
->mutex
);
179 static irqreturn_t
wl1271_irq(int irq
, void *cookie
)
184 wl1271_debug(DEBUG_IRQ
, "IRQ");
188 /* complete the ELP completion */
189 spin_lock_irqsave(&wl
->wl_lock
, flags
);
191 complete(wl
->elp_compl
);
192 wl
->elp_compl
= NULL
;
195 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
196 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
201 static int wl1271_fetch_firmware(struct wl1271
*wl
)
203 const struct firmware
*fw
;
206 ret
= request_firmware(&fw
, WL1271_FW_NAME
, &wl
->spi
->dev
);
209 wl1271_error("could not get firmware: %d", ret
);
214 wl1271_error("firmware size is not multiple of 32 bits: %zu",
220 wl
->fw_len
= fw
->size
;
221 wl
->fw
= vmalloc(wl
->fw_len
);
224 wl1271_error("could not allocate memory for the firmware");
229 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
234 release_firmware(fw
);
239 static int wl1271_fetch_nvs(struct wl1271
*wl
)
241 const struct firmware
*fw
;
244 ret
= request_firmware(&fw
, WL1271_NVS_NAME
, &wl
->spi
->dev
);
247 wl1271_error("could not get nvs file: %d", ret
);
252 wl1271_error("nvs size is not multiple of 32 bits: %zu",
258 wl
->nvs_len
= fw
->size
;
259 wl
->nvs
= kmalloc(wl
->nvs_len
, GFP_KERNEL
);
262 wl1271_error("could not allocate memory for the nvs file");
267 memcpy(wl
->nvs
, fw
->data
, wl
->nvs_len
);
272 release_firmware(fw
);
277 static void wl1271_fw_wakeup(struct wl1271
*wl
)
281 elp_reg
= ELPCTRL_WAKE_UP
;
282 wl1271_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
285 static int wl1271_setup(struct wl1271
*wl
)
287 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
291 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
292 if (!wl
->tx_res_if
) {
293 kfree(wl
->fw_status
);
297 INIT_WORK(&wl
->irq_work
, wl1271_irq_work
);
298 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
302 static int wl1271_chip_wakeup(struct wl1271
*wl
)
304 struct wl1271_partition_set partition
;
308 msleep(WL1271_POWER_ON_SLEEP
);
309 wl1271_spi_reset(wl
);
312 /* We don't need a real memory partition here, because we only want
313 * to use the registers at this point. */
314 memset(&partition
, 0, sizeof(partition
));
315 partition
.reg
.start
= REGISTERS_BASE
;
316 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
317 wl1271_set_partition(wl
, &partition
);
319 /* ELP module wake up */
320 wl1271_fw_wakeup(wl
);
322 /* whal_FwCtrl_BootSm() */
324 /* 0. read chip id from CHIP_ID */
325 wl
->chip
.id
= wl1271_reg_read32(wl
, CHIP_ID_B
);
327 /* 1. check if chip id is valid */
329 switch (wl
->chip
.id
) {
330 case CHIP_ID_1271_PG10
:
331 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
334 ret
= wl1271_setup(wl
);
338 case CHIP_ID_1271_PG20
:
339 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
342 ret
= wl1271_setup(wl
);
347 wl1271_error("unsupported chip id: 0x%x", wl
->chip
.id
);
352 if (wl
->fw
== NULL
) {
353 ret
= wl1271_fetch_firmware(wl
);
358 /* No NVS from netlink, try to get it from the filesystem */
359 if (wl
->nvs
== NULL
) {
360 ret
= wl1271_fetch_nvs(wl
);
369 struct wl1271_filter_params
{
370 unsigned int filters
;
371 unsigned int changed
;
373 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
376 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
379 FIF_BCN_PRBRESP_PROMISC | \
383 static void wl1271_filter_work(struct work_struct
*work
)
386 container_of(work
, struct wl1271
, filter_work
);
387 struct wl1271_filter_params
*fp
;
392 /* first, get the filter parameters */
393 spin_lock_irqsave(&wl
->wl_lock
, flags
);
394 fp
= wl
->filter_params
;
395 wl
->filter_params
= NULL
;
396 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
401 /* then, lock the mutex without risk of lock-up */
402 mutex_lock(&wl
->mutex
);
404 if (wl
->state
== WL1271_STATE_OFF
)
407 ret
= wl1271_ps_elp_wakeup(wl
, false);
411 /* configure the mc filter regardless of the changed flags */
412 if (fp
->filters
& FIF_ALLMULTI
)
415 ret
= wl1271_acx_group_address_tbl(wl
, enabled
,
416 fp
->mc_list
, fp
->mc_list_length
);
420 /* determine, whether supported filter values have changed */
421 if (fp
->changed
== 0)
424 /* apply configured filters */
425 ret
= wl1271_cmd_join(wl
);
430 wl1271_ps_elp_sleep(wl
);
433 mutex_unlock(&wl
->mutex
);
437 int wl1271_plt_start(struct wl1271
*wl
)
441 mutex_lock(&wl
->mutex
);
443 wl1271_notice("power up");
445 if (wl
->state
!= WL1271_STATE_OFF
) {
446 wl1271_error("cannot go into PLT state because not "
447 "in off state: %d", wl
->state
);
452 wl
->state
= WL1271_STATE_PLT
;
454 ret
= wl1271_chip_wakeup(wl
);
458 ret
= wl1271_boot(wl
);
462 wl1271_notice("firmware booted in PLT mode (%s)", wl
->chip
.fw_ver
);
464 ret
= wl1271_plt_init(wl
);
469 mutex_unlock(&wl
->mutex
);
474 int wl1271_plt_stop(struct wl1271
*wl
)
478 mutex_lock(&wl
->mutex
);
480 wl1271_notice("power down");
482 if (wl
->state
!= WL1271_STATE_PLT
) {
483 wl1271_error("cannot power down because not in PLT "
484 "state: %d", wl
->state
);
489 wl1271_disable_interrupts(wl
);
490 wl1271_power_off(wl
);
492 wl
->state
= WL1271_STATE_OFF
;
495 mutex_unlock(&wl
->mutex
);
501 static int wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
503 struct wl1271
*wl
= hw
->priv
;
505 skb_queue_tail(&wl
->tx_queue
, skb
);
508 * The chip specific setup must run before the first TX packet -
509 * before that, the tx_work will not be initialized!
512 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
515 * The workqueue is slow to process the tx_queue and we need stop
516 * the queue here, otherwise the queue will get too long.
518 if (skb_queue_len(&wl
->tx_queue
) >= WL1271_TX_QUEUE_MAX_LENGTH
) {
519 ieee80211_stop_queues(wl
->hw
);
522 * FIXME: this is racy, the variable is not properly
523 * protected. Maybe fix this by removing the stupid
524 * variable altogether and checking the real queue state?
526 wl
->tx_queue_stopped
= true;
532 static int wl1271_op_start(struct ieee80211_hw
*hw
)
534 struct wl1271
*wl
= hw
->priv
;
537 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
539 mutex_lock(&wl
->mutex
);
541 if (wl
->state
!= WL1271_STATE_OFF
) {
542 wl1271_error("cannot start because not in off state: %d",
548 ret
= wl1271_chip_wakeup(wl
);
552 ret
= wl1271_boot(wl
);
556 ret
= wl1271_hw_init(wl
);
560 wl
->state
= WL1271_STATE_ON
;
562 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver
);
566 wl1271_power_off(wl
);
568 mutex_unlock(&wl
->mutex
);
573 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
575 struct wl1271
*wl
= hw
->priv
;
581 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
583 /* complete/cancel ongoing work */
584 cancel_work_sync(&wl
->filter_work
);
585 spin_lock_irqsave(&wl
->wl_lock
, flags
);
586 kfree(wl
->filter_params
);
587 wl
->filter_params
= NULL
;
588 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
590 mutex_lock(&wl
->mutex
);
592 WARN_ON(wl
->state
!= WL1271_STATE_ON
);
595 mutex_unlock(&wl
->mutex
);
596 ieee80211_scan_completed(wl
->hw
, true);
597 mutex_lock(&wl
->mutex
);
598 wl
->scanning
= false;
601 wl
->state
= WL1271_STATE_OFF
;
603 wl1271_disable_interrupts(wl
);
605 mutex_unlock(&wl
->mutex
);
607 cancel_work_sync(&wl
->irq_work
);
608 cancel_work_sync(&wl
->tx_work
);
609 cancel_work_sync(&wl
->filter_work
);
611 mutex_lock(&wl
->mutex
);
613 /* let's notify MAC80211 about the remaining pending TX frames */
615 wl1271_power_off(wl
);
617 memset(wl
->bssid
, 0, ETH_ALEN
);
618 memset(wl
->ssid
, 0, IW_ESSID_MAX_SIZE
+ 1);
621 wl
->bss_type
= MAX_BSS_TYPE
;
622 wl
->band
= IEEE80211_BAND_2GHZ
;
627 wl
->tx_queue_stopped
= false;
628 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
629 wl
->tx_blocks_available
= 0;
630 wl
->tx_results_count
= 0;
631 wl
->tx_packets_count
= 0;
632 wl
->tx_security_last_seq
= 0;
633 wl
->tx_security_seq_16
= 0;
634 wl
->tx_security_seq_32
= 0;
636 wl
->session_counter
= 0;
639 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
640 wl
->tx_blocks_freed
[i
] = 0;
642 wl1271_debugfs_reset(wl
);
643 mutex_unlock(&wl
->mutex
);
646 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
647 struct ieee80211_if_init_conf
*conf
)
649 struct wl1271
*wl
= hw
->priv
;
652 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
653 conf
->type
, conf
->mac_addr
);
655 mutex_lock(&wl
->mutex
);
663 switch (conf
->type
) {
664 case NL80211_IFTYPE_STATION
:
665 wl
->bss_type
= BSS_TYPE_STA_BSS
;
667 case NL80211_IFTYPE_ADHOC
:
668 wl
->bss_type
= BSS_TYPE_IBSS
;
675 /* FIXME: what if conf->mac_addr changes? */
678 mutex_unlock(&wl
->mutex
);
682 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
683 struct ieee80211_if_init_conf
*conf
)
685 struct wl1271
*wl
= hw
->priv
;
687 mutex_lock(&wl
->mutex
);
688 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
690 mutex_unlock(&wl
->mutex
);
694 static int wl1271_op_config_interface(struct ieee80211_hw
*hw
,
695 struct ieee80211_vif
*vif
,
696 struct ieee80211_if_conf
*conf
)
698 struct wl1271
*wl
= hw
->priv
;
699 struct sk_buff
*beacon
;
702 wl1271_debug(DEBUG_MAC80211
, "mac80211 config_interface bssid %pM",
704 wl1271_dump_ascii(DEBUG_MAC80211
, "ssid: ", conf
->ssid
,
707 mutex_lock(&wl
->mutex
);
709 ret
= wl1271_ps_elp_wakeup(wl
, false);
713 memcpy(wl
->bssid
, conf
->bssid
, ETH_ALEN
);
715 ret
= wl1271_cmd_build_null_data(wl
);
719 wl
->ssid_len
= conf
->ssid_len
;
721 memcpy(wl
->ssid
, conf
->ssid
, wl
->ssid_len
);
723 if (wl
->bss_type
!= BSS_TYPE_IBSS
) {
724 ret
= wl1271_cmd_join(wl
);
729 if (conf
->changed
& IEEE80211_IFCC_BEACON
) {
730 beacon
= ieee80211_beacon_get(hw
, vif
);
731 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_BEACON
,
732 beacon
->data
, beacon
->len
);
735 dev_kfree_skb(beacon
);
739 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_PROBE_RESPONSE
,
740 beacon
->data
, beacon
->len
);
742 dev_kfree_skb(beacon
);
747 ret
= wl1271_cmd_join(wl
);
754 wl1271_ps_elp_sleep(wl
);
757 mutex_unlock(&wl
->mutex
);
763 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
765 struct wl1271
*wl
= hw
->priv
;
766 struct ieee80211_conf
*conf
= &hw
->conf
;
767 int channel
, ret
= 0;
769 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
771 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d",
773 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
776 mutex_lock(&wl
->mutex
);
778 wl
->band
= conf
->channel
->band
;
780 ret
= wl1271_ps_elp_wakeup(wl
, false);
784 if (channel
!= wl
->channel
) {
785 u8 old_channel
= wl
->channel
;
786 wl
->channel
= channel
;
788 ret
= wl1271_cmd_join(wl
);
790 wl
->channel
= old_channel
;
795 ret
= wl1271_cmd_build_null_data(wl
);
799 if (conf
->flags
& IEEE80211_CONF_PS
&& !wl
->psm_requested
) {
800 wl1271_info("psm enabled");
802 wl
->psm_requested
= true;
805 * We enter PSM only if we're already associated.
806 * If we're not, we'll enter it when joining an SSID,
807 * through the bss_info_changed() hook.
809 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
);
810 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
812 wl1271_info("psm disabled");
814 wl
->psm_requested
= false;
817 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
);
820 if (conf
->power_level
!= wl
->power_level
) {
821 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
825 wl
->power_level
= conf
->power_level
;
829 wl1271_ps_elp_sleep(wl
);
832 mutex_unlock(&wl
->mutex
);
837 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
, int mc_count
,
838 struct dev_addr_list
*mc_list
)
840 struct wl1271
*wl
= hw
->priv
;
841 struct wl1271_filter_params
*fp
;
846 * FIXME: we should return a hash that will be passed to
847 * configure_filter() instead of saving everything in the context.
850 fp
= kzalloc(sizeof(*fp
), GFP_KERNEL
);
852 wl1271_error("Out of memory setting filters.");
856 /* update multicast filtering parameters */
857 if (mc_count
> ACX_MC_ADDRESS_GROUP_MAX
) {
859 fp
->filters
|= FIF_ALLMULTI
;
862 fp
->mc_list_length
= 0;
863 for (i
= 0; i
< mc_count
; i
++) {
864 if (mc_list
->da_addrlen
== ETH_ALEN
) {
865 memcpy(fp
->mc_list
[fp
->mc_list_length
],
866 mc_list
->da_addr
, ETH_ALEN
);
867 fp
->mc_list_length
++;
869 wl1271_warning("Unknown mc address length.");
872 spin_lock_irqsave(&wl
->wl_lock
, flags
);
873 kfree(wl
->filter_params
);
874 wl
->filter_params
= fp
;
875 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
880 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
881 unsigned int changed
,
882 unsigned int *total
, u64 multicast
)
884 struct wl1271
*wl
= hw
->priv
;
886 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter");
888 *total
&= WL1271_SUPPORTED_FILTERS
;
889 changed
&= WL1271_SUPPORTED_FILTERS
;
895 * FIXME: for now we are still using a workqueue for filter
896 * configuration, but with the new mac80211, this is not needed,
897 * since configure_filter can now sleep. We now have
898 * prepare_multicast, which needs to be atomic instead.
901 /* store current filter config */
902 wl
->filter_params
->filters
= *total
;
903 wl
->filter_params
->changed
= changed
;
905 ieee80211_queue_work(wl
->hw
, &wl
->filter_work
);
908 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
909 struct ieee80211_vif
*vif
,
910 struct ieee80211_sta
*sta
,
911 struct ieee80211_key_conf
*key_conf
)
913 struct wl1271
*wl
= hw
->priv
;
920 static const u8 bcast_addr
[ETH_ALEN
] =
921 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
923 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
925 addr
= sta
? sta
->addr
: bcast_addr
;
927 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x", cmd
);
928 wl1271_dump(DEBUG_CRYPT
, "ADDR: ", addr
, ETH_ALEN
);
929 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
930 key_conf
->alg
, key_conf
->keyidx
,
931 key_conf
->keylen
, key_conf
->flags
);
932 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
934 if (is_zero_ether_addr(addr
)) {
935 /* We dont support TX only encryption */
940 mutex_lock(&wl
->mutex
);
942 ret
= wl1271_ps_elp_wakeup(wl
, false);
946 switch (key_conf
->alg
) {
950 key_conf
->hw_key_idx
= key_conf
->keyidx
;
955 key_conf
->hw_key_idx
= key_conf
->keyidx
;
956 tx_seq_32
= wl
->tx_security_seq_32
;
957 tx_seq_16
= wl
->tx_security_seq_16
;
962 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
963 tx_seq_32
= wl
->tx_security_seq_32
;
964 tx_seq_16
= wl
->tx_security_seq_16
;
967 wl1271_error("Unknown key algo 0x%x", key_conf
->alg
);
975 ret
= wl1271_cmd_set_key(wl
, KEY_ADD_OR_REPLACE
,
976 key_conf
->keyidx
, key_type
,
977 key_conf
->keylen
, key_conf
->key
,
978 addr
, tx_seq_32
, tx_seq_16
);
980 wl1271_error("Could not add or replace key");
986 ret
= wl1271_cmd_set_key(wl
, KEY_REMOVE
,
987 key_conf
->keyidx
, key_type
,
988 key_conf
->keylen
, key_conf
->key
,
991 wl1271_error("Could not remove key");
997 wl1271_error("Unsupported key cmd 0x%x", cmd
);
1005 wl1271_ps_elp_sleep(wl
);
1008 mutex_unlock(&wl
->mutex
);
1014 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
1015 struct cfg80211_scan_request
*req
)
1017 struct wl1271
*wl
= hw
->priv
;
1020 size_t ssid_len
= 0;
1022 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
1025 ssid
= req
->ssids
[0].ssid
;
1026 ssid_len
= req
->ssids
[0].ssid_len
;
1029 mutex_lock(&wl
->mutex
);
1031 ret
= wl1271_ps_elp_wakeup(wl
, false);
1035 ret
= wl1271_cmd_scan(hw
->priv
, ssid
, ssid_len
, 1, 0, 13, 3);
1037 wl1271_ps_elp_sleep(wl
);
1040 mutex_unlock(&wl
->mutex
);
1045 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
1047 struct wl1271
*wl
= hw
->priv
;
1050 mutex_lock(&wl
->mutex
);
1052 ret
= wl1271_ps_elp_wakeup(wl
, false);
1056 ret
= wl1271_acx_rts_threshold(wl
, (u16
) value
);
1058 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
1060 wl1271_ps_elp_sleep(wl
);
1063 mutex_unlock(&wl
->mutex
);
1068 static u32
wl1271_enabled_rates_get(struct wl1271
*wl
, u64 basic_rate_set
)
1070 struct ieee80211_supported_band
*band
;
1071 u32 enabled_rates
= 0;
1074 band
= wl
->hw
->wiphy
->bands
[wl
->band
];
1075 for (bit
= 0; bit
< band
->n_bitrates
; bit
++) {
1076 if (basic_rate_set
& 0x1)
1077 enabled_rates
|= band
->bitrates
[bit
].hw_value
;
1078 basic_rate_set
>>= 1;
1081 return enabled_rates
;
1084 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
1085 struct ieee80211_vif
*vif
,
1086 struct ieee80211_bss_conf
*bss_conf
,
1089 enum wl1271_cmd_ps_mode mode
;
1090 struct wl1271
*wl
= hw
->priv
;
1093 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed");
1095 mutex_lock(&wl
->mutex
);
1097 ret
= wl1271_ps_elp_wakeup(wl
, false);
1101 if (changed
& BSS_CHANGED_ASSOC
) {
1102 if (bss_conf
->assoc
) {
1103 wl
->beacon_int
= bss_conf
->beacon_int
;
1104 wl
->dtim_period
= bss_conf
->dtim_period
;
1105 wl
->aid
= bss_conf
->aid
;
1107 ret
= wl1271_cmd_join(wl
);
1109 wl1271_warning("Association configuration "
1114 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
1118 ret
= wl1271_acx_aid(wl
, wl
->aid
);
1122 /* If we want to go in PSM but we're not there yet */
1123 if (wl
->psm_requested
&& !wl
->psm
) {
1124 mode
= STATION_POWER_SAVE_MODE
;
1125 ret
= wl1271_ps_set_mode(wl
, mode
);
1130 /* use defaults when not associated */
1131 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
1132 wl
->dtim_period
= WL1271_DEFAULT_DTIM_PERIOD
;
1133 wl
->basic_rate_set
= WL1271_DEFAULT_BASIC_RATE_SET
;
1139 if (changed
& BSS_CHANGED_ERP_SLOT
) {
1140 if (bss_conf
->use_short_slot
)
1141 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
1143 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
1145 wl1271_warning("Set slot time failed %d", ret
);
1150 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
1151 if (bss_conf
->use_short_preamble
)
1152 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
1154 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
1157 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
1158 if (bss_conf
->use_cts_prot
)
1159 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
1161 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
1163 wl1271_warning("Set ctsprotect failed %d", ret
);
1168 if (changed
& BSS_CHANGED_BASIC_RATES
) {
1169 wl
->basic_rate_set
= wl1271_enabled_rates_get(
1170 wl
, bss_conf
->basic_rates
);
1171 ret
= wl1271_acx_rate_policies(wl
, wl
->basic_rate_set
);
1174 wl1271_warning("Set rate policies failed %d", ret
);
1177 ret
= wl1271_cmd_join(wl
);
1179 wl1271_warning("Join with new basic rate "
1180 "set failed %d", ret
);
1186 wl1271_ps_elp_sleep(wl
);
1189 mutex_unlock(&wl
->mutex
);
1193 /* can't be const, mac80211 writes to this */
1194 static struct ieee80211_rate wl1271_rates
[] = {
1197 .hw_value_short
= 0x1, },
1200 .hw_value_short
= 0x2,
1201 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
1204 .hw_value_short
= 0x4,
1205 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
1208 .hw_value_short
= 0x20,
1209 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
1212 .hw_value_short
= 0x8, },
1215 .hw_value_short
= 0x10, },
1218 .hw_value_short
= 0x40, },
1221 .hw_value_short
= 0x80, },
1224 .hw_value_short
= 0x200, },
1227 .hw_value_short
= 0x400, },
1230 .hw_value_short
= 0x800, },
1233 .hw_value_short
= 0x1000, },
1236 /* can't be const, mac80211 writes to this */
1237 static struct ieee80211_channel wl1271_channels
[] = {
1238 { .hw_value
= 1, .center_freq
= 2412},
1239 { .hw_value
= 2, .center_freq
= 2417},
1240 { .hw_value
= 3, .center_freq
= 2422},
1241 { .hw_value
= 4, .center_freq
= 2427},
1242 { .hw_value
= 5, .center_freq
= 2432},
1243 { .hw_value
= 6, .center_freq
= 2437},
1244 { .hw_value
= 7, .center_freq
= 2442},
1245 { .hw_value
= 8, .center_freq
= 2447},
1246 { .hw_value
= 9, .center_freq
= 2452},
1247 { .hw_value
= 10, .center_freq
= 2457},
1248 { .hw_value
= 11, .center_freq
= 2462},
1249 { .hw_value
= 12, .center_freq
= 2467},
1250 { .hw_value
= 13, .center_freq
= 2472},
1253 /* can't be const, mac80211 writes to this */
1254 static struct ieee80211_supported_band wl1271_band_2ghz
= {
1255 .channels
= wl1271_channels
,
1256 .n_channels
= ARRAY_SIZE(wl1271_channels
),
1257 .bitrates
= wl1271_rates
,
1258 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
1261 static const struct ieee80211_ops wl1271_ops
= {
1262 .start
= wl1271_op_start
,
1263 .stop
= wl1271_op_stop
,
1264 .add_interface
= wl1271_op_add_interface
,
1265 .remove_interface
= wl1271_op_remove_interface
,
1266 .config
= wl1271_op_config
,
1267 /* .config_interface = wl1271_op_config_interface, */
1268 .prepare_multicast
= wl1271_op_prepare_multicast
,
1269 .configure_filter
= wl1271_op_configure_filter
,
1271 .set_key
= wl1271_op_set_key
,
1272 .hw_scan
= wl1271_op_hw_scan
,
1273 .bss_info_changed
= wl1271_op_bss_info_changed
,
1274 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
1277 static int wl1271_register_hw(struct wl1271
*wl
)
1281 if (wl
->mac80211_registered
)
1284 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
1286 ret
= ieee80211_register_hw(wl
->hw
);
1288 wl1271_error("unable to register mac80211 hw: %d", ret
);
1292 wl
->mac80211_registered
= true;
1294 wl1271_notice("loaded");
1299 static int wl1271_init_ieee80211(struct wl1271
*wl
)
1301 /* The tx descriptor buffer and the TKIP space. */
1302 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
1303 sizeof(struct wl1271_tx_hw_descr
);
1306 /* FIXME: find a proper value */
1307 wl
->hw
->channel_change_time
= 10000;
1309 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
1310 IEEE80211_HW_NOISE_DBM
|
1311 IEEE80211_HW_BEACON_FILTER
;
1313 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
);
1314 wl
->hw
->wiphy
->max_scan_ssids
= 1;
1315 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &wl1271_band_2ghz
;
1317 SET_IEEE80211_DEV(wl
->hw
, &wl
->spi
->dev
);
1322 static void wl1271_device_release(struct device
*dev
)
1327 static struct platform_device wl1271_device
= {
1331 /* device model insists to have a release function */
1333 .release
= wl1271_device_release
,
1337 #define WL1271_DEFAULT_CHANNEL 0
1338 static int __devinit
wl1271_probe(struct spi_device
*spi
)
1340 struct wl12xx_platform_data
*pdata
;
1341 struct ieee80211_hw
*hw
;
1344 static const u8 nokia_oui
[3] = {0x00, 0x1f, 0xdf};
1346 pdata
= spi
->dev
.platform_data
;
1348 wl1271_error("no platform data");
1352 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
1354 wl1271_error("could not alloc ieee80211_hw");
1359 memset(wl
, 0, sizeof(*wl
));
1362 dev_set_drvdata(&spi
->dev
, wl
);
1365 skb_queue_head_init(&wl
->tx_queue
);
1367 INIT_WORK(&wl
->filter_work
, wl1271_filter_work
);
1368 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
1369 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
1370 wl
->scanning
= false;
1371 wl
->default_key
= 0;
1374 wl
->rx_config
= WL1271_DEFAULT_RX_CONFIG
;
1375 wl
->rx_filter
= WL1271_DEFAULT_RX_FILTER
;
1378 wl
->psm_requested
= false;
1379 wl
->tx_queue_stopped
= false;
1380 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1381 wl
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
1382 wl
->dtim_period
= WL1271_DEFAULT_DTIM_PERIOD
;
1383 wl
->basic_rate_set
= WL1271_DEFAULT_BASIC_RATE_SET
;
1384 wl
->band
= IEEE80211_BAND_2GHZ
;
1388 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
1389 wl
->tx_frames
[i
] = NULL
;
1391 spin_lock_init(&wl
->wl_lock
);
1394 * In case our MAC address is not correctly set,
1395 * we use a random but Nokia MAC.
1397 memcpy(wl
->mac_addr
, nokia_oui
, 3);
1398 get_random_bytes(wl
->mac_addr
+ 3, 3);
1400 wl
->state
= WL1271_STATE_OFF
;
1401 mutex_init(&wl
->mutex
);
1403 wl
->rx_descriptor
= kmalloc(sizeof(*wl
->rx_descriptor
), GFP_KERNEL
);
1404 if (!wl
->rx_descriptor
) {
1405 wl1271_error("could not allocate memory for rx descriptor");
1410 /* This is the only SPI value that we need to set here, the rest
1411 * comes from the board-peripherals file */
1412 spi
->bits_per_word
= 32;
1414 ret
= spi_setup(spi
);
1416 wl1271_error("spi_setup failed");
1420 wl
->set_power
= pdata
->set_power
;
1421 if (!wl
->set_power
) {
1422 wl1271_error("set power function missing in platform data");
1429 wl1271_error("irq missing in platform data");
1434 ret
= request_irq(wl
->irq
, wl1271_irq
, 0, DRIVER_NAME
, wl
);
1436 wl1271_error("request_irq() failed: %d", ret
);
1440 set_irq_type(wl
->irq
, IRQ_TYPE_EDGE_RISING
);
1442 disable_irq(wl
->irq
);
1444 ret
= platform_device_register(&wl1271_device
);
1446 wl1271_error("couldn't register platform device");
1449 dev_set_drvdata(&wl1271_device
.dev
, wl
);
1451 ret
= wl1271_init_ieee80211(wl
);
1455 ret
= wl1271_register_hw(wl
);
1459 wl1271_debugfs_init(wl
);
1461 wl1271_notice("initialized");
1466 platform_device_unregister(&wl1271_device
);
1469 free_irq(wl
->irq
, wl
);
1472 kfree(wl
->rx_descriptor
);
1473 wl
->rx_descriptor
= NULL
;
1475 ieee80211_free_hw(hw
);
1480 static int __devexit
wl1271_remove(struct spi_device
*spi
)
1482 struct wl1271
*wl
= dev_get_drvdata(&spi
->dev
);
1484 ieee80211_unregister_hw(wl
->hw
);
1486 wl1271_debugfs_exit(wl
);
1487 platform_device_unregister(&wl1271_device
);
1488 free_irq(wl
->irq
, wl
);
1489 kfree(wl
->target_mem_map
);
1495 kfree(wl
->rx_descriptor
);
1496 wl
->rx_descriptor
= NULL
;
1498 kfree(wl
->fw_status
);
1499 kfree(wl
->tx_res_if
);
1501 ieee80211_free_hw(wl
->hw
);
1507 static struct spi_driver wl1271_spi_driver
= {
1510 .bus
= &spi_bus_type
,
1511 .owner
= THIS_MODULE
,
1514 .probe
= wl1271_probe
,
1515 .remove
= __devexit_p(wl1271_remove
),
1518 static int __init
wl1271_init(void)
1522 ret
= spi_register_driver(&wl1271_spi_driver
);
1524 wl1271_error("failed to register spi driver: %d", ret
);
1532 static void __exit
wl1271_exit(void)
1534 spi_unregister_driver(&wl1271_spi_driver
);
1536 wl1271_notice("unloaded");
1539 module_init(wl1271_init
);
1540 module_exit(wl1271_exit
);
1542 MODULE_LICENSE("GPL");
1543 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
1544 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");