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>
35 #include <linux/inetdevice.h>
38 #include "wl12xx_80211.h"
39 #include "wl1271_reg.h"
40 #include "wl1271_spi.h"
41 #include "wl1271_event.h"
42 #include "wl1271_tx.h"
43 #include "wl1271_rx.h"
44 #include "wl1271_ps.h"
45 #include "wl1271_init.h"
46 #include "wl1271_debugfs.h"
47 #include "wl1271_cmd.h"
48 #include "wl1271_boot.h"
50 #define WL1271_BOOT_RETRIES 3
52 static struct conf_drv_settings default_conf
= {
54 .per_threshold
= 7500,
55 .max_scan_compensation_time
= 120000,
56 .nfs_sample_interval
= 400,
59 .probe_req_compensation
= 170,
60 .scan_window_compensation
= 50,
62 .beacon_miss_threshold
= 60,
63 .rate_adaptation_threshold
= CONF_HW_BIT_RATE_12MBPS
,
64 .rate_adaptation_snr
= 0
67 .rx_msdu_life_time
= 512000,
68 .packet_detection_threshold
= 0,
69 .ps_poll_timeout
= 15,
71 .rts_threshold
= 2347,
72 .rx_cca_threshold
= 0,
73 .irq_blk_threshold
= 0xFFFF,
74 .irq_pkt_threshold
= 0,
76 .queue_type
= CONF_RX_QUEUE_TYPE_LOW_PRIORITY
,
79 .tx_energy_detection
= 0,
81 .enabled_rates
= CONF_HW_BIT_RATE_1MBPS
|
82 CONF_HW_BIT_RATE_2MBPS
,
83 .short_retry_limit
= 10,
84 .long_retry_limit
= 10,
107 .aifsn
= CONF_TX_AIFS_PIFS
,
114 .aifsn
= CONF_TX_AIFS_PIFS
,
122 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
123 .tsid
= CONF_TX_AC_BE
,
124 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
125 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
130 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
131 .tsid
= CONF_TX_AC_BE
,
132 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
133 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
138 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
139 .tsid
= CONF_TX_AC_BE
,
140 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
141 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
146 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
147 .tsid
= CONF_TX_AC_BE
,
148 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
149 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
154 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
155 .tsid
= CONF_TX_AC_BE
,
156 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
157 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
162 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
163 .tsid
= CONF_TX_AC_BE
,
164 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
165 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
170 .channel_type
= CONF_CHANNEL_TYPE_DCF
,
171 .tsid
= CONF_TX_AC_BE
,
172 .ps_scheme
= CONF_PS_SCHEME_LEGACY
,
173 .ack_policy
= CONF_ACK_POLICY_LEGACY
,
177 .frag_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
,
178 .tx_compl_timeout
= 700,
179 .tx_compl_threshold
= 4
182 .wake_up_event
= CONF_WAKE_UP_EVENT_DTIM
,
183 .listen_interval
= 0,
184 .bcn_filt_mode
= CONF_BCN_FILT_MODE_ENABLED
,
185 .bcn_filt_ie_count
= 1,
188 .ie
= WLAN_EID_CHANNEL_SWITCH
,
189 .rule
= CONF_BCN_RULE_PASS_ON_APPEARANCE
,
192 .synch_fail_thold
= 10,
193 .bss_lose_timeout
= 100,
194 .beacon_rx_timeout
= 10000,
195 .broadcast_timeout
= 20000,
196 .rx_broadcast_in_ps
= 1,
197 .ps_poll_threshold
= 20,
198 .sig_trigger_count
= 2,
203 .metric
= CONF_TRIG_METRIC_RSSI_BEACON
,
204 .type
= CONF_TRIG_EVENT_TYPE_EDGE
,
205 .direction
= CONF_TRIG_EVENT_DIR_LOW
,
213 .metric
= CONF_TRIG_METRIC_RSSI_BEACON
,
214 .type
= CONF_TRIG_EVENT_TYPE_EDGE
,
215 .direction
= CONF_TRIG_EVENT_DIR_HIGH
,
222 .rssi_bcn_avg_weight
= 10,
223 .rssi_pkt_avg_weight
= 10,
224 .snr_bcn_avg_weight
= 10,
225 .snr_pkt_avg_weight
= 10
227 .bet_enable
= CONF_BET_MODE_ENABLE
,
228 .bet_max_consecutive
= 10,
229 .psm_entry_retries
= 3
233 .ref_clk
= CONF_REF_CLK_38_4_E
,
235 .clk_valid_on_wakeup
= 0,
237 .single_dual_band
= CONF_SINGLE_BAND
,
238 .tx_bip_fem_autodetect
= 1,
239 .tx_bip_fem_manufacturer
= 1,
242 .srf1
= { 0x07, 0x03, 0x18, 0x10, 0x05, 0xfb, 0xf0,
243 0xe8, 0, 0, 0, 0, 0, 0, 0, 0 },
244 .srf2
= { 0x07, 0x03, 0x18, 0x10, 0x05, 0xfb, 0xf0,
245 0xe8, 0, 0, 0, 0, 0, 0, 0, 0 },
246 .srf3
= { 0x07, 0x03, 0x18, 0x10, 0x05, 0xfb, 0xf0,
247 0xe8, 0, 0, 0, 0, 0, 0, 0, 0 },
248 .sr_debug_table
= { 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0 },
251 .sr_sen_n_p_gain
= 0,
256 .rx_trace_loss
= 0x24,
257 .tx_trace_loss
= 0x0,
258 .rx_rssi_and_proc_compens
= {
259 0xec, 0xf6, 0x00, 0x0c, 0x18, 0xf8,
260 0xfc, 0x00, 0x80, 0x10, 0xf0, 0xf8,
262 .rx_trace_loss_5
= { 0, 0, 0, 0, 0, 0, 0 },
263 .tx_trace_loss_5
= { 0, 0, 0, 0, 0, 0, 0 },
264 .rx_rssi_and_proc_compens_5
= {
265 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
266 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
268 .tx_ref_pd_voltage
= 0x1a9,
269 .tx_ref_power
= 0x80,
271 .tx_rate_limits_normal
= {
272 0x1d, 0x1f, 0x24, 0x28, 0x28, 0x29 },
273 .tx_rate_limits_degraded
= {
274 0x19, 0x1f, 0x22, 0x23, 0x27, 0x28 },
275 .tx_rate_limits_extreme
= {
276 0x19, 0x1c, 0x1e, 0x20, 0x24, 0x25 },
277 .tx_channel_limits_11b
= {
278 0x22, 0x50, 0x50, 0x50, 0x50, 0x50,
279 0x50, 0x50, 0x50, 0x50, 0x22, 0x50,
281 .tx_channel_limits_ofdm
= {
282 0x20, 0x50, 0x50, 0x50, 0x50, 0x50,
283 0x50, 0x50, 0x50, 0x50, 0x20, 0x50,
285 .tx_pdv_rate_offsets
= {
286 0x07, 0x08, 0x04, 0x02, 0x02, 0x00 },
288 0x11, 0x11, 0x15, 0x11, 0x15, 0x0f },
289 .rx_fem_insertion_loss
= 0x0e,
290 .degraded_low_to_normal_threshold
= 0x1e,
291 .degraded_normal_to_high_threshold
= 0x2d,
292 .tx_ref_pd_voltage_5
= {
293 0x0190, 0x01a4, 0x01c3, 0x01d8,
296 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },
298 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
299 .tx_rate_limits_normal_5
= {
300 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
301 .tx_rate_limits_degraded_5
= {
302 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
303 .tx_rate_limits_extreme_5
= {
304 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
305 .tx_channel_limits_ofdm_5
= {
306 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
307 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
308 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
309 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
311 .tx_pdv_rate_offsets_5
= {
312 0x01, 0x02, 0x02, 0x02, 0x02, 0x00 },
314 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 },
315 .rx_fem_insertion_loss_5
= {
316 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 },
317 .degraded_low_to_normal_threshold_5
= 0x00,
318 .degraded_normal_to_high_threshold_5
= 0x00
326 .host_clk_settling_time
= 5000,
327 .host_fast_wakeup_support
= false
331 static LIST_HEAD(wl_list
);
333 static void wl1271_conf_init(struct wl1271
*wl
)
337 * This function applies the default configuration to the driver. This
338 * function is invoked upon driver load (spi probe.)
340 * The configuration is stored in a run-time structure in order to
341 * facilitate for run-time adjustment of any of the parameters. Making
342 * changes to the configuration structure will apply the new values on
343 * the next interface up (wl1271_op_start.)
346 /* apply driver default configuration */
347 memcpy(&wl
->conf
, &default_conf
, sizeof(default_conf
));
349 if (wl1271_11a_enabled())
350 wl
->conf
.init
.genparam
.single_dual_band
= CONF_DUAL_BAND
;
354 static int wl1271_plt_init(struct wl1271
*wl
)
358 ret
= wl1271_cmd_general_parms(wl
);
362 ret
= wl1271_cmd_radio_parms(wl
);
366 ret
= wl1271_acx_init_mem_config(wl
);
370 ret
= wl1271_cmd_data_path(wl
, 1);
377 static void wl1271_disable_interrupts(struct wl1271
*wl
)
379 disable_irq(wl
->irq
);
382 static void wl1271_power_off(struct wl1271
*wl
)
384 wl
->set_power(false);
385 clear_bit(WL1271_FLAG_GPIO_POWER
, &wl
->flags
);
388 static void wl1271_power_on(struct wl1271
*wl
)
391 set_bit(WL1271_FLAG_GPIO_POWER
, &wl
->flags
);
394 static void wl1271_fw_status(struct wl1271
*wl
,
395 struct wl1271_fw_status
*status
)
400 wl1271_spi_read(wl
, FW_STATUS_ADDR
, status
,
401 sizeof(*status
), false);
403 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
404 "drv_rx_counter = %d, tx_results_counter = %d)",
406 status
->fw_rx_counter
,
407 status
->drv_rx_counter
,
408 status
->tx_results_counter
);
410 /* update number of available TX blocks */
411 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
412 u32 cnt
= le32_to_cpu(status
->tx_released_blks
[i
]) -
413 wl
->tx_blocks_freed
[i
];
415 wl
->tx_blocks_freed
[i
] =
416 le32_to_cpu(status
->tx_released_blks
[i
]);
417 wl
->tx_blocks_available
+= cnt
;
421 /* if more blocks are available now, schedule some tx work */
422 if (total
&& !skb_queue_empty(&wl
->tx_queue
))
423 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
425 /* update the host-chipset time offset */
426 wl
->time_offset
= jiffies_to_usecs(jiffies
) -
427 le32_to_cpu(status
->fw_localtime
);
430 static void wl1271_irq_work(struct work_struct
*work
)
435 container_of(work
, struct wl1271
, irq_work
);
437 mutex_lock(&wl
->mutex
);
439 wl1271_debug(DEBUG_IRQ
, "IRQ work");
441 if (wl
->state
== WL1271_STATE_OFF
)
444 ret
= wl1271_ps_elp_wakeup(wl
, true);
448 wl1271_spi_write32(wl
, ACX_REG_INTERRUPT_MASK
, WL1271_ACX_INTR_ALL
);
450 wl1271_fw_status(wl
, wl
->fw_status
);
451 intr
= le32_to_cpu(wl
->fw_status
->intr
);
453 wl1271_debug(DEBUG_IRQ
, "Zero interrupt received.");
457 intr
&= WL1271_INTR_MASK
;
459 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
460 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
461 wl1271_event_handle(wl
, 0);
464 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
465 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
466 wl1271_event_handle(wl
, 1);
469 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
470 wl1271_debug(DEBUG_IRQ
,
471 "WL1271_ACX_INTR_INIT_COMPLETE");
473 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
474 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
476 if (intr
& WL1271_ACX_INTR_DATA
) {
477 u8 tx_res_cnt
= wl
->fw_status
->tx_results_counter
-
478 wl
->tx_results_count
;
480 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
482 /* check for tx results */
484 wl1271_tx_complete(wl
, tx_res_cnt
);
486 wl1271_rx(wl
, wl
->fw_status
);
490 wl1271_spi_write32(wl
, ACX_REG_INTERRUPT_MASK
,
491 WL1271_ACX_INTR_ALL
& ~(WL1271_INTR_MASK
));
492 wl1271_ps_elp_sleep(wl
);
495 mutex_unlock(&wl
->mutex
);
498 static irqreturn_t
wl1271_irq(int irq
, void *cookie
)
503 wl1271_debug(DEBUG_IRQ
, "IRQ");
507 /* complete the ELP completion */
508 spin_lock_irqsave(&wl
->wl_lock
, flags
);
510 complete(wl
->elp_compl
);
511 wl
->elp_compl
= NULL
;
514 ieee80211_queue_work(wl
->hw
, &wl
->irq_work
);
515 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
520 static int wl1271_fetch_firmware(struct wl1271
*wl
)
522 const struct firmware
*fw
;
525 ret
= request_firmware(&fw
, WL1271_FW_NAME
, &wl
->spi
->dev
);
528 wl1271_error("could not get firmware: %d", ret
);
533 wl1271_error("firmware size is not multiple of 32 bits: %zu",
539 wl
->fw_len
= fw
->size
;
540 wl
->fw
= vmalloc(wl
->fw_len
);
543 wl1271_error("could not allocate memory for the firmware");
548 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
553 release_firmware(fw
);
558 static int wl1271_fetch_nvs(struct wl1271
*wl
)
560 const struct firmware
*fw
;
563 ret
= request_firmware(&fw
, WL1271_NVS_NAME
, &wl
->spi
->dev
);
566 wl1271_error("could not get nvs file: %d", ret
);
571 wl1271_error("nvs size is not multiple of 32 bits: %zu",
577 wl
->nvs_len
= fw
->size
;
578 wl
->nvs
= kmalloc(wl
->nvs_len
, GFP_KERNEL
);
581 wl1271_error("could not allocate memory for the nvs file");
586 memcpy(wl
->nvs
, fw
->data
, wl
->nvs_len
);
591 release_firmware(fw
);
596 static void wl1271_fw_wakeup(struct wl1271
*wl
)
600 elp_reg
= ELPCTRL_WAKE_UP
;
601 wl1271_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG_ADDR
, elp_reg
);
604 static int wl1271_setup(struct wl1271
*wl
)
606 wl
->fw_status
= kmalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
610 wl
->tx_res_if
= kmalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
611 if (!wl
->tx_res_if
) {
612 kfree(wl
->fw_status
);
616 INIT_WORK(&wl
->irq_work
, wl1271_irq_work
);
617 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
621 static int wl1271_chip_wakeup(struct wl1271
*wl
)
623 struct wl1271_partition_set partition
;
626 msleep(WL1271_PRE_POWER_ON_SLEEP
);
628 msleep(WL1271_POWER_ON_SLEEP
);
629 wl1271_spi_reset(wl
);
632 /* We don't need a real memory partition here, because we only want
633 * to use the registers at this point. */
634 memset(&partition
, 0, sizeof(partition
));
635 partition
.reg
.start
= REGISTERS_BASE
;
636 partition
.reg
.size
= REGISTERS_DOWN_SIZE
;
637 wl1271_set_partition(wl
, &partition
);
639 /* ELP module wake up */
640 wl1271_fw_wakeup(wl
);
642 /* whal_FwCtrl_BootSm() */
644 /* 0. read chip id from CHIP_ID */
645 wl
->chip
.id
= wl1271_spi_read32(wl
, CHIP_ID_B
);
647 /* 1. check if chip id is valid */
649 switch (wl
->chip
.id
) {
650 case CHIP_ID_1271_PG10
:
651 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
654 ret
= wl1271_setup(wl
);
658 case CHIP_ID_1271_PG20
:
659 wl1271_debug(DEBUG_BOOT
, "chip id 0x%x (1271 PG20)",
662 ret
= wl1271_setup(wl
);
667 wl1271_warning("unsupported chip id: 0x%x", wl
->chip
.id
);
672 if (wl
->fw
== NULL
) {
673 ret
= wl1271_fetch_firmware(wl
);
678 /* No NVS from netlink, try to get it from the filesystem */
679 if (wl
->nvs
== NULL
) {
680 ret
= wl1271_fetch_nvs(wl
);
689 int wl1271_plt_start(struct wl1271
*wl
)
691 int retries
= WL1271_BOOT_RETRIES
;
694 mutex_lock(&wl
->mutex
);
696 wl1271_notice("power up");
698 if (wl
->state
!= WL1271_STATE_OFF
) {
699 wl1271_error("cannot go into PLT state because not "
700 "in off state: %d", wl
->state
);
707 ret
= wl1271_chip_wakeup(wl
);
711 ret
= wl1271_boot(wl
);
715 ret
= wl1271_plt_init(wl
);
719 /* Make sure power saving is disabled */
720 ret
= wl1271_acx_sleep_auth(wl
, WL1271_PSM_CAM
);
724 wl
->state
= WL1271_STATE_PLT
;
725 wl1271_notice("firmware booted in PLT mode (%s)",
730 wl1271_disable_interrupts(wl
);
731 mutex_unlock(&wl
->mutex
);
732 /* Unlocking the mutex in the middle of handling is
733 inherently unsafe. In this case we deem it safe to do,
734 because we need to let any possibly pending IRQ out of
735 the system (and while we are WL1271_STATE_OFF the IRQ
736 work function will not do anything.) Also, any other
737 possible concurrent operations will fail due to the
738 current state, hence the wl1271 struct should be safe. */
739 cancel_work_sync(&wl
->irq_work
);
740 mutex_lock(&wl
->mutex
);
742 wl1271_power_off(wl
);
745 wl1271_error("firmware boot in PLT mode failed despite %d retries",
746 WL1271_BOOT_RETRIES
);
748 mutex_unlock(&wl
->mutex
);
753 int wl1271_plt_stop(struct wl1271
*wl
)
757 mutex_lock(&wl
->mutex
);
759 wl1271_notice("power down");
761 if (wl
->state
!= WL1271_STATE_PLT
) {
762 wl1271_error("cannot power down because not in PLT "
763 "state: %d", wl
->state
);
768 wl1271_disable_interrupts(wl
);
769 wl1271_power_off(wl
);
771 wl
->state
= WL1271_STATE_OFF
;
775 mutex_unlock(&wl
->mutex
);
781 static int wl1271_op_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
783 struct wl1271
*wl
= hw
->priv
;
784 struct ieee80211_conf
*conf
= &hw
->conf
;
785 struct ieee80211_tx_info
*txinfo
= IEEE80211_SKB_CB(skb
);
786 struct ieee80211_sta
*sta
= txinfo
->control
.sta
;
789 /* peek into the rates configured in the STA entry */
790 spin_lock_irqsave(&wl
->wl_lock
, flags
);
791 if (sta
&& sta
->supp_rates
[conf
->channel
->band
] != wl
->sta_rate_set
) {
792 wl
->sta_rate_set
= sta
->supp_rates
[conf
->channel
->band
];
793 set_bit(WL1271_FLAG_STA_RATES_CHANGED
, &wl
->flags
);
795 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
797 /* queue the packet */
798 skb_queue_tail(&wl
->tx_queue
, skb
);
801 * The chip specific setup must run before the first TX packet -
802 * before that, the tx_work will not be initialized!
805 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
808 * The workqueue is slow to process the tx_queue and we need stop
809 * the queue here, otherwise the queue will get too long.
811 if (skb_queue_len(&wl
->tx_queue
) >= WL1271_TX_QUEUE_MAX_LENGTH
) {
812 ieee80211_stop_queues(wl
->hw
);
815 * FIXME: this is racy, the variable is not properly
816 * protected. Maybe fix this by removing the stupid
817 * variable altogether and checking the real queue state?
819 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED
, &wl
->flags
);
825 static int wl1271_dev_notify(struct notifier_block
*me
, unsigned long what
,
828 struct net_device
*dev
;
829 struct wireless_dev
*wdev
;
831 struct ieee80211_hw
*hw
;
833 struct wl1271
*wl_temp
;
834 struct in_device
*idev
;
835 struct in_ifaddr
*ifa
= arg
;
838 /* FIXME: this ugly function should probably be implemented in the
839 * mac80211, and here should only be a simple callback handling actual
840 * setting of the filters. Now we need to dig up references to
841 * various structures to gain access to what we need.
842 * Also, because of this, there is no "initial" setting of the filter
843 * in "op_start", because we don't want to dig up struct net_device
844 * there - the filter will be set upon first change of the interface
847 dev
= ifa
->ifa_dev
->dev
;
849 wdev
= dev
->ieee80211_ptr
;
857 hw
= wiphy_priv(wiphy
);
861 /* Check that the interface is one supported by this driver. */
863 list_for_each_entry(wl
, &wl_list
, list
) {
870 /* Get the interface IP address for the device. "ifa" will become
872 - there is no IPV4 protocol address configured
873 - there are multiple (virtual) IPV4 addresses configured
874 When "ifa" is NULL, filtering will be disabled.
879 ifa
= idev
->ifa_list
;
881 if (ifa
&& ifa
->ifa_next
)
884 mutex_lock(&wl
->mutex
);
886 if (wl
->state
== WL1271_STATE_OFF
)
889 ret
= wl1271_ps_elp_wakeup(wl
, false);
893 ret
= wl1271_acx_arp_ip_filter(wl
, true,
894 (u8
*)&ifa
->ifa_address
,
897 ret
= wl1271_acx_arp_ip_filter(wl
, false, NULL
,
899 wl1271_ps_elp_sleep(wl
);
902 mutex_unlock(&wl
->mutex
);
907 static struct notifier_block wl1271_dev_notifier
= {
908 .notifier_call
= wl1271_dev_notify
,
912 static int wl1271_op_start(struct ieee80211_hw
*hw
)
914 struct wl1271
*wl
= hw
->priv
;
915 int retries
= WL1271_BOOT_RETRIES
;
918 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
920 mutex_lock(&wl
->mutex
);
922 if (wl
->state
!= WL1271_STATE_OFF
) {
923 wl1271_error("cannot start because not in off state: %d",
931 ret
= wl1271_chip_wakeup(wl
);
935 ret
= wl1271_boot(wl
);
939 ret
= wl1271_hw_init(wl
);
943 wl
->state
= WL1271_STATE_ON
;
944 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver
);
948 wl1271_disable_interrupts(wl
);
949 mutex_unlock(&wl
->mutex
);
950 /* Unlocking the mutex in the middle of handling is
951 inherently unsafe. In this case we deem it safe to do,
952 because we need to let any possibly pending IRQ out of
953 the system (and while we are WL1271_STATE_OFF the IRQ
954 work function will not do anything.) Also, any other
955 possible concurrent operations will fail due to the
956 current state, hence the wl1271 struct should be safe. */
957 cancel_work_sync(&wl
->irq_work
);
958 mutex_lock(&wl
->mutex
);
960 wl1271_power_off(wl
);
963 wl1271_error("firmware boot failed despite %d retries",
964 WL1271_BOOT_RETRIES
);
966 mutex_unlock(&wl
->mutex
);
969 list_add(&wl
->list
, &wl_list
);
970 register_inetaddr_notifier(&wl1271_dev_notifier
);
976 static void wl1271_op_stop(struct ieee80211_hw
*hw
)
978 struct wl1271
*wl
= hw
->priv
;
983 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
985 unregister_inetaddr_notifier(&wl1271_dev_notifier
);
988 mutex_lock(&wl
->mutex
);
990 WARN_ON(wl
->state
!= WL1271_STATE_ON
);
992 if (test_and_clear_bit(WL1271_FLAG_SCANNING
, &wl
->flags
)) {
993 mutex_unlock(&wl
->mutex
);
994 ieee80211_scan_completed(wl
->hw
, true);
995 mutex_lock(&wl
->mutex
);
998 wl
->state
= WL1271_STATE_OFF
;
1000 wl1271_disable_interrupts(wl
);
1002 mutex_unlock(&wl
->mutex
);
1004 cancel_work_sync(&wl
->irq_work
);
1005 cancel_work_sync(&wl
->tx_work
);
1007 mutex_lock(&wl
->mutex
);
1009 /* let's notify MAC80211 about the remaining pending TX frames */
1010 wl1271_tx_flush(wl
);
1011 wl1271_power_off(wl
);
1013 memset(wl
->bssid
, 0, ETH_ALEN
);
1014 memset(wl
->ssid
, 0, IW_ESSID_MAX_SIZE
+ 1);
1016 wl
->bss_type
= MAX_BSS_TYPE
;
1017 wl
->band
= IEEE80211_BAND_2GHZ
;
1020 wl
->psm_entry_retry
= 0;
1021 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1022 wl
->tx_blocks_available
= 0;
1023 wl
->tx_results_count
= 0;
1024 wl
->tx_packets_count
= 0;
1025 wl
->tx_security_last_seq
= 0;
1026 wl
->tx_security_seq_16
= 0;
1027 wl
->tx_security_seq_32
= 0;
1028 wl
->time_offset
= 0;
1029 wl
->session_counter
= 0;
1030 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1031 wl
->sta_rate_set
= 0;
1034 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
1035 wl
->tx_blocks_freed
[i
] = 0;
1037 wl1271_debugfs_reset(wl
);
1038 mutex_unlock(&wl
->mutex
);
1041 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
1042 struct ieee80211_if_init_conf
*conf
)
1044 struct wl1271
*wl
= hw
->priv
;
1047 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
1048 conf
->type
, conf
->mac_addr
);
1050 mutex_lock(&wl
->mutex
);
1056 wl
->vif
= conf
->vif
;
1058 switch (conf
->type
) {
1059 case NL80211_IFTYPE_STATION
:
1060 wl
->bss_type
= BSS_TYPE_STA_BSS
;
1062 case NL80211_IFTYPE_ADHOC
:
1063 wl
->bss_type
= BSS_TYPE_IBSS
;
1070 /* FIXME: what if conf->mac_addr changes? */
1073 mutex_unlock(&wl
->mutex
);
1077 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
1078 struct ieee80211_if_init_conf
*conf
)
1080 struct wl1271
*wl
= hw
->priv
;
1082 mutex_lock(&wl
->mutex
);
1083 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
1085 mutex_unlock(&wl
->mutex
);
1089 static int wl1271_op_config_interface(struct ieee80211_hw
*hw
,
1090 struct ieee80211_vif
*vif
,
1091 struct ieee80211_if_conf
*conf
)
1093 struct wl1271
*wl
= hw
->priv
;
1094 struct sk_buff
*beacon
;
1097 wl1271_debug(DEBUG_MAC80211
, "mac80211 config_interface bssid %pM",
1099 wl1271_dump_ascii(DEBUG_MAC80211
, "ssid: ", conf
->ssid
,
1102 mutex_lock(&wl
->mutex
);
1104 ret
= wl1271_ps_elp_wakeup(wl
, false);
1108 if (memcmp(wl
->bssid
, conf
->bssid
, ETH_ALEN
)) {
1109 wl1271_debug(DEBUG_MAC80211
, "bssid changed");
1111 memcpy(wl
->bssid
, conf
->bssid
, ETH_ALEN
);
1113 ret
= wl1271_cmd_join(wl
);
1117 ret
= wl1271_cmd_build_null_data(wl
);
1122 wl
->ssid_len
= conf
->ssid_len
;
1124 memcpy(wl
->ssid
, conf
->ssid
, wl
->ssid_len
);
1126 if (conf
->changed
& IEEE80211_IFCC_BEACON
) {
1127 beacon
= ieee80211_beacon_get(hw
, vif
);
1128 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_BEACON
,
1129 beacon
->data
, beacon
->len
);
1132 dev_kfree_skb(beacon
);
1136 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_PROBE_RESPONSE
,
1137 beacon
->data
, beacon
->len
);
1139 dev_kfree_skb(beacon
);
1146 wl1271_ps_elp_sleep(wl
);
1149 mutex_unlock(&wl
->mutex
);
1155 static int wl1271_join_channel(struct wl1271
*wl
, int channel
)
1158 /* we need to use a dummy BSSID for now */
1159 static const u8 dummy_bssid
[ETH_ALEN
] = { 0x0b, 0xad, 0xde,
1162 /* the dummy join is not required for ad-hoc */
1163 if (wl
->bss_type
== BSS_TYPE_IBSS
)
1166 /* disable mac filter, so we hear everything */
1167 wl
->rx_config
&= ~CFG_BSSID_FILTER_EN
;
1169 wl
->channel
= channel
;
1170 memcpy(wl
->bssid
, dummy_bssid
, ETH_ALEN
);
1172 ret
= wl1271_cmd_join(wl
);
1176 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1182 static int wl1271_unjoin_channel(struct wl1271
*wl
)
1186 /* to stop listening to a channel, we disconnect */
1187 ret
= wl1271_cmd_disconnect(wl
);
1191 clear_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1193 memset(wl
->bssid
, 0, ETH_ALEN
);
1194 wl
->rx_config
= WL1271_DEFAULT_RX_CONFIG
;
1200 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
1202 struct wl1271
*wl
= hw
->priv
;
1203 struct ieee80211_conf
*conf
= &hw
->conf
;
1204 int channel
, ret
= 0;
1206 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
1208 wl1271_debug(DEBUG_MAC80211
, "mac80211 config ch %d psm %s power %d %s",
1210 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
1212 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use");
1214 mutex_lock(&wl
->mutex
);
1216 wl
->band
= conf
->channel
->band
;
1218 ret
= wl1271_ps_elp_wakeup(wl
, false);
1222 if (changed
& IEEE80211_CONF_CHANGE_IDLE
) {
1223 if (conf
->flags
& IEEE80211_CONF_IDLE
&&
1224 test_bit(WL1271_FLAG_JOINED
, &wl
->flags
))
1225 wl1271_unjoin_channel(wl
);
1227 wl1271_join_channel(wl
, channel
);
1229 if (conf
->flags
& IEEE80211_CONF_IDLE
) {
1230 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1231 wl
->sta_rate_set
= 0;
1232 wl1271_acx_rate_policies(wl
);
1236 /* if the channel changes while joined, join again */
1237 if (channel
!= wl
->channel
&& test_bit(WL1271_FLAG_JOINED
, &wl
->flags
))
1238 wl1271_join_channel(wl
, channel
);
1240 if (conf
->flags
& IEEE80211_CONF_PS
&&
1241 !test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1242 set_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1245 * We enter PSM only if we're already associated.
1246 * If we're not, we'll enter it when joining an SSID,
1247 * through the bss_info_changed() hook.
1249 if (test_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
)) {
1250 wl1271_info("psm enabled");
1251 ret
= wl1271_ps_set_mode(wl
, STATION_POWER_SAVE_MODE
);
1253 } else if (!(conf
->flags
& IEEE80211_CONF_PS
) &&
1254 test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
)) {
1255 wl1271_info("psm disabled");
1257 clear_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
);
1259 if (test_bit(WL1271_FLAG_PSM
, &wl
->flags
))
1260 ret
= wl1271_ps_set_mode(wl
, STATION_ACTIVE_MODE
);
1263 if (conf
->power_level
!= wl
->power_level
) {
1264 ret
= wl1271_acx_tx_power(wl
, conf
->power_level
);
1268 wl
->power_level
= conf
->power_level
;
1272 wl1271_ps_elp_sleep(wl
);
1275 mutex_unlock(&wl
->mutex
);
1280 struct wl1271_filter_params
{
1283 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
1286 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
, int mc_count
,
1287 struct dev_addr_list
*mc_list
)
1289 struct wl1271_filter_params
*fp
;
1292 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
1294 wl1271_error("Out of memory setting filters.");
1298 /* update multicast filtering parameters */
1300 if (mc_count
> ACX_MC_ADDRESS_GROUP_MAX
) {
1302 fp
->enabled
= false;
1305 fp
->mc_list_length
= 0;
1306 for (i
= 0; i
< mc_count
; i
++) {
1307 if (mc_list
->da_addrlen
== ETH_ALEN
) {
1308 memcpy(fp
->mc_list
[fp
->mc_list_length
],
1309 mc_list
->da_addr
, ETH_ALEN
);
1310 fp
->mc_list_length
++;
1312 wl1271_warning("Unknown mc address length.");
1313 mc_list
= mc_list
->next
;
1316 return (u64
)(unsigned long)fp
;
1319 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1322 FIF_BCN_PRBRESP_PROMISC | \
1326 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
1327 unsigned int changed
,
1328 unsigned int *total
, u64 multicast
)
1330 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
1331 struct wl1271
*wl
= hw
->priv
;
1334 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter");
1336 mutex_lock(&wl
->mutex
);
1338 if (wl
->state
== WL1271_STATE_OFF
)
1341 ret
= wl1271_ps_elp_wakeup(wl
, false);
1345 *total
&= WL1271_SUPPORTED_FILTERS
;
1346 changed
&= WL1271_SUPPORTED_FILTERS
;
1348 if (*total
& FIF_ALLMULTI
)
1349 ret
= wl1271_acx_group_address_tbl(wl
, false, NULL
, 0);
1351 ret
= wl1271_acx_group_address_tbl(wl
, fp
->enabled
,
1353 fp
->mc_list_length
);
1359 /* FIXME: We still need to set our filters properly */
1361 /* determine, whether supported filter values have changed */
1365 /* apply configured filters */
1366 ret
= wl1271_acx_rx_config(wl
, wl
->rx_config
, wl
->rx_filter
);
1371 wl1271_ps_elp_sleep(wl
);
1374 mutex_unlock(&wl
->mutex
);
1377 static int wl1271_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
1378 struct ieee80211_vif
*vif
,
1379 struct ieee80211_sta
*sta
,
1380 struct ieee80211_key_conf
*key_conf
)
1382 struct wl1271
*wl
= hw
->priv
;
1389 static const u8 bcast_addr
[ETH_ALEN
] =
1390 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1392 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
1394 addr
= sta
? sta
->addr
: bcast_addr
;
1396 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x", cmd
);
1397 wl1271_dump(DEBUG_CRYPT
, "ADDR: ", addr
, ETH_ALEN
);
1398 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1399 key_conf
->alg
, key_conf
->keyidx
,
1400 key_conf
->keylen
, key_conf
->flags
);
1401 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
1403 if (is_zero_ether_addr(addr
)) {
1404 /* We dont support TX only encryption */
1409 mutex_lock(&wl
->mutex
);
1411 ret
= wl1271_ps_elp_wakeup(wl
, false);
1415 switch (key_conf
->alg
) {
1419 key_conf
->hw_key_idx
= key_conf
->keyidx
;
1422 key_type
= KEY_TKIP
;
1424 key_conf
->hw_key_idx
= key_conf
->keyidx
;
1425 tx_seq_32
= wl
->tx_security_seq_32
;
1426 tx_seq_16
= wl
->tx_security_seq_16
;
1431 key_conf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
1432 tx_seq_32
= wl
->tx_security_seq_32
;
1433 tx_seq_16
= wl
->tx_security_seq_16
;
1436 wl1271_error("Unknown key algo 0x%x", key_conf
->alg
);
1444 ret
= wl1271_cmd_set_key(wl
, KEY_ADD_OR_REPLACE
,
1445 key_conf
->keyidx
, key_type
,
1446 key_conf
->keylen
, key_conf
->key
,
1447 addr
, tx_seq_32
, tx_seq_16
);
1449 wl1271_error("Could not add or replace key");
1455 ret
= wl1271_cmd_set_key(wl
, KEY_REMOVE
,
1456 key_conf
->keyidx
, key_type
,
1457 key_conf
->keylen
, key_conf
->key
,
1460 wl1271_error("Could not remove key");
1466 wl1271_error("Unsupported key cmd 0x%x", cmd
);
1474 wl1271_ps_elp_sleep(wl
);
1477 mutex_unlock(&wl
->mutex
);
1483 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
1484 struct cfg80211_scan_request
*req
)
1486 struct wl1271
*wl
= hw
->priv
;
1491 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
1494 ssid
= req
->ssids
[0].ssid
;
1495 len
= req
->ssids
[0].ssid_len
;
1498 mutex_lock(&wl
->mutex
);
1500 ret
= wl1271_ps_elp_wakeup(wl
, false);
1504 if (wl1271_11a_enabled())
1505 ret
= wl1271_cmd_scan(hw
->priv
, ssid
, len
, 1, 0,
1506 WL1271_SCAN_BAND_DUAL
, 3);
1508 ret
= wl1271_cmd_scan(hw
->priv
, ssid
, len
, 1, 0,
1509 WL1271_SCAN_BAND_2_4_GHZ
, 3);
1511 wl1271_ps_elp_sleep(wl
);
1514 mutex_unlock(&wl
->mutex
);
1519 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
1521 struct wl1271
*wl
= hw
->priv
;
1524 mutex_lock(&wl
->mutex
);
1526 ret
= wl1271_ps_elp_wakeup(wl
, false);
1530 ret
= wl1271_acx_rts_threshold(wl
, (u16
) value
);
1532 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret
);
1534 wl1271_ps_elp_sleep(wl
);
1537 mutex_unlock(&wl
->mutex
);
1542 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
1543 struct ieee80211_vif
*vif
,
1544 struct ieee80211_bss_conf
*bss_conf
,
1547 enum wl1271_cmd_ps_mode mode
;
1548 struct wl1271
*wl
= hw
->priv
;
1551 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info changed");
1553 mutex_lock(&wl
->mutex
);
1555 ret
= wl1271_ps_elp_wakeup(wl
, false);
1559 if ((changed
& BSS_CHANGED_BSSID
) &&
1561 * Now we know the correct bssid, so we send a new join command
1562 * and enable the BSSID filter
1564 memcmp(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
)) {
1565 wl
->rx_config
|= CFG_BSSID_FILTER_EN
;
1566 memcpy(wl
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
1567 ret
= wl1271_cmd_build_null_data(wl
);
1569 wl1271_warning("cmd buld null data failed %d",
1573 ret
= wl1271_cmd_join(wl
);
1575 wl1271_warning("cmd join failed %d", ret
);
1578 set_bit(WL1271_FLAG_JOINED
, &wl
->flags
);
1581 if (wl
->bss_type
== BSS_TYPE_IBSS
) {
1582 /* FIXME: This implements rudimentary ad-hoc support -
1583 proper templates are on the wish list and notification
1584 on when they change. This patch will update the templates
1585 on every call to this function. Also, the firmware will not
1586 answer to probe-requests as it does not have the proper
1587 SSID set in the JOIN command. The probe-response template
1588 is set nevertheless, as the FW will ASSERT without it */
1589 struct sk_buff
*beacon
= ieee80211_beacon_get(hw
, vif
);
1592 struct ieee80211_hdr
*hdr
;
1593 ret
= wl1271_cmd_template_set(wl
, CMD_TEMPL_BEACON
,
1598 dev_kfree_skb(beacon
);
1602 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
1603 hdr
->frame_control
= cpu_to_le16(
1604 IEEE80211_FTYPE_MGMT
|
1605 IEEE80211_STYPE_PROBE_RESP
);
1607 ret
= wl1271_cmd_template_set(wl
,
1608 CMD_TEMPL_PROBE_RESPONSE
,
1611 dev_kfree_skb(beacon
);
1617 if (changed
& BSS_CHANGED_ASSOC
) {
1618 if (bss_conf
->assoc
) {
1619 wl
->aid
= bss_conf
->aid
;
1620 set_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
1623 * with wl1271, we don't need to update the
1624 * beacon_int and dtim_period, because the firmware
1625 * updates it by itself when the first beacon is
1626 * received after a join.
1628 ret
= wl1271_cmd_build_ps_poll(wl
, wl
->aid
);
1632 ret
= wl1271_acx_aid(wl
, wl
->aid
);
1636 /* If we want to go in PSM but we're not there yet */
1637 if (test_bit(WL1271_FLAG_PSM_REQUESTED
, &wl
->flags
) &&
1638 !test_bit(WL1271_FLAG_PSM
, &wl
->flags
)) {
1639 mode
= STATION_POWER_SAVE_MODE
;
1640 ret
= wl1271_ps_set_mode(wl
, mode
);
1645 /* use defaults when not associated */
1646 clear_bit(WL1271_FLAG_STA_ASSOCIATED
, &wl
->flags
);
1652 if (changed
& BSS_CHANGED_ERP_SLOT
) {
1653 if (bss_conf
->use_short_slot
)
1654 ret
= wl1271_acx_slot(wl
, SLOT_TIME_SHORT
);
1656 ret
= wl1271_acx_slot(wl
, SLOT_TIME_LONG
);
1658 wl1271_warning("Set slot time failed %d", ret
);
1663 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
1664 if (bss_conf
->use_short_preamble
)
1665 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_SHORT
);
1667 wl1271_acx_set_preamble(wl
, ACX_PREAMBLE_LONG
);
1670 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
1671 if (bss_conf
->use_cts_prot
)
1672 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_ENABLE
);
1674 ret
= wl1271_acx_cts_protect(wl
, CTSPROTECT_DISABLE
);
1676 wl1271_warning("Set ctsprotect failed %d", ret
);
1682 wl1271_ps_elp_sleep(wl
);
1685 mutex_unlock(&wl
->mutex
);
1689 /* can't be const, mac80211 writes to this */
1690 static struct ieee80211_rate wl1271_rates
[] = {
1692 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
1693 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
1695 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
1696 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
1697 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
1699 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
1700 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
1701 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
1703 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
1704 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
1705 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
1707 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
1708 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
1710 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
1711 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
1713 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
1714 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
1716 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
1717 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
1719 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
1720 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
1722 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
1723 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
1725 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
1726 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
1728 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
1729 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
1732 /* can't be const, mac80211 writes to this */
1733 static struct ieee80211_channel wl1271_channels
[] = {
1734 { .hw_value
= 1, .center_freq
= 2412, .max_power
= 25 },
1735 { .hw_value
= 2, .center_freq
= 2417, .max_power
= 25 },
1736 { .hw_value
= 3, .center_freq
= 2422, .max_power
= 25 },
1737 { .hw_value
= 4, .center_freq
= 2427, .max_power
= 25 },
1738 { .hw_value
= 5, .center_freq
= 2432, .max_power
= 25 },
1739 { .hw_value
= 6, .center_freq
= 2437, .max_power
= 25 },
1740 { .hw_value
= 7, .center_freq
= 2442, .max_power
= 25 },
1741 { .hw_value
= 8, .center_freq
= 2447, .max_power
= 25 },
1742 { .hw_value
= 9, .center_freq
= 2452, .max_power
= 25 },
1743 { .hw_value
= 10, .center_freq
= 2457, .max_power
= 25 },
1744 { .hw_value
= 11, .center_freq
= 2462, .max_power
= 25 },
1745 { .hw_value
= 12, .center_freq
= 2467, .max_power
= 25 },
1746 { .hw_value
= 13, .center_freq
= 2472, .max_power
= 25 },
1749 /* can't be const, mac80211 writes to this */
1750 static struct ieee80211_supported_band wl1271_band_2ghz
= {
1751 .channels
= wl1271_channels
,
1752 .n_channels
= ARRAY_SIZE(wl1271_channels
),
1753 .bitrates
= wl1271_rates
,
1754 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
1757 /* 5 GHz data rates for WL1273 */
1758 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
1760 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
1761 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
1763 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
1764 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
1766 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
1767 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
1769 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
1770 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
1772 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
1773 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
1775 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
1776 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
1778 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
1779 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
1781 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
1782 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
1785 /* 5 GHz band channels for WL1273 */
1786 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
1787 { .hw_value
= 183, .center_freq
= 4915},
1788 { .hw_value
= 184, .center_freq
= 4920},
1789 { .hw_value
= 185, .center_freq
= 4925},
1790 { .hw_value
= 187, .center_freq
= 4935},
1791 { .hw_value
= 188, .center_freq
= 4940},
1792 { .hw_value
= 189, .center_freq
= 4945},
1793 { .hw_value
= 192, .center_freq
= 4960},
1794 { .hw_value
= 196, .center_freq
= 4980},
1795 { .hw_value
= 7, .center_freq
= 5035},
1796 { .hw_value
= 8, .center_freq
= 5040},
1797 { .hw_value
= 9, .center_freq
= 5045},
1798 { .hw_value
= 11, .center_freq
= 5055},
1799 { .hw_value
= 12, .center_freq
= 5060},
1800 { .hw_value
= 16, .center_freq
= 5080},
1801 { .hw_value
= 34, .center_freq
= 5170},
1802 { .hw_value
= 36, .center_freq
= 5180},
1803 { .hw_value
= 38, .center_freq
= 5190},
1804 { .hw_value
= 40, .center_freq
= 5200},
1805 { .hw_value
= 42, .center_freq
= 5210},
1806 { .hw_value
= 44, .center_freq
= 5220},
1807 { .hw_value
= 46, .center_freq
= 5230},
1808 { .hw_value
= 48, .center_freq
= 5240},
1809 { .hw_value
= 52, .center_freq
= 5260},
1810 { .hw_value
= 56, .center_freq
= 5280},
1811 { .hw_value
= 60, .center_freq
= 5300},
1812 { .hw_value
= 64, .center_freq
= 5320},
1813 { .hw_value
= 100, .center_freq
= 5500},
1814 { .hw_value
= 104, .center_freq
= 5520},
1815 { .hw_value
= 108, .center_freq
= 5540},
1816 { .hw_value
= 112, .center_freq
= 5560},
1817 { .hw_value
= 116, .center_freq
= 5580},
1818 { .hw_value
= 120, .center_freq
= 5600},
1819 { .hw_value
= 124, .center_freq
= 5620},
1820 { .hw_value
= 128, .center_freq
= 5640},
1821 { .hw_value
= 132, .center_freq
= 5660},
1822 { .hw_value
= 136, .center_freq
= 5680},
1823 { .hw_value
= 140, .center_freq
= 5700},
1824 { .hw_value
= 149, .center_freq
= 5745},
1825 { .hw_value
= 153, .center_freq
= 5765},
1826 { .hw_value
= 157, .center_freq
= 5785},
1827 { .hw_value
= 161, .center_freq
= 5805},
1828 { .hw_value
= 165, .center_freq
= 5825},
1832 static struct ieee80211_supported_band wl1271_band_5ghz
= {
1833 .channels
= wl1271_channels_5ghz
,
1834 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
1835 .bitrates
= wl1271_rates_5ghz
,
1836 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
1839 static const struct ieee80211_ops wl1271_ops
= {
1840 .start
= wl1271_op_start
,
1841 .stop
= wl1271_op_stop
,
1842 .add_interface
= wl1271_op_add_interface
,
1843 .remove_interface
= wl1271_op_remove_interface
,
1844 .config
= wl1271_op_config
,
1845 /* .config_interface = wl1271_op_config_interface, */
1846 .prepare_multicast
= wl1271_op_prepare_multicast
,
1847 .configure_filter
= wl1271_op_configure_filter
,
1849 .set_key
= wl1271_op_set_key
,
1850 .hw_scan
= wl1271_op_hw_scan
,
1851 .bss_info_changed
= wl1271_op_bss_info_changed
,
1852 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
1855 static int wl1271_register_hw(struct wl1271
*wl
)
1859 if (wl
->mac80211_registered
)
1862 SET_IEEE80211_PERM_ADDR(wl
->hw
, wl
->mac_addr
);
1864 ret
= ieee80211_register_hw(wl
->hw
);
1866 wl1271_error("unable to register mac80211 hw: %d", ret
);
1870 wl
->mac80211_registered
= true;
1872 wl1271_notice("loaded");
1877 static int wl1271_init_ieee80211(struct wl1271
*wl
)
1879 /* The tx descriptor buffer and the TKIP space. */
1880 wl
->hw
->extra_tx_headroom
= WL1271_TKIP_IV_SPACE
+
1881 sizeof(struct wl1271_tx_hw_descr
);
1884 /* FIXME: find a proper value */
1885 wl
->hw
->channel_change_time
= 10000;
1887 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
1888 IEEE80211_HW_NOISE_DBM
|
1889 IEEE80211_HW_BEACON_FILTER
|
1890 IEEE80211_HW_SUPPORTS_PS
;
1892 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
1893 BIT(NL80211_IFTYPE_ADHOC
);
1894 wl
->hw
->wiphy
->max_scan_ssids
= 1;
1895 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &wl1271_band_2ghz
;
1897 if (wl1271_11a_enabled())
1898 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] = &wl1271_band_5ghz
;
1900 SET_IEEE80211_DEV(wl
->hw
, &wl
->spi
->dev
);
1905 static void wl1271_device_release(struct device
*dev
)
1910 static struct platform_device wl1271_device
= {
1914 /* device model insists to have a release function */
1916 .release
= wl1271_device_release
,
1920 #define WL1271_DEFAULT_CHANNEL 0
1921 static int __devinit
wl1271_probe(struct spi_device
*spi
)
1923 struct wl12xx_platform_data
*pdata
;
1924 struct ieee80211_hw
*hw
;
1927 static const u8 nokia_oui
[3] = {0x00, 0x1f, 0xdf};
1929 pdata
= spi
->dev
.platform_data
;
1931 wl1271_error("no platform data");
1935 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
1937 wl1271_error("could not alloc ieee80211_hw");
1942 memset(wl
, 0, sizeof(*wl
));
1944 INIT_LIST_HEAD(&wl
->list
);
1947 dev_set_drvdata(&spi
->dev
, wl
);
1950 skb_queue_head_init(&wl
->tx_queue
);
1952 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
1953 wl
->channel
= WL1271_DEFAULT_CHANNEL
;
1954 wl
->default_key
= 0;
1956 wl
->rx_config
= WL1271_DEFAULT_RX_CONFIG
;
1957 wl
->rx_filter
= WL1271_DEFAULT_RX_FILTER
;
1958 wl
->psm_entry_retry
= 0;
1959 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1960 wl
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
1961 wl
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
1962 wl
->sta_rate_set
= 0;
1963 wl
->band
= IEEE80211_BAND_2GHZ
;
1967 for (i
= 0; i
< ACX_TX_DESCRIPTORS
; i
++)
1968 wl
->tx_frames
[i
] = NULL
;
1970 spin_lock_init(&wl
->wl_lock
);
1973 * In case our MAC address is not correctly set,
1974 * we use a random but Nokia MAC.
1976 memcpy(wl
->mac_addr
, nokia_oui
, 3);
1977 get_random_bytes(wl
->mac_addr
+ 3, 3);
1979 wl
->state
= WL1271_STATE_OFF
;
1980 mutex_init(&wl
->mutex
);
1982 /* This is the only SPI value that we need to set here, the rest
1983 * comes from the board-peripherals file */
1984 spi
->bits_per_word
= 32;
1986 ret
= spi_setup(spi
);
1988 wl1271_error("spi_setup failed");
1992 wl
->set_power
= pdata
->set_power
;
1993 if (!wl
->set_power
) {
1994 wl1271_error("set power function missing in platform data");
2001 wl1271_error("irq missing in platform data");
2006 ret
= request_irq(wl
->irq
, wl1271_irq
, 0, DRIVER_NAME
, wl
);
2008 wl1271_error("request_irq() failed: %d", ret
);
2012 set_irq_type(wl
->irq
, IRQ_TYPE_EDGE_RISING
);
2014 disable_irq(wl
->irq
);
2016 ret
= platform_device_register(&wl1271_device
);
2018 wl1271_error("couldn't register platform device");
2021 dev_set_drvdata(&wl1271_device
.dev
, wl
);
2023 /* Apply default driver configuration. */
2024 wl1271_conf_init(wl
);
2026 ret
= wl1271_init_ieee80211(wl
);
2030 ret
= wl1271_register_hw(wl
);
2034 wl1271_debugfs_init(wl
);
2036 wl1271_notice("initialized");
2041 platform_device_unregister(&wl1271_device
);
2044 free_irq(wl
->irq
, wl
);
2047 ieee80211_free_hw(hw
);
2052 static int __devexit
wl1271_remove(struct spi_device
*spi
)
2054 struct wl1271
*wl
= dev_get_drvdata(&spi
->dev
);
2056 ieee80211_unregister_hw(wl
->hw
);
2058 wl1271_debugfs_exit(wl
);
2059 platform_device_unregister(&wl1271_device
);
2060 free_irq(wl
->irq
, wl
);
2061 kfree(wl
->target_mem_map
);
2067 kfree(wl
->fw_status
);
2068 kfree(wl
->tx_res_if
);
2070 ieee80211_free_hw(wl
->hw
);
2076 static struct spi_driver wl1271_spi_driver
= {
2079 .bus
= &spi_bus_type
,
2080 .owner
= THIS_MODULE
,
2083 .probe
= wl1271_probe
,
2084 .remove
= __devexit_p(wl1271_remove
),
2087 static int __init
wl1271_init(void)
2091 ret
= spi_register_driver(&wl1271_spi_driver
);
2093 wl1271_error("failed to register spi driver: %d", ret
);
2101 static void __exit
wl1271_exit(void)
2103 spi_unregister_driver(&wl1271_spi_driver
);
2105 wl1271_notice("unloaded");
2108 module_init(wl1271_init
);
2109 module_exit(wl1271_exit
);
2111 MODULE_LICENSE("GPL");
2112 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2113 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2114 MODULE_FIRMWARE(WL1271_FW_NAME
);