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