]> 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
wl1271: modify wl1271_acx_tid_cfg() to use function parameters
[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 */
ddb01a5b
JO		 1237 if (channel != wl->channel &&
1238 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1239 wl->channel = channel;
1240 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
1241 ret = wl1271_cmd_join(wl);
1242 if (ret < 0)
1243 wl1271_warning("cmd join to update channel failed %d",
1244 ret);
1245 } else
1246 wl->channel = channel;
c7f43e45 1247
71449f8d
JO		 1248 if (conf->flags & IEEE80211_CONF_PS &&
1249 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1250 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1251
1252 /*
1253 * We enter PSM only if we're already associated.
1254 * If we're not, we'll enter it when joining an SSID,
1255 * through the bss_info_changed() hook.
1256 */
830fb67b 1257 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
af5e084b 1258 wl1271_info("psm enabled");
d8c42c0c
JO		 1259 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1260 true);
af5e084b 1261 }
f5fc0f86 1262 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1263 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
f5fc0f86
LC		 1264 wl1271_info("psm disabled");
1265
71449f8d 1266 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1267
71449f8d 1268 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c
JO		 1269 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1270 true);
f5fc0f86
LC		 1271 }
1272
1273 if (conf->power_level != wl->power_level) {
1274 ret = wl1271_acx_tx_power(wl, conf->power_level);
1275 if (ret < 0)
c6317a54 1276 goto out_sleep;
f5fc0f86
LC		 1277
1278 wl->power_level = conf->power_level;
1279 }
1280
1281out_sleep:
1282 wl1271_ps_elp_sleep(wl);
1283
1284out:
1285 mutex_unlock(&wl->mutex);
1286
1287 return ret;
1288}
1289
b54853f1
JO		 1290struct wl1271_filter_params {
1291 bool enabled;
1292 int mc_list_length;
1293 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1294};
1295
c87dec9f
JO		 1296static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1297 struct dev_addr_list *mc_list)
1298{
c87dec9f 1299 struct wl1271_filter_params *fp;
c87dec9f
JO		 1300 int i;
1301
74441130 1302 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1303 if (!fp) {
1304 wl1271_error("Out of memory setting filters.");
1305 return 0;
1306 }
1307
1308 /* update multicast filtering parameters */
b54853f1 1309 fp->enabled = true;
c87dec9f
JO		 1310 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1311 mc_count = 0;
b54853f1 1312 fp->enabled = false;
c87dec9f
JO		 1313 }
1314
1315 fp->mc_list_length = 0;
1316 for (i = 0; i < mc_count; i++) {
1317 if (mc_list->da_addrlen == ETH_ALEN) {
1318 memcpy(fp->mc_list[fp->mc_list_length],
1319 mc_list->da_addr, ETH_ALEN);
1320 fp->mc_list_length++;
1321 } else
1322 wl1271_warning("Unknown mc address length.");
74441130 1323 mc_list = mc_list->next;
c87dec9f
JO		 1324 }
1325
b54853f1 1326 return (u64)(unsigned long)fp;
c87dec9f 1327}
f5fc0f86 1328
b54853f1
JO		 1329#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1330 FIF_ALLMULTI | \
1331 FIF_FCSFAIL | \
1332 FIF_BCN_PRBRESP_PROMISC | \
1333 FIF_CONTROL | \
1334 FIF_OTHER_BSS)
1335
f5fc0f86
LC		 1336static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1337 unsigned int changed,
c87dec9f 1338 unsigned int *total, u64 multicast)
f5fc0f86 1339{
b54853f1 1340 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1341 struct wl1271 *wl = hw->priv;
b54853f1 1342 int ret;
f5fc0f86
LC		 1343
1344 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1345
b54853f1
JO		 1346 mutex_lock(&wl->mutex);
1347
1348 if (wl->state == WL1271_STATE_OFF)
1349 goto out;
1350
1351 ret = wl1271_ps_elp_wakeup(wl, false);
1352 if (ret < 0)
1353 goto out;
1354
f5fc0f86
LC		 1355 *total &= WL1271_SUPPORTED_FILTERS;
1356 changed &= WL1271_SUPPORTED_FILTERS;
1357
b54853f1
JO		 1358 if (*total & FIF_ALLMULTI)
1359 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1360 else if (fp)
1361 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1362 fp->mc_list,
1363 fp->mc_list_length);
1364 if (ret < 0)
1365 goto out_sleep;
f5fc0f86 1366
b54853f1
JO		 1367 kfree(fp);
1368
1369 /* FIXME: We still need to set our filters properly */
c87dec9f 1370
b54853f1
JO		 1371 /* determine, whether supported filter values have changed */
1372 if (changed == 0)
1373 goto out_sleep;
c87dec9f 1374
b54853f1
JO		 1375 /* apply configured filters */
1376 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1377 if (ret < 0)
1378 goto out_sleep;
1379
1380out_sleep:
1381 wl1271_ps_elp_sleep(wl);
1382
1383out:
1384 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 1385}
1386
1387static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1388 struct ieee80211_vif *vif,
1389 struct ieee80211_sta *sta,
1390 struct ieee80211_key_conf *key_conf)
1391{
1392 struct wl1271 *wl = hw->priv;
1393 const u8 *addr;
1394 int ret;
ac4e4ce5
JO		 1395 u32 tx_seq_32 = 0;
1396 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1397 u8 key_type;
1398
1399 static const u8 bcast_addr[ETH_ALEN] =
1400 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1401
1402 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1403
1404 addr = sta ? sta->addr : bcast_addr;
1405
1406 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1407 wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1408 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1409 key_conf->alg, key_conf->keyidx,
1410 key_conf->keylen, key_conf->flags);
1411 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1412
1413 if (is_zero_ether_addr(addr)) {
1414 /* We dont support TX only encryption */
1415 ret = -EOPNOTSUPP;
1416 goto out;
1417 }
1418
1419 mutex_lock(&wl->mutex);
1420
1421 ret = wl1271_ps_elp_wakeup(wl, false);
1422 if (ret < 0)
1423 goto out_unlock;
1424
1425 switch (key_conf->alg) {
1426 case ALG_WEP:
1427 key_type = KEY_WEP;
1428
1429 key_conf->hw_key_idx = key_conf->keyidx;
1430 break;
1431 case ALG_TKIP:
1432 key_type = KEY_TKIP;
1433
1434 key_conf->hw_key_idx = key_conf->keyidx;
ac4e4ce5
JO		 1435 tx_seq_32 = wl->tx_security_seq_32;
1436 tx_seq_16 = wl->tx_security_seq_16;
f5fc0f86
LC		 1437 break;
1438 case ALG_CCMP:
1439 key_type = KEY_AES;
1440
1441 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
ac4e4ce5
JO		 1442 tx_seq_32 = wl->tx_security_seq_32;
1443 tx_seq_16 = wl->tx_security_seq_16;
f5fc0f86
LC		 1444 break;
1445 default:
1446 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1447
1448 ret = -EOPNOTSUPP;
1449 goto out_sleep;
1450 }
1451
1452 switch (cmd) {
1453 case SET_KEY:
1454 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1455 key_conf->keyidx, key_type,
1456 key_conf->keylen, key_conf->key,
ac4e4ce5 1457 addr, tx_seq_32, tx_seq_16);
f5fc0f86
LC		 1458 if (ret < 0) {
1459 wl1271_error("Could not add or replace key");
1460 goto out_sleep;
1461 }
1462 break;
1463
1464 case DISABLE_KEY:
1465 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1466 key_conf->keyidx, key_type,
1467 key_conf->keylen, key_conf->key,
ac4e4ce5 1468 addr, 0, 0);
f5fc0f86
LC		 1469 if (ret < 0) {
1470 wl1271_error("Could not remove key");
1471 goto out_sleep;
1472 }
1473 break;
1474
1475 default:
1476 wl1271_error("Unsupported key cmd 0x%x", cmd);
1477 ret = -EOPNOTSUPP;
1478 goto out_sleep;
1479
1480 break;
1481 }
1482
1483out_sleep:
1484 wl1271_ps_elp_sleep(wl);
1485
1486out_unlock:
1487 mutex_unlock(&wl->mutex);
1488
1489out:
1490 return ret;
1491}
1492
1493static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1494 struct cfg80211_scan_request *req)
1495{
1496 struct wl1271 *wl = hw->priv;
1497 int ret;
1498 u8 *ssid = NULL;
abb0b3bf 1499 size_t len = 0;
f5fc0f86
LC		 1500
1501 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1502
1503 if (req->n_ssids) {
1504 ssid = req->ssids[0].ssid;
abb0b3bf 1505 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1506 }
1507
1508 mutex_lock(&wl->mutex);
1509
1510 ret = wl1271_ps_elp_wakeup(wl, false);
1511 if (ret < 0)
1512 goto out;
1513
abb0b3bf
TP		 1514 if (wl1271_11a_enabled())
1515 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1516 WL1271_SCAN_BAND_DUAL, 3);
1517 else
1518 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1519 WL1271_SCAN_BAND_2_4_GHZ, 3);
f5fc0f86
LC		 1520
1521 wl1271_ps_elp_sleep(wl);
1522
1523out:
1524 mutex_unlock(&wl->mutex);
1525
1526 return ret;
1527}
1528
1529static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1530{
1531 struct wl1271 *wl = hw->priv;
1532 int ret;
1533
1534 mutex_lock(&wl->mutex);
1535
1536 ret = wl1271_ps_elp_wakeup(wl, false);
1537 if (ret < 0)
1538 goto out;
1539
1540 ret = wl1271_acx_rts_threshold(wl, (u16) value);
1541 if (ret < 0)
1542 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1543
1544 wl1271_ps_elp_sleep(wl);
1545
1546out:
1547 mutex_unlock(&wl->mutex);
1548
1549 return ret;
1550}
1551
30240fc7
JO		 1552static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1553{
1554 u8 *ptr = beacon->data +
1555 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1556
1557 /* find the location of the ssid in the beacon */
1558 while (ptr < beacon->data + beacon->len) {
1559 if (ptr[0] == WLAN_EID_SSID) {
1560 wl->ssid_len = ptr[1];
1561 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1562 return;
1563 }
1564 ptr += ptr[1];
1565 }
1566 wl1271_error("ad-hoc beacon template has no SSID!\n");
1567}
1568
f5fc0f86
LC		 1569static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1570 struct ieee80211_vif *vif,
1571 struct ieee80211_bss_conf *bss_conf,
1572 u32 changed)
1573{
1574 enum wl1271_cmd_ps_mode mode;
1575 struct wl1271 *wl = hw->priv;
1576 int ret;
1577
1578 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1579
1580 mutex_lock(&wl->mutex);
1581
1582 ret = wl1271_ps_elp_wakeup(wl, false);
1583 if (ret < 0)
1584 goto out;
1585
e0d8bbf0
JO		 1586 if (wl->bss_type == BSS_TYPE_IBSS) {
1587 /* FIXME: This implements rudimentary ad-hoc support -
1588 proper templates are on the wish list and notification
1589 on when they change. This patch will update the templates
30240fc7 1590 on every call to this function. */
e0d8bbf0
JO		 1591 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1592
1593 if (beacon) {
1594 struct ieee80211_hdr *hdr;
30240fc7
JO		 1595
1596 wl1271_ssid_set(wl, beacon);
e0d8bbf0
JO		 1597 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1598 beacon->data,
1599 beacon->len);
1600
1601 if (ret < 0) {
1602 dev_kfree_skb(beacon);
1603 goto out_sleep;
1604 }
1605
1606 hdr = (struct ieee80211_hdr *) beacon->data;
1607 hdr->frame_control = cpu_to_le16(
1608 IEEE80211_FTYPE_MGMT |
1609 IEEE80211_STYPE_PROBE_RESP);
1610
1611 ret = wl1271_cmd_template_set(wl,
1612 CMD_TEMPL_PROBE_RESPONSE,
1613 beacon->data,
1614 beacon->len);
1615 dev_kfree_skb(beacon);
1616 if (ret < 0)
1617 goto out_sleep;
1618 }
1619 }
1620
30240fc7
JO		 1621 if ((changed & BSS_CHANGED_BSSID) &&
1622 /*
1623 * Now we know the correct bssid, so we send a new join command
1624 * and enable the BSSID filter
1625 */
1626 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1627 wl->rx_config |= CFG_BSSID_FILTER_EN;
1628 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1629 ret = wl1271_cmd_build_null_data(wl);
1630 if (ret < 0) {
1631 wl1271_warning("cmd buld null data failed %d",
1632 ret);
1633 goto out_sleep;
1634 }
1635
1636 ret = wl1271_cmd_join(wl);
1637 if (ret < 0) {
1638 wl1271_warning("cmd join failed %d", ret);
1639 goto out_sleep;
1640 }
1641 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1642 }
1643
f5fc0f86
LC		 1644 if (changed & BSS_CHANGED_ASSOC) {
1645 if (bss_conf->assoc) {
1646 wl->aid = bss_conf->aid;
830fb67b 1647 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
f5fc0f86 1648
ae751bab
LC		 1649 /*
1650 * with wl1271, we don't need to update the
1651 * beacon_int and dtim_period, because the firmware
1652 * updates it by itself when the first beacon is
1653 * received after a join.
1654 */
f5fc0f86
LC		 1655 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1656 if (ret < 0)
1657 goto out_sleep;
1658
1659 ret = wl1271_acx_aid(wl, wl->aid);
1660 if (ret < 0)
1661 goto out_sleep;
1662
1663 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 1664 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1665 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
f5fc0f86 1666 mode = STATION_POWER_SAVE_MODE;
d8c42c0c 1667 ret = wl1271_ps_set_mode(wl, mode, true);
f5fc0f86
LC		 1668 if (ret < 0)
1669 goto out_sleep;
1670 }
d94cd297
JO		 1671 } else {
1672 /* use defaults when not associated */
830fb67b 1673 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 1674 wl->aid = 0;
f5fc0f86 1675 }
d94cd297 1676
f5fc0f86 1677 }
8a5a37a6 1678
f5fc0f86
LC		 1679 if (changed & BSS_CHANGED_ERP_SLOT) {
1680 if (bss_conf->use_short_slot)
1681 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1682 else
1683 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1684 if (ret < 0) {
1685 wl1271_warning("Set slot time failed %d", ret);
1686 goto out_sleep;
1687 }
1688 }
1689
1690 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1691 if (bss_conf->use_short_preamble)
1692 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1693 else
1694 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1695 }
1696
1697 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1698 if (bss_conf->use_cts_prot)
1699 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1700 else
1701 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1702 if (ret < 0) {
1703 wl1271_warning("Set ctsprotect failed %d", ret);
1704 goto out_sleep;
1705 }
1706 }
1707
1708out_sleep:
1709 wl1271_ps_elp_sleep(wl);
1710
1711out:
1712 mutex_unlock(&wl->mutex);
1713}
1714
1715
1716/* can't be const, mac80211 writes to this */
1717static struct ieee80211_rate wl1271_rates[] = {
1718 { .bitrate = 10,
2b60100b
JO		 1719 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1720 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 1721 { .bitrate = 20,
2b60100b
JO		 1722 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1723 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 1724 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1725 { .bitrate = 55,
2b60100b
JO		 1726 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1727 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 1728 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1729 { .bitrate = 110,
2b60100b
JO		 1730 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1731 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 1732 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1733 { .bitrate = 60,
2b60100b
JO		 1734 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1735 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 1736 { .bitrate = 90,
2b60100b
JO		 1737 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1738 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 1739 { .bitrate = 120,
2b60100b
JO		 1740 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1741 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 1742 { .bitrate = 180,
2b60100b
JO		 1743 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1744 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 1745 { .bitrate = 240,
2b60100b
JO		 1746 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1747 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 1748 { .bitrate = 360,
2b60100b
JO		 1749 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1750 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 1751 { .bitrate = 480,
2b60100b
JO		 1752 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1753 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 1754 { .bitrate = 540,
2b60100b
JO		 1755 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1756 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 1757};
1758
1759/* can't be const, mac80211 writes to this */
1760static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1
LC		 1761 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1762 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1763 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1764 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1765 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1766 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1767 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1768 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1769 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1770 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1771 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1772 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1773 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
f5fc0f86
LC		 1774};
1775
1776/* can't be const, mac80211 writes to this */
1777static struct ieee80211_supported_band wl1271_band_2ghz = {
1778 .channels = wl1271_channels,
1779 .n_channels = ARRAY_SIZE(wl1271_channels),
1780 .bitrates = wl1271_rates,
1781 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1782};
1783
1ebec3d7
TP		 1784/* 5 GHz data rates for WL1273 */
1785static struct ieee80211_rate wl1271_rates_5ghz[] = {
1786 { .bitrate = 60,
1787 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1788 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1789 { .bitrate = 90,
1790 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1791 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1792 { .bitrate = 120,
1793 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1794 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1795 { .bitrate = 180,
1796 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1797 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1798 { .bitrate = 240,
1799 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1800 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1801 { .bitrate = 360,
1802 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1803 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1804 { .bitrate = 480,
1805 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1806 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1807 { .bitrate = 540,
1808 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1809 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1810};
1811
1812/* 5 GHz band channels for WL1273 */
1813static struct ieee80211_channel wl1271_channels_5ghz[] = {
1814 { .hw_value = 183, .center_freq = 4915},
1815 { .hw_value = 184, .center_freq = 4920},
1816 { .hw_value = 185, .center_freq = 4925},
1817 { .hw_value = 187, .center_freq = 4935},
1818 { .hw_value = 188, .center_freq = 4940},
1819 { .hw_value = 189, .center_freq = 4945},
1820 { .hw_value = 192, .center_freq = 4960},
1821 { .hw_value = 196, .center_freq = 4980},
1822 { .hw_value = 7, .center_freq = 5035},
1823 { .hw_value = 8, .center_freq = 5040},
1824 { .hw_value = 9, .center_freq = 5045},
1825 { .hw_value = 11, .center_freq = 5055},
1826 { .hw_value = 12, .center_freq = 5060},
1827 { .hw_value = 16, .center_freq = 5080},
1828 { .hw_value = 34, .center_freq = 5170},
1829 { .hw_value = 36, .center_freq = 5180},
1830 { .hw_value = 38, .center_freq = 5190},
1831 { .hw_value = 40, .center_freq = 5200},
1832 { .hw_value = 42, .center_freq = 5210},
1833 { .hw_value = 44, .center_freq = 5220},
1834 { .hw_value = 46, .center_freq = 5230},
1835 { .hw_value = 48, .center_freq = 5240},
1836 { .hw_value = 52, .center_freq = 5260},
1837 { .hw_value = 56, .center_freq = 5280},
1838 { .hw_value = 60, .center_freq = 5300},
1839 { .hw_value = 64, .center_freq = 5320},
1840 { .hw_value = 100, .center_freq = 5500},
1841 { .hw_value = 104, .center_freq = 5520},
1842 { .hw_value = 108, .center_freq = 5540},
1843 { .hw_value = 112, .center_freq = 5560},
1844 { .hw_value = 116, .center_freq = 5580},
1845 { .hw_value = 120, .center_freq = 5600},
1846 { .hw_value = 124, .center_freq = 5620},
1847 { .hw_value = 128, .center_freq = 5640},
1848 { .hw_value = 132, .center_freq = 5660},
1849 { .hw_value = 136, .center_freq = 5680},
1850 { .hw_value = 140, .center_freq = 5700},
1851 { .hw_value = 149, .center_freq = 5745},
1852 { .hw_value = 153, .center_freq = 5765},
1853 { .hw_value = 157, .center_freq = 5785},
1854 { .hw_value = 161, .center_freq = 5805},
1855 { .hw_value = 165, .center_freq = 5825},
1856};
1857
1858
1859static struct ieee80211_supported_band wl1271_band_5ghz = {
1860 .channels = wl1271_channels_5ghz,
1861 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1862 .bitrates = wl1271_rates_5ghz,
1863 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1864};
1865
f5fc0f86
LC		 1866static const struct ieee80211_ops wl1271_ops = {
1867 .start = wl1271_op_start,
1868 .stop = wl1271_op_stop,
1869 .add_interface = wl1271_op_add_interface,
1870 .remove_interface = wl1271_op_remove_interface,
1871 .config = wl1271_op_config,
1872/* .config_interface = wl1271_op_config_interface, */
c87dec9f 1873 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 1874 .configure_filter = wl1271_op_configure_filter,
1875 .tx = wl1271_op_tx,
1876 .set_key = wl1271_op_set_key,
1877 .hw_scan = wl1271_op_hw_scan,
1878 .bss_info_changed = wl1271_op_bss_info_changed,
1879 .set_rts_threshold = wl1271_op_set_rts_threshold,
1880};
1881
1882static int wl1271_register_hw(struct wl1271 *wl)
1883{
1884 int ret;
1885
1886 if (wl->mac80211_registered)
1887 return 0;
1888
1889 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1890
1891 ret = ieee80211_register_hw(wl->hw);
1892 if (ret < 0) {
1893 wl1271_error("unable to register mac80211 hw: %d", ret);
1894 return ret;
1895 }
1896
1897 wl->mac80211_registered = true;
1898
1899 wl1271_notice("loaded");
1900
1901 return 0;
1902}
1903
1904static int wl1271_init_ieee80211(struct wl1271 *wl)
1905{
1e2b7976
JO		 1906 /* The tx descriptor buffer and the TKIP space. */
1907 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1908 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 1909
1910 /* unit us */
1911 /* FIXME: find a proper value */
1912 wl->hw->channel_change_time = 10000;
1913
1914 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1922167b 1915 IEEE80211_HW_NOISE_DBM |
03442a33
JO		 1916 IEEE80211_HW_BEACON_FILTER |
1917 IEEE80211_HW_SUPPORTS_PS;
f5fc0f86 1918
e0d8bbf0
JO		 1919 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1920 BIT(NL80211_IFTYPE_ADHOC);
f5fc0f86
LC		 1921 wl->hw->wiphy->max_scan_ssids = 1;
1922 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1923
1ebec3d7
TP		 1924 if (wl1271_11a_enabled())
1925 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1926
f5fc0f86
LC		 1927 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
1928
1929 return 0;
1930}
1931
1932static void wl1271_device_release(struct device *dev)
1933{
1934
1935}
1936
1937static struct platform_device wl1271_device = {
1938 .name = "wl1271",
1939 .id = -1,
1940
1941 /* device model insists to have a release function */
1942 .dev = {
1943 .release = wl1271_device_release,
1944 },
1945};
1946
1947#define WL1271_DEFAULT_CHANNEL 0
1948static int __devinit wl1271_probe(struct spi_device *spi)
1949{
1950 struct wl12xx_platform_data *pdata;
1951 struct ieee80211_hw *hw;
1952 struct wl1271 *wl;
1953 int ret, i;
1954 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
1955
1956 pdata = spi->dev.platform_data;
1957 if (!pdata) {
1958 wl1271_error("no platform data");
1959 return -ENODEV;
1960 }
1961
1962 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
1963 if (!hw) {
1964 wl1271_error("could not alloc ieee80211_hw");
1965 return -ENOMEM;
1966 }
1967
1968 wl = hw->priv;
1969 memset(wl, 0, sizeof(*wl));
1970
01c09162
JO		 1971 INIT_LIST_HEAD(&wl->list);
1972
f5fc0f86
LC		 1973 wl->hw = hw;
1974 dev_set_drvdata(&spi->dev, wl);
1975 wl->spi = spi;
1976
1977 skb_queue_head_init(&wl->tx_queue);
1978
37b70a81 1979 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
f5fc0f86 1980 wl->channel = WL1271_DEFAULT_CHANNEL;
f5fc0f86 1981 wl->default_key = 0;
f5fc0f86
LC		 1982 wl->rx_counter = 0;
1983 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1984 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
19ad0715 1985 wl->psm_entry_retry = 0;
f5fc0f86 1986 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 1987 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
830fb67b
JO		 1988 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1989 wl->sta_rate_set = 0;
8a5a37a6 1990 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 1991 wl->vif = NULL;
830fb67b 1992 wl->flags = 0;
f5fc0f86 1993
be7078c2 1994 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 1995 wl->tx_frames[i] = NULL;
1996
1997 spin_lock_init(&wl->wl_lock);
1998
1999 /*
2000 * In case our MAC address is not correctly set,
2001 * we use a random but Nokia MAC.
2002 */
2003 memcpy(wl->mac_addr, nokia_oui, 3);
2004 get_random_bytes(wl->mac_addr + 3, 3);
2005
2006 wl->state = WL1271_STATE_OFF;
2007 mutex_init(&wl->mutex);
2008
f5fc0f86
LC		 2009 /* This is the only SPI value that we need to set here, the rest
2010 * comes from the board-peripherals file */
2011 spi->bits_per_word = 32;
2012
2013 ret = spi_setup(spi);
2014 if (ret < 0) {
2015 wl1271_error("spi_setup failed");
2016 goto out_free;
2017 }
2018
2019 wl->set_power = pdata->set_power;
2020 if (!wl->set_power) {
2021 wl1271_error("set power function missing in platform data");
2022 ret = -ENODEV;
2023 goto out_free;
2024 }
2025
2026 wl->irq = spi->irq;
2027 if (wl->irq < 0) {
2028 wl1271_error("irq missing in platform data");
2029 ret = -ENODEV;
2030 goto out_free;
2031 }
2032
2033 ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
2034 if (ret < 0) {
2035 wl1271_error("request_irq() failed: %d", ret);
2036 goto out_free;
2037 }
2038
2039 set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
2040
2041 disable_irq(wl->irq);
2042
2043 ret = platform_device_register(&wl1271_device);
2044 if (ret) {
2045 wl1271_error("couldn't register platform device");
2046 goto out_irq;
2047 }
2048 dev_set_drvdata(&wl1271_device.dev, wl);
2049
2b60100b
JO		 2050 /* Apply default driver configuration. */
2051 wl1271_conf_init(wl);
2052
f5fc0f86
LC		 2053 ret = wl1271_init_ieee80211(wl);
2054 if (ret)
2055 goto out_platform;
2056
2057 ret = wl1271_register_hw(wl);
2058 if (ret)
2059 goto out_platform;
2060
2061 wl1271_debugfs_init(wl);
2062
2063 wl1271_notice("initialized");
2064
2065 return 0;
2066
2067 out_platform:
2068 platform_device_unregister(&wl1271_device);
2069
2070 out_irq:
2071 free_irq(wl->irq, wl);
2072
2073 out_free:
f5fc0f86
LC		 2074 ieee80211_free_hw(hw);
2075
2076 return ret;
2077}
2078
2079static int __devexit wl1271_remove(struct spi_device *spi)
2080{
2081 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
2082
2083 ieee80211_unregister_hw(wl->hw);
2084
2085 wl1271_debugfs_exit(wl);
2086 platform_device_unregister(&wl1271_device);
2087 free_irq(wl->irq, wl);
2088 kfree(wl->target_mem_map);
1fba4974 2089 vfree(wl->fw);
f5fc0f86
LC		 2090 wl->fw = NULL;
2091 kfree(wl->nvs);
2092 wl->nvs = NULL;
2093
f5fc0f86
LC		 2094 kfree(wl->fw_status);
2095 kfree(wl->tx_res_if);
2096
2097 ieee80211_free_hw(wl->hw);
2098
2099 return 0;
2100}
2101
2102
2103static struct spi_driver wl1271_spi_driver = {
2104 .driver = {
2105 .name = "wl1271",
2106 .bus = &spi_bus_type,
2107 .owner = THIS_MODULE,
2108 },
2109
2110 .probe = wl1271_probe,
2111 .remove = __devexit_p(wl1271_remove),
2112};
2113
2114static int __init wl1271_init(void)
2115{
2116 int ret;
2117
2118 ret = spi_register_driver(&wl1271_spi_driver);
2119 if (ret < 0) {
2120 wl1271_error("failed to register spi driver: %d", ret);
2121 goto out;
2122 }
2123
2124out:
2125 return ret;
2126}
2127
2128static void __exit wl1271_exit(void)
2129{
2130 spi_unregister_driver(&wl1271_spi_driver);
2131
2132 wl1271_notice("unloaded");
2133}
2134
2135module_init(wl1271_init);
2136module_exit(wl1271_exit);
2137
2138MODULE_LICENSE("GPL");
2139MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2f018725 2140MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
49f146de 2141MODULE_FIRMWARE(WL1271_FW_NAME);
Clone of davem's net-next-2.6 tree