aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/wl12xx/wl1271_main.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/wl12xx/wl1271_main.c')
-rw-r--r--drivers/net/wireless/wl12xx/wl1271_main.c1439
1 files changed, 1143 insertions, 296 deletions
diff --git a/drivers/net/wireless/wl12xx/wl1271_main.c b/drivers/net/wireless/wl12xx/wl1271_main.c
index 27298b19d5bd..65a1aeba2419 100644
--- a/drivers/net/wireless/wl12xx/wl1271_main.c
+++ b/drivers/net/wireless/wl12xx/wl1271_main.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * This file is part of wl1271 2 * This file is part of wl1271
3 * 3 *
4 * Copyright (C) 2008-2009 Nokia Corporation 4 * Copyright (C) 2008-2010 Nokia Corporation
5 * 5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com> 6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 * 7 *
@@ -30,12 +30,16 @@
30#include <linux/spi/spi.h> 30#include <linux/spi/spi.h>
31#include <linux/crc32.h> 31#include <linux/crc32.h>
32#include <linux/etherdevice.h> 32#include <linux/etherdevice.h>
33#include <linux/vmalloc.h>
33#include <linux/spi/wl12xx.h> 34#include <linux/spi/wl12xx.h>
35#include <linux/inetdevice.h>
36#include <linux/slab.h>
34 37
35#include "wl1271.h" 38#include "wl1271.h"
36#include "wl12xx_80211.h" 39#include "wl12xx_80211.h"
37#include "wl1271_reg.h" 40#include "wl1271_reg.h"
38#include "wl1271_spi.h" 41#include "wl1271_spi.h"
42#include "wl1271_io.h"
39#include "wl1271_event.h" 43#include "wl1271_event.h"
40#include "wl1271_tx.h" 44#include "wl1271_tx.h"
41#include "wl1271_rx.h" 45#include "wl1271_rx.h"
@@ -44,20 +48,321 @@
44#include "wl1271_debugfs.h" 48#include "wl1271_debugfs.h"
45#include "wl1271_cmd.h" 49#include "wl1271_cmd.h"
46#include "wl1271_boot.h" 50#include "wl1271_boot.h"
51#include "wl1271_testmode.h"
52
53#define WL1271_BOOT_RETRIES 3
54
55static struct conf_drv_settings default_conf = {
56 .sg = {
57 .per_threshold = 7500,
58 .max_scan_compensation_time = 120000,
59 .nfs_sample_interval = 400,
60 .load_ratio = 50,
61 .auto_ps_mode = 0,
62 .probe_req_compensation = 170,
63 .scan_window_compensation = 50,
64 .antenna_config = 0,
65 .beacon_miss_threshold = 60,
66 .rate_adaptation_threshold = CONF_HW_BIT_RATE_12MBPS,
67 .rate_adaptation_snr = 0
68 },
69 .rx = {
70 .rx_msdu_life_time = 512000,
71 .packet_detection_threshold = 0,
72 .ps_poll_timeout = 15,
73 .upsd_timeout = 15,
74 .rts_threshold = 2347,
75 .rx_cca_threshold = 0,
76 .irq_blk_threshold = 0xFFFF,
77 .irq_pkt_threshold = 0,
78 .irq_timeout = 600,
79 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
80 },
81 .tx = {
82 .tx_energy_detection = 0,
83 .rc_conf = {
84 .enabled_rates = CONF_HW_BIT_RATE_1MBPS |
85 CONF_HW_BIT_RATE_2MBPS,
86 .short_retry_limit = 10,
87 .long_retry_limit = 10,
88 .aflags = 0
89 },
90 .ac_conf_count = 4,
91 .ac_conf = {
92 [0] = {
93 .ac = CONF_TX_AC_BE,
94 .cw_min = 15,
95 .cw_max = 63,
96 .aifsn = 3,
97 .tx_op_limit = 0,
98 },
99 [1] = {
100 .ac = CONF_TX_AC_BK,
101 .cw_min = 15,
102 .cw_max = 63,
103 .aifsn = 7,
104 .tx_op_limit = 0,
105 },
106 [2] = {
107 .ac = CONF_TX_AC_VI,
108 .cw_min = 15,
109 .cw_max = 63,
110 .aifsn = CONF_TX_AIFS_PIFS,
111 .tx_op_limit = 3008,
112 },
113 [3] = {
114 .ac = CONF_TX_AC_VO,
115 .cw_min = 15,
116 .cw_max = 63,
117 .aifsn = CONF_TX_AIFS_PIFS,
118 .tx_op_limit = 1504,
119 },
120 },
121 .tid_conf_count = 7,
122 .tid_conf = {
123 [0] = {
124 .queue_id = 0,
125 .channel_type = CONF_CHANNEL_TYPE_DCF,
126 .tsid = CONF_TX_AC_BE,
127 .ps_scheme = CONF_PS_SCHEME_LEGACY,
128 .ack_policy = CONF_ACK_POLICY_LEGACY,
129 .apsd_conf = {0, 0},
130 },
131 [1] = {
132 .queue_id = 1,
133 .channel_type = CONF_CHANNEL_TYPE_DCF,
134 .tsid = CONF_TX_AC_BE,
135 .ps_scheme = CONF_PS_SCHEME_LEGACY,
136 .ack_policy = CONF_ACK_POLICY_LEGACY,
137 .apsd_conf = {0, 0},
138 },
139 [2] = {
140 .queue_id = 2,
141 .channel_type = CONF_CHANNEL_TYPE_DCF,
142 .tsid = CONF_TX_AC_BE,
143 .ps_scheme = CONF_PS_SCHEME_LEGACY,
144 .ack_policy = CONF_ACK_POLICY_LEGACY,
145 .apsd_conf = {0, 0},
146 },
147 [3] = {
148 .queue_id = 3,
149 .channel_type = CONF_CHANNEL_TYPE_DCF,
150 .tsid = CONF_TX_AC_BE,
151 .ps_scheme = CONF_PS_SCHEME_LEGACY,
152 .ack_policy = CONF_ACK_POLICY_LEGACY,
153 .apsd_conf = {0, 0},
154 },
155 [4] = {
156 .queue_id = 4,
157 .channel_type = CONF_CHANNEL_TYPE_DCF,
158 .tsid = CONF_TX_AC_BE,
159 .ps_scheme = CONF_PS_SCHEME_LEGACY,
160 .ack_policy = CONF_ACK_POLICY_LEGACY,
161 .apsd_conf = {0, 0},
162 },
163 [5] = {
164 .queue_id = 5,
165 .channel_type = CONF_CHANNEL_TYPE_DCF,
166 .tsid = CONF_TX_AC_BE,
167 .ps_scheme = CONF_PS_SCHEME_LEGACY,
168 .ack_policy = CONF_ACK_POLICY_LEGACY,
169 .apsd_conf = {0, 0},
170 },
171 [6] = {
172 .queue_id = 6,
173 .channel_type = CONF_CHANNEL_TYPE_DCF,
174 .tsid = CONF_TX_AC_BE,
175 .ps_scheme = CONF_PS_SCHEME_LEGACY,
176 .ack_policy = CONF_ACK_POLICY_LEGACY,
177 .apsd_conf = {0, 0},
178 }
179 },
180 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
181 .tx_compl_timeout = 700,
182 .tx_compl_threshold = 4
183 },
184 .conn = {
185 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
186 .listen_interval = 0,
187 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
188 .bcn_filt_ie_count = 1,
189 .bcn_filt_ie = {
190 [0] = {
191 .ie = WLAN_EID_CHANNEL_SWITCH,
192 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
193 }
194 },
195 .synch_fail_thold = 10,
196 .bss_lose_timeout = 100,
197 .beacon_rx_timeout = 10000,
198 .broadcast_timeout = 20000,
199 .rx_broadcast_in_ps = 1,
200 .ps_poll_threshold = 20,
201 .sig_trigger_count = 2,
202 .sig_trigger = {
203 [0] = {
204 .threshold = -75,
205 .pacing = 500,
206 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
207 .type = CONF_TRIG_EVENT_TYPE_EDGE,
208 .direction = CONF_TRIG_EVENT_DIR_LOW,
209 .hysteresis = 2,
210 .index = 0,
211 .enable = 1
212 },
213 [1] = {
214 .threshold = -75,
215 .pacing = 500,
216 .metric = CONF_TRIG_METRIC_RSSI_BEACON,
217 .type = CONF_TRIG_EVENT_TYPE_EDGE,
218 .direction = CONF_TRIG_EVENT_DIR_HIGH,
219 .hysteresis = 2,
220 .index = 1,
221 .enable = 1
222 }
223 },
224 .sig_weights = {
225 .rssi_bcn_avg_weight = 10,
226 .rssi_pkt_avg_weight = 10,
227 .snr_bcn_avg_weight = 10,
228 .snr_pkt_avg_weight = 10
229 },
230 .bet_enable = CONF_BET_MODE_ENABLE,
231 .bet_max_consecutive = 10,
232 .psm_entry_retries = 3
233 },
234 .init = {
235 .radioparam = {
236 .fem = 1,
237 }
238 },
239 .itrim = {
240 .enable = false,
241 .timeout = 50000,
242 },
243 .pm_config = {
244 .host_clk_settling_time = 5000,
245 .host_fast_wakeup_support = false
246 }
247};
248
249static LIST_HEAD(wl_list);
250
251static void wl1271_conf_init(struct wl1271 *wl)
252{
253
254 /*
255 * This function applies the default configuration to the driver. This
256 * function is invoked upon driver load (spi probe.)
257 *
258 * The configuration is stored in a run-time structure in order to
259 * facilitate for run-time adjustment of any of the parameters. Making
260 * changes to the configuration structure will apply the new values on
261 * the next interface up (wl1271_op_start.)
262 */
263
264 /* apply driver default configuration */
265 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
266}
267
47 268
48static int wl1271_plt_init(struct wl1271 *wl) 269static int wl1271_plt_init(struct wl1271 *wl)
49{ 270{
50 int ret; 271 struct conf_tx_ac_category *conf_ac;
272 struct conf_tx_tid *conf_tid;
273 int ret, i;
51 274
52 ret = wl1271_acx_init_mem_config(wl); 275 ret = wl1271_cmd_general_parms(wl);
276 if (ret < 0)
277 return ret;
278
279 ret = wl1271_cmd_radio_parms(wl);
53 if (ret < 0) 280 if (ret < 0)
54 return ret; 281 return ret;
55 282
56 ret = wl1271_cmd_data_path(wl, wl->channel, 1); 283 ret = wl1271_init_templates_config(wl);
57 if (ret < 0) 284 if (ret < 0)
58 return ret; 285 return ret;
59 286
287 ret = wl1271_acx_init_mem_config(wl);
288 if (ret < 0)
289 return ret;
290
291 /* PHY layer config */
292 ret = wl1271_init_phy_config(wl);
293 if (ret < 0)
294 goto out_free_memmap;
295
296 ret = wl1271_acx_dco_itrim_params(wl);
297 if (ret < 0)
298 goto out_free_memmap;
299
300 /* Initialize connection monitoring thresholds */
301 ret = wl1271_acx_conn_monit_params(wl);
302 if (ret < 0)
303 goto out_free_memmap;
304
305 /* Bluetooth WLAN coexistence */
306 ret = wl1271_init_pta(wl);
307 if (ret < 0)
308 goto out_free_memmap;
309
310 /* Energy detection */
311 ret = wl1271_init_energy_detection(wl);
312 if (ret < 0)
313 goto out_free_memmap;
314
315 /* Default fragmentation threshold */
316 ret = wl1271_acx_frag_threshold(wl);
317 if (ret < 0)
318 goto out_free_memmap;
319
320 /* Default TID configuration */
321 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
322 conf_tid = &wl->conf.tx.tid_conf[i];
323 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
324 conf_tid->channel_type,
325 conf_tid->tsid,
326 conf_tid->ps_scheme,
327 conf_tid->ack_policy,
328 conf_tid->apsd_conf[0],
329 conf_tid->apsd_conf[1]);
330 if (ret < 0)
331 goto out_free_memmap;
332 }
333
334 /* Default AC configuration */
335 for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
336 conf_ac = &wl->conf.tx.ac_conf[i];
337 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
338 conf_ac->cw_max, conf_ac->aifsn,
339 conf_ac->tx_op_limit);
340 if (ret < 0)
341 goto out_free_memmap;
342 }
343
344 /* Enable data path */
345 ret = wl1271_cmd_data_path(wl, 1);
346 if (ret < 0)
347 goto out_free_memmap;
348
349 /* Configure for CAM power saving (ie. always active) */
350 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
351 if (ret < 0)
352 goto out_free_memmap;
353
354 /* configure PM */
355 ret = wl1271_acx_pm_config(wl);
356 if (ret < 0)
357 goto out_free_memmap;
358
60 return 0; 359 return 0;
360
361 out_free_memmap:
362 kfree(wl->target_mem_map);
363 wl->target_mem_map = NULL;
364
365 return ret;
61} 366}
62 367
63static void wl1271_disable_interrupts(struct wl1271 *wl) 368static void wl1271_disable_interrupts(struct wl1271 *wl)
@@ -68,27 +373,22 @@ static void wl1271_disable_interrupts(struct wl1271 *wl)
68static void wl1271_power_off(struct wl1271 *wl) 373static void wl1271_power_off(struct wl1271 *wl)
69{ 374{
70 wl->set_power(false); 375 wl->set_power(false);
376 clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
71} 377}
72 378
73static void wl1271_power_on(struct wl1271 *wl) 379static void wl1271_power_on(struct wl1271 *wl)
74{ 380{
75 wl->set_power(true); 381 wl->set_power(true);
382 set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
76} 383}
77 384
78static void wl1271_fw_status(struct wl1271 *wl, struct wl1271_fw_status *status) 385static void wl1271_fw_status(struct wl1271 *wl,
386 struct wl1271_fw_status *status)
79{ 387{
80 u32 total = 0; 388 u32 total = 0;
81 int i; 389 int i;
82 390
83 /* 391 wl1271_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
84 * FIXME: Reading the FW status directly from the registers seems to
85 * be the right thing to do, but it doesn't work. And in the
86 * reference driver, there is a workaround called
87 * USE_SDIO_24M_WORKAROUND, which reads the status from memory
88 * instead, so we do the same here.
89 */
90
91 wl1271_spi_mem_read(wl, STATUS_MEM_ADDRESS, status, sizeof(*status));
92 392
93 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, " 393 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
94 "drv_rx_counter = %d, tx_results_counter = %d)", 394 "drv_rx_counter = %d, tx_results_counter = %d)",
@@ -99,25 +399,28 @@ static void wl1271_fw_status(struct wl1271 *wl, struct wl1271_fw_status *status)
99 399
100 /* update number of available TX blocks */ 400 /* update number of available TX blocks */
101 for (i = 0; i < NUM_TX_QUEUES; i++) { 401 for (i = 0; i < NUM_TX_QUEUES; i++) {
102 u32 cnt = status->tx_released_blks[i] - wl->tx_blocks_freed[i]; 402 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
103 wl->tx_blocks_freed[i] = status->tx_released_blks[i]; 403 wl->tx_blocks_freed[i];
404
405 wl->tx_blocks_freed[i] =
406 le32_to_cpu(status->tx_released_blks[i]);
104 wl->tx_blocks_available += cnt; 407 wl->tx_blocks_available += cnt;
105 total += cnt; 408 total += cnt;
106 } 409 }
107 410
108 /* if more blocks are available now, schedule some tx work */ 411 /* if more blocks are available now, schedule some tx work */
109 if (total && !skb_queue_empty(&wl->tx_queue)) 412 if (total && !skb_queue_empty(&wl->tx_queue))
110 schedule_work(&wl->tx_work); 413 ieee80211_queue_work(wl->hw, &wl->tx_work);
111 414
112 /* update the host-chipset time offset */ 415 /* update the host-chipset time offset */
113 wl->time_offset = jiffies_to_usecs(jiffies) - status->fw_localtime; 416 wl->time_offset = jiffies_to_usecs(jiffies) -
417 le32_to_cpu(status->fw_localtime);
114} 418}
115 419
116#define WL1271_IRQ_MAX_LOOPS 10
117static void wl1271_irq_work(struct work_struct *work) 420static void wl1271_irq_work(struct work_struct *work)
118{ 421{
119 u32 intr, ctr = WL1271_IRQ_MAX_LOOPS;
120 int ret; 422 int ret;
423 u32 intr;
121 struct wl1271 *wl = 424 struct wl1271 *wl =
122 container_of(work, struct wl1271, irq_work); 425 container_of(work, struct wl1271, irq_work);
123 426
@@ -132,9 +435,10 @@ static void wl1271_irq_work(struct work_struct *work)
132 if (ret < 0) 435 if (ret < 0)
133 goto out; 436 goto out;
134 437
135 wl1271_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1271_ACX_INTR_ALL); 438 wl1271_write32(wl, ACX_REG_INTERRUPT_MASK, WL1271_ACX_INTR_ALL);
136 439
137 intr = wl1271_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); 440 wl1271_fw_status(wl, wl->fw_status);
441 intr = le32_to_cpu(wl->fw_status->intr);
138 if (!intr) { 442 if (!intr) {
139 wl1271_debug(DEBUG_IRQ, "Zero interrupt received."); 443 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
140 goto out_sleep; 444 goto out_sleep;
@@ -142,47 +446,39 @@ static void wl1271_irq_work(struct work_struct *work)
142 446
143 intr &= WL1271_INTR_MASK; 447 intr &= WL1271_INTR_MASK;
144 448
145 do { 449 if (intr & WL1271_ACX_INTR_EVENT_A) {
146 wl1271_fw_status(wl, wl->fw_status); 450 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
147 451 wl1271_event_handle(wl, 0);
452 }
148 453
149 if (intr & (WL1271_ACX_INTR_EVENT_A | 454 if (intr & WL1271_ACX_INTR_EVENT_B) {
150 WL1271_ACX_INTR_EVENT_B)) { 455 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
151 wl1271_debug(DEBUG_IRQ, 456 wl1271_event_handle(wl, 1);
152 "WL1271_ACX_INTR_EVENT (0x%x)", intr); 457 }
153 if (intr & WL1271_ACX_INTR_EVENT_A)
154 wl1271_event_handle(wl, 0);
155 else
156 wl1271_event_handle(wl, 1);
157 }
158 458
159 if (intr & WL1271_ACX_INTR_INIT_COMPLETE) 459 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
160 wl1271_debug(DEBUG_IRQ, 460 wl1271_debug(DEBUG_IRQ,
161 "WL1271_ACX_INTR_INIT_COMPLETE"); 461 "WL1271_ACX_INTR_INIT_COMPLETE");
162 462
163 if (intr & WL1271_ACX_INTR_HW_AVAILABLE) 463 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
164 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE"); 464 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
165 465
166 if (intr & WL1271_ACX_INTR_DATA) { 466 if (intr & WL1271_ACX_INTR_DATA) {
167 u8 tx_res_cnt = wl->fw_status->tx_results_counter - 467 u8 tx_res_cnt = wl->fw_status->tx_results_counter -
168 wl->tx_results_count; 468 wl->tx_results_count;
169 469
170 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA"); 470 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
171 471
172 /* check for tx results */ 472 /* check for tx results */
173 if (tx_res_cnt) 473 if (tx_res_cnt)
174 wl1271_tx_complete(wl, tx_res_cnt); 474 wl1271_tx_complete(wl, tx_res_cnt);
175 475
176 wl1271_rx(wl, wl->fw_status); 476 wl1271_rx(wl, wl->fw_status);
177 } 477 }
178
179 intr = wl1271_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
180 intr &= WL1271_INTR_MASK;
181 } while (intr && --ctr);
182 478
183out_sleep: 479out_sleep:
184 wl1271_reg_write32(wl, ACX_REG_INTERRUPT_MASK, 480 wl1271_write32(wl, ACX_REG_INTERRUPT_MASK,
185 WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK)); 481 WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK));
186 wl1271_ps_elp_sleep(wl); 482 wl1271_ps_elp_sleep(wl);
187 483
188out: 484out:
@@ -205,7 +501,7 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)
205 wl->elp_compl = NULL; 501 wl->elp_compl = NULL;
206 } 502 }
207 503
208 schedule_work(&wl->irq_work); 504 ieee80211_queue_work(wl->hw, &wl->irq_work);
209 spin_unlock_irqrestore(&wl->wl_lock, flags); 505 spin_unlock_irqrestore(&wl->wl_lock, flags);
210 506
211 return IRQ_HANDLED; 507 return IRQ_HANDLED;
@@ -231,7 +527,7 @@ static int wl1271_fetch_firmware(struct wl1271 *wl)
231 } 527 }
232 528
233 wl->fw_len = fw->size; 529 wl->fw_len = fw->size;
234 wl->fw = kmalloc(wl->fw_len, GFP_KERNEL); 530 wl->fw = vmalloc(wl->fw_len);
235 531
236 if (!wl->fw) { 532 if (!wl->fw) {
237 wl1271_error("could not allocate memory for the firmware"); 533 wl1271_error("could not allocate memory for the firmware");
@@ -249,6 +545,40 @@ out:
249 return ret; 545 return ret;
250} 546}
251 547
548static int wl1271_update_mac_addr(struct wl1271 *wl)
549{
550 int ret = 0;
551 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
552
553 /* get mac address from the NVS */
554 wl->mac_addr[0] = nvs_ptr[11];
555 wl->mac_addr[1] = nvs_ptr[10];
556 wl->mac_addr[2] = nvs_ptr[6];
557 wl->mac_addr[3] = nvs_ptr[5];
558 wl->mac_addr[4] = nvs_ptr[4];
559 wl->mac_addr[5] = nvs_ptr[3];
560
561 /* FIXME: if it is a zero-address, we should bail out. Now, instead,
562 we randomize an address */
563 if (is_zero_ether_addr(wl->mac_addr)) {
564 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
565 memcpy(wl->mac_addr, nokia_oui, 3);
566 get_random_bytes(wl->mac_addr + 3, 3);
567
568 /* update this address to the NVS */
569 nvs_ptr[11] = wl->mac_addr[0];
570 nvs_ptr[10] = wl->mac_addr[1];
571 nvs_ptr[6] = wl->mac_addr[2];
572 nvs_ptr[5] = wl->mac_addr[3];
573 nvs_ptr[4] = wl->mac_addr[4];
574 nvs_ptr[3] = wl->mac_addr[5];
575 }
576
577 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
578
579 return ret;
580}
581
252static int wl1271_fetch_nvs(struct wl1271 *wl) 582static int wl1271_fetch_nvs(struct wl1271 *wl)
253{ 583{
254 const struct firmware *fw; 584 const struct firmware *fw;
@@ -261,15 +591,14 @@ static int wl1271_fetch_nvs(struct wl1271 *wl)
261 return ret; 591 return ret;
262 } 592 }
263 593
264 if (fw->size % 4) { 594 if (fw->size != sizeof(struct wl1271_nvs_file)) {
265 wl1271_error("nvs size is not multiple of 32 bits: %zu", 595 wl1271_error("nvs size is not as expected: %zu != %zu",
266 fw->size); 596 fw->size, sizeof(struct wl1271_nvs_file));
267 ret = -EILSEQ; 597 ret = -EILSEQ;
268 goto out; 598 goto out;
269 } 599 }
270 600
271 wl->nvs_len = fw->size; 601 wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
272 wl->nvs = kmalloc(wl->nvs_len, GFP_KERNEL);
273 602
274 if (!wl->nvs) { 603 if (!wl->nvs) {
275 wl1271_error("could not allocate memory for the nvs file"); 604 wl1271_error("could not allocate memory for the nvs file");
@@ -277,9 +606,9 @@ static int wl1271_fetch_nvs(struct wl1271 *wl)
277 goto out; 606 goto out;
278 } 607 }
279 608
280 memcpy(wl->nvs, fw->data, wl->nvs_len); 609 memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
281 610
282 ret = 0; 611 ret = wl1271_update_mac_addr(wl);
283 612
284out: 613out:
285 release_firmware(fw); 614 release_firmware(fw);
@@ -292,7 +621,7 @@ static void wl1271_fw_wakeup(struct wl1271 *wl)
292 u32 elp_reg; 621 u32 elp_reg;
293 622
294 elp_reg = ELPCTRL_WAKE_UP; 623 elp_reg = ELPCTRL_WAKE_UP;
295 wl1271_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg); 624 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
296} 625}
297 626
298static int wl1271_setup(struct wl1271 *wl) 627static int wl1271_setup(struct wl1271 *wl)
@@ -314,20 +643,21 @@ static int wl1271_setup(struct wl1271 *wl)
314 643
315static int wl1271_chip_wakeup(struct wl1271 *wl) 644static int wl1271_chip_wakeup(struct wl1271 *wl)
316{ 645{
646 struct wl1271_partition_set partition;
317 int ret = 0; 647 int ret = 0;
318 648
649 msleep(WL1271_PRE_POWER_ON_SLEEP);
319 wl1271_power_on(wl); 650 wl1271_power_on(wl);
320 msleep(WL1271_POWER_ON_SLEEP); 651 msleep(WL1271_POWER_ON_SLEEP);
321 wl1271_spi_reset(wl); 652 wl1271_io_reset(wl);
322 wl1271_spi_init(wl); 653 wl1271_io_init(wl);
323 654
324 /* We don't need a real memory partition here, because we only want 655 /* We don't need a real memory partition here, because we only want
325 * to use the registers at this point. */ 656 * to use the registers at this point. */
326 wl1271_set_partition(wl, 657 memset(&partition, 0, sizeof(partition));
327 0x00000000, 658 partition.reg.start = REGISTERS_BASE;
328 0x00000000, 659 partition.reg.size = REGISTERS_DOWN_SIZE;
329 REGISTERS_BASE, 660 wl1271_set_partition(wl, &partition);
330 REGISTERS_DOWN_SIZE);
331 661
332 /* ELP module wake up */ 662 /* ELP module wake up */
333 wl1271_fw_wakeup(wl); 663 wl1271_fw_wakeup(wl);
@@ -335,7 +665,7 @@ static int wl1271_chip_wakeup(struct wl1271 *wl)
335 /* whal_FwCtrl_BootSm() */ 665 /* whal_FwCtrl_BootSm() */
336 666
337 /* 0. read chip id from CHIP_ID */ 667 /* 0. read chip id from CHIP_ID */
338 wl->chip.id = wl1271_reg_read32(wl, CHIP_ID_B); 668 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
339 669
340 /* 1. check if chip id is valid */ 670 /* 1. check if chip id is valid */
341 671
@@ -357,7 +687,7 @@ static int wl1271_chip_wakeup(struct wl1271 *wl)
357 goto out; 687 goto out;
358 break; 688 break;
359 default: 689 default:
360 wl1271_error("unsupported chip id: 0x%x", wl->chip.id); 690 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
361 ret = -ENODEV; 691 ret = -ENODEV;
362 goto out; 692 goto out;
363 } 693 }
@@ -379,35 +709,9 @@ out:
379 return ret; 709 return ret;
380} 710}
381 711
382static void wl1271_filter_work(struct work_struct *work)
383{
384 struct wl1271 *wl =
385 container_of(work, struct wl1271, filter_work);
386 int ret;
387
388 mutex_lock(&wl->mutex);
389
390 if (wl->state == WL1271_STATE_OFF)
391 goto out;
392
393 ret = wl1271_ps_elp_wakeup(wl, false);
394 if (ret < 0)
395 goto out;
396
397 /* FIXME: replace the magic numbers with proper definitions */
398 ret = wl1271_cmd_join(wl, wl->bss_type, 1, 100, 0);
399 if (ret < 0)
400 goto out_sleep;
401
402out_sleep:
403 wl1271_ps_elp_sleep(wl);
404
405out:
406 mutex_unlock(&wl->mutex);
407}
408
409int wl1271_plt_start(struct wl1271 *wl) 712int wl1271_plt_start(struct wl1271 *wl)
410{ 713{
714 int retries = WL1271_BOOT_RETRIES;
411 int ret; 715 int ret;
412 716
413 mutex_lock(&wl->mutex); 717 mutex_lock(&wl->mutex);
@@ -421,22 +725,43 @@ int wl1271_plt_start(struct wl1271 *wl)
421 goto out; 725 goto out;
422 } 726 }
423 727
424 wl->state = WL1271_STATE_PLT; 728 while (retries) {
425 729 retries--;
426 ret = wl1271_chip_wakeup(wl); 730 ret = wl1271_chip_wakeup(wl);
427 if (ret < 0) 731 if (ret < 0)
428 goto out; 732 goto power_off;
429 733
430 ret = wl1271_boot(wl); 734 ret = wl1271_boot(wl);
431 if (ret < 0) 735 if (ret < 0)
432 goto out; 736 goto power_off;
433 737
434 wl1271_notice("firmware booted in PLT mode (%s)", wl->chip.fw_ver); 738 ret = wl1271_plt_init(wl);
739 if (ret < 0)
740 goto irq_disable;
435 741
436 ret = wl1271_plt_init(wl); 742 wl->state = WL1271_STATE_PLT;
437 if (ret < 0) 743 wl1271_notice("firmware booted in PLT mode (%s)",
744 wl->chip.fw_ver);
438 goto out; 745 goto out;
439 746
747irq_disable:
748 wl1271_disable_interrupts(wl);
749 mutex_unlock(&wl->mutex);
750 /* Unlocking the mutex in the middle of handling is
751 inherently unsafe. In this case we deem it safe to do,
752 because we need to let any possibly pending IRQ out of
753 the system (and while we are WL1271_STATE_OFF the IRQ
754 work function will not do anything.) Also, any other
755 possible concurrent operations will fail due to the
756 current state, hence the wl1271 struct should be safe. */
757 cancel_work_sync(&wl->irq_work);
758 mutex_lock(&wl->mutex);
759power_off:
760 wl1271_power_off(wl);
761 }
762
763 wl1271_error("firmware boot in PLT mode failed despite %d retries",
764 WL1271_BOOT_RETRIES);
440out: 765out:
441 mutex_unlock(&wl->mutex); 766 mutex_unlock(&wl->mutex);
442 767
@@ -462,6 +787,7 @@ int wl1271_plt_stop(struct wl1271 *wl)
462 wl1271_power_off(wl); 787 wl1271_power_off(wl);
463 788
464 wl->state = WL1271_STATE_OFF; 789 wl->state = WL1271_STATE_OFF;
790 wl->rx_counter = 0;
465 791
466out: 792out:
467 mutex_unlock(&wl->mutex); 793 mutex_unlock(&wl->mutex);
@@ -473,7 +799,20 @@ out:
473static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb) 799static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
474{ 800{
475 struct wl1271 *wl = hw->priv; 801 struct wl1271 *wl = hw->priv;
802 struct ieee80211_conf *conf = &hw->conf;
803 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
804 struct ieee80211_sta *sta = txinfo->control.sta;
805 unsigned long flags;
476 806
807 /* peek into the rates configured in the STA entry */
808 spin_lock_irqsave(&wl->wl_lock, flags);
809 if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
810 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
811 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
812 }
813 spin_unlock_irqrestore(&wl->wl_lock, flags);
814
815 /* queue the packet */
477 skb_queue_tail(&wl->tx_queue, skb); 816 skb_queue_tail(&wl->tx_queue, skb);
478 817
479 /* 818 /*
@@ -481,7 +820,7 @@ static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
481 * before that, the tx_work will not be initialized! 820 * before that, the tx_work will not be initialized!
482 */ 821 */
483 822
484 schedule_work(&wl->tx_work); 823 ieee80211_queue_work(wl->hw, &wl->tx_work);
485 824
486 /* 825 /*
487 * The workqueue is slow to process the tx_queue and we need stop 826 * The workqueue is slow to process the tx_queue and we need stop
@@ -495,15 +834,103 @@ static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
495 * protected. Maybe fix this by removing the stupid 834 * protected. Maybe fix this by removing the stupid
496 * variable altogether and checking the real queue state? 835 * variable altogether and checking the real queue state?
497 */ 836 */
498 wl->tx_queue_stopped = true; 837 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
499 } 838 }
500 839
501 return NETDEV_TX_OK; 840 return NETDEV_TX_OK;
502} 841}
503 842
843static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
844 void *arg)
845{
846 struct net_device *dev;
847 struct wireless_dev *wdev;
848 struct wiphy *wiphy;
849 struct ieee80211_hw *hw;
850 struct wl1271 *wl;
851 struct wl1271 *wl_temp;
852 struct in_device *idev;
853 struct in_ifaddr *ifa = arg;
854 int ret = 0;
855
856 /* FIXME: this ugly function should probably be implemented in the
857 * mac80211, and here should only be a simple callback handling actual
858 * setting of the filters. Now we need to dig up references to
859 * various structures to gain access to what we need.
860 * Also, because of this, there is no "initial" setting of the filter
861 * in "op_start", because we don't want to dig up struct net_device
862 * there - the filter will be set upon first change of the interface
863 * IP address. */
864
865 dev = ifa->ifa_dev->dev;
866
867 wdev = dev->ieee80211_ptr;
868 if (wdev == NULL)
869 return NOTIFY_DONE;
870
871 wiphy = wdev->wiphy;
872 if (wiphy == NULL)
873 return NOTIFY_DONE;
874
875 hw = wiphy_priv(wiphy);
876 if (hw == NULL)
877 return NOTIFY_DONE;
878
879 /* Check that the interface is one supported by this driver. */
880 wl_temp = hw->priv;
881 list_for_each_entry(wl, &wl_list, list) {
882 if (wl == wl_temp)
883 break;
884 }
885 if (wl == NULL)
886 return NOTIFY_DONE;
887
888 /* Get the interface IP address for the device. "ifa" will become
889 NULL if:
890 - there is no IPV4 protocol address configured
891 - there are multiple (virtual) IPV4 addresses configured
892 When "ifa" is NULL, filtering will be disabled.
893 */
894 ifa = NULL;
895 idev = dev->ip_ptr;
896 if (idev)
897 ifa = idev->ifa_list;
898
899 if (ifa && ifa->ifa_next)
900 ifa = NULL;
901
902 mutex_lock(&wl->mutex);
903
904 if (wl->state == WL1271_STATE_OFF)
905 goto out;
906
907 ret = wl1271_ps_elp_wakeup(wl, false);
908 if (ret < 0)
909 goto out;
910 if (ifa)
911 ret = wl1271_acx_arp_ip_filter(wl, true,
912 (u8 *)&ifa->ifa_address,
913 ACX_IPV4_VERSION);
914 else
915 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
916 ACX_IPV4_VERSION);
917 wl1271_ps_elp_sleep(wl);
918
919out:
920 mutex_unlock(&wl->mutex);
921
922 return NOTIFY_OK;
923}
924
925static struct notifier_block wl1271_dev_notifier = {
926 .notifier_call = wl1271_dev_notify,
927};
928
929
504static int wl1271_op_start(struct ieee80211_hw *hw) 930static int wl1271_op_start(struct ieee80211_hw *hw)
505{ 931{
506 struct wl1271 *wl = hw->priv; 932 struct wl1271 *wl = hw->priv;
933 int retries = WL1271_BOOT_RETRIES;
507 int ret = 0; 934 int ret = 0;
508 935
509 wl1271_debug(DEBUG_MAC80211, "mac80211 start"); 936 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
@@ -517,28 +944,50 @@ static int wl1271_op_start(struct ieee80211_hw *hw)
517 goto out; 944 goto out;
518 } 945 }
519 946
520 ret = wl1271_chip_wakeup(wl); 947 while (retries) {
521 if (ret < 0) 948 retries--;
522 goto out; 949 ret = wl1271_chip_wakeup(wl);
523 950 if (ret < 0)
524 ret = wl1271_boot(wl); 951 goto power_off;
525 if (ret < 0)
526 goto out;
527 952
528 ret = wl1271_hw_init(wl); 953 ret = wl1271_boot(wl);
529 if (ret < 0) 954 if (ret < 0)
530 goto out; 955 goto power_off;
531 956
532 wl->state = WL1271_STATE_ON; 957 ret = wl1271_hw_init(wl);
958 if (ret < 0)
959 goto irq_disable;
533 960
534 wl1271_info("firmware booted (%s)", wl->chip.fw_ver); 961 wl->state = WL1271_STATE_ON;
962 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
963 goto out;
535 964
536out: 965irq_disable:
537 if (ret < 0) 966 wl1271_disable_interrupts(wl);
967 mutex_unlock(&wl->mutex);
968 /* Unlocking the mutex in the middle of handling is
969 inherently unsafe. In this case we deem it safe to do,
970 because we need to let any possibly pending IRQ out of
971 the system (and while we are WL1271_STATE_OFF the IRQ
972 work function will not do anything.) Also, any other
973 possible concurrent operations will fail due to the
974 current state, hence the wl1271 struct should be safe. */
975 cancel_work_sync(&wl->irq_work);
976 mutex_lock(&wl->mutex);
977power_off:
538 wl1271_power_off(wl); 978 wl1271_power_off(wl);
979 }
539 980
981 wl1271_error("firmware boot failed despite %d retries",
982 WL1271_BOOT_RETRIES);
983out:
540 mutex_unlock(&wl->mutex); 984 mutex_unlock(&wl->mutex);
541 985
986 if (!ret) {
987 list_add(&wl->list, &wl_list);
988 register_inetaddr_notifier(&wl1271_dev_notifier);
989 }
990
542 return ret; 991 return ret;
543} 992}
544 993
@@ -551,15 +1000,17 @@ static void wl1271_op_stop(struct ieee80211_hw *hw)
551 1000
552 wl1271_debug(DEBUG_MAC80211, "mac80211 stop"); 1001 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
553 1002
1003 unregister_inetaddr_notifier(&wl1271_dev_notifier);
1004 list_del(&wl->list);
1005
554 mutex_lock(&wl->mutex); 1006 mutex_lock(&wl->mutex);
555 1007
556 WARN_ON(wl->state != WL1271_STATE_ON); 1008 WARN_ON(wl->state != WL1271_STATE_ON);
557 1009
558 if (wl->scanning) { 1010 if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
559 mutex_unlock(&wl->mutex); 1011 mutex_unlock(&wl->mutex);
560 ieee80211_scan_completed(wl->hw, true); 1012 ieee80211_scan_completed(wl->hw, true);
561 mutex_lock(&wl->mutex); 1013 mutex_lock(&wl->mutex);
562 wl->scanning = false;
563 } 1014 }
564 1015
565 wl->state = WL1271_STATE_OFF; 1016 wl->state = WL1271_STATE_OFF;
@@ -570,7 +1021,6 @@ static void wl1271_op_stop(struct ieee80211_hw *hw)
570 1021
571 cancel_work_sync(&wl->irq_work); 1022 cancel_work_sync(&wl->irq_work);
572 cancel_work_sync(&wl->tx_work); 1023 cancel_work_sync(&wl->tx_work);
573 cancel_work_sync(&wl->filter_work);
574 1024
575 mutex_lock(&wl->mutex); 1025 mutex_lock(&wl->mutex);
576 1026
@@ -581,19 +1031,24 @@ static void wl1271_op_stop(struct ieee80211_hw *hw)
581 memset(wl->bssid, 0, ETH_ALEN); 1031 memset(wl->bssid, 0, ETH_ALEN);
582 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1); 1032 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
583 wl->ssid_len = 0; 1033 wl->ssid_len = 0;
584 wl->listen_int = 1;
585 wl->bss_type = MAX_BSS_TYPE; 1034 wl->bss_type = MAX_BSS_TYPE;
1035 wl->band = IEEE80211_BAND_2GHZ;
586 1036
587 wl->rx_counter = 0; 1037 wl->rx_counter = 0;
588 wl->elp = false; 1038 wl->psm_entry_retry = 0;
589 wl->psm = 0;
590 wl->tx_queue_stopped = false;
591 wl->power_level = WL1271_DEFAULT_POWER_LEVEL; 1039 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
592 wl->tx_blocks_available = 0; 1040 wl->tx_blocks_available = 0;
593 wl->tx_results_count = 0; 1041 wl->tx_results_count = 0;
594 wl->tx_packets_count = 0; 1042 wl->tx_packets_count = 0;
1043 wl->tx_security_last_seq = 0;
1044 wl->tx_security_seq_16 = 0;
1045 wl->tx_security_seq_32 = 0;
595 wl->time_offset = 0; 1046 wl->time_offset = 0;
596 wl->session_counter = 0; 1047 wl->session_counter = 0;
1048 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1049 wl->sta_rate_set = 0;
1050 wl->flags = 0;
1051
597 for (i = 0; i < NUM_TX_QUEUES; i++) 1052 for (i = 0; i < NUM_TX_QUEUES; i++)
598 wl->tx_blocks_freed[i] = 0; 1053 wl->tx_blocks_freed[i] = 0;
599 1054
@@ -602,17 +1057,23 @@ static void wl1271_op_stop(struct ieee80211_hw *hw)
602} 1057}
603 1058
604static int wl1271_op_add_interface(struct ieee80211_hw *hw, 1059static int wl1271_op_add_interface(struct ieee80211_hw *hw,
605 struct ieee80211_if_init_conf *conf) 1060 struct ieee80211_vif *vif)
606{ 1061{
607 struct wl1271 *wl = hw->priv; 1062 struct wl1271 *wl = hw->priv;
608 int ret = 0; 1063 int ret = 0;
609 1064
610 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM", 1065 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
611 conf->type, conf->mac_addr); 1066 vif->type, vif->addr);
612 1067
613 mutex_lock(&wl->mutex); 1068 mutex_lock(&wl->mutex);
1069 if (wl->vif) {
1070 ret = -EBUSY;
1071 goto out;
1072 }
1073
1074 wl->vif = vif;
614 1075
615 switch (conf->type) { 1076 switch (vif->type) {
616 case NL80211_IFTYPE_STATION: 1077 case NL80211_IFTYPE_STATION:
617 wl->bss_type = BSS_TYPE_STA_BSS; 1078 wl->bss_type = BSS_TYPE_STA_BSS;
618 break; 1079 break;
@@ -632,9 +1093,14 @@ out:
632} 1093}
633 1094
634static void wl1271_op_remove_interface(struct ieee80211_hw *hw, 1095static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
635 struct ieee80211_if_init_conf *conf) 1096 struct ieee80211_vif *vif)
636{ 1097{
1098 struct wl1271 *wl = hw->priv;
1099
1100 mutex_lock(&wl->mutex);
637 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface"); 1101 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1102 wl->vif = NULL;
1103 mutex_unlock(&wl->mutex);
638} 1104}
639 1105
640#if 0 1106#if 0
@@ -657,23 +1123,24 @@ static int wl1271_op_config_interface(struct ieee80211_hw *hw,
657 if (ret < 0) 1123 if (ret < 0)
658 goto out; 1124 goto out;
659 1125
660 memcpy(wl->bssid, conf->bssid, ETH_ALEN); 1126 if (memcmp(wl->bssid, conf->bssid, ETH_ALEN)) {
1127 wl1271_debug(DEBUG_MAC80211, "bssid changed");
661 1128
662 ret = wl1271_cmd_build_null_data(wl); 1129 memcpy(wl->bssid, conf->bssid, ETH_ALEN);
663 if (ret < 0)
664 goto out_sleep;
665 1130
666 wl->ssid_len = conf->ssid_len; 1131 ret = wl1271_cmd_join(wl);
667 if (wl->ssid_len) 1132 if (ret < 0)
668 memcpy(wl->ssid, conf->ssid, wl->ssid_len); 1133 goto out_sleep;
669 1134
670 if (wl->bss_type != BSS_TYPE_IBSS) { 1135 ret = wl1271_cmd_build_null_data(wl);
671 /* FIXME: replace the magic numbers with proper definitions */
672 ret = wl1271_cmd_join(wl, wl->bss_type, 5, 100, 1);
673 if (ret < 0) 1136 if (ret < 0)
674 goto out_sleep; 1137 goto out_sleep;
675 } 1138 }
676 1139
1140 wl->ssid_len = conf->ssid_len;
1141 if (wl->ssid_len)
1142 memcpy(wl->ssid, conf->ssid, wl->ssid_len);
1143
677 if (conf->changed & IEEE80211_IFCC_BEACON) { 1144 if (conf->changed & IEEE80211_IFCC_BEACON) {
678 beacon = ieee80211_beacon_get(hw, vif); 1145 beacon = ieee80211_beacon_get(hw, vif);
679 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON, 1146 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
@@ -691,12 +1158,6 @@ static int wl1271_op_config_interface(struct ieee80211_hw *hw,
691 1158
692 if (ret < 0) 1159 if (ret < 0)
693 goto out_sleep; 1160 goto out_sleep;
694
695 /* FIXME: replace the magic numbers with proper definitions */
696 ret = wl1271_cmd_join(wl, wl->bss_type, 1, 100, 0);
697
698 if (ret < 0)
699 goto out_sleep;
700 } 1161 }
701 1162
702out_sleep: 1163out_sleep:
@@ -709,6 +1170,51 @@ out:
709} 1170}
710#endif 1171#endif
711 1172
1173static int wl1271_join_channel(struct wl1271 *wl, int channel)
1174{
1175 int ret = 0;
1176 /* we need to use a dummy BSSID for now */
1177 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1178 0xad, 0xbe, 0xef };
1179
1180 /* the dummy join is not required for ad-hoc */
1181 if (wl->bss_type == BSS_TYPE_IBSS)
1182 goto out;
1183
1184 /* disable mac filter, so we hear everything */
1185 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1186
1187 wl->channel = channel;
1188 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1189
1190 ret = wl1271_cmd_join(wl);
1191 if (ret < 0)
1192 goto out;
1193
1194 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1195
1196out:
1197 return ret;
1198}
1199
1200static int wl1271_unjoin_channel(struct wl1271 *wl)
1201{
1202 int ret;
1203
1204 /* to stop listening to a channel, we disconnect */
1205 ret = wl1271_cmd_disconnect(wl);
1206 if (ret < 0)
1207 goto out;
1208
1209 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1210 wl->channel = 0;
1211 memset(wl->bssid, 0, ETH_ALEN);
1212 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1213
1214out:
1215 return ret;
1216}
1217
712static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed) 1218static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
713{ 1219{
714 struct wl1271 *wl = hw->priv; 1220 struct wl1271 *wl = hw->priv;
@@ -717,58 +1223,75 @@ static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
717 1223
718 channel = ieee80211_frequency_to_channel(conf->channel->center_freq); 1224 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
719 1225
720 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d", 1226 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
721 channel, 1227 channel,
722 conf->flags & IEEE80211_CONF_PS ? "on" : "off", 1228 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
723 conf->power_level); 1229 conf->power_level,
1230 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
724 1231
725 mutex_lock(&wl->mutex); 1232 mutex_lock(&wl->mutex);
726 1233
1234 wl->band = conf->channel->band;
1235
727 ret = wl1271_ps_elp_wakeup(wl, false); 1236 ret = wl1271_ps_elp_wakeup(wl, false);
728 if (ret < 0) 1237 if (ret < 0)
729 goto out; 1238 goto out;
730 1239
731 if (channel != wl->channel) { 1240 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
732 u8 old_channel = wl->channel; 1241 if (conf->flags & IEEE80211_CONF_IDLE &&
733 wl->channel = channel; 1242 test_bit(WL1271_FLAG_JOINED, &wl->flags))
734 1243 wl1271_unjoin_channel(wl);
735 /* FIXME: use beacon interval provided by mac80211 */ 1244 else if (!(conf->flags & IEEE80211_CONF_IDLE))
736 ret = wl1271_cmd_join(wl, wl->bss_type, 1, 100, 0); 1245 wl1271_join_channel(wl, channel);
737 if (ret < 0) { 1246
738 wl->channel = old_channel; 1247 if (conf->flags & IEEE80211_CONF_IDLE) {
739 goto out_sleep; 1248 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1249 wl->sta_rate_set = 0;
1250 wl1271_acx_rate_policies(wl);
740 } 1251 }
741 } 1252 }
742 1253
743 ret = wl1271_cmd_build_null_data(wl); 1254 /* if the channel changes while joined, join again */
744 if (ret < 0) 1255 if (channel != wl->channel &&
745 goto out_sleep; 1256 test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
746 1257 wl->channel = channel;
747 if (conf->flags & IEEE80211_CONF_PS && !wl->psm_requested) { 1258 /* FIXME: maybe use CMD_CHANNEL_SWITCH for this? */
748 wl1271_info("psm enabled"); 1259 ret = wl1271_cmd_join(wl);
1260 if (ret < 0)
1261 wl1271_warning("cmd join to update channel failed %d",
1262 ret);
1263 } else
1264 wl->channel = channel;
749 1265
750 wl->psm_requested = true; 1266 if (conf->flags & IEEE80211_CONF_PS &&
1267 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1268 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
751 1269
752 /* 1270 /*
753 * We enter PSM only if we're already associated. 1271 * We enter PSM only if we're already associated.
754 * If we're not, we'll enter it when joining an SSID, 1272 * If we're not, we'll enter it when joining an SSID,
755 * through the bss_info_changed() hook. 1273 * through the bss_info_changed() hook.
756 */ 1274 */
757 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE); 1275 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1276 wl1271_info("psm enabled");
1277 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1278 true);
1279 }
758 } else if (!(conf->flags & IEEE80211_CONF_PS) && 1280 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
759 wl->psm_requested) { 1281 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
760 wl1271_info("psm disabled"); 1282 wl1271_info("psm disabled");
761 1283
762 wl->psm_requested = false; 1284 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
763 1285
764 if (wl->psm) 1286 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
765 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE); 1287 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1288 true);
766 } 1289 }
767 1290
768 if (conf->power_level != wl->power_level) { 1291 if (conf->power_level != wl->power_level) {
769 ret = wl1271_acx_tx_power(wl, conf->power_level); 1292 ret = wl1271_acx_tx_power(wl, conf->power_level);
770 if (ret < 0) 1293 if (ret < 0)
771 goto out; 1294 goto out_sleep;
772 1295
773 wl->power_level = conf->power_level; 1296 wl->power_level = conf->power_level;
774 } 1297 }
@@ -782,6 +1305,45 @@ out:
782 return ret; 1305 return ret;
783} 1306}
784 1307
1308struct wl1271_filter_params {
1309 bool enabled;
1310 int mc_list_length;
1311 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1312};
1313
1314static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1315 struct dev_addr_list *mc_list)
1316{
1317 struct wl1271_filter_params *fp;
1318 int i;
1319
1320 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1321 if (!fp) {
1322 wl1271_error("Out of memory setting filters.");
1323 return 0;
1324 }
1325
1326 /* update multicast filtering parameters */
1327 fp->enabled = true;
1328 if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1329 mc_count = 0;
1330 fp->enabled = false;
1331 }
1332
1333 fp->mc_list_length = 0;
1334 for (i = 0; i < mc_count; i++) {
1335 if (mc_list->da_addrlen == ETH_ALEN) {
1336 memcpy(fp->mc_list[fp->mc_list_length],
1337 mc_list->da_addr, ETH_ALEN);
1338 fp->mc_list_length++;
1339 } else
1340 wl1271_warning("Unknown mc address length.");
1341 mc_list = mc_list->next;
1342 }
1343
1344 return (u64)(unsigned long)fp;
1345}
1346
785#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \ 1347#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
786 FIF_ALLMULTI | \ 1348 FIF_ALLMULTI | \
787 FIF_FCSFAIL | \ 1349 FIF_FCSFAIL | \
@@ -791,28 +1353,53 @@ out:
791 1353
792static void wl1271_op_configure_filter(struct ieee80211_hw *hw, 1354static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
793 unsigned int changed, 1355 unsigned int changed,
794 unsigned int *total,u64 multicast) 1356 unsigned int *total, u64 multicast)
795{ 1357{
1358 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
796 struct wl1271 *wl = hw->priv; 1359 struct wl1271 *wl = hw->priv;
1360 int ret;
797 1361
798 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter"); 1362 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
799 1363
1364 mutex_lock(&wl->mutex);
1365
1366 if (wl->state == WL1271_STATE_OFF)
1367 goto out;
1368
1369 ret = wl1271_ps_elp_wakeup(wl, false);
1370 if (ret < 0)
1371 goto out;
1372
800 *total &= WL1271_SUPPORTED_FILTERS; 1373 *total &= WL1271_SUPPORTED_FILTERS;
801 changed &= WL1271_SUPPORTED_FILTERS; 1374 changed &= WL1271_SUPPORTED_FILTERS;
802 1375
1376 if (*total & FIF_ALLMULTI)
1377 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1378 else if (fp)
1379 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1380 fp->mc_list,
1381 fp->mc_list_length);
1382 if (ret < 0)
1383 goto out_sleep;
1384
1385 kfree(fp);
1386
1387 /* FIXME: We still need to set our filters properly */
1388
1389 /* determine, whether supported filter values have changed */
803 if (changed == 0) 1390 if (changed == 0)
804 return; 1391 goto out_sleep;
805 1392
806 /* FIXME: wl->rx_config and wl->rx_filter are not protected */ 1393 /* apply configured filters */
807 wl->rx_config = WL1271_DEFAULT_RX_CONFIG; 1394 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
808 wl->rx_filter = WL1271_DEFAULT_RX_FILTER; 1395 if (ret < 0)
1396 goto out_sleep;
809 1397
810 /* 1398out_sleep:
811 * FIXME: workqueues need to be properly cancelled on stop(), for 1399 wl1271_ps_elp_sleep(wl);
812 * now let's just disable changing the filter settings. They will 1400
813 * be updated any on config(). 1401out:
814 */ 1402 mutex_unlock(&wl->mutex);
815 /* schedule_work(&wl->filter_work); */
816} 1403}
817 1404
818static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 1405static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
@@ -823,6 +1410,8 @@ static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
823 struct wl1271 *wl = hw->priv; 1410 struct wl1271 *wl = hw->priv;
824 const u8 *addr; 1411 const u8 *addr;
825 int ret; 1412 int ret;
1413 u32 tx_seq_32 = 0;
1414 u16 tx_seq_16 = 0;
826 u8 key_type; 1415 u8 key_type;
827 1416
828 static const u8 bcast_addr[ETH_ALEN] = 1417 static const u8 bcast_addr[ETH_ALEN] =
@@ -861,11 +1450,15 @@ static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
861 key_type = KEY_TKIP; 1450 key_type = KEY_TKIP;
862 1451
863 key_conf->hw_key_idx = key_conf->keyidx; 1452 key_conf->hw_key_idx = key_conf->keyidx;
1453 tx_seq_32 = wl->tx_security_seq_32;
1454 tx_seq_16 = wl->tx_security_seq_16;
864 break; 1455 break;
865 case ALG_CCMP: 1456 case ALG_CCMP:
866 key_type = KEY_AES; 1457 key_type = KEY_AES;
867 1458
868 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 1459 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1460 tx_seq_32 = wl->tx_security_seq_32;
1461 tx_seq_16 = wl->tx_security_seq_16;
869 break; 1462 break;
870 default: 1463 default:
871 wl1271_error("Unknown key algo 0x%x", key_conf->alg); 1464 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
@@ -879,18 +1472,33 @@ static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
879 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE, 1472 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
880 key_conf->keyidx, key_type, 1473 key_conf->keyidx, key_type,
881 key_conf->keylen, key_conf->key, 1474 key_conf->keylen, key_conf->key,
882 addr); 1475 addr, tx_seq_32, tx_seq_16);
883 if (ret < 0) { 1476 if (ret < 0) {
884 wl1271_error("Could not add or replace key"); 1477 wl1271_error("Could not add or replace key");
885 goto out_sleep; 1478 goto out_sleep;
886 } 1479 }
1480
1481 /* the default WEP key needs to be configured at least once */
1482 if (key_type == KEY_WEP) {
1483 ret = wl1271_cmd_set_default_wep_key(wl,
1484 wl->default_key);
1485 if (ret < 0)
1486 goto out_sleep;
1487 }
887 break; 1488 break;
888 1489
889 case DISABLE_KEY: 1490 case DISABLE_KEY:
1491 /* The wl1271 does not allow to remove unicast keys - they
1492 will be cleared automatically on next CMD_JOIN. Ignore the
1493 request silently, as we dont want the mac80211 to emit
1494 an error message. */
1495 if (!is_broadcast_ether_addr(addr))
1496 break;
1497
890 ret = wl1271_cmd_set_key(wl, KEY_REMOVE, 1498 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
891 key_conf->keyidx, key_type, 1499 key_conf->keyidx, key_type,
892 key_conf->keylen, key_conf->key, 1500 key_conf->keylen, key_conf->key,
893 addr); 1501 addr, 0, 0);
894 if (ret < 0) { 1502 if (ret < 0) {
895 wl1271_error("Could not remove key"); 1503 wl1271_error("Could not remove key");
896 goto out_sleep; 1504 goto out_sleep;
@@ -921,13 +1529,13 @@ static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
921 struct wl1271 *wl = hw->priv; 1529 struct wl1271 *wl = hw->priv;
922 int ret; 1530 int ret;
923 u8 *ssid = NULL; 1531 u8 *ssid = NULL;
924 size_t ssid_len = 0; 1532 size_t len = 0;
925 1533
926 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan"); 1534 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
927 1535
928 if (req->n_ssids) { 1536 if (req->n_ssids) {
929 ssid = req->ssids[0].ssid; 1537 ssid = req->ssids[0].ssid;
930 ssid_len = req->ssids[0].ssid_len; 1538 len = req->ssids[0].ssid_len;
931 } 1539 }
932 1540
933 mutex_lock(&wl->mutex); 1541 mutex_lock(&wl->mutex);
@@ -936,7 +1544,12 @@ static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
936 if (ret < 0) 1544 if (ret < 0)
937 goto out; 1545 goto out;
938 1546
939 ret = wl1271_cmd_scan(hw->priv, ssid, ssid_len, 1, 0, 13, 3); 1547 if (wl1271_11a_enabled())
1548 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1549 WL1271_SCAN_BAND_DUAL, 3);
1550 else
1551 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1552 WL1271_SCAN_BAND_2_4_GHZ, 3);
940 1553
941 wl1271_ps_elp_sleep(wl); 1554 wl1271_ps_elp_sleep(wl);
942 1555
@@ -969,6 +1582,23 @@ out:
969 return ret; 1582 return ret;
970} 1583}
971 1584
1585static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1586{
1587 u8 *ptr = beacon->data +
1588 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1589
1590 /* find the location of the ssid in the beacon */
1591 while (ptr < beacon->data + beacon->len) {
1592 if (ptr[0] == WLAN_EID_SSID) {
1593 wl->ssid_len = ptr[1];
1594 memcpy(wl->ssid, ptr+2, wl->ssid_len);
1595 return;
1596 }
1597 ptr += ptr[1];
1598 }
1599 wl1271_error("ad-hoc beacon template has no SSID!\n");
1600}
1601
972static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw, 1602static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
973 struct ieee80211_vif *vif, 1603 struct ieee80211_vif *vif,
974 struct ieee80211_bss_conf *bss_conf, 1604 struct ieee80211_bss_conf *bss_conf,
@@ -976,6 +1606,7 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
976{ 1606{
977 enum wl1271_cmd_ps_mode mode; 1607 enum wl1271_cmd_ps_mode mode;
978 struct wl1271 *wl = hw->priv; 1608 struct wl1271 *wl = hw->priv;
1609 bool do_join = false;
979 int ret; 1610 int ret;
980 1611
981 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed"); 1612 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
@@ -986,10 +1617,74 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
986 if (ret < 0) 1617 if (ret < 0)
987 goto out; 1618 goto out;
988 1619
1620 if (wl->bss_type == BSS_TYPE_IBSS) {
1621 /* FIXME: This implements rudimentary ad-hoc support -
1622 proper templates are on the wish list and notification
1623 on when they change. This patch will update the templates
1624 on every call to this function. */
1625 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1626
1627 if (beacon) {
1628 struct ieee80211_hdr *hdr;
1629
1630 wl1271_ssid_set(wl, beacon);
1631 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1632 beacon->data,
1633 beacon->len);
1634
1635 if (ret < 0) {
1636 dev_kfree_skb(beacon);
1637 goto out_sleep;
1638 }
1639
1640 hdr = (struct ieee80211_hdr *) beacon->data;
1641 hdr->frame_control = cpu_to_le16(
1642 IEEE80211_FTYPE_MGMT |
1643 IEEE80211_STYPE_PROBE_RESP);
1644
1645 ret = wl1271_cmd_template_set(wl,
1646 CMD_TEMPL_PROBE_RESPONSE,
1647 beacon->data,
1648 beacon->len);
1649 dev_kfree_skb(beacon);
1650 if (ret < 0)
1651 goto out_sleep;
1652
1653 /* Need to update the SSID (for filtering etc) */
1654 do_join = true;
1655 }
1656 }
1657
1658 if ((changed & BSS_CHANGED_BSSID) &&
1659 /*
1660 * Now we know the correct bssid, so we send a new join command
1661 * and enable the BSSID filter
1662 */
1663 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1664 wl->rx_config |= CFG_BSSID_FILTER_EN;
1665 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1666 ret = wl1271_cmd_build_null_data(wl);
1667 if (ret < 0) {
1668 wl1271_warning("cmd buld null data failed %d",
1669 ret);
1670 goto out_sleep;
1671 }
1672
1673 /* Need to update the BSSID (for filtering etc) */
1674 do_join = true;
1675 }
1676
989 if (changed & BSS_CHANGED_ASSOC) { 1677 if (changed & BSS_CHANGED_ASSOC) {
990 if (bss_conf->assoc) { 1678 if (bss_conf->assoc) {
991 wl->aid = bss_conf->aid; 1679 wl->aid = bss_conf->aid;
992 1680 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1681
1682 /*
1683 * with wl1271, we don't need to update the
1684 * beacon_int and dtim_period, because the firmware
1685 * updates it by itself when the first beacon is
1686 * received after a join.
1687 */
993 ret = wl1271_cmd_build_ps_poll(wl, wl->aid); 1688 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
994 if (ret < 0) 1689 if (ret < 0)
995 goto out_sleep; 1690 goto out_sleep;
@@ -999,14 +1694,21 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
999 goto out_sleep; 1694 goto out_sleep;
1000 1695
1001 /* If we want to go in PSM but we're not there yet */ 1696 /* If we want to go in PSM but we're not there yet */
1002 if (wl->psm_requested && !wl->psm) { 1697 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1698 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1003 mode = STATION_POWER_SAVE_MODE; 1699 mode = STATION_POWER_SAVE_MODE;
1004 ret = wl1271_ps_set_mode(wl, mode); 1700 ret = wl1271_ps_set_mode(wl, mode, true);
1005 if (ret < 0) 1701 if (ret < 0)
1006 goto out_sleep; 1702 goto out_sleep;
1007 } 1703 }
1704 } else {
1705 /* use defaults when not associated */
1706 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1707 wl->aid = 0;
1008 } 1708 }
1709
1009 } 1710 }
1711
1010 if (changed & BSS_CHANGED_ERP_SLOT) { 1712 if (changed & BSS_CHANGED_ERP_SLOT) {
1011 if (bss_conf->use_short_slot) 1713 if (bss_conf->use_short_slot)
1012 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT); 1714 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
@@ -1036,72 +1738,118 @@ static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1036 } 1738 }
1037 } 1739 }
1038 1740
1741 if (do_join) {
1742 ret = wl1271_cmd_join(wl);
1743 if (ret < 0) {
1744 wl1271_warning("cmd join failed %d", ret);
1745 goto out_sleep;
1746 }
1747 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1748 }
1749
1750out_sleep:
1751 wl1271_ps_elp_sleep(wl);
1752
1753out:
1754 mutex_unlock(&wl->mutex);
1755}
1756
1757static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1758 const struct ieee80211_tx_queue_params *params)
1759{
1760 struct wl1271 *wl = hw->priv;
1761 int ret;
1762
1763 mutex_lock(&wl->mutex);
1764
1765 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1766
1767 ret = wl1271_ps_elp_wakeup(wl, false);
1768 if (ret < 0)
1769 goto out;
1770
1771 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1772 params->cw_min, params->cw_max,
1773 params->aifs, params->txop);
1774 if (ret < 0)
1775 goto out_sleep;
1776
1777 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1778 CONF_CHANNEL_TYPE_EDCF,
1779 wl1271_tx_get_queue(queue),
1780 CONF_PS_SCHEME_LEGACY_PSPOLL,
1781 CONF_ACK_POLICY_LEGACY, 0, 0);
1782 if (ret < 0)
1783 goto out_sleep;
1784
1039out_sleep: 1785out_sleep:
1040 wl1271_ps_elp_sleep(wl); 1786 wl1271_ps_elp_sleep(wl);
1041 1787
1042out: 1788out:
1043 mutex_unlock(&wl->mutex); 1789 mutex_unlock(&wl->mutex);
1790
1791 return ret;
1044} 1792}
1045 1793
1046 1794
1047/* can't be const, mac80211 writes to this */ 1795/* can't be const, mac80211 writes to this */
1048static struct ieee80211_rate wl1271_rates[] = { 1796static struct ieee80211_rate wl1271_rates[] = {
1049 { .bitrate = 10, 1797 { .bitrate = 10,
1050 .hw_value = 0x1, 1798 .hw_value = CONF_HW_BIT_RATE_1MBPS,
1051 .hw_value_short = 0x1, }, 1799 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1052 { .bitrate = 20, 1800 { .bitrate = 20,
1053 .hw_value = 0x2, 1801 .hw_value = CONF_HW_BIT_RATE_2MBPS,
1054 .hw_value_short = 0x2, 1802 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1055 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 1803 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1056 { .bitrate = 55, 1804 { .bitrate = 55,
1057 .hw_value = 0x4, 1805 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1058 .hw_value_short = 0x4, 1806 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1059 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 1807 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1060 { .bitrate = 110, 1808 { .bitrate = 110,
1061 .hw_value = 0x20, 1809 .hw_value = CONF_HW_BIT_RATE_11MBPS,
1062 .hw_value_short = 0x20, 1810 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1063 .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 1811 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1064 { .bitrate = 60, 1812 { .bitrate = 60,
1065 .hw_value = 0x8, 1813 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1066 .hw_value_short = 0x8, }, 1814 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1067 { .bitrate = 90, 1815 { .bitrate = 90,
1068 .hw_value = 0x10, 1816 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1069 .hw_value_short = 0x10, }, 1817 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1070 { .bitrate = 120, 1818 { .bitrate = 120,
1071 .hw_value = 0x40, 1819 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1072 .hw_value_short = 0x40, }, 1820 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1073 { .bitrate = 180, 1821 { .bitrate = 180,
1074 .hw_value = 0x80, 1822 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1075 .hw_value_short = 0x80, }, 1823 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1076 { .bitrate = 240, 1824 { .bitrate = 240,
1077 .hw_value = 0x200, 1825 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1078 .hw_value_short = 0x200, }, 1826 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1079 { .bitrate = 360, 1827 { .bitrate = 360,
1080 .hw_value = 0x400, 1828 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1081 .hw_value_short = 0x400, }, 1829 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1082 { .bitrate = 480, 1830 { .bitrate = 480,
1083 .hw_value = 0x800, 1831 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1084 .hw_value_short = 0x800, }, 1832 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1085 { .bitrate = 540, 1833 { .bitrate = 540,
1086 .hw_value = 0x1000, 1834 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1087 .hw_value_short = 0x1000, }, 1835 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1088}; 1836};
1089 1837
1090/* can't be const, mac80211 writes to this */ 1838/* can't be const, mac80211 writes to this */
1091static struct ieee80211_channel wl1271_channels[] = { 1839static struct ieee80211_channel wl1271_channels[] = {
1092 { .hw_value = 1, .center_freq = 2412}, 1840 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1093 { .hw_value = 2, .center_freq = 2417}, 1841 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1094 { .hw_value = 3, .center_freq = 2422}, 1842 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1095 { .hw_value = 4, .center_freq = 2427}, 1843 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1096 { .hw_value = 5, .center_freq = 2432}, 1844 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1097 { .hw_value = 6, .center_freq = 2437}, 1845 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1098 { .hw_value = 7, .center_freq = 2442}, 1846 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1099 { .hw_value = 8, .center_freq = 2447}, 1847 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1100 { .hw_value = 9, .center_freq = 2452}, 1848 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1101 { .hw_value = 10, .center_freq = 2457}, 1849 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1102 { .hw_value = 11, .center_freq = 2462}, 1850 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1103 { .hw_value = 12, .center_freq = 2467}, 1851 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1104 { .hw_value = 13, .center_freq = 2472}, 1852 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1105}; 1853};
1106 1854
1107/* can't be const, mac80211 writes to this */ 1855/* can't be const, mac80211 writes to this */
@@ -1112,6 +1860,88 @@ static struct ieee80211_supported_band wl1271_band_2ghz = {
1112 .n_bitrates = ARRAY_SIZE(wl1271_rates), 1860 .n_bitrates = ARRAY_SIZE(wl1271_rates),
1113}; 1861};
1114 1862
1863/* 5 GHz data rates for WL1273 */
1864static struct ieee80211_rate wl1271_rates_5ghz[] = {
1865 { .bitrate = 60,
1866 .hw_value = CONF_HW_BIT_RATE_6MBPS,
1867 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1868 { .bitrate = 90,
1869 .hw_value = CONF_HW_BIT_RATE_9MBPS,
1870 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1871 { .bitrate = 120,
1872 .hw_value = CONF_HW_BIT_RATE_12MBPS,
1873 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1874 { .bitrate = 180,
1875 .hw_value = CONF_HW_BIT_RATE_18MBPS,
1876 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1877 { .bitrate = 240,
1878 .hw_value = CONF_HW_BIT_RATE_24MBPS,
1879 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1880 { .bitrate = 360,
1881 .hw_value = CONF_HW_BIT_RATE_36MBPS,
1882 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1883 { .bitrate = 480,
1884 .hw_value = CONF_HW_BIT_RATE_48MBPS,
1885 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1886 { .bitrate = 540,
1887 .hw_value = CONF_HW_BIT_RATE_54MBPS,
1888 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1889};
1890
1891/* 5 GHz band channels for WL1273 */
1892static struct ieee80211_channel wl1271_channels_5ghz[] = {
1893 { .hw_value = 183, .center_freq = 4915},
1894 { .hw_value = 184, .center_freq = 4920},
1895 { .hw_value = 185, .center_freq = 4925},
1896 { .hw_value = 187, .center_freq = 4935},
1897 { .hw_value = 188, .center_freq = 4940},
1898 { .hw_value = 189, .center_freq = 4945},
1899 { .hw_value = 192, .center_freq = 4960},
1900 { .hw_value = 196, .center_freq = 4980},
1901 { .hw_value = 7, .center_freq = 5035},
1902 { .hw_value = 8, .center_freq = 5040},
1903 { .hw_value = 9, .center_freq = 5045},
1904 { .hw_value = 11, .center_freq = 5055},
1905 { .hw_value = 12, .center_freq = 5060},
1906 { .hw_value = 16, .center_freq = 5080},
1907 { .hw_value = 34, .center_freq = 5170},
1908 { .hw_value = 36, .center_freq = 5180},
1909 { .hw_value = 38, .center_freq = 5190},
1910 { .hw_value = 40, .center_freq = 5200},
1911 { .hw_value = 42, .center_freq = 5210},
1912 { .hw_value = 44, .center_freq = 5220},
1913 { .hw_value = 46, .center_freq = 5230},
1914 { .hw_value = 48, .center_freq = 5240},
1915 { .hw_value = 52, .center_freq = 5260},
1916 { .hw_value = 56, .center_freq = 5280},
1917 { .hw_value = 60, .center_freq = 5300},
1918 { .hw_value = 64, .center_freq = 5320},
1919 { .hw_value = 100, .center_freq = 5500},
1920 { .hw_value = 104, .center_freq = 5520},
1921 { .hw_value = 108, .center_freq = 5540},
1922 { .hw_value = 112, .center_freq = 5560},
1923 { .hw_value = 116, .center_freq = 5580},
1924 { .hw_value = 120, .center_freq = 5600},
1925 { .hw_value = 124, .center_freq = 5620},
1926 { .hw_value = 128, .center_freq = 5640},
1927 { .hw_value = 132, .center_freq = 5660},
1928 { .hw_value = 136, .center_freq = 5680},
1929 { .hw_value = 140, .center_freq = 5700},
1930 { .hw_value = 149, .center_freq = 5745},
1931 { .hw_value = 153, .center_freq = 5765},
1932 { .hw_value = 157, .center_freq = 5785},
1933 { .hw_value = 161, .center_freq = 5805},
1934 { .hw_value = 165, .center_freq = 5825},
1935};
1936
1937
1938static struct ieee80211_supported_band wl1271_band_5ghz = {
1939 .channels = wl1271_channels_5ghz,
1940 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1941 .bitrates = wl1271_rates_5ghz,
1942 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1943};
1944
1115static const struct ieee80211_ops wl1271_ops = { 1945static const struct ieee80211_ops wl1271_ops = {
1116 .start = wl1271_op_start, 1946 .start = wl1271_op_start,
1117 .stop = wl1271_op_stop, 1947 .stop = wl1271_op_stop,
@@ -1119,12 +1949,15 @@ static const struct ieee80211_ops wl1271_ops = {
1119 .remove_interface = wl1271_op_remove_interface, 1949 .remove_interface = wl1271_op_remove_interface,
1120 .config = wl1271_op_config, 1950 .config = wl1271_op_config,
1121/* .config_interface = wl1271_op_config_interface, */ 1951/* .config_interface = wl1271_op_config_interface, */
1952 .prepare_multicast = wl1271_op_prepare_multicast,
1122 .configure_filter = wl1271_op_configure_filter, 1953 .configure_filter = wl1271_op_configure_filter,
1123 .tx = wl1271_op_tx, 1954 .tx = wl1271_op_tx,
1124 .set_key = wl1271_op_set_key, 1955 .set_key = wl1271_op_set_key,
1125 .hw_scan = wl1271_op_hw_scan, 1956 .hw_scan = wl1271_op_hw_scan,
1126 .bss_info_changed = wl1271_op_bss_info_changed, 1957 .bss_info_changed = wl1271_op_bss_info_changed,
1127 .set_rts_threshold = wl1271_op_set_rts_threshold, 1958 .set_rts_threshold = wl1271_op_set_rts_threshold,
1959 .conf_tx = wl1271_op_conf_tx,
1960 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
1128}; 1961};
1129 1962
1130static int wl1271_register_hw(struct wl1271 *wl) 1963static int wl1271_register_hw(struct wl1271 *wl)
@@ -1151,24 +1984,27 @@ static int wl1271_register_hw(struct wl1271 *wl)
1151 1984
1152static int wl1271_init_ieee80211(struct wl1271 *wl) 1985static int wl1271_init_ieee80211(struct wl1271 *wl)
1153{ 1986{
1154 /* 1987 /* The tx descriptor buffer and the TKIP space. */
1155 * The tx descriptor buffer and the TKIP space. 1988 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1156 * 1989 sizeof(struct wl1271_tx_hw_descr);
1157 * FIXME: add correct 1271 descriptor size
1158 */
1159 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE;
1160 1990
1161 /* unit us */ 1991 /* unit us */
1162 /* FIXME: find a proper value */ 1992 /* FIXME: find a proper value */
1163 wl->hw->channel_change_time = 10000; 1993 wl->hw->channel_change_time = 10000;
1164 1994
1165 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM | 1995 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1166 IEEE80211_HW_NOISE_DBM; 1996 IEEE80211_HW_NOISE_DBM |
1997 IEEE80211_HW_BEACON_FILTER |
1998 IEEE80211_HW_SUPPORTS_PS;
1167 1999
1168 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION); 2000 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2001 BIT(NL80211_IFTYPE_ADHOC);
1169 wl->hw->wiphy->max_scan_ssids = 1; 2002 wl->hw->wiphy->max_scan_ssids = 1;
1170 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz; 2003 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1171 2004
2005 if (wl1271_11a_enabled())
2006 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2007
1172 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev); 2008 SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
1173 2009
1174 return 0; 2010 return 0;
@@ -1190,73 +2026,99 @@ static struct platform_device wl1271_device = {
1190}; 2026};
1191 2027
1192#define WL1271_DEFAULT_CHANNEL 0 2028#define WL1271_DEFAULT_CHANNEL 0
1193static int __devinit wl1271_probe(struct spi_device *spi) 2029
2030static struct ieee80211_hw *wl1271_alloc_hw(void)
1194{ 2031{
1195 struct wl12xx_platform_data *pdata;
1196 struct ieee80211_hw *hw; 2032 struct ieee80211_hw *hw;
1197 struct wl1271 *wl; 2033 struct wl1271 *wl;
1198 int ret, i; 2034 int i;
1199 static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
1200
1201 pdata = spi->dev.platform_data;
1202 if (!pdata) {
1203 wl1271_error("no platform data");
1204 return -ENODEV;
1205 }
1206 2035
1207 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops); 2036 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
1208 if (!hw) { 2037 if (!hw) {
1209 wl1271_error("could not alloc ieee80211_hw"); 2038 wl1271_error("could not alloc ieee80211_hw");
1210 return -ENOMEM; 2039 return ERR_PTR(-ENOMEM);
1211 } 2040 }
1212 2041
1213 wl = hw->priv; 2042 wl = hw->priv;
1214 memset(wl, 0, sizeof(*wl)); 2043 memset(wl, 0, sizeof(*wl));
1215 2044
2045 INIT_LIST_HEAD(&wl->list);
2046
1216 wl->hw = hw; 2047 wl->hw = hw;
1217 dev_set_drvdata(&spi->dev, wl);
1218 wl->spi = spi;
1219 2048
1220 skb_queue_head_init(&wl->tx_queue); 2049 skb_queue_head_init(&wl->tx_queue);
1221 2050
1222 INIT_WORK(&wl->filter_work, wl1271_filter_work); 2051 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
1223 wl->channel = WL1271_DEFAULT_CHANNEL; 2052 wl->channel = WL1271_DEFAULT_CHANNEL;
1224 wl->scanning = false;
1225 wl->default_key = 0; 2053 wl->default_key = 0;
1226 wl->listen_int = 1;
1227 wl->rx_counter = 0; 2054 wl->rx_counter = 0;
1228 wl->rx_config = WL1271_DEFAULT_RX_CONFIG; 2055 wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1229 wl->rx_filter = WL1271_DEFAULT_RX_FILTER; 2056 wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1230 wl->elp = false; 2057 wl->psm_entry_retry = 0;
1231 wl->psm = 0;
1232 wl->psm_requested = false;
1233 wl->tx_queue_stopped = false;
1234 wl->power_level = WL1271_DEFAULT_POWER_LEVEL; 2058 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1235 2059 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
1236 /* We use the default power on sleep time until we know which chip 2060 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1237 * we're using */ 2061 wl->sta_rate_set = 0;
1238 for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++) 2062 wl->band = IEEE80211_BAND_2GHZ;
2063 wl->vif = NULL;
2064 wl->flags = 0;
2065
2066 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
1239 wl->tx_frames[i] = NULL; 2067 wl->tx_frames[i] = NULL;
1240 2068
1241 spin_lock_init(&wl->wl_lock); 2069 spin_lock_init(&wl->wl_lock);
1242 2070
1243 /*
1244 * In case our MAC address is not correctly set,
1245 * we use a random but Nokia MAC.
1246 */
1247 memcpy(wl->mac_addr, nokia_oui, 3);
1248 get_random_bytes(wl->mac_addr + 3, 3);
1249
1250 wl->state = WL1271_STATE_OFF; 2071 wl->state = WL1271_STATE_OFF;
1251 mutex_init(&wl->mutex); 2072 mutex_init(&wl->mutex);
1252 2073
1253 wl->rx_descriptor = kmalloc(sizeof(*wl->rx_descriptor), GFP_KERNEL); 2074 /* Apply default driver configuration. */
1254 if (!wl->rx_descriptor) { 2075 wl1271_conf_init(wl);
1255 wl1271_error("could not allocate memory for rx descriptor"); 2076
1256 ret = -ENOMEM; 2077 return hw;
1257 goto out_free; 2078}
2079
2080int wl1271_free_hw(struct wl1271 *wl)
2081{
2082 ieee80211_unregister_hw(wl->hw);
2083
2084 wl1271_debugfs_exit(wl);
2085
2086 kfree(wl->target_mem_map);
2087 vfree(wl->fw);
2088 wl->fw = NULL;
2089 kfree(wl->nvs);
2090 wl->nvs = NULL;
2091
2092 kfree(wl->fw_status);
2093 kfree(wl->tx_res_if);
2094
2095 ieee80211_free_hw(wl->hw);
2096
2097 return 0;
2098}
2099
2100static int __devinit wl1271_probe(struct spi_device *spi)
2101{
2102 struct wl12xx_platform_data *pdata;
2103 struct ieee80211_hw *hw;
2104 struct wl1271 *wl;
2105 int ret;
2106
2107 pdata = spi->dev.platform_data;
2108 if (!pdata) {
2109 wl1271_error("no platform data");
2110 return -ENODEV;
1258 } 2111 }
1259 2112
2113 hw = wl1271_alloc_hw();
2114 if (IS_ERR(hw))
2115 return PTR_ERR(hw);
2116
2117 wl = hw->priv;
2118
2119 dev_set_drvdata(&spi->dev, wl);
2120 wl->spi = spi;
2121
1260 /* This is the only SPI value that we need to set here, the rest 2122 /* This is the only SPI value that we need to set here, the rest
1261 * comes from the board-peripherals file */ 2123 * comes from the board-peripherals file */
1262 spi->bits_per_word = 32; 2124 spi->bits_per_word = 32;
@@ -1319,9 +2181,6 @@ static int __devinit wl1271_probe(struct spi_device *spi)
1319 free_irq(wl->irq, wl); 2181 free_irq(wl->irq, wl);
1320 2182
1321 out_free: 2183 out_free:
1322 kfree(wl->rx_descriptor);
1323 wl->rx_descriptor = NULL;
1324
1325 ieee80211_free_hw(hw); 2184 ieee80211_free_hw(hw);
1326 2185
1327 return ret; 2186 return ret;
@@ -1331,24 +2190,10 @@ static int __devexit wl1271_remove(struct spi_device *spi)
1331{ 2190{
1332 struct wl1271 *wl = dev_get_drvdata(&spi->dev); 2191 struct wl1271 *wl = dev_get_drvdata(&spi->dev);
1333 2192
1334 ieee80211_unregister_hw(wl->hw);
1335
1336 wl1271_debugfs_exit(wl);
1337 platform_device_unregister(&wl1271_device); 2193 platform_device_unregister(&wl1271_device);
1338 free_irq(wl->irq, wl); 2194 free_irq(wl->irq, wl);
1339 kfree(wl->target_mem_map);
1340 kfree(wl->fw);
1341 wl->fw = NULL;
1342 kfree(wl->nvs);
1343 wl->nvs = NULL;
1344
1345 kfree(wl->rx_descriptor);
1346 wl->rx_descriptor = NULL;
1347
1348 kfree(wl->fw_status);
1349 kfree(wl->tx_res_if);
1350 2195
1351 ieee80211_free_hw(wl->hw); 2196 wl1271_free_hw(wl);
1352 2197
1353 return 0; 2198 return 0;
1354} 2199}
@@ -1391,3 +2236,5 @@ module_exit(wl1271_exit);
1391 2236
1392MODULE_LICENSE("GPL"); 2237MODULE_LICENSE("GPL");
1393MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>"); 2238MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2239MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2240MODULE_FIRMWARE(WL1271_FW_NAME);
generated by cgit v1.2.2 (git 2.25.0) at 2025-07-29 04:06:25 -0400