]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/wireless/wl12xx/wl1271_main.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: rtl8192su: fix compile error from wireless-testing commit
[net-next-2.6.git] / drivers / net / wireless / wl12xx / wl1271_main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
4 * Copyright (C) 2008-2009 Nokia Corporation
5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
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.
11 *
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.
16 *
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
20 * 02110-1301 USA
21 *
22 */
23
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>
1fba4974 33#include <linux/vmalloc.h>
f5fc0f86 34#include <linux/spi/wl12xx.h>
01c09162 35#include <linux/inetdevice.h>
f5fc0f86
LC		 36
37#include "wl1271.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"
49
9ccd9217
JO		 50#define WL1271_BOOT_RETRIES 3
51
8a08048a
JO		 52static struct conf_drv_settings default_conf = {
53 .sg = {
54 .per_threshold = 7500,
55 .max_scan_compensation_time = 120000,
56 .nfs_sample_interval = 400,
57 .load_ratio = 50,
58 .auto_ps_mode = 0,
59 .probe_req_compensation = 170,
60 .scan_window_compensation = 50,
61 .antenna_config = 0,
62 .beacon_miss_threshold = 60,
63 .rate_adaptation_threshold = CONF_HW_BIT_RATE_12MBPS,
64 .rate_adaptation_snr = 0
65 },
66 .rx = {
67 .rx_msdu_life_time = 512000,
68 .packet_detection_threshold = 0,
69 .ps_poll_timeout = 15,
70 .upsd_timeout = 15,
71 .rts_threshold = 2347,
3ed8f2c6
LC		 72 .rx_cca_threshold = 0,
73 .irq_blk_threshold = 0xFFFF,
74 .irq_pkt_threshold = 0,
75 .irq_timeout = 600,
8a08048a
JO		 76 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
77 },
78 .tx = {
79 .tx_energy_detection = 0,
80 .rc_conf = {
ec078d94
JO		 81 .enabled_rates = CONF_HW_BIT_RATE_1MBPS |
82 CONF_HW_BIT_RATE_2MBPS,
8a08048a
JO		 83 .short_retry_limit = 10,
84 .long_retry_limit = 10,
85 .aflags = 0
45b531a8 86 },
8a08048a
JO		 87 .ac_conf_count = 4,
88 .ac_conf = {
89 [0] = {
90 .ac = CONF_TX_AC_BE,
91 .cw_min = 15,
92 .cw_max = 63,
93 .aifsn = 3,
94 .tx_op_limit = 0,
45b531a8 95 },
8a08048a
JO		 96 [1] = {
97 .ac = CONF_TX_AC_BK,
98 .cw_min = 15,
99 .cw_max = 63,
100 .aifsn = 7,
101 .tx_op_limit = 0,
45b531a8 102 },
8a08048a
JO		 103 [2] = {
104 .ac = CONF_TX_AC_VI,
105 .cw_min = 15,
106 .cw_max = 63,
107 .aifsn = CONF_TX_AIFS_PIFS,
108 .tx_op_limit = 3008,
109 },
110 [3] = {
111 .ac = CONF_TX_AC_VO,
112 .cw_min = 15,
113 .cw_max = 63,
114 .aifsn = CONF_TX_AIFS_PIFS,
115 .tx_op_limit = 1504,
45b531a8 116 },
51f2be24 117 },
8a08048a
JO		 118 .tid_conf_count = 7,
119 .tid_conf = {
120 [0] = {
121 .queue_id = 0,
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,
126 .apsd_conf = {0, 0},
127 },
128 [1] = {
129 .queue_id = 1,
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,
134 .apsd_conf = {0, 0},
51f2be24 135 },
8a08048a
JO		 136 [2] = {
137 .queue_id = 2,
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,
142 .apsd_conf = {0, 0},
51f2be24 143 },
8a08048a
JO		 144 [3] = {
145 .queue_id = 3,
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,
150 .apsd_conf = {0, 0},
151 },
152 [4] = {
153 .queue_id = 4,
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,
158 .apsd_conf = {0, 0},
159 },
160 [5] = {
161 .queue_id = 5,
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,
166 .apsd_conf = {0, 0},
167 },
168 [6] = {
169 .queue_id = 6,
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,
174 .apsd_conf = {0, 0},
175 }
176 },
177 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
3ed8f2c6
LC		 178 .tx_compl_timeout = 700,
179 .tx_compl_threshold = 4
8a08048a
JO		 180 },
181 .conn = {
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,
186 .bcn_filt_ie = {
187 [0] = {
188 .ie = WLAN_EID_CHANNEL_SWITCH,
189 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
51f2be24 190 }
47fab7d5 191 },
3ed8f2c6 192 .synch_fail_thold = 10,
8a08048a
JO		 193 .bss_lose_timeout = 100,
194 .beacon_rx_timeout = 10000,
195 .broadcast_timeout = 20000,
196 .rx_broadcast_in_ps = 1,
3ed8f2c6 197 .ps_poll_threshold = 20,
8a08048a
JO		 198 .sig_trigger_count = 2,
199 .sig_trigger = {
200 [0] = {
201 .threshold = -75,
202 .pacing = 500,
203 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
204 .type = CONF_TRIG_EVENT_TYPE_EDGE,
205 .direction = CONF_TRIG_EVENT_DIR_LOW,
206 .hysteresis = 2,
207 .index = 0,
208 .enable = 1
47fab7d5 209 },
8a08048a
JO		 210 [1] = {
211 .threshold = -75,
212 .pacing = 500,
213 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
214 .type = CONF_TRIG_EVENT_TYPE_EDGE,
215 .direction = CONF_TRIG_EVENT_DIR_HIGH,
216 .hysteresis = 2,
217 .index = 1,
218 .enable = 1
219 }
220 },
221 .sig_weights = {
222 .rssi_bcn_avg_weight = 10,
223 .rssi_pkt_avg_weight = 10,
224 .snr_bcn_avg_weight = 10,
225 .snr_pkt_avg_weight = 10
11f70f97
JO		 226 },
227 .bet_enable = CONF_BET_MODE_ENABLE,
84502563 228 .bet_max_consecutive = 10,
19ad0715 229 .psm_entry_retries = 3
8a08048a
JO		 230 },
231 .init = {
8a08048a 232 .genparam = {
c7c8adb5 233 .ref_clk = CONF_REF_CLK_38_4_E,
8a08048a
JO		 234 .settling_time = 5,
235 .clk_valid_on_wakeup = 0,
236 .dc2dcmode = 0,
1ebec3d7 237 .single_dual_band = CONF_SINGLE_BAND,
a3e84847 238 .tx_bip_fem_autodetect = 1,
8a08048a
JO		 239 .tx_bip_fem_manufacturer = 1,
240 .settings = 1,
76c0f8d3 241 .sr_state = 1,
149e3878
JO		 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 },
76c0f8d3
LC		 248 .sr_debug_table = { 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0 },
250 .sr_sen_n_p = 0,
251 .sr_sen_n_p_gain = 0,
252 .sr_sen_nrn = 0,
253 .sr_sen_prn = 0,
8a08048a
JO		 254 },
255 .radioparam = {
a3e84847
LC		 256 .rx_trace_loss = 0x24,
257 .tx_trace_loss = 0x0,
8a08048a
JO		 258 .rx_rssi_and_proc_compens = {
259 0xec, 0xf6, 0x00, 0x0c, 0x18, 0xf8,
1b38ea88 260 0xfc, 0x00, 0x80, 0x10, 0xf0, 0xf8,
8a08048a
JO		 261 0x00, 0x0a, 0x14 },
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,
267 0x00, 0x00, 0x00 },
a3e84847
LC		 268 .tx_ref_pd_voltage = 0x1a9,
269 .tx_ref_power = 0x80,
8a08048a
JO		 270 .tx_offset_db = 0x0,
271 .tx_rate_limits_normal = {
a3e84847 272 0x1d, 0x1f, 0x24, 0x28, 0x28, 0x29 },
8a08048a 273 .tx_rate_limits_degraded = {
a3e84847 274 0x19, 0x1f, 0x22, 0x23, 0x27, 0x28 },
cf18be44
LC		 275 .tx_rate_limits_extreme = {
276 0x19, 0x1c, 0x1e, 0x20, 0x24, 0x25 },
8a08048a
JO		 277 .tx_channel_limits_11b = {
278 0x22, 0x50, 0x50, 0x50, 0x50, 0x50,
279 0x50, 0x50, 0x50, 0x50, 0x22, 0x50,
280 0x22, 0x50 },
281 .tx_channel_limits_ofdm = {
282 0x20, 0x50, 0x50, 0x50, 0x50, 0x50,
283 0x50, 0x50, 0x50, 0x50, 0x20, 0x50,
284 0x20, 0x50 },
285 .tx_pdv_rate_offsets = {
a3e84847 286 0x07, 0x08, 0x04, 0x02, 0x02, 0x00 },
8a08048a 287 .tx_ibias = {
a3e84847
LC		 288 0x11, 0x11, 0x15, 0x11, 0x15, 0x0f },
289 .rx_fem_insertion_loss = 0x0e,
cf18be44
LC		 290 .degraded_low_to_normal_threshold = 0x1e,
291 .degraded_normal_to_high_threshold = 0x2d,
1ebec3d7
TP		 292 .tx_ref_pd_voltage_5 = {
293 0x0190, 0x01a4, 0x01c3, 0x01d8,
294 0x020a, 0x021c },
295 .tx_ref_power_5 = {
296 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },
297 .tx_offset_db_5 = {
8a08048a 298 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1ebec3d7
TP		 299 .tx_rate_limits_normal_5 = {
300 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
8a08048a 301 .tx_rate_limits_degraded_5 = {
1ebec3d7 302 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
cf18be44
LC		 303 .tx_rate_limits_extreme_5 = {
304 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
8a08048a 305 .tx_channel_limits_ofdm_5 = {
1ebec3d7
TP		 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,
310 0x50, 0x50, 0x50 },
8a08048a 311 .tx_pdv_rate_offsets_5 = {
1ebec3d7 312 0x01, 0x02, 0x02, 0x02, 0x02, 0x00 },
8a08048a 313 .tx_ibias_5 = {
1ebec3d7
TP		 314 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 },
315 .rx_fem_insertion_loss_5 = {
cf18be44
LC		 316 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 },
317 .degraded_low_to_normal_threshold_5 = 0x00,
318 .degraded_normal_to_high_threshold_5 = 0x00
2b60100b 319 }
6e92b416
LC		 320 },
321 .itrim = {
322 .enable = false,
323 .timeout = 50000,
38ad2d87
JO		 324 },
325 .pm_config = {
326 .host_clk_settling_time = 5000,
327 .host_fast_wakeup_support = false
8a08048a
JO		 328 }
329};
330
01c09162
JO		 331static LIST_HEAD(wl_list);
332
8a08048a
JO		 333static void wl1271_conf_init(struct wl1271 *wl)
334{
2b60100b
JO		 335
336 /*
337 * This function applies the default configuration to the driver. This
338 * function is invoked upon driver load (spi probe.)
339 *
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.)
344 */
345
346 /* apply driver default configuration */
8a08048a 347 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
1ebec3d7
TP		 348
349 if (wl1271_11a_enabled())
350 wl->conf.init.genparam.single_dual_band = CONF_DUAL_BAND;
2b60100b
JO		 351}
352
353
f5fc0f86
LC		 354static int wl1271_plt_init(struct wl1271 *wl)
355{
356 int ret;
357
98b5dd5d 358 ret = wl1271_cmd_general_parms(wl);
4a90406b 359 if (ret < 0)
cc7defa3
LC		 360 return ret;
361
98b5dd5d 362 ret = wl1271_cmd_radio_parms(wl);
4a90406b 363 if (ret < 0)
cc7defa3
LC		 364 return ret;
365
f5fc0f86
LC		 366 ret = wl1271_acx_init_mem_config(wl);
367 if (ret < 0)
368 return ret;
369
94210897 370 ret = wl1271_cmd_data_path(wl, 1);
f5fc0f86
LC		 371 if (ret < 0)
372 return ret;
373
374 return 0;
375}
376
377static void wl1271_disable_interrupts(struct wl1271 *wl)
378{
379 disable_irq(wl->irq);
380}
381
382static void wl1271_power_off(struct wl1271 *wl)
383{
384 wl->set_power(false);
71449f8d 385 clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
f5fc0f86
LC		 386}
387
388static void wl1271_power_on(struct wl1271 *wl)
389{
390 wl->set_power(true);
71449f8d 391 set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
f5fc0f86
LC		 392}
393
c15f63bf
JO		 394static void wl1271_fw_status(struct wl1271 *wl,
395 struct wl1271_fw_status *status)
f5fc0f86
LC		 396{
397 u32 total = 0;
398 int i;
399
74621417
JO		 400 wl1271_spi_read(wl, FW_STATUS_ADDR, status,
401 sizeof(*status), false);
f5fc0f86
LC		 402
403 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
404 "drv_rx_counter = %d, tx_results_counter = %d)",
405 status->intr,
406 status->fw_rx_counter,
407 status->drv_rx_counter,
408 status->tx_results_counter);
409
410 /* update number of available TX blocks */
411 for (i = 0; i < NUM_TX_QUEUES; i++) {
d0f63b20
LC		 412 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
413 wl->tx_blocks_freed[i];
414
415 wl->tx_blocks_freed[i] =
416 le32_to_cpu(status->tx_released_blks[i]);
f5fc0f86
LC		 417 wl->tx_blocks_available += cnt;
418 total += cnt;
419 }
420
421 /* if more blocks are available now, schedule some tx work */
422 if (total && !skb_queue_empty(&wl->tx_queue))
a64b07e8 423 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 424
425 /* update the host-chipset time offset */
d0f63b20
LC		 426 wl->time_offset = jiffies_to_usecs(jiffies) -
427 le32_to_cpu(status->fw_localtime);
f5fc0f86
LC		 428}
429
f5fc0f86
LC		 430static void wl1271_irq_work(struct work_struct *work)
431{
f5fc0f86 432 int ret;
c15f63bf 433 u32 intr;
f5fc0f86
LC		 434 struct wl1271 *wl =
435 container_of(work, struct wl1271, irq_work);
436
437 mutex_lock(&wl->mutex);
438
439 wl1271_debug(DEBUG_IRQ, "IRQ work");
440
441 if (wl->state == WL1271_STATE_OFF)
442 goto out;
443
444 ret = wl1271_ps_elp_wakeup(wl, true);
445 if (ret < 0)
446 goto out;
447
74621417 448 wl1271_spi_write32(wl, ACX_REG_INTERRUPT_MASK, WL1271_ACX_INTR_ALL);
f5fc0f86 449
c15f63bf 450 wl1271_fw_status(wl, wl->fw_status);
d0f63b20 451 intr = le32_to_cpu(wl->fw_status->intr);
f5fc0f86
LC		 452 if (!intr) {
453 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
454 goto out_sleep;
455 }
456
457 intr &= WL1271_INTR_MASK;
458
1fd2794f 459 if (intr & WL1271_ACX_INTR_EVENT_A) {
1fd2794f 460 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
13f2dc52 461 wl1271_event_handle(wl, 0);
1fd2794f
JO		 462 }
463
464 if (intr & WL1271_ACX_INTR_EVENT_B) {
465 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
13f2dc52 466 wl1271_event_handle(wl, 1);
c15f63bf 467 }
f5fc0f86 468
c15f63bf
JO		 469 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
470 wl1271_debug(DEBUG_IRQ,
471 "WL1271_ACX_INTR_INIT_COMPLETE");
f5fc0f86 472
c15f63bf
JO		 473 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
474 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
f5fc0f86 475
c15f63bf
JO		 476 if (intr & WL1271_ACX_INTR_DATA) {
477 u8 tx_res_cnt = wl->fw_status->tx_results_counter -
478 wl->tx_results_count;
f5fc0f86 479
c15f63bf 480 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
f5fc0f86 481
c15f63bf
JO		 482 /* check for tx results */
483 if (tx_res_cnt)
484 wl1271_tx_complete(wl, tx_res_cnt);
f5fc0f86 485
c15f63bf
JO		 486 wl1271_rx(wl, wl->fw_status);
487 }
f5fc0f86
LC		 488
489out_sleep:
74621417 490 wl1271_spi_write32(wl, ACX_REG_INTERRUPT_MASK,
73d0a13c 491 WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK));
f5fc0f86
LC		 492 wl1271_ps_elp_sleep(wl);
493
494out:
495 mutex_unlock(&wl->mutex);
496}
497
498static irqreturn_t wl1271_irq(int irq, void *cookie)
499{
500 struct wl1271 *wl;
501 unsigned long flags;
502
503 wl1271_debug(DEBUG_IRQ, "IRQ");
504
505 wl = cookie;
506
507 /* complete the ELP completion */
508 spin_lock_irqsave(&wl->wl_lock, flags);
509 if (wl->elp_compl) {
510 complete(wl->elp_compl);
511 wl->elp_compl = NULL;
512 }
513
a64b07e8 514 ieee80211_queue_work(wl->hw, &wl->irq_work);
f5fc0f86
LC		 515 spin_unlock_irqrestore(&wl->wl_lock, flags);
516
517 return IRQ_HANDLED;
518}
519
520static int wl1271_fetch_firmware(struct wl1271 *wl)
521{
522 const struct firmware *fw;
523 int ret;
524
525 ret = request_firmware(&fw, WL1271_FW_NAME, &wl->spi->dev);
526
527 if (ret < 0) {
528 wl1271_error("could not get firmware: %d", ret);
529 return ret;
530 }
531
532 if (fw->size % 4) {
533 wl1271_error("firmware size is not multiple of 32 bits: %zu",
534 fw->size);
535 ret = -EILSEQ;
536 goto out;
537 }
538
539 wl->fw_len = fw->size;
1fba4974 540 wl->fw = vmalloc(wl->fw_len);
f5fc0f86
LC		 541
542 if (!wl->fw) {
543 wl1271_error("could not allocate memory for the firmware");
544 ret = -ENOMEM;
545 goto out;
546 }
547
548 memcpy(wl->fw, fw->data, wl->fw_len);
549
550 ret = 0;
551
552out:
553 release_firmware(fw);
554
555 return ret;
556}
557
558static int wl1271_fetch_nvs(struct wl1271 *wl)
559{
560 const struct firmware *fw;
561 int ret;
562
563 ret = request_firmware(&fw, WL1271_NVS_NAME, &wl->spi->dev);
564
565 if (ret < 0) {
566 wl1271_error("could not get nvs file: %d", ret);
567 return ret;
568 }
569
570 if (fw->size % 4) {
571 wl1271_error("nvs size is not multiple of 32 bits: %zu",
572 fw->size);
573 ret = -EILSEQ;
574 goto out;
575 }
576
577 wl->nvs_len = fw->size;
578 wl->nvs = kmalloc(wl->nvs_len, GFP_KERNEL);
579
580 if (!wl->nvs) {
581 wl1271_error("could not allocate memory for the nvs file");
582 ret = -ENOMEM;
583 goto out;
584 }
585
586 memcpy(wl->nvs, fw->data, wl->nvs_len);
587
588 ret = 0;
589
590out:
591 release_firmware(fw);
592
593 return ret;
594}
595
596static void wl1271_fw_wakeup(struct wl1271 *wl)
597{
598 u32 elp_reg;
599
600 elp_reg = ELPCTRL_WAKE_UP;
74621417 601 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
f5fc0f86
LC		 602}
603
604static int wl1271_setup(struct wl1271 *wl)
605{
606 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
607 if (!wl->fw_status)
608 return -ENOMEM;
609
610 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
611 if (!wl->tx_res_if) {
612 kfree(wl->fw_status);
613 return -ENOMEM;
614 }
615
616 INIT_WORK(&wl->irq_work, wl1271_irq_work);
617 INIT_WORK(&wl->tx_work, wl1271_tx_work);
618 return 0;
619}
620
621static int wl1271_chip_wakeup(struct wl1271 *wl)
622{
451de97a 623 struct wl1271_partition_set partition;
f5fc0f86
LC		 624 int ret = 0;
625
01ac17ec 626 msleep(WL1271_PRE_POWER_ON_SLEEP);
f5fc0f86
LC		 627 wl1271_power_on(wl);
628 msleep(WL1271_POWER_ON_SLEEP);
629 wl1271_spi_reset(wl);
630 wl1271_spi_init(wl);
631
632 /* We don't need a real memory partition here, because we only want
633 * to use the registers at this point. */
451de97a
JO		 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);
f5fc0f86
LC		 638
639 /* ELP module wake up */
640 wl1271_fw_wakeup(wl);
641
642 /* whal_FwCtrl_BootSm() */
643
644 /* 0. read chip id from CHIP_ID */
74621417 645 wl->chip.id = wl1271_spi_read32(wl, CHIP_ID_B);
f5fc0f86
LC		 646
647 /* 1. check if chip id is valid */
648
649 switch (wl->chip.id) {
650 case CHIP_ID_1271_PG10:
651 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
652 wl->chip.id);
653
654 ret = wl1271_setup(wl);
655 if (ret < 0)
9ccd9217 656 goto out;
f5fc0f86
LC		 657 break;
658 case CHIP_ID_1271_PG20:
659 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
660 wl->chip.id);
661
662 ret = wl1271_setup(wl);
663 if (ret < 0)
9ccd9217 664 goto out;
f5fc0f86
LC		 665 break;
666 default:
9ccd9217 667 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
f5fc0f86 668 ret = -ENODEV;
9ccd9217 669 goto out;
f5fc0f86
LC		 670 }
671
672 if (wl->fw == NULL) {
673 ret = wl1271_fetch_firmware(wl);
674 if (ret < 0)
9ccd9217 675 goto out;
f5fc0f86
LC		 676 }
677
678 /* No NVS from netlink, try to get it from the filesystem */
679 if (wl->nvs == NULL) {
680 ret = wl1271_fetch_nvs(wl);
681 if (ret < 0)
9ccd9217 682 goto out;
f5fc0f86
LC		 683 }
684
685out:
686 return ret;
687}
688
f5fc0f86
LC		 689int wl1271_plt_start(struct wl1271 *wl)
690{
9ccd9217 691 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 692 int ret;
693
694 mutex_lock(&wl->mutex);
695
696 wl1271_notice("power up");
697
698 if (wl->state != WL1271_STATE_OFF) {
699 wl1271_error("cannot go into PLT state because not "
700 "in off state: %d", wl->state);
701 ret = -EBUSY;
702 goto out;
703 }
704
9ccd9217
JO		 705 while (retries) {
706 retries--;
707 ret = wl1271_chip_wakeup(wl);
708 if (ret < 0)
709 goto power_off;
f5fc0f86 710
9ccd9217
JO		 711 ret = wl1271_boot(wl);
712 if (ret < 0)
713 goto power_off;
eb5b28d0 714
9ccd9217
JO		 715 ret = wl1271_plt_init(wl);
716 if (ret < 0)
717 goto irq_disable;
bd5ea18f 718
9ccd9217
JO		 719 /* Make sure power saving is disabled */
720 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
721 if (ret < 0)
722 goto irq_disable;
eb5b28d0 723
9ccd9217
JO		 724 wl->state = WL1271_STATE_PLT;
725 wl1271_notice("firmware booted in PLT mode (%s)",
726 wl->chip.fw_ver);
727 goto out;
eb5b28d0 728
9ccd9217
JO		 729irq_disable:
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);
741power_off:
742 wl1271_power_off(wl);
743 }
f5fc0f86 744
9ccd9217
JO		 745 wl1271_error("firmware boot in PLT mode failed despite %d retries",
746 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 747out:
748 mutex_unlock(&wl->mutex);
749
750 return ret;
751}
752
753int wl1271_plt_stop(struct wl1271 *wl)
754{
755 int ret = 0;
756
757 mutex_lock(&wl->mutex);
758
759 wl1271_notice("power down");
760
761 if (wl->state != WL1271_STATE_PLT) {
762 wl1271_error("cannot power down because not in PLT "
763 "state: %d", wl->state);
764 ret = -EBUSY;
765 goto out;
766 }
767
768 wl1271_disable_interrupts(wl);
769 wl1271_power_off(wl);
770
771 wl->state = WL1271_STATE_OFF;
bd5ea18f 772 wl->rx_counter = 0;
f5fc0f86
LC		 773
774out:
775 mutex_unlock(&wl->mutex);
776
777 return ret;
778}
779
780
781static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
782{
783 struct wl1271 *wl = hw->priv;
830fb67b
JO		 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;
787 unsigned long flags;
f5fc0f86 788
830fb67b
JO		 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);
794 }
795 spin_unlock_irqrestore(&wl->wl_lock, flags);
796
797 /* queue the packet */
f5fc0f86
LC		 798 skb_queue_tail(&wl->tx_queue, skb);
799
800 /*
801 * The chip specific setup must run before the first TX packet -
802 * before that, the tx_work will not be initialized!
803 */
804
a64b07e8 805 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 806
807 /*
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.
810 */
811 if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_MAX_LENGTH) {
812 ieee80211_stop_queues(wl->hw);
813
814 /*
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?
818 */
71449f8d 819 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
f5fc0f86
LC		 820 }
821
822 return NETDEV_TX_OK;
823}
824
01c09162
JO		 825static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
826 void *arg)
827{
828 struct net_device *dev;
829 struct wireless_dev *wdev;
830 struct wiphy *wiphy;
831 struct ieee80211_hw *hw;
832 struct wl1271 *wl;
833 struct wl1271 *wl_temp;
834 struct in_device *idev;
835 struct in_ifaddr *ifa = arg;
836 int ret = 0;
837
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
845 * IP address. */
846
847 dev = ifa->ifa_dev->dev;
848
849 wdev = dev->ieee80211_ptr;
850 if (wdev == NULL)
17d7265c 851 return NOTIFY_DONE;
01c09162
JO		 852
853 wiphy = wdev->wiphy;
854 if (wiphy == NULL)
17d7265c 855 return NOTIFY_DONE;
01c09162
JO		 856
857 hw = wiphy_priv(wiphy);
858 if (hw == NULL)
17d7265c 859 return NOTIFY_DONE;
01c09162
JO		 860
861 /* Check that the interface is one supported by this driver. */
862 wl_temp = hw->priv;
863 list_for_each_entry(wl, &wl_list, list) {
864 if (wl == wl_temp)
865 break;
866 }
867 if (wl == NULL)
17d7265c 868 return NOTIFY_DONE;
01c09162
JO		 869
870 /* Get the interface IP address for the device. "ifa" will become
871 NULL if:
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.
875 */
876 ifa = NULL;
877 idev = dev->ip_ptr;
878 if (idev)
879 ifa = idev->ifa_list;
880
881 if (ifa && ifa->ifa_next)
882 ifa = NULL;
883
884 mutex_lock(&wl->mutex);
885
886 if (wl->state == WL1271_STATE_OFF)
887 goto out;
888
889 ret = wl1271_ps_elp_wakeup(wl, false);
890 if (ret < 0)
891 goto out;
892 if (ifa)
893 ret = wl1271_acx_arp_ip_filter(wl, true,
894 (u8 *)&ifa->ifa_address,
895 ACX_IPV4_VERSION);
896 else
897 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
898 ACX_IPV4_VERSION);
899 wl1271_ps_elp_sleep(wl);
900
901out:
902 mutex_unlock(&wl->mutex);
903
17d7265c 904 return NOTIFY_OK;
01c09162
JO		 905}
906
907static struct notifier_block wl1271_dev_notifier = {
908 .notifier_call = wl1271_dev_notify,
909};
910
911
f5fc0f86
LC		 912static int wl1271_op_start(struct ieee80211_hw *hw)
913{
914 struct wl1271 *wl = hw->priv;
9ccd9217 915 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 916 int ret = 0;
917
918 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
919
920 mutex_lock(&wl->mutex);
921
922 if (wl->state != WL1271_STATE_OFF) {
923 wl1271_error("cannot start because not in off state: %d",
924 wl->state);
925 ret = -EBUSY;
926 goto out;
927 }
928
9ccd9217
JO		 929 while (retries) {
930 retries--;
931 ret = wl1271_chip_wakeup(wl);
932 if (ret < 0)
933 goto power_off;
f5fc0f86 934
9ccd9217
JO		 935 ret = wl1271_boot(wl);
936 if (ret < 0)
937 goto power_off;
f5fc0f86 938
9ccd9217
JO		 939 ret = wl1271_hw_init(wl);
940 if (ret < 0)
941 goto irq_disable;
f5fc0f86 942
9ccd9217
JO		 943 wl->state = WL1271_STATE_ON;
944 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
945 goto out;
eb5b28d0 946
9ccd9217
JO		 947irq_disable:
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);
959power_off:
960 wl1271_power_off(wl);
961 }
eb5b28d0 962
9ccd9217
JO		 963 wl1271_error("firmware boot failed despite %d retries",
964 WL1271_BOOT_RETRIES);
eb5b28d0 965out:
f5fc0f86
LC		 966 mutex_unlock(&wl->mutex);
967
01c09162
JO		 968 if (!ret) {
969 list_add(&wl->list, &wl_list);
970 register_inetaddr_notifier(&wl1271_dev_notifier);
971 }
972
f5fc0f86
LC		 973 return ret;
974}
975
976static void wl1271_op_stop(struct ieee80211_hw *hw)
977{
978 struct wl1271 *wl = hw->priv;
979 int i;
980
981 wl1271_info("down");
982
983 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
984
01c09162
JO		 985 unregister_inetaddr_notifier(&wl1271_dev_notifier);
986 list_del(&wl->list);
987
f5fc0f86
LC		 988 mutex_lock(&wl->mutex);
989
990 WARN_ON(wl->state != WL1271_STATE_ON);
991
71449f8d 992 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
f5fc0f86
LC		 993 mutex_unlock(&wl->mutex);
994 ieee80211_scan_completed(wl->hw, true);
995 mutex_lock(&wl->mutex);
f5fc0f86
LC		 996 }
997
998 wl->state = WL1271_STATE_OFF;
999
1000 wl1271_disable_interrupts(wl);
1001
1002 mutex_unlock(&wl->mutex);
1003
1004 cancel_work_sync(&wl->irq_work);
1005 cancel_work_sync(&wl->tx_work);
f5fc0f86
LC		 1006
1007 mutex_lock(&wl->mutex);
1008
1009 /* let's notify MAC80211 about the remaining pending TX frames */
1010 wl1271_tx_flush(wl);
1011 wl1271_power_off(wl);
1012
1013 memset(wl->bssid, 0, ETH_ALEN);
1014 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1015 wl->ssid_len = 0;
f5fc0f86 1016 wl->bss_type = MAX_BSS_TYPE;
8a5a37a6 1017 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1018
1019 wl->rx_counter = 0;
19ad0715 1020 wl->psm_entry_retry = 0;
f5fc0f86
LC		 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;
ac4e4ce5
JO		 1025 wl->tx_security_last_seq = 0;
1026 wl->tx_security_seq_16 = 0;
1027 wl->tx_security_seq_32 = 0;
f5fc0f86
LC		 1028 wl->time_offset = 0;
1029 wl->session_counter = 0;
830fb67b
JO		 1030 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1031 wl->sta_rate_set = 0;
1032 wl->flags = 0;
d6e19d13 1033
f5fc0f86
LC		 1034 for (i = 0; i < NUM_TX_QUEUES; i++)
1035 wl->tx_blocks_freed[i] = 0;
1036
1037 wl1271_debugfs_reset(wl);
1038 mutex_unlock(&wl->mutex);
1039}
1040
1041static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1ed32e4f 1042 struct ieee80211_vif *vif)
f5fc0f86
LC		 1043{
1044 struct wl1271 *wl = hw->priv;
f5fc0f86
LC		 1045 int ret = 0;
1046
e5539bcb 1047 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1ed32e4f 1048 vif->type, vif->addr);
f5fc0f86
LC		 1049
1050 mutex_lock(&wl->mutex);
b771eee5
JO		 1051 if (wl->vif) {
1052 ret = -EBUSY;
1053 goto out;
1054 }
1055
1ed32e4f 1056 wl->vif = vif;
f5fc0f86 1057
1ed32e4f 1058 switch (vif->type) {
f5fc0f86
LC		 1059 case NL80211_IFTYPE_STATION:
1060 wl->bss_type = BSS_TYPE_STA_BSS;
1061 break;
1062 case NL80211_IFTYPE_ADHOC:
1063 wl->bss_type = BSS_TYPE_IBSS;
1064 break;
1065 default:
1066 ret = -EOPNOTSUPP;
1067 goto out;
1068 }
1069
1070 /* FIXME: what if conf->mac_addr changes? */
1071
1072out:
1073 mutex_unlock(&wl->mutex);
1074 return ret;
1075}
1076
1077static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1ed32e4f 1078 struct ieee80211_vif *vif)
f5fc0f86 1079{
b771eee5
JO		 1080 struct wl1271 *wl = hw->priv;
1081
1082 mutex_lock(&wl->mutex);
f5fc0f86 1083 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
b771eee5
JO		 1084 wl->vif = NULL;
1085 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 1086}
1087
1088#if 0
1089static int wl1271_op_config_interface(struct ieee80211_hw *hw,
1090 struct ieee80211_vif *vif,
1091 struct ieee80211_if_conf *conf)
1092{
1093 struct wl1271 *wl = hw->priv;
1094 struct sk_buff *beacon;
f5fc0f86
LC		 1095 int ret;
1096
3264690b
DM		 1097 wl1271_debug(DEBUG_MAC80211, "mac80211 config_interface bssid %pM",
1098 conf->bssid);
f5fc0f86
LC		 1099 wl1271_dump_ascii(DEBUG_MAC80211, "ssid: ", conf->ssid,
1100 conf->ssid_len);
1101
1102 mutex_lock(&wl->mutex);
1103
1104 ret = wl1271_ps_elp_wakeup(wl, false);
1105 if (ret < 0)
1106 goto out;
1107
ae751bab
LC		 1108 if (memcmp(wl->bssid, conf->bssid, ETH_ALEN)) {
1109 wl1271_debug(DEBUG_MAC80211, "bssid changed");
1110
1111 memcpy(wl->bssid, conf->bssid, ETH_ALEN);
1112
1113 ret = wl1271_cmd_join(wl);
1114 if (ret < 0)
1115 goto out_sleep;
f5fc0f86 1116
c6317a54
JO		 1117 ret = wl1271_cmd_build_null_data(wl);
1118 if (ret < 0)
1119 goto out_sleep;
1120 }
f5fc0f86
LC		 1121
1122 wl->ssid_len = conf->ssid_len;
1123 if (wl->ssid_len)
1124 memcpy(wl->ssid, conf->ssid, wl->ssid_len);
1125
f5fc0f86
LC		 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);
1130
1131 if (ret < 0) {
1132 dev_kfree_skb(beacon);
1133 goto out_sleep;
1134 }
1135
1136 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE,
1137 beacon->data, beacon->len);
1138
1139 dev_kfree_skb(beacon);
1140
f5fc0f86
LC		 1141 if (ret < 0)
1142 goto out_sleep;
1143 }
1144
1145out_sleep:
1146 wl1271_ps_elp_sleep(wl);
1147
1148out:
1149 mutex_unlock(&wl->mutex);
1150
1151 return ret;
1152}
1153#endif
1154
c7f43e45
LC		 1155static int wl1271_join_channel(struct wl1271 *wl, int channel)
1156{
e0d8bbf0 1157 int ret = 0;
c7f43e45
LC		 1158 /* we need to use a dummy BSSID for now */
1159 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1160 0xad, 0xbe, 0xef };
1161
e0d8bbf0
JO		 1162 /* the dummy join is not required for ad-hoc */
1163 if (wl->bss_type == BSS_TYPE_IBSS)
1164 goto out;
1165
c7f43e45
LC		 1166 /* disable mac filter, so we hear everything */
1167 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1168
1169 wl->channel = channel;
1170 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1171
1172 ret = wl1271_cmd_join(wl);
1173 if (ret < 0)
1174 goto out;
1175
71449f8d 1176 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1177
1178out:
1179 return ret;
1180}
1181
1182static int wl1271_unjoin_channel(struct wl1271 *wl)
1183{
1184 int ret;
1185
1186 /* to stop listening to a channel, we disconnect */
1187 ret = wl1271_cmd_disconnect(wl);
1188 if (ret < 0)
1189 goto out;
1190
71449f8d 1191 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1192 wl->channel = 0;
1193 memset(wl->bssid, 0, ETH_ALEN);
1194 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1195
1196out:
1197 return ret;
1198}
1199
f5fc0f86
LC		 1200static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1201{
1202 struct wl1271 *wl = hw->priv;
1203 struct ieee80211_conf *conf = &hw->conf;
1204 int channel, ret = 0;
1205
1206 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1207
c7f43e45 1208 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
f5fc0f86
LC		 1209 channel,
1210 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45
LC		 1211 conf->power_level,
1212 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
f5fc0f86
LC		 1213
1214 mutex_lock(&wl->mutex);
1215
8a5a37a6
JO		 1216 wl->band = conf->channel->band;
1217
f5fc0f86
LC		 1218 ret = wl1271_ps_elp_wakeup(wl, false);
1219 if (ret < 0)
1220 goto out;
1221
c7f43e45 1222 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
71449f8d
JO		 1223 if (conf->flags & IEEE80211_CONF_IDLE &&
1224 test_bit(WL1271_FLAG_JOINED, &wl->flags))
c7f43e45 1225 wl1271_unjoin_channel(wl);
8f648c00 1226 else if (!(conf->flags & IEEE80211_CONF_IDLE))
c7f43e45 1227 wl1271_join_channel(wl, channel);
a6fe2313
JO		 1228
1229 if (conf->flags & IEEE80211_CONF_IDLE) {
830fb67b
JO		 1230 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1231 wl->sta_rate_set = 0;
1232 wl1271_acx_rate_policies(wl);
a6fe2313 1233 }
f5fc0f86
LC		 1234 }
1235
c7f43e45 1236 /* if the channel changes while joined, join again */
71449f8d 1237 if (channel != wl->channel && test_bit(WL1271_FLAG_JOINED, &wl->flags))
c7f43e45
LC		 1238 wl1271_join_channel(wl, channel);
1239
71449f8d
JO		 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);
f5fc0f86
LC		 1243
1244 /*
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.
1248 */
830fb67b 1249 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
af5e084b
JO		 1250 wl1271_info("psm enabled");
1251 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
1252 }
f5fc0f86 1253 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1254 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
f5fc0f86
LC		 1255 wl1271_info("psm disabled");
1256
71449f8d 1257 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1258
71449f8d 1259 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
f5fc0f86
LC		 1260 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE);
1261 }
1262
1263 if (conf->power_level != wl->power_level) {
1264 ret = wl1271_acx_tx_power(wl, conf->power_level);
1265 if (ret < 0)
c6317a54 1266 goto out_sleep;
f5fc0f86
LC		 1267
1268 wl->power_level = conf->power_level;
1269 }
1270
1271out_sleep:
1272 wl1271_ps_elp_sleep(wl);
1273
1274out:
1275 mutex_unlock(&wl->mutex);
1276
1277 return ret;
1278}
1279
b54853f1
JO		 1280struct wl1271_filter_params {
1281 bool enabled;
1282 int mc_list_length;
1283 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1284};
1285
c87dec9f
JO		 1286static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1287 struct dev_addr_list *mc_list)
1288{
c87dec9f 1289 struct wl1271_filter_params *fp;
c87dec9f
JO		 1290 int i;
1291
74441130 1292 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1293 if (!fp) {
1294 wl1271_error("Out of memory setting filters.");
1295 return 0;
1296 }
1297
1298 /* update multicast filtering parameters */
b54853f1 1299 fp->enabled = true;
c87dec9f
JO		 1300 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1301 mc_count = 0;
b54853f1 1302 fp->enabled = false;
c87dec9f
JO		 1303 }
1304
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++;
1311 } else
1312 wl1271_warning("Unknown mc address length.");
74441130 1313 mc_list = mc_list->next;
c87dec9f
JO		 1314 }
1315
b54853f1 1316 return (u64)(unsigned long)fp;
c87dec9f 1317}
f5fc0f86 1318
b54853f1
JO		 1319#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1320 FIF_ALLMULTI | \
1321 FIF_FCSFAIL | \
1322 FIF_BCN_PRBRESP_PROMISC | \
1323 FIF_CONTROL | \
1324 FIF_OTHER_BSS)
1325
f5fc0f86
LC		 1326static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1327 unsigned int changed,
c87dec9f 1328 unsigned int *total, u64 multicast)
f5fc0f86 1329{
b54853f1 1330 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1331 struct wl1271 *wl = hw->priv;
b54853f1 1332 int ret;
f5fc0f86
LC		 1333
1334 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1335
b54853f1
JO		 1336 mutex_lock(&wl->mutex);
1337
1338 if (wl->state == WL1271_STATE_OFF)
1339 goto out;
1340
1341 ret = wl1271_ps_elp_wakeup(wl, false);
1342 if (ret < 0)
1343 goto out;
1344
f5fc0f86
LC		 1345 *total &= WL1271_SUPPORTED_FILTERS;
1346 changed &= WL1271_SUPPORTED_FILTERS;
1347
b54853f1
JO		 1348 if (*total & FIF_ALLMULTI)
1349 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1350 else if (fp)
1351 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1352 fp->mc_list,
1353 fp->mc_list_length);
1354 if (ret < 0)
1355 goto out_sleep;
f5fc0f86 1356
b54853f1
JO		 1357 kfree(fp);
1358
1359 /* FIXME: We still need to set our filters properly */
c87dec9f 1360
b54853f1
JO		 1361 /* determine, whether supported filter values have changed */
1362 if (changed == 0)
1363 goto out_sleep;
c87dec9f 1364
b54853f1
JO		 1365 /* apply configured filters */
1366 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1367 if (ret < 0)
1368 goto out_sleep;
1369
1370out_sleep:
1371 wl1271_ps_elp_sleep(wl);
1372
1373out:
1374 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 1375}
1376
1377static 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)
1381{
1382 struct wl1271 *wl = hw->priv;
1383 const u8 *addr;
1384 int ret;
ac4e4ce5
JO		 1385 u32 tx_seq_32 = 0;
1386 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1387 u8 key_type;
1388
1389 static const u8 bcast_addr[ETH_ALEN] =
1390 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1391
1392 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1393
1394 addr = sta ? sta->addr : bcast_addr;
1395
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);
1402
1403 if (is_zero_ether_addr(addr)) {
1404 /* We dont support TX only encryption */
1405 ret = -EOPNOTSUPP;
1406 goto out;
1407 }
1408
1409 mutex_lock(&wl->mutex);
1410
1411 ret = wl1271_ps_elp_wakeup(wl, false);
1412 if (ret < 0)
1413 goto out_unlock;
1414
1415 switch (key_conf->alg) {
1416 case ALG_WEP:
1417 key_type = KEY_WEP;
1418
1419 key_conf->hw_key_idx = key_conf->keyidx;
1420 break;
1421 case ALG_TKIP:
1422 key_type = KEY_TKIP;
1423
1424 key_conf->hw_key_idx = key_conf->keyidx;
ac4e4ce5
JO		 1425 tx_seq_32 = wl->tx_security_seq_32;
1426 tx_seq_16 = wl->tx_security_seq_16;
f5fc0f86
LC		 1427 break;
1428 case ALG_CCMP:
1429 key_type = KEY_AES;
1430
1431 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
ac4e4ce5
JO		 1432 tx_seq_32 = wl->tx_security_seq_32;
1433 tx_seq_16 = wl->tx_security_seq_16;
f5fc0f86
LC		 1434 break;
1435 default:
1436 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1437
1438 ret = -EOPNOTSUPP;
1439 goto out_sleep;
1440 }
1441
1442 switch (cmd) {
1443 case SET_KEY:
1444 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1445 key_conf->keyidx, key_type,
1446 key_conf->keylen, key_conf->key,
ac4e4ce5 1447 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1448 if (ret < 0) {
1449 wl1271_error("Could not add or replace key");
1450 goto out_sleep;
1451 }
1452 break;
1453
1454 case DISABLE_KEY:
1455 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1456 key_conf->keyidx, key_type,
1457 key_conf->keylen, key_conf->key,
ac4e4ce5 1458 addr, 0, 0);
f5fc0f86
LC		 1459 if (ret < 0) {
1460 wl1271_error("Could not remove key");
1461 goto out_sleep;
1462 }
1463 break;
1464
1465 default:
1466 wl1271_error("Unsupported key cmd 0x%x", cmd);
1467 ret = -EOPNOTSUPP;
1468 goto out_sleep;
1469
1470 break;
1471 }
1472
1473out_sleep:
1474 wl1271_ps_elp_sleep(wl);
1475
1476out_unlock:
1477 mutex_unlock(&wl->mutex);
1478
1479out:
1480 return ret;
1481}
1482
1483static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1484 struct cfg80211_scan_request *req)
1485{
1486 struct wl1271 *wl = hw->priv;
1487 int ret;
1488 u8 *ssid = NULL;
abb0b3bf 1489 size_t len = 0;
f5fc0f86
LC		 1490
1491 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1492
1493 if (req->n_ssids) {
1494 ssid = req->ssids[0].ssid;
abb0b3bf 1495 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1496 }
1497
1498 mutex_lock(&wl->mutex);
1499
1500 ret = wl1271_ps_elp_wakeup(wl, false);
1501 if (ret < 0)
1502 goto out;
1503
abb0b3bf
TP		 1504 if (wl1271_11a_enabled())
1505 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1506 WL1271_SCAN_BAND_DUAL, 3);
1507 else
1508 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1509 WL1271_SCAN_BAND_2_4_GHZ, 3);
f5fc0f86
LC		 1510
1511 wl1271_ps_elp_sleep(wl);
1512
1513out:
1514 mutex_unlock(&wl->mutex);
1515
1516 return ret;
1517}
1518
1519static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1520{
1521 struct wl1271 *wl = hw->priv;
1522 int ret;
1523
1524 mutex_lock(&wl->mutex);
1525
1526 ret = wl1271_ps_elp_wakeup(wl, false);
1527 if (ret < 0)
1528 goto out;
1529
1530 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1531 if (ret < 0)
1532 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1533
1534 wl1271_ps_elp_sleep(wl);
1535
1536out:
1537 mutex_unlock(&wl->mutex);
1538
1539 return ret;
1540}
1541
1542static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1543 struct ieee80211_vif *vif,
1544 struct ieee80211_bss_conf *bss_conf,
1545 u32 changed)
1546{
1547 enum wl1271_cmd_ps_mode mode;
1548 struct wl1271 *wl = hw->priv;
1549 int ret;
1550
1551 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1552
1553 mutex_lock(&wl->mutex);
1554
1555 ret = wl1271_ps_elp_wakeup(wl, false);
1556 if (ret < 0)
1557 goto out;
1558
c7f43e45
LC		 1559 if ((changed & BSS_CHANGED_BSSID) &&
1560 /*
1561 * Now we know the correct bssid, so we send a new join command
1562 * and enable the BSSID filter
1563 */
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);
bdcbbb94
LC		 1567 ret = wl1271_cmd_build_null_data(wl);
1568 if (ret < 0) {
1569 wl1271_warning("cmd buld null data failed %d",
1570 ret);
1571 goto out_sleep;
1572 }
cd264769
LC		 1573 ret = wl1271_cmd_join(wl);
1574 if (ret < 0) {
1575 wl1271_warning("cmd join failed %d", ret);
1576 goto out_sleep;
1577 }
71449f8d 1578 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1579 }
1580
e0d8bbf0
JO		 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);
1590
1591 if (beacon) {
1592 struct ieee80211_hdr *hdr;
1593 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1594 beacon->data,
1595 beacon->len);
1596
1597 if (ret < 0) {
1598 dev_kfree_skb(beacon);
1599 goto out_sleep;
1600 }
1601
1602 hdr = (struct ieee80211_hdr *) beacon->data;
1603 hdr->frame_control = cpu_to_le16(
1604 IEEE80211_FTYPE_MGMT |
1605 IEEE80211_STYPE_PROBE_RESP);
1606
1607 ret = wl1271_cmd_template_set(wl,
1608 CMD_TEMPL_PROBE_RESPONSE,
1609 beacon->data,
1610 beacon->len);
1611 dev_kfree_skb(beacon);
1612 if (ret < 0)
1613 goto out_sleep;
1614 }
1615 }
1616
f5fc0f86
LC		 1617 if (changed & BSS_CHANGED_ASSOC) {
1618 if (bss_conf->assoc) {
1619 wl->aid = bss_conf->aid;
830fb67b 1620 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
f5fc0f86 1621
ae751bab
LC		 1622 /*
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.
1627 */
f5fc0f86
LC		 1628 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1629 if (ret < 0)
1630 goto out_sleep;
1631
1632 ret = wl1271_acx_aid(wl, wl->aid);
1633 if (ret < 0)
1634 goto out_sleep;
1635
1636 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1637 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1638 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86
LC		 1639 mode = STATION_POWER_SAVE_MODE;
1640 ret = wl1271_ps_set_mode(wl, mode);
1641 if (ret < 0)
1642 goto out_sleep;
1643 }
d94cd297
JO		 1644 } else {
1645 /* use defaults when not associated */
830fb67b 1646 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1647 wl->aid = 0;
f5fc0f86 1648 }
d94cd297 1649
f5fc0f86 1650 }
8a5a37a6 1651
f5fc0f86
LC		 1652 if (changed & BSS_CHANGED_ERP_SLOT) {
1653 if (bss_conf->use_short_slot)
1654 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1655 else
1656 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1657 if (ret < 0) {
1658 wl1271_warning("Set slot time failed %d", ret);
1659 goto out_sleep;
1660 }
1661 }
1662
1663 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1664 if (bss_conf->use_short_preamble)
1665 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1666 else
1667 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1668 }
1669
1670 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1671 if (bss_conf->use_cts_prot)
1672 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1673 else
1674 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1675 if (ret < 0) {
1676 wl1271_warning("Set ctsprotect failed %d", ret);
1677 goto out_sleep;
1678 }
1679 }
1680
1681out_sleep:
1682 wl1271_ps_elp_sleep(wl);
1683
1684out:
1685 mutex_unlock(&wl->mutex);
1686}
1687
1688
1689/* can't be const, mac80211 writes to this */
1690static struct ieee80211_rate wl1271_rates[] = {
1691 { .bitrate = 10,
2b60100b
JO		 1692 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1693 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 1694 { .bitrate = 20,
2b60100b
JO		 1695 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1696 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 1697 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1698 { .bitrate = 55,
2b60100b
JO		 1699 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1700 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 1701 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1702 { .bitrate = 110,
2b60100b
JO		 1703 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1704 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 1705 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1706 { .bitrate = 60,
2b60100b
JO		 1707 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1708 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 1709 { .bitrate = 90,
2b60100b
JO		 1710 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1711 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 1712 { .bitrate = 120,
2b60100b
JO		 1713 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1714 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 1715 { .bitrate = 180,
2b60100b
JO		 1716 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1717 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 1718 { .bitrate = 240,
2b60100b
JO		 1719 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1720 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 1721 { .bitrate = 360,
2b60100b
JO		 1722 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1723 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 1724 { .bitrate = 480,
2b60100b
JO		 1725 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1726 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 1727 { .bitrate = 540,
2b60100b
JO		 1728 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1729 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 1730};
1731
1732/* can't be const, mac80211 writes to this */
1733static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1
LC		 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 },
f5fc0f86
LC		 1747};
1748
1749/* can't be const, mac80211 writes to this */
1750static 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),
1755};
1756
1ebec3d7
TP		 1757/* 5 GHz data rates for WL1273 */
1758static struct ieee80211_rate wl1271_rates_5ghz[] = {
1759 { .bitrate = 60,
1760 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1761 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1762 { .bitrate = 90,
1763 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1764 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1765 { .bitrate = 120,
1766 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1767 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1768 { .bitrate = 180,
1769 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1770 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1771 { .bitrate = 240,
1772 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1773 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1774 { .bitrate = 360,
1775 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1776 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1777 { .bitrate = 480,
1778 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1779 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1780 { .bitrate = 540,
1781 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1782 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1783};
1784
1785/* 5 GHz band channels for WL1273 */
1786static 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},
1829};
1830
1831
1832static 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),
1837};
1838
f5fc0f86
LC		 1839static 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, */
c87dec9f 1846 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 1847 .configure_filter = wl1271_op_configure_filter,
1848 .tx = wl1271_op_tx,
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,
1853};
1854
1855static int wl1271_register_hw(struct wl1271 *wl)
1856{
1857 int ret;
1858
1859 if (wl->mac80211_registered)
1860 return 0;
1861
1862 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1863
1864 ret = ieee80211_register_hw(wl->hw);
1865 if (ret < 0) {
1866 wl1271_error("unable to register mac80211 hw: %d", ret);
1867 return ret;
1868 }
1869
1870 wl->mac80211_registered = true;
1871
1872 wl1271_notice("loaded");
1873
1874 return 0;
1875}
1876
1877static int wl1271_init_ieee80211(struct wl1271 *wl)
1878{
1e2b7976
JO		 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);
f5fc0f86
LC		 1882
1883 /* unit us */
1884 /* FIXME: find a proper value */
1885 wl->hw->channel_change_time = 10000;
1886
1887 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1922167b 1888 IEEE80211_HW_NOISE_DBM |
03442a33
JO		 1889 IEEE80211_HW_BEACON_FILTER |
1890 IEEE80211_HW_SUPPORTS_PS;
f5fc0f86 1891
e0d8bbf0
JO		 1892 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1893 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 1894 wl->hw->wiphy->max_scan_ssids = 1;
1895 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1896
1ebec3d7
TP		 1897 if (wl1271_11a_enabled())
1898 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1899
f5fc0f86
LC		 1900 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
1901
1902 return 0;
1903}
1904
1905static void wl1271_device_release(struct device *dev)
1906{
1907
1908}
1909
1910static struct platform_device wl1271_device = {
1911 .name = "wl1271",
1912 .id = -1,
1913
1914 /* device model insists to have a release function */
1915 .dev = {
1916 .release = wl1271_device_release,
1917 },
1918};
1919
1920#define WL1271_DEFAULT_CHANNEL 0
1921static int __devinit wl1271_probe(struct spi_device *spi)
1922{
1923 struct wl12xx_platform_data *pdata;
1924 struct ieee80211_hw *hw;
1925 struct wl1271 *wl;
1926 int ret, i;
1927 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
1928
1929 pdata = spi->dev.platform_data;
1930 if (!pdata) {
1931 wl1271_error("no platform data");
1932 return -ENODEV;
1933 }
1934
1935 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
1936 if (!hw) {
1937 wl1271_error("could not alloc ieee80211_hw");
1938 return -ENOMEM;
1939 }
1940
1941 wl = hw->priv;
1942 memset(wl, 0, sizeof(*wl));
1943
01c09162
JO		 1944 INIT_LIST_HEAD(&wl->list);
1945
f5fc0f86
LC		 1946 wl->hw = hw;
1947 dev_set_drvdata(&spi->dev, wl);
1948 wl->spi = spi;
1949
1950 skb_queue_head_init(&wl->tx_queue);
1951
37b70a81 1952 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
f5fc0f86 1953 wl->channel = WL1271_DEFAULT_CHANNEL;
f5fc0f86 1954 wl->default_key = 0;
f5fc0f86
LC		 1955 wl->rx_counter = 0;
1956 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1957 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 1958 wl->psm_entry_retry = 0;
f5fc0f86 1959 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 1960 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 1961 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1962 wl->sta_rate_set = 0;
8a5a37a6 1963 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 1964 wl->vif = NULL;
830fb67b 1965 wl->flags = 0;
f5fc0f86 1966
be7078c2 1967 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 1968 wl->tx_frames[i] = NULL;
1969
1970 spin_lock_init(&wl->wl_lock);
1971
1972 /*
1973 * In case our MAC address is not correctly set,
1974 * we use a random but Nokia MAC.
1975 */
1976 memcpy(wl->mac_addr, nokia_oui, 3);
1977 get_random_bytes(wl->mac_addr + 3, 3);
1978
1979 wl->state = WL1271_STATE_OFF;
1980 mutex_init(&wl->mutex);
1981
f5fc0f86
LC		 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;
1985
1986 ret = spi_setup(spi);
1987 if (ret < 0) {
1988 wl1271_error("spi_setup failed");
1989 goto out_free;
1990 }
1991
1992 wl->set_power = pdata->set_power;
1993 if (!wl->set_power) {
1994 wl1271_error("set power function missing in platform data");
1995 ret = -ENODEV;
1996 goto out_free;
1997 }
1998
1999 wl->irq = spi->irq;
2000 if (wl->irq < 0) {
2001 wl1271_error("irq missing in platform data");
2002 ret = -ENODEV;
2003 goto out_free;
2004 }
2005
2006 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
2007 if (ret < 0) {
2008 wl1271_error("request_irq() failed: %d", ret);
2009 goto out_free;
2010 }
2011
2012 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
2013
2014 disable_irq(wl->irq);
2015
2016 ret = platform_device_register(&wl1271_device);
2017 if (ret) {
2018 wl1271_error("couldn't register platform device");
2019 goto out_irq;
2020 }
2021 dev_set_drvdata(&wl1271_device.dev, wl);
2022
2b60100b
JO		 2023 /* Apply default driver configuration. */
2024 wl1271_conf_init(wl);
2025
f5fc0f86
LC		 2026 ret = wl1271_init_ieee80211(wl);
2027 if (ret)
2028 goto out_platform;
2029
2030 ret = wl1271_register_hw(wl);
2031 if (ret)
2032 goto out_platform;
2033
2034 wl1271_debugfs_init(wl);
2035
2036 wl1271_notice("initialized");
2037
2038 return 0;
2039
2040 out_platform:
2041 platform_device_unregister(&wl1271_device);
2042
2043 out_irq:
2044 free_irq(wl->irq, wl);
2045
2046 out_free:
f5fc0f86
LC		 2047 ieee80211_free_hw(hw);
2048
2049 return ret;
2050}
2051
2052static int __devexit wl1271_remove(struct spi_device *spi)
2053{
2054 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
2055
2056 ieee80211_unregister_hw(wl->hw);
2057
2058 wl1271_debugfs_exit(wl);
2059 platform_device_unregister(&wl1271_device);
2060 free_irq(wl->irq, wl);
2061 kfree(wl->target_mem_map);
1fba4974 2062 vfree(wl->fw);
f5fc0f86
LC		 2063 wl->fw = NULL;
2064 kfree(wl->nvs);
2065 wl->nvs = NULL;
2066
f5fc0f86
LC		 2067 kfree(wl->fw_status);
2068 kfree(wl->tx_res_if);
2069
2070 ieee80211_free_hw(wl->hw);
2071
2072 return 0;
2073}
2074
2075
2076static struct spi_driver wl1271_spi_driver = {
2077 .driver = {
2078 .name = "wl1271",
2079 .bus = &spi_bus_type,
2080 .owner = THIS_MODULE,
2081 },
2082
2083 .probe = wl1271_probe,
2084 .remove = __devexit_p(wl1271_remove),
2085};
2086
2087static int __init wl1271_init(void)
2088{
2089 int ret;
2090
2091 ret = spi_register_driver(&wl1271_spi_driver);
2092 if (ret < 0) {
2093 wl1271_error("failed to register spi driver: %d", ret);
2094 goto out;
2095 }
2096
2097out:
2098 return ret;
2099}
2100
2101static void __exit wl1271_exit(void)
2102{
2103 spi_unregister_driver(&wl1271_spi_driver);
2104
2105 wl1271_notice("unloaded");
2106}
2107
2108module_init(wl1271_init);
2109module_exit(wl1271_exit);
2110
2111MODULE_LICENSE("GPL");
2112MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2f018725 2113MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
49f146de 2114MODULE_FIRMWARE(WL1271_FW_NAME);
Clone of davem's net-next-2.6 tree