wl1271: Add support for acx_pm_config
[linux-2.6.git] / drivers / net / wireless / wl12xx / wl1271_main.c
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>
33 #include <linux/vmalloc.h>
34 #include <linux/spi/wl12xx.h>
35 #include <linux/inetdevice.h>
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
50 #define WL1271_BOOT_RETRIES 3
51
52 static 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,
72                 .rx_cca_threshold            = 0,
73                 .irq_blk_threshold           = 0xFFFF,
74                 .irq_pkt_threshold           = 0,
75                 .irq_timeout                 = 600,
76                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
77         },
78         .tx = {
79                 .tx_energy_detection         = 0,
80                 .rc_conf                     = {
81                         .enabled_rates       = CONF_HW_BIT_RATE_1MBPS |
82                                                CONF_HW_BIT_RATE_2MBPS,
83                         .short_retry_limit   = 10,
84                         .long_retry_limit    = 10,
85                         .aflags              = 0
86                 },
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,
95                         },
96                         [1] = {
97                                 .ac          = CONF_TX_AC_BK,
98                                 .cw_min      = 15,
99                                 .cw_max      = 63,
100                                 .aifsn       = 7,
101                                 .tx_op_limit = 0,
102                         },
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,
116                         },
117                 },
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},
135                         },
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},
143                         },
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,
178                 .tx_compl_timeout            = 700,
179                 .tx_compl_threshold          = 4
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,
190                         }
191                 },
192                 .synch_fail_thold            = 10,
193                 .bss_lose_timeout            = 100,
194                 .beacon_rx_timeout           = 10000,
195                 .broadcast_timeout           = 20000,
196                 .rx_broadcast_in_ps          = 1,
197                 .ps_poll_threshold           = 20,
198                 .sig_trigger_count           = 2,
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
209                         },
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
226                 },
227                 .bet_enable                  = CONF_BET_MODE_ENABLE,
228                 .bet_max_consecutive         = 10,
229                 .psm_entry_retries           = 3
230         },
231         .init = {
232                 .genparam                    = {
233                         .ref_clk             = CONF_REF_CLK_38_4_E,
234                         .settling_time       = 5,
235                         .clk_valid_on_wakeup = 0,
236                         .dc2dcmode           = 0,
237                         .single_dual_band    = CONF_SINGLE_BAND,
238                         .tx_bip_fem_autodetect = 1,
239                         .tx_bip_fem_manufacturer = 1,
240                         .settings = 1,
241                         .sr_state = 1,
242                         .srf1 = { 0x07, 0x03, 0x18, 0x10, 0x05, 0xfb, 0xf0,
243                                   0xe8, 0, 0, 0, 0, 0, 0, 0, 0 },
244                         .srf2 = { 0x07, 0x03, 0x18, 0x10, 0x05, 0xfb, 0xf0,
245                                   0xe8, 0, 0, 0, 0, 0, 0, 0, 0 },
246                         .srf3 = { 0x07, 0x03, 0x18, 0x10, 0x05, 0xfb, 0xf0,
247                                   0xe8, 0, 0, 0, 0, 0, 0, 0, 0 },
248                         .sr_debug_table = { 0, 0, 0, 0, 0, 0, 0, 0,
249                                             0, 0, 0, 0, 0, 0, 0, 0 },
250                         .sr_sen_n_p = 0,
251                         .sr_sen_n_p_gain = 0,
252                         .sr_sen_nrn = 0,
253                         .sr_sen_prn = 0,
254                 },
255                 .radioparam = {
256                         .rx_trace_loss       = 0x24,
257                         .tx_trace_loss       = 0x0,
258                         .rx_rssi_and_proc_compens = {
259                                 0xec, 0xf6, 0x00, 0x0c, 0x18, 0xf8,
260                                 0xfc, 0x00, 0x80, 0x10, 0xf0, 0xf8,
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 },
268                         .tx_ref_pd_voltage   = 0x1a9,
269                         .tx_ref_power        = 0x80,
270                         .tx_offset_db        = 0x0,
271                         .tx_rate_limits_normal = {
272                                 0x1d, 0x1f, 0x24, 0x28, 0x28, 0x29 },
273                         .tx_rate_limits_degraded = {
274                                 0x19, 0x1f, 0x22, 0x23, 0x27, 0x28 },
275                         .tx_rate_limits_extreme = {
276                                 0x19, 0x1c, 0x1e, 0x20, 0x24, 0x25 },
277                         .tx_channel_limits_11b = {
278                                 0x22, 0x50, 0x50, 0x50, 0x50, 0x50,
279                                 0x50, 0x50, 0x50, 0x50, 0x22, 0x50,
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 = {
286                                 0x07, 0x08, 0x04, 0x02, 0x02, 0x00 },
287                         .tx_ibias            = {
288                                 0x11, 0x11, 0x15, 0x11, 0x15, 0x0f },
289                         .rx_fem_insertion_loss = 0x0e,
290                         .degraded_low_to_normal_threshold = 0x1e,
291                         .degraded_normal_to_high_threshold = 0x2d,
292                         .tx_ref_pd_voltage_5 = {
293                                 0x0190, 0x01a4, 0x01c3, 0x01d8,
294                                 0x020a, 0x021c },
295                         .tx_ref_power_5      = {
296                                 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },
297                         .tx_offset_db_5      = {
298                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
299                         .tx_rate_limits_normal_5 = {
300                                 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
301                         .tx_rate_limits_degraded_5 = {
302                                 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
303                         .tx_rate_limits_extreme_5 = {
304                                 0x1b, 0x1e, 0x21, 0x23, 0x27, 0x00 },
305                         .tx_channel_limits_ofdm_5 = {
306                                 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
307                                 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
308                                 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
309                                 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
310                                 0x50, 0x50, 0x50 },
311                         .tx_pdv_rate_offsets_5 = {
312                                 0x01, 0x02, 0x02, 0x02, 0x02, 0x00 },
313                         .tx_ibias_5          = {
314                                 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 },
315                         .rx_fem_insertion_loss_5 = {
316                                 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 },
317                         .degraded_low_to_normal_threshold_5 = 0x00,
318                         .degraded_normal_to_high_threshold_5 = 0x00
319                 }
320         },
321         .itrim = {
322                 .enable = false,
323                 .timeout = 50000,
324         },
325         .pm_config = {
326                 .host_clk_settling_time = 5000,
327                 .host_fast_wakeup_support = false
328         }
329 };
330
331 static LIST_HEAD(wl_list);
332
333 static void wl1271_conf_init(struct wl1271 *wl)
334 {
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 */
347         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
348
349         if (wl1271_11a_enabled())
350                 wl->conf.init.genparam.single_dual_band = CONF_DUAL_BAND;
351 }
352
353
354 static int wl1271_plt_init(struct wl1271 *wl)
355 {
356         int ret;
357
358         ret = wl1271_cmd_general_parms(wl);
359         if (ret < 0)
360                 return ret;
361
362         ret = wl1271_cmd_radio_parms(wl);
363         if (ret < 0)
364                 return ret;
365
366         ret = wl1271_acx_init_mem_config(wl);
367         if (ret < 0)
368                 return ret;
369
370         ret = wl1271_cmd_data_path(wl, 1);
371         if (ret < 0)
372                 return ret;
373
374         return 0;
375 }
376
377 static void wl1271_disable_interrupts(struct wl1271 *wl)
378 {
379         disable_irq(wl->irq);
380 }
381
382 static void wl1271_power_off(struct wl1271 *wl)
383 {
384         wl->set_power(false);
385         clear_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
386 }
387
388 static void wl1271_power_on(struct wl1271 *wl)
389 {
390         wl->set_power(true);
391         set_bit(WL1271_FLAG_GPIO_POWER, &wl->flags);
392 }
393
394 static void wl1271_fw_status(struct wl1271 *wl,
395                              struct wl1271_fw_status *status)
396 {
397         u32 total = 0;
398         int i;
399
400         wl1271_spi_read(wl, FW_STATUS_ADDR, status,
401                         sizeof(*status), false);
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++) {
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]);
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))
423                 ieee80211_queue_work(wl->hw, &wl->tx_work);
424
425         /* update the host-chipset time offset */
426         wl->time_offset = jiffies_to_usecs(jiffies) -
427                 le32_to_cpu(status->fw_localtime);
428 }
429
430 static void wl1271_irq_work(struct work_struct *work)
431 {
432         int ret;
433         u32 intr;
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
448         wl1271_spi_write32(wl, ACX_REG_INTERRUPT_MASK, WL1271_ACX_INTR_ALL);
449
450         wl1271_fw_status(wl, wl->fw_status);
451         intr = le32_to_cpu(wl->fw_status->intr);
452         if (!intr) {
453                 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
454                 goto out_sleep;
455         }
456
457         intr &= WL1271_INTR_MASK;
458
459         if (intr & WL1271_ACX_INTR_EVENT_A) {
460                 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
461                 wl1271_event_handle(wl, 0);
462         }
463
464         if (intr & WL1271_ACX_INTR_EVENT_B) {
465                 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
466                 wl1271_event_handle(wl, 1);
467         }
468
469         if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
470                 wl1271_debug(DEBUG_IRQ,
471                              "WL1271_ACX_INTR_INIT_COMPLETE");
472
473         if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
474                 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
475
476         if (intr & WL1271_ACX_INTR_DATA) {
477                 u8 tx_res_cnt = wl->fw_status->tx_results_counter -
478                         wl->tx_results_count;
479
480                 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
481
482                 /* check for tx results */
483                 if (tx_res_cnt)
484                         wl1271_tx_complete(wl, tx_res_cnt);
485
486                 wl1271_rx(wl, wl->fw_status);
487         }
488
489 out_sleep:
490         wl1271_spi_write32(wl, ACX_REG_INTERRUPT_MASK,
491                            WL1271_ACX_INTR_ALL & ~(WL1271_INTR_MASK));
492         wl1271_ps_elp_sleep(wl);
493
494 out:
495         mutex_unlock(&wl->mutex);
496 }
497
498 static 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
514         ieee80211_queue_work(wl->hw, &wl->irq_work);
515         spin_unlock_irqrestore(&wl->wl_lock, flags);
516
517         return IRQ_HANDLED;
518 }
519
520 static 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;
540         wl->fw = vmalloc(wl->fw_len);
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
552 out:
553         release_firmware(fw);
554
555         return ret;
556 }
557
558 static 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
590 out:
591         release_firmware(fw);
592
593         return ret;
594 }
595
596 static void wl1271_fw_wakeup(struct wl1271 *wl)
597 {
598         u32 elp_reg;
599
600         elp_reg = ELPCTRL_WAKE_UP;
601         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
602 }
603
604 static 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
621 static int wl1271_chip_wakeup(struct wl1271 *wl)
622 {
623         struct wl1271_partition_set partition;
624         int ret = 0;
625
626         msleep(WL1271_PRE_POWER_ON_SLEEP);
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. */
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);
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 */
645         wl->chip.id = wl1271_spi_read32(wl, CHIP_ID_B);
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)
656                         goto out;
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)
664                         goto out;
665                 break;
666         default:
667                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
668                 ret = -ENODEV;
669                 goto out;
670         }
671
672         if (wl->fw == NULL) {
673                 ret = wl1271_fetch_firmware(wl);
674                 if (ret < 0)
675                         goto out;
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)
682                         goto out;
683         }
684
685 out:
686         return ret;
687 }
688
689 int wl1271_plt_start(struct wl1271 *wl)
690 {
691         int retries = WL1271_BOOT_RETRIES;
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
705         while (retries) {
706                 retries--;
707                 ret = wl1271_chip_wakeup(wl);
708                 if (ret < 0)
709                         goto power_off;
710
711                 ret = wl1271_boot(wl);
712                 if (ret < 0)
713                         goto power_off;
714
715                 ret = wl1271_plt_init(wl);
716                 if (ret < 0)
717                         goto irq_disable;
718
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;
723
724                 wl->state = WL1271_STATE_PLT;
725                 wl1271_notice("firmware booted in PLT mode (%s)",
726                               wl->chip.fw_ver);
727                 goto out;
728
729 irq_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);
741 power_off:
742                 wl1271_power_off(wl);
743         }
744
745         wl1271_error("firmware boot in PLT mode failed despite %d retries",
746                      WL1271_BOOT_RETRIES);
747 out:
748         mutex_unlock(&wl->mutex);
749
750         return ret;
751 }
752
753 int 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;
772         wl->rx_counter = 0;
773
774 out:
775         mutex_unlock(&wl->mutex);
776
777         return ret;
778 }
779
780
781 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
782 {
783         struct wl1271 *wl = hw->priv;
784         struct ieee80211_conf *conf = &hw->conf;
785         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
786         struct ieee80211_sta *sta = txinfo->control.sta;
787         unsigned long flags;
788
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 */
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
805         ieee80211_queue_work(wl->hw, &wl->tx_work);
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                  */
819                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
820         }
821
822         return NETDEV_TX_OK;
823 }
824
825 static 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)
851                 return NOTIFY_DONE;
852
853         wiphy = wdev->wiphy;
854         if (wiphy == NULL)
855                 return NOTIFY_DONE;
856
857         hw = wiphy_priv(wiphy);
858         if (hw == NULL)
859                 return NOTIFY_DONE;
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)
868                 return NOTIFY_DONE;
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
901 out:
902         mutex_unlock(&wl->mutex);
903
904         return NOTIFY_OK;
905 }
906
907 static struct notifier_block wl1271_dev_notifier = {
908         .notifier_call = wl1271_dev_notify,
909 };
910
911
912 static int wl1271_op_start(struct ieee80211_hw *hw)
913 {
914         struct wl1271 *wl = hw->priv;
915         int retries = WL1271_BOOT_RETRIES;
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
929         while (retries) {
930                 retries--;
931                 ret = wl1271_chip_wakeup(wl);
932                 if (ret < 0)
933                         goto power_off;
934
935                 ret = wl1271_boot(wl);
936                 if (ret < 0)
937                         goto power_off;
938
939                 ret = wl1271_hw_init(wl);
940                 if (ret < 0)
941                         goto irq_disable;
942
943                 wl->state = WL1271_STATE_ON;
944                 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
945                 goto out;
946
947 irq_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);
959 power_off:
960                 wl1271_power_off(wl);
961         }
962
963         wl1271_error("firmware boot failed despite %d retries",
964                      WL1271_BOOT_RETRIES);
965 out:
966         mutex_unlock(&wl->mutex);
967
968         if (!ret) {
969                 list_add(&wl->list, &wl_list);
970                 register_inetaddr_notifier(&wl1271_dev_notifier);
971         }
972
973         return ret;
974 }
975
976 static 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
985         unregister_inetaddr_notifier(&wl1271_dev_notifier);
986         list_del(&wl->list);
987
988         mutex_lock(&wl->mutex);
989
990         WARN_ON(wl->state != WL1271_STATE_ON);
991
992         if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
993                 mutex_unlock(&wl->mutex);
994                 ieee80211_scan_completed(wl->hw, true);
995                 mutex_lock(&wl->mutex);
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);
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;
1016         wl->bss_type = MAX_BSS_TYPE;
1017         wl->band = IEEE80211_BAND_2GHZ;
1018
1019         wl->rx_counter = 0;
1020         wl->psm_entry_retry = 0;
1021         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1022         wl->tx_blocks_available = 0;
1023         wl->tx_results_count = 0;
1024         wl->tx_packets_count = 0;
1025         wl->tx_security_last_seq = 0;
1026         wl->tx_security_seq_16 = 0;
1027         wl->tx_security_seq_32 = 0;
1028         wl->time_offset = 0;
1029         wl->session_counter = 0;
1030         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1031         wl->sta_rate_set = 0;
1032         wl->flags = 0;
1033
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
1041 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1042                                    struct ieee80211_if_init_conf *conf)
1043 {
1044         struct wl1271 *wl = hw->priv;
1045         int ret = 0;
1046
1047         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1048                      conf->type, conf->mac_addr);
1049
1050         mutex_lock(&wl->mutex);
1051         if (wl->vif) {
1052                 ret = -EBUSY;
1053                 goto out;
1054         }
1055
1056         wl->vif = conf->vif;
1057
1058         switch (conf->type) {
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
1072 out:
1073         mutex_unlock(&wl->mutex);
1074         return ret;
1075 }
1076
1077 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1078                                          struct ieee80211_if_init_conf *conf)
1079 {
1080         struct wl1271 *wl = hw->priv;
1081
1082         mutex_lock(&wl->mutex);
1083         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1084         wl->vif = NULL;
1085         mutex_unlock(&wl->mutex);
1086 }
1087
1088 #if 0
1089 static 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;
1095         int ret;
1096
1097         wl1271_debug(DEBUG_MAC80211, "mac80211 config_interface bssid %pM",
1098                      conf->bssid);
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
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;
1116
1117                 ret = wl1271_cmd_build_null_data(wl);
1118                 if (ret < 0)
1119                         goto out_sleep;
1120         }
1121
1122         wl->ssid_len = conf->ssid_len;
1123         if (wl->ssid_len)
1124                 memcpy(wl->ssid, conf->ssid, wl->ssid_len);
1125
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
1141                 if (ret < 0)
1142                         goto out_sleep;
1143         }
1144
1145 out_sleep:
1146         wl1271_ps_elp_sleep(wl);
1147
1148 out:
1149         mutex_unlock(&wl->mutex);
1150
1151         return ret;
1152 }
1153 #endif
1154
1155 static int wl1271_join_channel(struct wl1271 *wl, int channel)
1156 {
1157         int ret = 0;
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
1162         /* the dummy join is not required for ad-hoc */
1163         if (wl->bss_type == BSS_TYPE_IBSS)
1164                 goto out;
1165
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
1176         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1177
1178 out:
1179         return ret;
1180 }
1181
1182 static 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
1191         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1192         wl->channel = 0;
1193         memset(wl->bssid, 0, ETH_ALEN);
1194         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1195
1196 out:
1197         return ret;
1198 }
1199
1200 static 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
1208         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1209                      channel,
1210                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1211                      conf->power_level,
1212                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1213
1214         mutex_lock(&wl->mutex);
1215
1216         wl->band = conf->channel->band;
1217
1218         ret = wl1271_ps_elp_wakeup(wl, false);
1219         if (ret < 0)
1220                 goto out;
1221
1222         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1223                 if (conf->flags & IEEE80211_CONF_IDLE &&
1224                     test_bit(WL1271_FLAG_JOINED, &wl->flags))
1225                         wl1271_unjoin_channel(wl);
1226                 else
1227                         wl1271_join_channel(wl, channel);
1228
1229                 if (conf->flags & IEEE80211_CONF_IDLE) {
1230                         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1231                         wl->sta_rate_set = 0;
1232                         wl1271_acx_rate_policies(wl);
1233                 }
1234         }
1235
1236         /* if the channel changes while joined, join again */
1237         if (channel != wl->channel && test_bit(WL1271_FLAG_JOINED, &wl->flags))
1238                 wl1271_join_channel(wl, channel);
1239
1240         if (conf->flags & IEEE80211_CONF_PS &&
1241             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1242                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1243
1244                 /*
1245                  * We enter PSM only if we're already associated.
1246                  * If we're not, we'll enter it when joining an SSID,
1247                  * through the bss_info_changed() hook.
1248                  */
1249                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1250                         wl1271_info("psm enabled");
1251                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
1252                 }
1253         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1254                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1255                 wl1271_info("psm disabled");
1256
1257                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1258
1259                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1260                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE);
1261         }
1262
1263         if (conf->power_level != wl->power_level) {
1264                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1265                 if (ret < 0)
1266                         goto out_sleep;
1267
1268                 wl->power_level = conf->power_level;
1269         }
1270
1271 out_sleep:
1272         wl1271_ps_elp_sleep(wl);
1273
1274 out:
1275         mutex_unlock(&wl->mutex);
1276
1277         return ret;
1278 }
1279
1280 struct wl1271_filter_params {
1281         bool enabled;
1282         int mc_list_length;
1283         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1284 };
1285
1286 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw, int mc_count,
1287                                        struct dev_addr_list *mc_list)
1288 {
1289         struct wl1271_filter_params *fp;
1290         int i;
1291
1292         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1293         if (!fp) {
1294                 wl1271_error("Out of memory setting filters.");
1295                 return 0;
1296         }
1297
1298         /* update multicast filtering parameters */
1299         fp->enabled = true;
1300         if (mc_count > ACX_MC_ADDRESS_GROUP_MAX) {
1301                 mc_count = 0;
1302                 fp->enabled = false;
1303         }
1304
1305         fp->mc_list_length = 0;
1306         for (i = 0; i < mc_count; i++) {
1307                 if (mc_list->da_addrlen == ETH_ALEN) {
1308                         memcpy(fp->mc_list[fp->mc_list_length],
1309                                mc_list->da_addr, ETH_ALEN);
1310                         fp->mc_list_length++;
1311                 } else
1312                         wl1271_warning("Unknown mc address length.");
1313                 mc_list = mc_list->next;
1314         }
1315
1316         return (u64)(unsigned long)fp;
1317 }
1318
1319 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1320                                   FIF_ALLMULTI | \
1321                                   FIF_FCSFAIL | \
1322                                   FIF_BCN_PRBRESP_PROMISC | \
1323                                   FIF_CONTROL | \
1324                                   FIF_OTHER_BSS)
1325
1326 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1327                                        unsigned int changed,
1328                                        unsigned int *total, u64 multicast)
1329 {
1330         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1331         struct wl1271 *wl = hw->priv;
1332         int ret;
1333
1334         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1335
1336         mutex_lock(&wl->mutex);
1337
1338         if (wl->state == WL1271_STATE_OFF)
1339                 goto out;
1340
1341         ret = wl1271_ps_elp_wakeup(wl, false);
1342         if (ret < 0)
1343                 goto out;
1344
1345         *total &= WL1271_SUPPORTED_FILTERS;
1346         changed &= WL1271_SUPPORTED_FILTERS;
1347
1348         if (*total & FIF_ALLMULTI)
1349                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1350         else if (fp)
1351                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1352                                                    fp->mc_list,
1353                                                    fp->mc_list_length);
1354         if (ret < 0)
1355                 goto out_sleep;
1356
1357         kfree(fp);
1358
1359         /* FIXME: We still need to set our filters properly */
1360
1361         /* determine, whether supported filter values have changed */
1362         if (changed == 0)
1363                 goto out_sleep;
1364
1365         /* apply configured filters */
1366         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1367         if (ret < 0)
1368                 goto out_sleep;
1369
1370 out_sleep:
1371         wl1271_ps_elp_sleep(wl);
1372
1373 out:
1374         mutex_unlock(&wl->mutex);
1375 }
1376
1377 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1378                              struct ieee80211_vif *vif,
1379                              struct ieee80211_sta *sta,
1380                              struct ieee80211_key_conf *key_conf)
1381 {
1382         struct wl1271 *wl = hw->priv;
1383         const u8 *addr;
1384         int ret;
1385         u32 tx_seq_32 = 0;
1386         u16 tx_seq_16 = 0;
1387         u8 key_type;
1388
1389         static const u8 bcast_addr[ETH_ALEN] =
1390                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1391
1392         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1393
1394         addr = sta ? sta->addr : bcast_addr;
1395
1396         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1397         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1398         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1399                      key_conf->alg, key_conf->keyidx,
1400                      key_conf->keylen, key_conf->flags);
1401         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1402
1403         if (is_zero_ether_addr(addr)) {
1404                 /* We dont support TX only encryption */
1405                 ret = -EOPNOTSUPP;
1406                 goto out;
1407         }
1408
1409         mutex_lock(&wl->mutex);
1410
1411         ret = wl1271_ps_elp_wakeup(wl, false);
1412         if (ret < 0)
1413                 goto out_unlock;
1414
1415         switch (key_conf->alg) {
1416         case ALG_WEP:
1417                 key_type = KEY_WEP;
1418
1419                 key_conf->hw_key_idx = key_conf->keyidx;
1420                 break;
1421         case ALG_TKIP:
1422                 key_type = KEY_TKIP;
1423
1424                 key_conf->hw_key_idx = key_conf->keyidx;
1425                 tx_seq_32 = wl->tx_security_seq_32;
1426                 tx_seq_16 = wl->tx_security_seq_16;
1427                 break;
1428         case ALG_CCMP:
1429                 key_type = KEY_AES;
1430
1431                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1432                 tx_seq_32 = wl->tx_security_seq_32;
1433                 tx_seq_16 = wl->tx_security_seq_16;
1434                 break;
1435         default:
1436                 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1437
1438                 ret = -EOPNOTSUPP;
1439                 goto out_sleep;
1440         }
1441
1442         switch (cmd) {
1443         case SET_KEY:
1444                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1445                                          key_conf->keyidx, key_type,
1446                                          key_conf->keylen, key_conf->key,
1447                                          addr, tx_seq_32, tx_seq_16);
1448                 if (ret < 0) {
1449                         wl1271_error("Could not add or replace key");
1450                         goto out_sleep;
1451                 }
1452                 break;
1453
1454         case DISABLE_KEY:
1455                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1456                                          key_conf->keyidx, key_type,
1457                                          key_conf->keylen, key_conf->key,
1458                                          addr, 0, 0);
1459                 if (ret < 0) {
1460                         wl1271_error("Could not remove key");
1461                         goto out_sleep;
1462                 }
1463                 break;
1464
1465         default:
1466                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1467                 ret = -EOPNOTSUPP;
1468                 goto out_sleep;
1469
1470                 break;
1471         }
1472
1473 out_sleep:
1474         wl1271_ps_elp_sleep(wl);
1475
1476 out_unlock:
1477         mutex_unlock(&wl->mutex);
1478
1479 out:
1480         return ret;
1481 }
1482
1483 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1484                              struct cfg80211_scan_request *req)
1485 {
1486         struct wl1271 *wl = hw->priv;
1487         int ret;
1488         u8 *ssid = NULL;
1489         size_t len = 0;
1490
1491         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1492
1493         if (req->n_ssids) {
1494                 ssid = req->ssids[0].ssid;
1495                 len = req->ssids[0].ssid_len;
1496         }
1497
1498         mutex_lock(&wl->mutex);
1499
1500         ret = wl1271_ps_elp_wakeup(wl, false);
1501         if (ret < 0)
1502                 goto out;
1503
1504         if (wl1271_11a_enabled())
1505                 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1506                                       WL1271_SCAN_BAND_DUAL, 3);
1507         else
1508                 ret = wl1271_cmd_scan(hw->priv, ssid, len, 1, 0,
1509                                       WL1271_SCAN_BAND_2_4_GHZ, 3);
1510
1511         wl1271_ps_elp_sleep(wl);
1512
1513 out:
1514         mutex_unlock(&wl->mutex);
1515
1516         return ret;
1517 }
1518
1519 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1520 {
1521         struct wl1271 *wl = hw->priv;
1522         int ret;
1523
1524         mutex_lock(&wl->mutex);
1525
1526         ret = wl1271_ps_elp_wakeup(wl, false);
1527         if (ret < 0)
1528                 goto out;
1529
1530         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1531         if (ret < 0)
1532                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1533
1534         wl1271_ps_elp_sleep(wl);
1535
1536 out:
1537         mutex_unlock(&wl->mutex);
1538
1539         return ret;
1540 }
1541
1542 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1543                                        struct ieee80211_vif *vif,
1544                                        struct ieee80211_bss_conf *bss_conf,
1545                                        u32 changed)
1546 {
1547         enum wl1271_cmd_ps_mode mode;
1548         struct wl1271 *wl = hw->priv;
1549         int ret;
1550
1551         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1552
1553         mutex_lock(&wl->mutex);
1554
1555         ret = wl1271_ps_elp_wakeup(wl, false);
1556         if (ret < 0)
1557                 goto out;
1558
1559         if ((changed & BSS_CHANGED_BSSID) &&
1560             /*
1561              * Now we know the correct bssid, so we send a new join command
1562              * and enable the BSSID filter
1563              */
1564             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1565                         wl->rx_config |= CFG_BSSID_FILTER_EN;
1566                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1567                         ret = wl1271_cmd_build_null_data(wl);
1568                         if (ret < 0) {
1569                                 wl1271_warning("cmd buld null data failed %d",
1570                                                ret);
1571                                 goto out_sleep;
1572                         }
1573                         ret = wl1271_cmd_join(wl);
1574                         if (ret < 0) {
1575                                 wl1271_warning("cmd join failed %d", ret);
1576                                 goto out_sleep;
1577                         }
1578                         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1579         }
1580
1581         if (wl->bss_type == BSS_TYPE_IBSS) {
1582                 /* FIXME: This implements rudimentary ad-hoc support -
1583                    proper templates are on the wish list and notification
1584                    on when they change. This patch will update the templates
1585                    on every call to this function. Also, the firmware will not
1586                    answer to probe-requests as it does not have the proper
1587                    SSID set in the JOIN command. The probe-response template
1588                    is set nevertheless, as the FW will ASSERT without it */
1589                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1590
1591                 if (beacon) {
1592                         struct ieee80211_hdr *hdr;
1593                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1594                                                       beacon->data,
1595                                                       beacon->len);
1596
1597                         if (ret < 0) {
1598                                 dev_kfree_skb(beacon);
1599                                 goto out_sleep;
1600                         }
1601
1602                         hdr = (struct ieee80211_hdr *) beacon->data;
1603                         hdr->frame_control = cpu_to_le16(
1604                                 IEEE80211_FTYPE_MGMT |
1605                                 IEEE80211_STYPE_PROBE_RESP);
1606
1607                         ret = wl1271_cmd_template_set(wl,
1608                                                       CMD_TEMPL_PROBE_RESPONSE,
1609                                                       beacon->data,
1610                                                       beacon->len);
1611                         dev_kfree_skb(beacon);
1612                         if (ret < 0)
1613                                 goto out_sleep;
1614                 }
1615         }
1616
1617         if (changed & BSS_CHANGED_ASSOC) {
1618                 if (bss_conf->assoc) {
1619                         wl->aid = bss_conf->aid;
1620                         set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1621
1622                         /*
1623                          * with wl1271, we don't need to update the
1624                          * beacon_int and dtim_period, because the firmware
1625                          * updates it by itself when the first beacon is
1626                          * received after a join.
1627                          */
1628                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1629                         if (ret < 0)
1630                                 goto out_sleep;
1631
1632                         ret = wl1271_acx_aid(wl, wl->aid);
1633                         if (ret < 0)
1634                                 goto out_sleep;
1635
1636                         /* If we want to go in PSM but we're not there yet */
1637                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1638                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1639                                 mode = STATION_POWER_SAVE_MODE;
1640                                 ret = wl1271_ps_set_mode(wl, mode);
1641                                 if (ret < 0)
1642                                         goto out_sleep;
1643                         }
1644                 } else {
1645                         /* use defaults when not associated */
1646                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1647                         wl->aid = 0;
1648                 }
1649
1650         }
1651
1652         if (changed & BSS_CHANGED_ERP_SLOT) {
1653                 if (bss_conf->use_short_slot)
1654                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1655                 else
1656                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1657                 if (ret < 0) {
1658                         wl1271_warning("Set slot time failed %d", ret);
1659                         goto out_sleep;
1660                 }
1661         }
1662
1663         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1664                 if (bss_conf->use_short_preamble)
1665                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1666                 else
1667                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1668         }
1669
1670         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1671                 if (bss_conf->use_cts_prot)
1672                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1673                 else
1674                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1675                 if (ret < 0) {
1676                         wl1271_warning("Set ctsprotect failed %d", ret);
1677                         goto out_sleep;
1678                 }
1679         }
1680
1681 out_sleep:
1682         wl1271_ps_elp_sleep(wl);
1683
1684 out:
1685         mutex_unlock(&wl->mutex);
1686 }
1687
1688
1689 /* can't be const, mac80211 writes to this */
1690 static struct ieee80211_rate wl1271_rates[] = {
1691         { .bitrate = 10,
1692           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1693           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1694         { .bitrate = 20,
1695           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1696           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1697           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1698         { .bitrate = 55,
1699           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1700           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1701           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1702         { .bitrate = 110,
1703           .hw_value = CONF_HW_BIT_RATE_11MBPS,
1704           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1705           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1706         { .bitrate = 60,
1707           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1708           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1709         { .bitrate = 90,
1710           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1711           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1712         { .bitrate = 120,
1713           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1714           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1715         { .bitrate = 180,
1716           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1717           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1718         { .bitrate = 240,
1719           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1720           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1721         { .bitrate = 360,
1722          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1723          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1724         { .bitrate = 480,
1725           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1726           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1727         { .bitrate = 540,
1728           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1729           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1730 };
1731
1732 /* can't be const, mac80211 writes to this */
1733 static struct ieee80211_channel wl1271_channels[] = {
1734         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1735         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1736         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1737         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1738         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1739         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1740         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1741         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1742         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1743         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1744         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1745         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1746         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1747 };
1748
1749 /* can't be const, mac80211 writes to this */
1750 static struct ieee80211_supported_band wl1271_band_2ghz = {
1751         .channels = wl1271_channels,
1752         .n_channels = ARRAY_SIZE(wl1271_channels),
1753         .bitrates = wl1271_rates,
1754         .n_bitrates = ARRAY_SIZE(wl1271_rates),
1755 };
1756
1757 /* 5 GHz data rates for WL1273 */
1758 static struct ieee80211_rate wl1271_rates_5ghz[] = {
1759         { .bitrate = 60,
1760           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1761           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1762         { .bitrate = 90,
1763           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1764           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1765         { .bitrate = 120,
1766           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1767           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1768         { .bitrate = 180,
1769           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1770           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1771         { .bitrate = 240,
1772           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1773           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1774         { .bitrate = 360,
1775          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1776          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1777         { .bitrate = 480,
1778           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1779           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1780         { .bitrate = 540,
1781           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1782           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1783 };
1784
1785 /* 5 GHz band channels for WL1273 */
1786 static struct ieee80211_channel wl1271_channels_5ghz[] = {
1787         { .hw_value = 183, .center_freq = 4915},
1788         { .hw_value = 184, .center_freq = 4920},
1789         { .hw_value = 185, .center_freq = 4925},
1790         { .hw_value = 187, .center_freq = 4935},
1791         { .hw_value = 188, .center_freq = 4940},
1792         { .hw_value = 189, .center_freq = 4945},
1793         { .hw_value = 192, .center_freq = 4960},
1794         { .hw_value = 196, .center_freq = 4980},
1795         { .hw_value = 7, .center_freq = 5035},
1796         { .hw_value = 8, .center_freq = 5040},
1797         { .hw_value = 9, .center_freq = 5045},
1798         { .hw_value = 11, .center_freq = 5055},
1799         { .hw_value = 12, .center_freq = 5060},
1800         { .hw_value = 16, .center_freq = 5080},
1801         { .hw_value = 34, .center_freq = 5170},
1802         { .hw_value = 36, .center_freq = 5180},
1803         { .hw_value = 38, .center_freq = 5190},
1804         { .hw_value = 40, .center_freq = 5200},
1805         { .hw_value = 42, .center_freq = 5210},
1806         { .hw_value = 44, .center_freq = 5220},
1807         { .hw_value = 46, .center_freq = 5230},
1808         { .hw_value = 48, .center_freq = 5240},
1809         { .hw_value = 52, .center_freq = 5260},
1810         { .hw_value = 56, .center_freq = 5280},
1811         { .hw_value = 60, .center_freq = 5300},
1812         { .hw_value = 64, .center_freq = 5320},
1813         { .hw_value = 100, .center_freq = 5500},
1814         { .hw_value = 104, .center_freq = 5520},
1815         { .hw_value = 108, .center_freq = 5540},
1816         { .hw_value = 112, .center_freq = 5560},
1817         { .hw_value = 116, .center_freq = 5580},
1818         { .hw_value = 120, .center_freq = 5600},
1819         { .hw_value = 124, .center_freq = 5620},
1820         { .hw_value = 128, .center_freq = 5640},
1821         { .hw_value = 132, .center_freq = 5660},
1822         { .hw_value = 136, .center_freq = 5680},
1823         { .hw_value = 140, .center_freq = 5700},
1824         { .hw_value = 149, .center_freq = 5745},
1825         { .hw_value = 153, .center_freq = 5765},
1826         { .hw_value = 157, .center_freq = 5785},
1827         { .hw_value = 161, .center_freq = 5805},
1828         { .hw_value = 165, .center_freq = 5825},
1829 };
1830
1831
1832 static struct ieee80211_supported_band wl1271_band_5ghz = {
1833         .channels = wl1271_channels_5ghz,
1834         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
1835         .bitrates = wl1271_rates_5ghz,
1836         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
1837 };
1838
1839 static const struct ieee80211_ops wl1271_ops = {
1840         .start = wl1271_op_start,
1841         .stop = wl1271_op_stop,
1842         .add_interface = wl1271_op_add_interface,
1843         .remove_interface = wl1271_op_remove_interface,
1844         .config = wl1271_op_config,
1845 /*      .config_interface = wl1271_op_config_interface, */
1846         .prepare_multicast = wl1271_op_prepare_multicast,
1847         .configure_filter = wl1271_op_configure_filter,
1848         .tx = wl1271_op_tx,
1849         .set_key = wl1271_op_set_key,
1850         .hw_scan = wl1271_op_hw_scan,
1851         .bss_info_changed = wl1271_op_bss_info_changed,
1852         .set_rts_threshold = wl1271_op_set_rts_threshold,
1853 };
1854
1855 static int wl1271_register_hw(struct wl1271 *wl)
1856 {
1857         int ret;
1858
1859         if (wl->mac80211_registered)
1860                 return 0;
1861
1862         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
1863
1864         ret = ieee80211_register_hw(wl->hw);
1865         if (ret < 0) {
1866                 wl1271_error("unable to register mac80211 hw: %d", ret);
1867                 return ret;
1868         }
1869
1870         wl->mac80211_registered = true;
1871
1872         wl1271_notice("loaded");
1873
1874         return 0;
1875 }
1876
1877 static int wl1271_init_ieee80211(struct wl1271 *wl)
1878 {
1879         /* The tx descriptor buffer and the TKIP space. */
1880         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
1881                 sizeof(struct wl1271_tx_hw_descr);
1882
1883         /* unit us */
1884         /* FIXME: find a proper value */
1885         wl->hw->channel_change_time = 10000;
1886
1887         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
1888                 IEEE80211_HW_NOISE_DBM |
1889                 IEEE80211_HW_BEACON_FILTER |
1890                 IEEE80211_HW_SUPPORTS_PS;
1891
1892         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1893                 BIT(NL80211_IFTYPE_ADHOC);
1894         wl->hw->wiphy->max_scan_ssids = 1;
1895         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
1896
1897         if (wl1271_11a_enabled())
1898                 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
1899
1900         SET_IEEE80211_DEV(wl->hw, &wl->spi->dev);
1901
1902         return 0;
1903 }
1904
1905 static void wl1271_device_release(struct device *dev)
1906 {
1907
1908 }
1909
1910 static struct platform_device wl1271_device = {
1911         .name           = "wl1271",
1912         .id             = -1,
1913
1914         /* device model insists to have a release function */
1915         .dev            = {
1916                 .release = wl1271_device_release,
1917         },
1918 };
1919
1920 #define WL1271_DEFAULT_CHANNEL 0
1921 static int __devinit wl1271_probe(struct spi_device *spi)
1922 {
1923         struct wl12xx_platform_data *pdata;
1924         struct ieee80211_hw *hw;
1925         struct wl1271 *wl;
1926         int ret, i;
1927         static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf};
1928
1929         pdata = spi->dev.platform_data;
1930         if (!pdata) {
1931                 wl1271_error("no platform data");
1932                 return -ENODEV;
1933         }
1934
1935         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
1936         if (!hw) {
1937                 wl1271_error("could not alloc ieee80211_hw");
1938                 return -ENOMEM;
1939         }
1940
1941         wl = hw->priv;
1942         memset(wl, 0, sizeof(*wl));
1943
1944         INIT_LIST_HEAD(&wl->list);
1945
1946         wl->hw = hw;
1947         dev_set_drvdata(&spi->dev, wl);
1948         wl->spi = spi;
1949
1950         skb_queue_head_init(&wl->tx_queue);
1951
1952         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
1953         wl->channel = WL1271_DEFAULT_CHANNEL;
1954         wl->default_key = 0;
1955         wl->rx_counter = 0;
1956         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1957         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1958         wl->psm_entry_retry = 0;
1959         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1960         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
1961         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1962         wl->sta_rate_set = 0;
1963         wl->band = IEEE80211_BAND_2GHZ;
1964         wl->vif = NULL;
1965         wl->flags = 0;
1966
1967         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
1968                 wl->tx_frames[i] = NULL;
1969
1970         spin_lock_init(&wl->wl_lock);
1971
1972         /*
1973          * In case our MAC address is not correctly set,
1974          * we use a random but Nokia MAC.
1975          */
1976         memcpy(wl->mac_addr, nokia_oui, 3);
1977         get_random_bytes(wl->mac_addr + 3, 3);
1978
1979         wl->state = WL1271_STATE_OFF;
1980         mutex_init(&wl->mutex);
1981
1982         /* This is the only SPI value that we need to set here, the rest
1983          * comes from the board-peripherals file */
1984         spi->bits_per_word = 32;
1985
1986         ret = spi_setup(spi);
1987         if (ret < 0) {
1988                 wl1271_error("spi_setup failed");
1989                 goto out_free;
1990         }
1991
1992         wl->set_power = pdata->set_power;
1993         if (!wl->set_power) {
1994                 wl1271_error("set power function missing in platform data");
1995                 ret = -ENODEV;
1996                 goto out_free;
1997         }
1998
1999         wl->irq = spi->irq;
2000         if (wl->irq < 0) {
2001                 wl1271_error("irq missing in platform data");
2002                 ret = -ENODEV;
2003                 goto out_free;
2004         }
2005
2006         ret = request_irq(wl->irq, wl1271_irq, 0, DRIVER_NAME, wl);
2007         if (ret < 0) {
2008                 wl1271_error("request_irq() failed: %d", ret);
2009                 goto out_free;
2010         }
2011
2012         set_irq_type(wl->irq, IRQ_TYPE_EDGE_RISING);
2013
2014         disable_irq(wl->irq);
2015
2016         ret = platform_device_register(&wl1271_device);
2017         if (ret) {
2018                 wl1271_error("couldn't register platform device");
2019                 goto out_irq;
2020         }
2021         dev_set_drvdata(&wl1271_device.dev, wl);
2022
2023         /* Apply default driver configuration. */
2024         wl1271_conf_init(wl);
2025
2026         ret = wl1271_init_ieee80211(wl);
2027         if (ret)
2028                 goto out_platform;
2029
2030         ret = wl1271_register_hw(wl);
2031         if (ret)
2032                 goto out_platform;
2033
2034         wl1271_debugfs_init(wl);
2035
2036         wl1271_notice("initialized");
2037
2038         return 0;
2039
2040  out_platform:
2041         platform_device_unregister(&wl1271_device);
2042
2043  out_irq:
2044         free_irq(wl->irq, wl);
2045
2046  out_free:
2047         ieee80211_free_hw(hw);
2048
2049         return ret;
2050 }
2051
2052 static int __devexit wl1271_remove(struct spi_device *spi)
2053 {
2054         struct wl1271 *wl = dev_get_drvdata(&spi->dev);
2055
2056         ieee80211_unregister_hw(wl->hw);
2057
2058         wl1271_debugfs_exit(wl);
2059         platform_device_unregister(&wl1271_device);
2060         free_irq(wl->irq, wl);
2061         kfree(wl->target_mem_map);
2062         vfree(wl->fw);
2063         wl->fw = NULL;
2064         kfree(wl->nvs);
2065         wl->nvs = NULL;
2066
2067         kfree(wl->fw_status);
2068         kfree(wl->tx_res_if);
2069
2070         ieee80211_free_hw(wl->hw);
2071
2072         return 0;
2073 }
2074
2075
2076 static struct spi_driver wl1271_spi_driver = {
2077         .driver = {
2078                 .name           = "wl1271",
2079                 .bus            = &spi_bus_type,
2080                 .owner          = THIS_MODULE,
2081         },
2082
2083         .probe          = wl1271_probe,
2084         .remove         = __devexit_p(wl1271_remove),
2085 };
2086
2087 static int __init wl1271_init(void)
2088 {
2089         int ret;
2090
2091         ret = spi_register_driver(&wl1271_spi_driver);
2092         if (ret < 0) {
2093                 wl1271_error("failed to register spi driver: %d", ret);
2094                 goto out;
2095         }
2096
2097 out:
2098         return ret;
2099 }
2100
2101 static void __exit wl1271_exit(void)
2102 {
2103         spi_unregister_driver(&wl1271_spi_driver);
2104
2105         wl1271_notice("unloaded");
2106 }
2107
2108 module_init(wl1271_init);
2109 module_exit(wl1271_exit);
2110
2111 MODULE_LICENSE("GPL");
2112 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2113 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
2114 MODULE_FIRMWARE(WL1271_FW_NAME);