Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / drivers / net / wireless / wl12xx / wl1271_main.c
1 /*
2  * This file is part of wl1271
3  *
4  * Copyright (C) 2008-2010 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/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/inetdevice.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
34
35 #include "wl1271.h"
36 #include "wl12xx_80211.h"
37 #include "wl1271_reg.h"
38 #include "wl1271_io.h"
39 #include "wl1271_event.h"
40 #include "wl1271_tx.h"
41 #include "wl1271_rx.h"
42 #include "wl1271_ps.h"
43 #include "wl1271_init.h"
44 #include "wl1271_debugfs.h"
45 #include "wl1271_cmd.h"
46 #include "wl1271_boot.h"
47 #include "wl1271_testmode.h"
48
49 #define WL1271_BOOT_RETRIES 3
50
51 static struct conf_drv_settings default_conf = {
52         .sg = {
53                 .params = {
54                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
55                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
56                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
57                         [CONF_SG_BT_LOAD_RATIO]                     = 50,
58                         [CONF_SG_AUTO_PS_MODE]                      = 0,
59                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
60                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
61                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
62                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
63                         [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
64                         [CONF_SG_RATE_ADAPT_SNR]                    = 0,
65                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
66                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
67                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
68                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
69                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
70                         /* Note: with UPSD, this should be 4 */
71                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
72                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
73                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
74                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
75                         /* Note: with UPDS, this should be 15 */
76                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
77                         /* Note: with UPDS, this should be 50 */
78                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
79                         /* Note: with UPDS, this should be 10 */
80                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
81                         [CONF_SG_RXT]                               = 1200,
82                         [CONF_SG_TXT]                               = 1000,
83                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
84                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
85                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
86                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
90                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
91                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
92                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
93                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
94                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
95                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
96                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
98                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
99                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
100                         [CONF_SG_DHCP_TIME]                         = 5000,
101                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
102                 },
103                 .state = CONF_SG_PROTECTIVE,
104         },
105         .rx = {
106                 .rx_msdu_life_time           = 512000,
107                 .packet_detection_threshold  = 0,
108                 .ps_poll_timeout             = 15,
109                 .upsd_timeout                = 15,
110                 .rts_threshold               = 2347,
111                 .rx_cca_threshold            = 0,
112                 .irq_blk_threshold           = 0xFFFF,
113                 .irq_pkt_threshold           = 0,
114                 .irq_timeout                 = 600,
115                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116         },
117         .tx = {
118                 .tx_energy_detection         = 0,
119                 .rc_conf                     = {
120                         .enabled_rates       = 0,
121                         .short_retry_limit   = 10,
122                         .long_retry_limit    = 10,
123                         .aflags              = 0
124                 },
125                 .ac_conf_count               = 4,
126                 .ac_conf                     = {
127                         [0] = {
128                                 .ac          = CONF_TX_AC_BE,
129                                 .cw_min      = 15,
130                                 .cw_max      = 63,
131                                 .aifsn       = 3,
132                                 .tx_op_limit = 0,
133                         },
134                         [1] = {
135                                 .ac          = CONF_TX_AC_BK,
136                                 .cw_min      = 15,
137                                 .cw_max      = 63,
138                                 .aifsn       = 7,
139                                 .tx_op_limit = 0,
140                         },
141                         [2] = {
142                                 .ac          = CONF_TX_AC_VI,
143                                 .cw_min      = 15,
144                                 .cw_max      = 63,
145                                 .aifsn       = CONF_TX_AIFS_PIFS,
146                                 .tx_op_limit = 3008,
147                         },
148                         [3] = {
149                                 .ac          = CONF_TX_AC_VO,
150                                 .cw_min      = 15,
151                                 .cw_max      = 63,
152                                 .aifsn       = CONF_TX_AIFS_PIFS,
153                                 .tx_op_limit = 1504,
154                         },
155                 },
156                 .tid_conf_count = 7,
157                 .tid_conf = {
158                         [0] = {
159                                 .queue_id    = 0,
160                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
161                                 .tsid        = CONF_TX_AC_BE,
162                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
163                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
164                                 .apsd_conf   = {0, 0},
165                         },
166                         [1] = {
167                                 .queue_id    = 1,
168                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
169                                 .tsid        = CONF_TX_AC_BE,
170                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
171                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
172                                 .apsd_conf   = {0, 0},
173                         },
174                         [2] = {
175                                 .queue_id    = 2,
176                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
177                                 .tsid        = CONF_TX_AC_BE,
178                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
179                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
180                                 .apsd_conf   = {0, 0},
181                         },
182                         [3] = {
183                                 .queue_id    = 3,
184                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
185                                 .tsid        = CONF_TX_AC_BE,
186                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
187                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
188                                 .apsd_conf   = {0, 0},
189                         },
190                         [4] = {
191                                 .queue_id    = 4,
192                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
193                                 .tsid        = CONF_TX_AC_BE,
194                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
195                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
196                                 .apsd_conf   = {0, 0},
197                         },
198                         [5] = {
199                                 .queue_id    = 5,
200                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
201                                 .tsid        = CONF_TX_AC_BE,
202                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
203                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
204                                 .apsd_conf   = {0, 0},
205                         },
206                         [6] = {
207                                 .queue_id    = 6,
208                                 .channel_type = CONF_CHANNEL_TYPE_DCF,
209                                 .tsid        = CONF_TX_AC_BE,
210                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
211                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
212                                 .apsd_conf   = {0, 0},
213                         }
214                 },
215                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
216                 .tx_compl_timeout            = 700,
217                 .tx_compl_threshold          = 4,
218                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
219                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
220         },
221         .conn = {
222                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
223                 .listen_interval             = 1,
224                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
225                 .bcn_filt_ie_count           = 1,
226                 .bcn_filt_ie = {
227                         [0] = {
228                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
229                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
230                         }
231                 },
232                 .synch_fail_thold            = 10,
233                 .bss_lose_timeout            = 100,
234                 .beacon_rx_timeout           = 10000,
235                 .broadcast_timeout           = 20000,
236                 .rx_broadcast_in_ps          = 1,
237                 .ps_poll_threshold           = 20,
238                 .bet_enable                  = CONF_BET_MODE_ENABLE,
239                 .bet_max_consecutive         = 10,
240                 .psm_entry_retries           = 3,
241                 .keep_alive_interval         = 55000,
242                 .max_listen_interval         = 20,
243         },
244         .init = {
245                 .radioparam = {
246                         .fem                 = 1,
247                 }
248         },
249         .itrim = {
250                 .enable = false,
251                 .timeout = 50000,
252         },
253         .pm_config = {
254                 .host_clk_settling_time = 5000,
255                 .host_fast_wakeup_support = false
256         },
257         .roam_trigger = {
258                 /* FIXME: due to firmware bug, must use value 1 for now */
259                 .trigger_pacing               = 1,
260                 .avg_weight_rssi_beacon       = 20,
261                 .avg_weight_rssi_data         = 10,
262                 .avg_weight_snr_beacon        = 20,
263                 .avg_weight_snr_data          = 10
264         }
265 };
266
267 static void wl1271_device_release(struct device *dev)
268 {
269
270 }
271
272 static struct platform_device wl1271_device = {
273         .name           = "wl1271",
274         .id             = -1,
275
276         /* device model insists to have a release function */
277         .dev            = {
278                 .release = wl1271_device_release,
279         },
280 };
281
282 static LIST_HEAD(wl_list);
283
284 static void wl1271_conf_init(struct wl1271 *wl)
285 {
286
287         /*
288          * This function applies the default configuration to the driver. This
289          * function is invoked upon driver load (spi probe.)
290          *
291          * The configuration is stored in a run-time structure in order to
292          * facilitate for run-time adjustment of any of the parameters. Making
293          * changes to the configuration structure will apply the new values on
294          * the next interface up (wl1271_op_start.)
295          */
296
297         /* apply driver default configuration */
298         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
299 }
300
301
302 static int wl1271_plt_init(struct wl1271 *wl)
303 {
304         struct conf_tx_ac_category *conf_ac;
305         struct conf_tx_tid *conf_tid;
306         int ret, i;
307
308         ret = wl1271_cmd_general_parms(wl);
309         if (ret < 0)
310                 return ret;
311
312         ret = wl1271_cmd_radio_parms(wl);
313         if (ret < 0)
314                 return ret;
315
316         ret = wl1271_init_templates_config(wl);
317         if (ret < 0)
318                 return ret;
319
320         ret = wl1271_acx_init_mem_config(wl);
321         if (ret < 0)
322                 return ret;
323
324         /* PHY layer config */
325         ret = wl1271_init_phy_config(wl);
326         if (ret < 0)
327                 goto out_free_memmap;
328
329         ret = wl1271_acx_dco_itrim_params(wl);
330         if (ret < 0)
331                 goto out_free_memmap;
332
333         /* Initialize connection monitoring thresholds */
334         ret = wl1271_acx_conn_monit_params(wl, false);
335         if (ret < 0)
336                 goto out_free_memmap;
337
338         /* Bluetooth WLAN coexistence */
339         ret = wl1271_init_pta(wl);
340         if (ret < 0)
341                 goto out_free_memmap;
342
343         /* Energy detection */
344         ret = wl1271_init_energy_detection(wl);
345         if (ret < 0)
346                 goto out_free_memmap;
347
348         /* Default fragmentation threshold */
349         ret = wl1271_acx_frag_threshold(wl);
350         if (ret < 0)
351                 goto out_free_memmap;
352
353         /* Default TID configuration */
354         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
355                 conf_tid = &wl->conf.tx.tid_conf[i];
356                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
357                                          conf_tid->channel_type,
358                                          conf_tid->tsid,
359                                          conf_tid->ps_scheme,
360                                          conf_tid->ack_policy,
361                                          conf_tid->apsd_conf[0],
362                                          conf_tid->apsd_conf[1]);
363                 if (ret < 0)
364                         goto out_free_memmap;
365         }
366
367         /* Default AC configuration */
368         for (i = 0; i < wl->conf.tx.ac_conf_count; i++) {
369                 conf_ac = &wl->conf.tx.ac_conf[i];
370                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
371                                         conf_ac->cw_max, conf_ac->aifsn,
372                                         conf_ac->tx_op_limit);
373                 if (ret < 0)
374                         goto out_free_memmap;
375         }
376
377         /* Enable data path */
378         ret = wl1271_cmd_data_path(wl, 1);
379         if (ret < 0)
380                 goto out_free_memmap;
381
382         /* Configure for CAM power saving (ie. always active) */
383         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
384         if (ret < 0)
385                 goto out_free_memmap;
386
387         /* configure PM */
388         ret = wl1271_acx_pm_config(wl);
389         if (ret < 0)
390                 goto out_free_memmap;
391
392         return 0;
393
394  out_free_memmap:
395         kfree(wl->target_mem_map);
396         wl->target_mem_map = NULL;
397
398         return ret;
399 }
400
401 static void wl1271_fw_status(struct wl1271 *wl,
402                              struct wl1271_fw_status *status)
403 {
404         struct timespec ts;
405         u32 total = 0;
406         int i;
407
408         wl1271_raw_read(wl, FW_STATUS_ADDR, status, sizeof(*status), false);
409
410         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
411                      "drv_rx_counter = %d, tx_results_counter = %d)",
412                      status->intr,
413                      status->fw_rx_counter,
414                      status->drv_rx_counter,
415                      status->tx_results_counter);
416
417         /* update number of available TX blocks */
418         for (i = 0; i < NUM_TX_QUEUES; i++) {
419                 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
420                         wl->tx_blocks_freed[i];
421
422                 wl->tx_blocks_freed[i] =
423                         le32_to_cpu(status->tx_released_blks[i]);
424                 wl->tx_blocks_available += cnt;
425                 total += cnt;
426         }
427
428         /* if more blocks are available now, schedule some tx work */
429         if (total && !skb_queue_empty(&wl->tx_queue))
430                 ieee80211_queue_work(wl->hw, &wl->tx_work);
431
432         /* update the host-chipset time offset */
433         getnstimeofday(&ts);
434         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
435                 (s64)le32_to_cpu(status->fw_localtime);
436 }
437
438 #define WL1271_IRQ_MAX_LOOPS 10
439
440 static void wl1271_irq_work(struct work_struct *work)
441 {
442         int ret;
443         u32 intr;
444         int loopcount = WL1271_IRQ_MAX_LOOPS;
445         unsigned long flags;
446         struct wl1271 *wl =
447                 container_of(work, struct wl1271, irq_work);
448
449         mutex_lock(&wl->mutex);
450
451         wl1271_debug(DEBUG_IRQ, "IRQ work");
452
453         if (unlikely(wl->state == WL1271_STATE_OFF))
454                 goto out;
455
456         ret = wl1271_ps_elp_wakeup(wl, true);
457         if (ret < 0)
458                 goto out;
459
460         spin_lock_irqsave(&wl->wl_lock, flags);
461         while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
462                 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
463                 spin_unlock_irqrestore(&wl->wl_lock, flags);
464                 loopcount--;
465
466                 wl1271_fw_status(wl, wl->fw_status);
467                 intr = le32_to_cpu(wl->fw_status->intr);
468                 if (!intr) {
469                         wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
470                         spin_lock_irqsave(&wl->wl_lock, flags);
471                         continue;
472                 }
473
474                 intr &= WL1271_INTR_MASK;
475
476                 if (intr & WL1271_ACX_INTR_DATA) {
477                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
478
479                         /* check for tx results */
480                         if (wl->fw_status->tx_results_counter !=
481                             (wl->tx_results_count & 0xff))
482                                 wl1271_tx_complete(wl);
483
484                         wl1271_rx(wl, wl->fw_status);
485                 }
486
487                 if (intr & WL1271_ACX_INTR_EVENT_A) {
488                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
489                         wl1271_event_handle(wl, 0);
490                 }
491
492                 if (intr & WL1271_ACX_INTR_EVENT_B) {
493                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
494                         wl1271_event_handle(wl, 1);
495                 }
496
497                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
498                         wl1271_debug(DEBUG_IRQ,
499                                      "WL1271_ACX_INTR_INIT_COMPLETE");
500
501                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
502                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
503
504                 spin_lock_irqsave(&wl->wl_lock, flags);
505         }
506
507         if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
508                 ieee80211_queue_work(wl->hw, &wl->irq_work);
509         else
510                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
511         spin_unlock_irqrestore(&wl->wl_lock, flags);
512
513         wl1271_ps_elp_sleep(wl);
514
515 out:
516         mutex_unlock(&wl->mutex);
517 }
518
519 static int wl1271_fetch_firmware(struct wl1271 *wl)
520 {
521         const struct firmware *fw;
522         int ret;
523
524         ret = request_firmware(&fw, WL1271_FW_NAME, wl1271_wl_to_dev(wl));
525
526         if (ret < 0) {
527                 wl1271_error("could not get firmware: %d", ret);
528                 return ret;
529         }
530
531         if (fw->size % 4) {
532                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
533                              fw->size);
534                 ret = -EILSEQ;
535                 goto out;
536         }
537
538         wl->fw_len = fw->size;
539         wl->fw = vmalloc(wl->fw_len);
540
541         if (!wl->fw) {
542                 wl1271_error("could not allocate memory for the firmware");
543                 ret = -ENOMEM;
544                 goto out;
545         }
546
547         memcpy(wl->fw, fw->data, wl->fw_len);
548
549         ret = 0;
550
551 out:
552         release_firmware(fw);
553
554         return ret;
555 }
556
557 static int wl1271_fetch_nvs(struct wl1271 *wl)
558 {
559         const struct firmware *fw;
560         int ret;
561
562         ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
563
564         if (ret < 0) {
565                 wl1271_error("could not get nvs file: %d", ret);
566                 return ret;
567         }
568
569         if (fw->size != sizeof(struct wl1271_nvs_file)) {
570                 wl1271_error("nvs size is not as expected: %zu != %zu",
571                              fw->size, sizeof(struct wl1271_nvs_file));
572                 ret = -EILSEQ;
573                 goto out;
574         }
575
576         wl->nvs = kmalloc(sizeof(struct wl1271_nvs_file), GFP_KERNEL);
577
578         if (!wl->nvs) {
579                 wl1271_error("could not allocate memory for the nvs file");
580                 ret = -ENOMEM;
581                 goto out;
582         }
583
584         memcpy(wl->nvs, fw->data, sizeof(struct wl1271_nvs_file));
585
586 out:
587         release_firmware(fw);
588
589         return ret;
590 }
591
592 static void wl1271_fw_wakeup(struct wl1271 *wl)
593 {
594         u32 elp_reg;
595
596         elp_reg = ELPCTRL_WAKE_UP;
597         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
598 }
599
600 static int wl1271_setup(struct wl1271 *wl)
601 {
602         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
603         if (!wl->fw_status)
604                 return -ENOMEM;
605
606         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
607         if (!wl->tx_res_if) {
608                 kfree(wl->fw_status);
609                 return -ENOMEM;
610         }
611
612         INIT_WORK(&wl->irq_work, wl1271_irq_work);
613         INIT_WORK(&wl->tx_work, wl1271_tx_work);
614         return 0;
615 }
616
617 static int wl1271_chip_wakeup(struct wl1271 *wl)
618 {
619         struct wl1271_partition_set partition;
620         int ret = 0;
621
622         msleep(WL1271_PRE_POWER_ON_SLEEP);
623         wl1271_power_on(wl);
624         msleep(WL1271_POWER_ON_SLEEP);
625         wl1271_io_reset(wl);
626         wl1271_io_init(wl);
627
628         /* We don't need a real memory partition here, because we only want
629          * to use the registers at this point. */
630         memset(&partition, 0, sizeof(partition));
631         partition.reg.start = REGISTERS_BASE;
632         partition.reg.size = REGISTERS_DOWN_SIZE;
633         wl1271_set_partition(wl, &partition);
634
635         /* ELP module wake up */
636         wl1271_fw_wakeup(wl);
637
638         /* whal_FwCtrl_BootSm() */
639
640         /* 0. read chip id from CHIP_ID */
641         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
642
643         /* 1. check if chip id is valid */
644
645         switch (wl->chip.id) {
646         case CHIP_ID_1271_PG10:
647                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
648                                wl->chip.id);
649
650                 ret = wl1271_setup(wl);
651                 if (ret < 0)
652                         goto out;
653                 break;
654         case CHIP_ID_1271_PG20:
655                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
656                              wl->chip.id);
657
658                 ret = wl1271_setup(wl);
659                 if (ret < 0)
660                         goto out;
661                 break;
662         default:
663                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
664                 ret = -ENODEV;
665                 goto out;
666         }
667
668         if (wl->fw == NULL) {
669                 ret = wl1271_fetch_firmware(wl);
670                 if (ret < 0)
671                         goto out;
672         }
673
674         /* No NVS from netlink, try to get it from the filesystem */
675         if (wl->nvs == NULL) {
676                 ret = wl1271_fetch_nvs(wl);
677                 if (ret < 0)
678                         goto out;
679         }
680
681 out:
682         return ret;
683 }
684
685 int wl1271_plt_start(struct wl1271 *wl)
686 {
687         int retries = WL1271_BOOT_RETRIES;
688         int ret;
689
690         mutex_lock(&wl->mutex);
691
692         wl1271_notice("power up");
693
694         if (wl->state != WL1271_STATE_OFF) {
695                 wl1271_error("cannot go into PLT state because not "
696                              "in off state: %d", wl->state);
697                 ret = -EBUSY;
698                 goto out;
699         }
700
701         while (retries) {
702                 retries--;
703                 ret = wl1271_chip_wakeup(wl);
704                 if (ret < 0)
705                         goto power_off;
706
707                 ret = wl1271_boot(wl);
708                 if (ret < 0)
709                         goto power_off;
710
711                 ret = wl1271_plt_init(wl);
712                 if (ret < 0)
713                         goto irq_disable;
714
715                 wl->state = WL1271_STATE_PLT;
716                 wl1271_notice("firmware booted in PLT mode (%s)",
717                               wl->chip.fw_ver);
718                 goto out;
719
720 irq_disable:
721                 wl1271_disable_interrupts(wl);
722                 mutex_unlock(&wl->mutex);
723                 /* Unlocking the mutex in the middle of handling is
724                    inherently unsafe. In this case we deem it safe to do,
725                    because we need to let any possibly pending IRQ out of
726                    the system (and while we are WL1271_STATE_OFF the IRQ
727                    work function will not do anything.) Also, any other
728                    possible concurrent operations will fail due to the
729                    current state, hence the wl1271 struct should be safe. */
730                 cancel_work_sync(&wl->irq_work);
731                 mutex_lock(&wl->mutex);
732 power_off:
733                 wl1271_power_off(wl);
734         }
735
736         wl1271_error("firmware boot in PLT mode failed despite %d retries",
737                      WL1271_BOOT_RETRIES);
738 out:
739         mutex_unlock(&wl->mutex);
740
741         return ret;
742 }
743
744 int wl1271_plt_stop(struct wl1271 *wl)
745 {
746         int ret = 0;
747
748         mutex_lock(&wl->mutex);
749
750         wl1271_notice("power down");
751
752         if (wl->state != WL1271_STATE_PLT) {
753                 wl1271_error("cannot power down because not in PLT "
754                              "state: %d", wl->state);
755                 ret = -EBUSY;
756                 goto out;
757         }
758
759         wl1271_disable_interrupts(wl);
760         wl1271_power_off(wl);
761
762         wl->state = WL1271_STATE_OFF;
763         wl->rx_counter = 0;
764
765 out:
766         mutex_unlock(&wl->mutex);
767
768         return ret;
769 }
770
771
772 static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
773 {
774         struct wl1271 *wl = hw->priv;
775         struct ieee80211_conf *conf = &hw->conf;
776         struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb);
777         struct ieee80211_sta *sta = txinfo->control.sta;
778         unsigned long flags;
779
780         /* peek into the rates configured in the STA entry */
781         spin_lock_irqsave(&wl->wl_lock, flags);
782         if (sta && sta->supp_rates[conf->channel->band] != wl->sta_rate_set) {
783                 wl->sta_rate_set = sta->supp_rates[conf->channel->band];
784                 set_bit(WL1271_FLAG_STA_RATES_CHANGED, &wl->flags);
785         }
786         spin_unlock_irqrestore(&wl->wl_lock, flags);
787
788         /* queue the packet */
789         skb_queue_tail(&wl->tx_queue, skb);
790
791         /*
792          * The chip specific setup must run before the first TX packet -
793          * before that, the tx_work will not be initialized!
794          */
795
796         ieee80211_queue_work(wl->hw, &wl->tx_work);
797
798         /*
799          * The workqueue is slow to process the tx_queue and we need stop
800          * the queue here, otherwise the queue will get too long.
801          */
802         if (skb_queue_len(&wl->tx_queue) >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
803                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
804
805                 spin_lock_irqsave(&wl->wl_lock, flags);
806                 ieee80211_stop_queues(wl->hw);
807                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
808                 spin_unlock_irqrestore(&wl->wl_lock, flags);
809         }
810
811         return NETDEV_TX_OK;
812 }
813
814 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
815                              void *arg)
816 {
817         struct net_device *dev;
818         struct wireless_dev *wdev;
819         struct wiphy *wiphy;
820         struct ieee80211_hw *hw;
821         struct wl1271 *wl;
822         struct wl1271 *wl_temp;
823         struct in_device *idev;
824         struct in_ifaddr *ifa = arg;
825         int ret = 0;
826
827         /* FIXME: this ugly function should probably be implemented in the
828          * mac80211, and here should only be a simple callback handling actual
829          * setting of the filters. Now we need to dig up references to
830          * various structures to gain access to what we need.
831          * Also, because of this, there is no "initial" setting of the filter
832          * in "op_start", because we don't want to dig up struct net_device
833          * there - the filter will be set upon first change of the interface
834          * IP address. */
835
836         dev = ifa->ifa_dev->dev;
837
838         wdev = dev->ieee80211_ptr;
839         if (wdev == NULL)
840                 return NOTIFY_DONE;
841
842         wiphy = wdev->wiphy;
843         if (wiphy == NULL)
844                 return NOTIFY_DONE;
845
846         hw = wiphy_priv(wiphy);
847         if (hw == NULL)
848                 return NOTIFY_DONE;
849
850         /* Check that the interface is one supported by this driver. */
851         wl_temp = hw->priv;
852         list_for_each_entry(wl, &wl_list, list) {
853                 if (wl == wl_temp)
854                         break;
855         }
856         if (wl != wl_temp)
857                 return NOTIFY_DONE;
858
859         /* Get the interface IP address for the device. "ifa" will become
860            NULL if:
861              - there is no IPV4 protocol address configured
862              - there are multiple (virtual) IPV4 addresses configured
863            When "ifa" is NULL, filtering will be disabled.
864         */
865         ifa = NULL;
866         idev = dev->ip_ptr;
867         if (idev)
868                 ifa = idev->ifa_list;
869
870         if (ifa && ifa->ifa_next)
871                 ifa = NULL;
872
873         mutex_lock(&wl->mutex);
874
875         if (wl->state == WL1271_STATE_OFF)
876                 goto out;
877
878         ret = wl1271_ps_elp_wakeup(wl, false);
879         if (ret < 0)
880                 goto out;
881         if (ifa)
882                 ret = wl1271_acx_arp_ip_filter(wl, true,
883                                                (u8 *)&ifa->ifa_address,
884                                                ACX_IPV4_VERSION);
885         else
886                 ret = wl1271_acx_arp_ip_filter(wl, false, NULL,
887                                                ACX_IPV4_VERSION);
888         wl1271_ps_elp_sleep(wl);
889
890 out:
891         mutex_unlock(&wl->mutex);
892
893         return NOTIFY_OK;
894 }
895
896 static struct notifier_block wl1271_dev_notifier = {
897         .notifier_call = wl1271_dev_notify,
898 };
899
900
901 static int wl1271_op_start(struct ieee80211_hw *hw)
902 {
903         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
904
905         /*
906          * We have to delay the booting of the hardware because
907          * we need to know the local MAC address before downloading and
908          * initializing the firmware. The MAC address cannot be changed
909          * after boot, and without the proper MAC address, the firmware
910          * will not function properly.
911          *
912          * The MAC address is first known when the corresponding interface
913          * is added. That is where we will initialize the hardware.
914          */
915
916         return 0;
917 }
918
919 static void wl1271_op_stop(struct ieee80211_hw *hw)
920 {
921         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
922 }
923
924 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
925                                    struct ieee80211_vif *vif)
926 {
927         struct wl1271 *wl = hw->priv;
928         int retries = WL1271_BOOT_RETRIES;
929         int ret = 0;
930
931         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
932                      vif->type, vif->addr);
933
934         mutex_lock(&wl->mutex);
935         if (wl->vif) {
936                 ret = -EBUSY;
937                 goto out;
938         }
939
940         wl->vif = vif;
941
942         switch (vif->type) {
943         case NL80211_IFTYPE_STATION:
944                 wl->bss_type = BSS_TYPE_STA_BSS;
945                 wl->set_bss_type = BSS_TYPE_STA_BSS;
946                 break;
947         case NL80211_IFTYPE_ADHOC:
948                 wl->bss_type = BSS_TYPE_IBSS;
949                 wl->set_bss_type = BSS_TYPE_STA_BSS;
950                 break;
951         default:
952                 ret = -EOPNOTSUPP;
953                 goto out;
954         }
955
956         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
957
958         if (wl->state != WL1271_STATE_OFF) {
959                 wl1271_error("cannot start because not in off state: %d",
960                              wl->state);
961                 ret = -EBUSY;
962                 goto out;
963         }
964
965         while (retries) {
966                 retries--;
967                 ret = wl1271_chip_wakeup(wl);
968                 if (ret < 0)
969                         goto power_off;
970
971                 ret = wl1271_boot(wl);
972                 if (ret < 0)
973                         goto power_off;
974
975                 ret = wl1271_hw_init(wl);
976                 if (ret < 0)
977                         goto irq_disable;
978
979                 wl->state = WL1271_STATE_ON;
980                 wl1271_info("firmware booted (%s)", wl->chip.fw_ver);
981                 goto out;
982
983 irq_disable:
984                 wl1271_disable_interrupts(wl);
985                 mutex_unlock(&wl->mutex);
986                 /* Unlocking the mutex in the middle of handling is
987                    inherently unsafe. In this case we deem it safe to do,
988                    because we need to let any possibly pending IRQ out of
989                    the system (and while we are WL1271_STATE_OFF the IRQ
990                    work function will not do anything.) Also, any other
991                    possible concurrent operations will fail due to the
992                    current state, hence the wl1271 struct should be safe. */
993                 cancel_work_sync(&wl->irq_work);
994                 mutex_lock(&wl->mutex);
995 power_off:
996                 wl1271_power_off(wl);
997         }
998
999         wl1271_error("firmware boot failed despite %d retries",
1000                      WL1271_BOOT_RETRIES);
1001 out:
1002         mutex_unlock(&wl->mutex);
1003
1004         if (!ret) {
1005                 list_add(&wl->list, &wl_list);
1006                 register_inetaddr_notifier(&wl1271_dev_notifier);
1007         }
1008
1009         return ret;
1010 }
1011
1012 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1013                                        struct ieee80211_vif *vif)
1014 {
1015         struct wl1271 *wl = hw->priv;
1016         int i;
1017
1018         unregister_inetaddr_notifier(&wl1271_dev_notifier);
1019
1020         mutex_lock(&wl->mutex);
1021         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1022
1023         wl1271_info("down");
1024
1025         list_del(&wl->list);
1026
1027         WARN_ON(wl->state != WL1271_STATE_ON);
1028
1029         if (test_and_clear_bit(WL1271_FLAG_SCANNING, &wl->flags)) {
1030                 mutex_unlock(&wl->mutex);
1031                 ieee80211_scan_completed(wl->hw, true);
1032                 mutex_lock(&wl->mutex);
1033         }
1034
1035         wl->state = WL1271_STATE_OFF;
1036
1037         wl1271_disable_interrupts(wl);
1038
1039         mutex_unlock(&wl->mutex);
1040
1041         cancel_work_sync(&wl->irq_work);
1042         cancel_work_sync(&wl->tx_work);
1043
1044         mutex_lock(&wl->mutex);
1045
1046         /* let's notify MAC80211 about the remaining pending TX frames */
1047         wl1271_tx_flush(wl);
1048         wl1271_power_off(wl);
1049
1050         memset(wl->bssid, 0, ETH_ALEN);
1051         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1052         wl->ssid_len = 0;
1053         wl->bss_type = MAX_BSS_TYPE;
1054         wl->set_bss_type = MAX_BSS_TYPE;
1055         wl->band = IEEE80211_BAND_2GHZ;
1056
1057         wl->rx_counter = 0;
1058         wl->psm_entry_retry = 0;
1059         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1060         wl->tx_blocks_available = 0;
1061         wl->tx_results_count = 0;
1062         wl->tx_packets_count = 0;
1063         wl->tx_security_last_seq = 0;
1064         wl->tx_security_seq = 0;
1065         wl->time_offset = 0;
1066         wl->session_counter = 0;
1067         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1068         wl->sta_rate_set = 0;
1069         wl->flags = 0;
1070         wl->vif = NULL;
1071         wl->filters = 0;
1072
1073         for (i = 0; i < NUM_TX_QUEUES; i++)
1074                 wl->tx_blocks_freed[i] = 0;
1075
1076         wl1271_debugfs_reset(wl);
1077
1078         kfree(wl->fw_status);
1079         wl->fw_status = NULL;
1080         kfree(wl->tx_res_if);
1081         wl->tx_res_if = NULL;
1082         kfree(wl->target_mem_map);
1083         wl->target_mem_map = NULL;
1084
1085         mutex_unlock(&wl->mutex);
1086 }
1087
1088 static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1089 {
1090         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
1091         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
1092
1093         /* combine requested filters with current filter config */
1094         filters = wl->filters | filters;
1095
1096         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1097
1098         if (filters & FIF_PROMISC_IN_BSS) {
1099                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1100                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1101                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1102         }
1103         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1104                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1105                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1106                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1107         }
1108         if (filters & FIF_OTHER_BSS) {
1109                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1110                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1111         }
1112         if (filters & FIF_CONTROL) {
1113                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1114                 wl->rx_filter |= CFG_RX_CTL_EN;
1115         }
1116         if (filters & FIF_FCSFAIL) {
1117                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1118                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1119         }
1120 }
1121
1122 static int wl1271_dummy_join(struct wl1271 *wl)
1123 {
1124         int ret = 0;
1125         /* we need to use a dummy BSSID for now */
1126         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1127                                                   0xad, 0xbe, 0xef };
1128
1129         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1130
1131         /* pass through frames from all BSS */
1132         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1133
1134         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1135         if (ret < 0)
1136                 goto out;
1137
1138         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1139
1140 out:
1141         return ret;
1142 }
1143
1144 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1145 {
1146         int ret;
1147
1148         /*
1149          * One of the side effects of the JOIN command is that is clears
1150          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1151          * to a WPA/WPA2 access point will therefore kill the data-path.
1152          * Currently there is no supported scenario for JOIN during
1153          * association - if it becomes a supported scenario, the WPA/WPA2 keys
1154          * must be handled somehow.
1155          *
1156          */
1157         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1158                 wl1271_info("JOIN while associated.");
1159
1160         if (set_assoc)
1161                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1162
1163         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1164         if (ret < 0)
1165                 goto out;
1166
1167         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1168
1169         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1170                 goto out;
1171
1172         /*
1173          * The join command disable the keep-alive mode, shut down its process,
1174          * and also clear the template config, so we need to reset it all after
1175          * the join. The acx_aid starts the keep-alive process, and the order
1176          * of the commands below is relevant.
1177          */
1178         ret = wl1271_acx_keep_alive_mode(wl, true);
1179         if (ret < 0)
1180                 goto out;
1181
1182         ret = wl1271_acx_aid(wl, wl->aid);
1183         if (ret < 0)
1184                 goto out;
1185
1186         ret = wl1271_cmd_build_klv_null_data(wl);
1187         if (ret < 0)
1188                 goto out;
1189
1190         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1191                                            ACX_KEEP_ALIVE_TPL_VALID);
1192         if (ret < 0)
1193                 goto out;
1194
1195 out:
1196         return ret;
1197 }
1198
1199 static int wl1271_unjoin(struct wl1271 *wl)
1200 {
1201         int ret;
1202
1203         /* to stop listening to a channel, we disconnect */
1204         ret = wl1271_cmd_disconnect(wl);
1205         if (ret < 0)
1206                 goto out;
1207
1208         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1209         memset(wl->bssid, 0, ETH_ALEN);
1210
1211         /* stop filterting packets based on bssid */
1212         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1213
1214 out:
1215         return ret;
1216 }
1217
1218 static void wl1271_set_band_rate(struct wl1271 *wl)
1219 {
1220         if (wl->band == IEEE80211_BAND_2GHZ)
1221                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1222         else
1223                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1224 }
1225
1226 static u32 wl1271_min_rate_get(struct wl1271 *wl)
1227 {
1228         int i;
1229         u32 rate = 0;
1230
1231         if (!wl->basic_rate_set) {
1232                 WARN_ON(1);
1233                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1234         }
1235
1236         for (i = 0; !rate; i++) {
1237                 if ((wl->basic_rate_set >> i) & 0x1)
1238                         rate = 1 << i;
1239         }
1240
1241         return rate;
1242 }
1243
1244 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1245 {
1246         struct wl1271 *wl = hw->priv;
1247         struct ieee80211_conf *conf = &hw->conf;
1248         int channel, ret = 0;
1249
1250         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1251
1252         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s",
1253                      channel,
1254                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1255                      conf->power_level,
1256                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use");
1257
1258         mutex_lock(&wl->mutex);
1259
1260         if (unlikely(wl->state == WL1271_STATE_OFF))
1261                 goto out;
1262
1263         ret = wl1271_ps_elp_wakeup(wl, false);
1264         if (ret < 0)
1265                 goto out;
1266
1267         /* if the channel changes while joined, join again */
1268         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1269             ((wl->band != conf->channel->band) ||
1270              (wl->channel != channel))) {
1271                 wl->band = conf->channel->band;
1272                 wl->channel = channel;
1273
1274                 /*
1275                  * FIXME: the mac80211 should really provide a fixed rate
1276                  * to use here. for now, just use the smallest possible rate
1277                  * for the band as a fixed rate for association frames and
1278                  * other control messages.
1279                  */
1280                 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1281                         wl1271_set_band_rate(wl);
1282
1283                 wl->basic_rate = wl1271_min_rate_get(wl);
1284                 ret = wl1271_acx_rate_policies(wl);
1285                 if (ret < 0)
1286                         wl1271_warning("rate policy for update channel "
1287                                        "failed %d", ret);
1288
1289                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1290                         ret = wl1271_join(wl, false);
1291                         if (ret < 0)
1292                                 wl1271_warning("cmd join to update channel "
1293                                                "failed %d", ret);
1294                 }
1295         }
1296
1297         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1298                 if (conf->flags & IEEE80211_CONF_IDLE &&
1299                     test_bit(WL1271_FLAG_JOINED, &wl->flags))
1300                         wl1271_unjoin(wl);
1301                 else if (!(conf->flags & IEEE80211_CONF_IDLE))
1302                         wl1271_dummy_join(wl);
1303
1304                 if (conf->flags & IEEE80211_CONF_IDLE) {
1305                         wl->rate_set = wl1271_min_rate_get(wl);
1306                         wl->sta_rate_set = 0;
1307                         wl1271_acx_rate_policies(wl);
1308                         wl1271_acx_keep_alive_config(
1309                                 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1310                                 ACX_KEEP_ALIVE_TPL_INVALID);
1311                         set_bit(WL1271_FLAG_IDLE, &wl->flags);
1312                 } else
1313                         clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1314         }
1315
1316         if (conf->flags & IEEE80211_CONF_PS &&
1317             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1318                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1319
1320                 /*
1321                  * We enter PSM only if we're already associated.
1322                  * If we're not, we'll enter it when joining an SSID,
1323                  * through the bss_info_changed() hook.
1324                  */
1325                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
1326                         wl1271_debug(DEBUG_PSM, "psm enabled");
1327                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1328                                                  true);
1329                 }
1330         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
1331                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1332                 wl1271_debug(DEBUG_PSM, "psm disabled");
1333
1334                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
1335
1336                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
1337                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1338                                                  true);
1339         }
1340
1341         if (conf->power_level != wl->power_level) {
1342                 ret = wl1271_acx_tx_power(wl, conf->power_level);
1343                 if (ret < 0)
1344                         goto out_sleep;
1345
1346                 wl->power_level = conf->power_level;
1347         }
1348
1349 out_sleep:
1350         wl1271_ps_elp_sleep(wl);
1351
1352 out:
1353         mutex_unlock(&wl->mutex);
1354
1355         return ret;
1356 }
1357
1358 struct wl1271_filter_params {
1359         bool enabled;
1360         int mc_list_length;
1361         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1362 };
1363
1364 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1365                                        struct netdev_hw_addr_list *mc_list)
1366 {
1367         struct wl1271_filter_params *fp;
1368         struct netdev_hw_addr *ha;
1369         struct wl1271 *wl = hw->priv;
1370
1371         if (unlikely(wl->state == WL1271_STATE_OFF))
1372                 return 0;
1373
1374         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
1375         if (!fp) {
1376                 wl1271_error("Out of memory setting filters.");
1377                 return 0;
1378         }
1379
1380         /* update multicast filtering parameters */
1381         fp->mc_list_length = 0;
1382         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1383                 fp->enabled = false;
1384         } else {
1385                 fp->enabled = true;
1386                 netdev_hw_addr_list_for_each(ha, mc_list) {
1387                         memcpy(fp->mc_list[fp->mc_list_length],
1388                                         ha->addr, ETH_ALEN);
1389                         fp->mc_list_length++;
1390                 }
1391         }
1392
1393         return (u64)(unsigned long)fp;
1394 }
1395
1396 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1397                                   FIF_ALLMULTI | \
1398                                   FIF_FCSFAIL | \
1399                                   FIF_BCN_PRBRESP_PROMISC | \
1400                                   FIF_CONTROL | \
1401                                   FIF_OTHER_BSS)
1402
1403 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1404                                        unsigned int changed,
1405                                        unsigned int *total, u64 multicast)
1406 {
1407         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
1408         struct wl1271 *wl = hw->priv;
1409         int ret;
1410
1411         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter");
1412
1413         mutex_lock(&wl->mutex);
1414
1415         *total &= WL1271_SUPPORTED_FILTERS;
1416         changed &= WL1271_SUPPORTED_FILTERS;
1417
1418         if (unlikely(wl->state == WL1271_STATE_OFF))
1419                 goto out;
1420
1421         ret = wl1271_ps_elp_wakeup(wl, false);
1422         if (ret < 0)
1423                 goto out;
1424
1425
1426         if (*total & FIF_ALLMULTI)
1427                 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1428         else if (fp)
1429                 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1430                                                    fp->mc_list,
1431                                                    fp->mc_list_length);
1432         if (ret < 0)
1433                 goto out_sleep;
1434
1435         /* determine, whether supported filter values have changed */
1436         if (changed == 0)
1437                 goto out_sleep;
1438
1439         /* configure filters */
1440         wl->filters = *total;
1441         wl1271_configure_filters(wl, 0);
1442
1443         /* apply configured filters */
1444         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1445         if (ret < 0)
1446                 goto out_sleep;
1447
1448 out_sleep:
1449         wl1271_ps_elp_sleep(wl);
1450
1451 out:
1452         mutex_unlock(&wl->mutex);
1453         kfree(fp);
1454 }
1455
1456 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1457                              struct ieee80211_vif *vif,
1458                              struct ieee80211_sta *sta,
1459                              struct ieee80211_key_conf *key_conf)
1460 {
1461         struct wl1271 *wl = hw->priv;
1462         const u8 *addr;
1463         int ret;
1464         u32 tx_seq_32 = 0;
1465         u16 tx_seq_16 = 0;
1466         u8 key_type;
1467
1468         static const u8 bcast_addr[ETH_ALEN] =
1469                 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1470
1471         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1472
1473         addr = sta ? sta->addr : bcast_addr;
1474
1475         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
1476         wl1271_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
1477         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
1478                      key_conf->alg, key_conf->keyidx,
1479                      key_conf->keylen, key_conf->flags);
1480         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1481
1482         if (is_zero_ether_addr(addr)) {
1483                 /* We dont support TX only encryption */
1484                 ret = -EOPNOTSUPP;
1485                 goto out;
1486         }
1487
1488         mutex_lock(&wl->mutex);
1489
1490         ret = wl1271_ps_elp_wakeup(wl, false);
1491         if (ret < 0)
1492                 goto out_unlock;
1493
1494         switch (key_conf->alg) {
1495         case ALG_WEP:
1496                 key_type = KEY_WEP;
1497
1498                 key_conf->hw_key_idx = key_conf->keyidx;
1499                 break;
1500         case ALG_TKIP:
1501                 key_type = KEY_TKIP;
1502
1503                 key_conf->hw_key_idx = key_conf->keyidx;
1504                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1505                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1506                 break;
1507         case ALG_CCMP:
1508                 key_type = KEY_AES;
1509
1510                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1511                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1512                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1513                 break;
1514         default:
1515                 wl1271_error("Unknown key algo 0x%x", key_conf->alg);
1516
1517                 ret = -EOPNOTSUPP;
1518                 goto out_sleep;
1519         }
1520
1521         switch (cmd) {
1522         case SET_KEY:
1523                 ret = wl1271_cmd_set_key(wl, KEY_ADD_OR_REPLACE,
1524                                          key_conf->keyidx, key_type,
1525                                          key_conf->keylen, key_conf->key,
1526                                          addr, tx_seq_32, tx_seq_16);
1527                 if (ret < 0) {
1528                         wl1271_error("Could not add or replace key");
1529                         goto out_sleep;
1530                 }
1531
1532                 /* the default WEP key needs to be configured at least once */
1533                 if (key_type == KEY_WEP) {
1534                         ret = wl1271_cmd_set_default_wep_key(wl,
1535                                                              wl->default_key);
1536                         if (ret < 0)
1537                                 goto out_sleep;
1538                 }
1539                 break;
1540
1541         case DISABLE_KEY:
1542                 /* The wl1271 does not allow to remove unicast keys - they
1543                    will be cleared automatically on next CMD_JOIN. Ignore the
1544                    request silently, as we dont want the mac80211 to emit
1545                    an error message. */
1546                 if (!is_broadcast_ether_addr(addr))
1547                         break;
1548
1549                 ret = wl1271_cmd_set_key(wl, KEY_REMOVE,
1550                                          key_conf->keyidx, key_type,
1551                                          key_conf->keylen, key_conf->key,
1552                                          addr, 0, 0);
1553                 if (ret < 0) {
1554                         wl1271_error("Could not remove key");
1555                         goto out_sleep;
1556                 }
1557                 break;
1558
1559         default:
1560                 wl1271_error("Unsupported key cmd 0x%x", cmd);
1561                 ret = -EOPNOTSUPP;
1562                 break;
1563         }
1564
1565 out_sleep:
1566         wl1271_ps_elp_sleep(wl);
1567
1568 out_unlock:
1569         mutex_unlock(&wl->mutex);
1570
1571 out:
1572         return ret;
1573 }
1574
1575 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
1576                              struct ieee80211_vif *vif,
1577                              struct cfg80211_scan_request *req)
1578 {
1579         struct wl1271 *wl = hw->priv;
1580         int ret;
1581         u8 *ssid = NULL;
1582         size_t len = 0;
1583
1584         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1585
1586         if (req->n_ssids) {
1587                 ssid = req->ssids[0].ssid;
1588                 len = req->ssids[0].ssid_len;
1589         }
1590
1591         mutex_lock(&wl->mutex);
1592
1593         ret = wl1271_ps_elp_wakeup(wl, false);
1594         if (ret < 0)
1595                 goto out;
1596
1597         if (wl1271_11a_enabled())
1598                 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1599                                       req->ie, req->ie_len, 1, 0,
1600                                       WL1271_SCAN_BAND_DUAL, 3);
1601         else
1602                 ret = wl1271_cmd_scan(hw->priv, ssid, len,
1603                                       req->ie, req->ie_len, 1, 0,
1604                                       WL1271_SCAN_BAND_2_4_GHZ, 3);
1605
1606         wl1271_ps_elp_sleep(wl);
1607
1608 out:
1609         mutex_unlock(&wl->mutex);
1610
1611         return ret;
1612 }
1613
1614 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1615 {
1616         struct wl1271 *wl = hw->priv;
1617         int ret = 0;
1618
1619         mutex_lock(&wl->mutex);
1620
1621         if (unlikely(wl->state == WL1271_STATE_OFF))
1622                 goto out;
1623
1624         ret = wl1271_ps_elp_wakeup(wl, false);
1625         if (ret < 0)
1626                 goto out;
1627
1628         ret = wl1271_acx_rts_threshold(wl, (u16) value);
1629         if (ret < 0)
1630                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
1631
1632         wl1271_ps_elp_sleep(wl);
1633
1634 out:
1635         mutex_unlock(&wl->mutex);
1636
1637         return ret;
1638 }
1639
1640 static void wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *beacon)
1641 {
1642         u8 *ptr = beacon->data +
1643                 offsetof(struct ieee80211_mgmt, u.beacon.variable);
1644
1645         /* find the location of the ssid in the beacon */
1646         while (ptr < beacon->data + beacon->len) {
1647                 if (ptr[0] == WLAN_EID_SSID) {
1648                         wl->ssid_len = ptr[1];
1649                         memcpy(wl->ssid, ptr+2, wl->ssid_len);
1650                         return;
1651                 }
1652                 ptr += ptr[1];
1653         }
1654         wl1271_error("ad-hoc beacon template has no SSID!\n");
1655 }
1656
1657 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
1658                                        struct ieee80211_vif *vif,
1659                                        struct ieee80211_bss_conf *bss_conf,
1660                                        u32 changed)
1661 {
1662         enum wl1271_cmd_ps_mode mode;
1663         struct wl1271 *wl = hw->priv;
1664         bool do_join = false;
1665         bool set_assoc = false;
1666         int ret;
1667
1668         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed");
1669
1670         mutex_lock(&wl->mutex);
1671
1672         ret = wl1271_ps_elp_wakeup(wl, false);
1673         if (ret < 0)
1674                 goto out;
1675
1676         if ((changed && BSS_CHANGED_BEACON_INT) &&
1677             (wl->bss_type == BSS_TYPE_IBSS)) {
1678                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon interval updated: %d",
1679                         bss_conf->beacon_int);
1680
1681                 wl->beacon_int = bss_conf->beacon_int;
1682                 do_join = true;
1683         }
1684
1685         if ((changed && BSS_CHANGED_BEACON) &&
1686             (wl->bss_type == BSS_TYPE_IBSS)) {
1687                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
1688
1689                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beacon updated");
1690
1691                 if (beacon) {
1692                         struct ieee80211_hdr *hdr;
1693
1694                         wl1271_ssid_set(wl, beacon);
1695                         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON,
1696                                                       beacon->data,
1697                                                       beacon->len, 0,
1698                                                       wl1271_min_rate_get(wl));
1699
1700                         if (ret < 0) {
1701                                 dev_kfree_skb(beacon);
1702                                 goto out_sleep;
1703                         }
1704
1705                         hdr = (struct ieee80211_hdr *) beacon->data;
1706                         hdr->frame_control = cpu_to_le16(
1707                                 IEEE80211_FTYPE_MGMT |
1708                                 IEEE80211_STYPE_PROBE_RESP);
1709
1710                         ret = wl1271_cmd_template_set(wl,
1711                                                       CMD_TEMPL_PROBE_RESPONSE,
1712                                                       beacon->data,
1713                                                       beacon->len, 0,
1714                                                       wl1271_min_rate_get(wl));
1715                         dev_kfree_skb(beacon);
1716                         if (ret < 0)
1717                                 goto out_sleep;
1718
1719                         /* Need to update the SSID (for filtering etc) */
1720                         do_join = true;
1721                 }
1722         }
1723
1724         if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1725             (wl->bss_type == BSS_TYPE_IBSS)) {
1726                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
1727                              bss_conf->enable_beacon ? "enabled" : "disabled");
1728
1729                 if (bss_conf->enable_beacon)
1730                         wl->set_bss_type = BSS_TYPE_IBSS;
1731                 else
1732                         wl->set_bss_type = BSS_TYPE_STA_BSS;
1733                 do_join = true;
1734         }
1735
1736         if (changed & BSS_CHANGED_CQM) {
1737                 bool enable = false;
1738                 if (bss_conf->cqm_rssi_thold)
1739                         enable = true;
1740                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
1741                                                   bss_conf->cqm_rssi_thold,
1742                                                   bss_conf->cqm_rssi_hyst);
1743                 if (ret < 0)
1744                         goto out;
1745                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
1746         }
1747
1748         if ((changed & BSS_CHANGED_BSSID) &&
1749             /*
1750              * Now we know the correct bssid, so we send a new join command
1751              * and enable the BSSID filter
1752              */
1753             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
1754                         memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
1755
1756                         ret = wl1271_cmd_build_null_data(wl);
1757                         if (ret < 0)
1758                                 goto out_sleep;
1759
1760                         ret = wl1271_build_qos_null_data(wl);
1761                         if (ret < 0)
1762                                 goto out_sleep;
1763
1764                         /* filter out all packets not from this BSSID */
1765                         wl1271_configure_filters(wl, 0);
1766
1767                         /* Need to update the BSSID (for filtering etc) */
1768                         do_join = true;
1769         }
1770
1771         if (changed & BSS_CHANGED_ASSOC) {
1772                 if (bss_conf->assoc) {
1773                         u32 rates;
1774                         wl->aid = bss_conf->aid;
1775                         set_assoc = true;
1776
1777                         /*
1778                          * use basic rates from AP, and determine lowest rate
1779                          * to use with control frames.
1780                          */
1781                         rates = bss_conf->basic_rates;
1782                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
1783                                                                          rates);
1784                         wl->basic_rate = wl1271_min_rate_get(wl);
1785                         ret = wl1271_acx_rate_policies(wl);
1786                         if (ret < 0)
1787                                 goto out_sleep;
1788
1789                         /*
1790                          * with wl1271, we don't need to update the
1791                          * beacon_int and dtim_period, because the firmware
1792                          * updates it by itself when the first beacon is
1793                          * received after a join.
1794                          */
1795                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
1796                         if (ret < 0)
1797                                 goto out_sleep;
1798
1799                         /*
1800                          * The SSID is intentionally set to NULL here - the
1801                          * firmware will set the probe request with a
1802                          * broadcast SSID regardless of what we set in the
1803                          * template.
1804                          */
1805                         ret = wl1271_cmd_build_probe_req(wl, NULL, 0,
1806                                                          NULL, 0, wl->band);
1807
1808                         /* enable the connection monitoring feature */
1809                         ret = wl1271_acx_conn_monit_params(wl, true);
1810                         if (ret < 0)
1811                                 goto out_sleep;
1812
1813                         /* If we want to go in PSM but we're not there yet */
1814                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
1815                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1816                                 mode = STATION_POWER_SAVE_MODE;
1817                                 ret = wl1271_ps_set_mode(wl, mode, true);
1818                                 if (ret < 0)
1819                                         goto out_sleep;
1820                         }
1821                 } else {
1822                         /* use defaults when not associated */
1823                         clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1824                         wl->aid = 0;
1825
1826                         /* revert back to minimum rates for the current band */
1827                         wl1271_set_band_rate(wl);
1828                         wl->basic_rate = wl1271_min_rate_get(wl);
1829                         ret = wl1271_acx_rate_policies(wl);
1830                         if (ret < 0)
1831                                 goto out_sleep;
1832
1833                         /* disable connection monitor features */
1834                         ret = wl1271_acx_conn_monit_params(wl, false);
1835
1836                         /* Disable the keep-alive feature */
1837                         ret = wl1271_acx_keep_alive_mode(wl, false);
1838
1839                         if (ret < 0)
1840                                 goto out_sleep;
1841                 }
1842
1843         }
1844
1845         if (changed & BSS_CHANGED_ERP_SLOT) {
1846                 if (bss_conf->use_short_slot)
1847                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
1848                 else
1849                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
1850                 if (ret < 0) {
1851                         wl1271_warning("Set slot time failed %d", ret);
1852                         goto out_sleep;
1853                 }
1854         }
1855
1856         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1857                 if (bss_conf->use_short_preamble)
1858                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
1859                 else
1860                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
1861         }
1862
1863         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1864                 if (bss_conf->use_cts_prot)
1865                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
1866                 else
1867                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
1868                 if (ret < 0) {
1869                         wl1271_warning("Set ctsprotect failed %d", ret);
1870                         goto out_sleep;
1871                 }
1872         }
1873
1874         if (do_join) {
1875                 ret = wl1271_join(wl, set_assoc);
1876                 if (ret < 0) {
1877                         wl1271_warning("cmd join failed %d", ret);
1878                         goto out_sleep;
1879                 }
1880         }
1881
1882 out_sleep:
1883         wl1271_ps_elp_sleep(wl);
1884
1885 out:
1886         mutex_unlock(&wl->mutex);
1887 }
1888
1889 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1890                              const struct ieee80211_tx_queue_params *params)
1891 {
1892         struct wl1271 *wl = hw->priv;
1893         u8 ps_scheme;
1894         int ret;
1895
1896         mutex_lock(&wl->mutex);
1897
1898         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
1899
1900         ret = wl1271_ps_elp_wakeup(wl, false);
1901         if (ret < 0)
1902                 goto out;
1903
1904         /* the txop is confed in units of 32us by the mac80211, we need us */
1905         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
1906                                 params->cw_min, params->cw_max,
1907                                 params->aifs, params->txop << 5);
1908         if (ret < 0)
1909                 goto out_sleep;
1910
1911         if (params->uapsd)
1912                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
1913         else
1914                 ps_scheme = CONF_PS_SCHEME_LEGACY;
1915
1916         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
1917                                  CONF_CHANNEL_TYPE_EDCF,
1918                                  wl1271_tx_get_queue(queue),
1919                                  ps_scheme, CONF_ACK_POLICY_LEGACY, 0, 0);
1920         if (ret < 0)
1921                 goto out_sleep;
1922
1923 out_sleep:
1924         wl1271_ps_elp_sleep(wl);
1925
1926 out:
1927         mutex_unlock(&wl->mutex);
1928
1929         return ret;
1930 }
1931
1932
1933 /* can't be const, mac80211 writes to this */
1934 static struct ieee80211_rate wl1271_rates[] = {
1935         { .bitrate = 10,
1936           .hw_value = CONF_HW_BIT_RATE_1MBPS,
1937           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
1938         { .bitrate = 20,
1939           .hw_value = CONF_HW_BIT_RATE_2MBPS,
1940           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
1941           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1942         { .bitrate = 55,
1943           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
1944           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
1945           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1946         { .bitrate = 110,
1947           .hw_value = CONF_HW_BIT_RATE_11MBPS,
1948           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
1949           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
1950         { .bitrate = 60,
1951           .hw_value = CONF_HW_BIT_RATE_6MBPS,
1952           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
1953         { .bitrate = 90,
1954           .hw_value = CONF_HW_BIT_RATE_9MBPS,
1955           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
1956         { .bitrate = 120,
1957           .hw_value = CONF_HW_BIT_RATE_12MBPS,
1958           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
1959         { .bitrate = 180,
1960           .hw_value = CONF_HW_BIT_RATE_18MBPS,
1961           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
1962         { .bitrate = 240,
1963           .hw_value = CONF_HW_BIT_RATE_24MBPS,
1964           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
1965         { .bitrate = 360,
1966          .hw_value = CONF_HW_BIT_RATE_36MBPS,
1967          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
1968         { .bitrate = 480,
1969           .hw_value = CONF_HW_BIT_RATE_48MBPS,
1970           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
1971         { .bitrate = 540,
1972           .hw_value = CONF_HW_BIT_RATE_54MBPS,
1973           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
1974 };
1975
1976 /* can't be const, mac80211 writes to this */
1977 static struct ieee80211_channel wl1271_channels[] = {
1978         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
1979         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
1980         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
1981         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
1982         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
1983         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
1984         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
1985         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
1986         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
1987         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
1988         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
1989         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
1990         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
1991 };
1992
1993 /* mapping to indexes for wl1271_rates */
1994 const static u8 wl1271_rate_to_idx_2ghz[] = {
1995         /* MCS rates are used only with 11n */
1996         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
1997         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
1998         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
1999         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2000         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2001         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2002         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2003         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2004
2005         11,                            /* CONF_HW_RXTX_RATE_54   */
2006         10,                            /* CONF_HW_RXTX_RATE_48   */
2007         9,                             /* CONF_HW_RXTX_RATE_36   */
2008         8,                             /* CONF_HW_RXTX_RATE_24   */
2009
2010         /* TI-specific rate */
2011         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2012
2013         7,                             /* CONF_HW_RXTX_RATE_18   */
2014         6,                             /* CONF_HW_RXTX_RATE_12   */
2015         3,                             /* CONF_HW_RXTX_RATE_11   */
2016         5,                             /* CONF_HW_RXTX_RATE_9    */
2017         4,                             /* CONF_HW_RXTX_RATE_6    */
2018         2,                             /* CONF_HW_RXTX_RATE_5_5  */
2019         1,                             /* CONF_HW_RXTX_RATE_2    */
2020         0                              /* CONF_HW_RXTX_RATE_1    */
2021 };
2022
2023 /* can't be const, mac80211 writes to this */
2024 static struct ieee80211_supported_band wl1271_band_2ghz = {
2025         .channels = wl1271_channels,
2026         .n_channels = ARRAY_SIZE(wl1271_channels),
2027         .bitrates = wl1271_rates,
2028         .n_bitrates = ARRAY_SIZE(wl1271_rates),
2029 };
2030
2031 /* 5 GHz data rates for WL1273 */
2032 static struct ieee80211_rate wl1271_rates_5ghz[] = {
2033         { .bitrate = 60,
2034           .hw_value = CONF_HW_BIT_RATE_6MBPS,
2035           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2036         { .bitrate = 90,
2037           .hw_value = CONF_HW_BIT_RATE_9MBPS,
2038           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2039         { .bitrate = 120,
2040           .hw_value = CONF_HW_BIT_RATE_12MBPS,
2041           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2042         { .bitrate = 180,
2043           .hw_value = CONF_HW_BIT_RATE_18MBPS,
2044           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2045         { .bitrate = 240,
2046           .hw_value = CONF_HW_BIT_RATE_24MBPS,
2047           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2048         { .bitrate = 360,
2049          .hw_value = CONF_HW_BIT_RATE_36MBPS,
2050          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2051         { .bitrate = 480,
2052           .hw_value = CONF_HW_BIT_RATE_48MBPS,
2053           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2054         { .bitrate = 540,
2055           .hw_value = CONF_HW_BIT_RATE_54MBPS,
2056           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2057 };
2058
2059 /* 5 GHz band channels for WL1273 */
2060 static struct ieee80211_channel wl1271_channels_5ghz[] = {
2061         { .hw_value = 183, .center_freq = 4915},
2062         { .hw_value = 184, .center_freq = 4920},
2063         { .hw_value = 185, .center_freq = 4925},
2064         { .hw_value = 187, .center_freq = 4935},
2065         { .hw_value = 188, .center_freq = 4940},
2066         { .hw_value = 189, .center_freq = 4945},
2067         { .hw_value = 192, .center_freq = 4960},
2068         { .hw_value = 196, .center_freq = 4980},
2069         { .hw_value = 7, .center_freq = 5035},
2070         { .hw_value = 8, .center_freq = 5040},
2071         { .hw_value = 9, .center_freq = 5045},
2072         { .hw_value = 11, .center_freq = 5055},
2073         { .hw_value = 12, .center_freq = 5060},
2074         { .hw_value = 16, .center_freq = 5080},
2075         { .hw_value = 34, .center_freq = 5170},
2076         { .hw_value = 36, .center_freq = 5180},
2077         { .hw_value = 38, .center_freq = 5190},
2078         { .hw_value = 40, .center_freq = 5200},
2079         { .hw_value = 42, .center_freq = 5210},
2080         { .hw_value = 44, .center_freq = 5220},
2081         { .hw_value = 46, .center_freq = 5230},
2082         { .hw_value = 48, .center_freq = 5240},
2083         { .hw_value = 52, .center_freq = 5260},
2084         { .hw_value = 56, .center_freq = 5280},
2085         { .hw_value = 60, .center_freq = 5300},
2086         { .hw_value = 64, .center_freq = 5320},
2087         { .hw_value = 100, .center_freq = 5500},
2088         { .hw_value = 104, .center_freq = 5520},
2089         { .hw_value = 108, .center_freq = 5540},
2090         { .hw_value = 112, .center_freq = 5560},
2091         { .hw_value = 116, .center_freq = 5580},
2092         { .hw_value = 120, .center_freq = 5600},
2093         { .hw_value = 124, .center_freq = 5620},
2094         { .hw_value = 128, .center_freq = 5640},
2095         { .hw_value = 132, .center_freq = 5660},
2096         { .hw_value = 136, .center_freq = 5680},
2097         { .hw_value = 140, .center_freq = 5700},
2098         { .hw_value = 149, .center_freq = 5745},
2099         { .hw_value = 153, .center_freq = 5765},
2100         { .hw_value = 157, .center_freq = 5785},
2101         { .hw_value = 161, .center_freq = 5805},
2102         { .hw_value = 165, .center_freq = 5825},
2103 };
2104
2105 /* mapping to indexes for wl1271_rates_5ghz */
2106 const static u8 wl1271_rate_to_idx_5ghz[] = {
2107         /* MCS rates are used only with 11n */
2108         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS7 */
2109         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS6 */
2110         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS5 */
2111         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS4 */
2112         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS3 */
2113         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS2 */
2114         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS1 */
2115         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_MCS0 */
2116
2117         7,                             /* CONF_HW_RXTX_RATE_54   */
2118         6,                             /* CONF_HW_RXTX_RATE_48   */
2119         5,                             /* CONF_HW_RXTX_RATE_36   */
2120         4,                             /* CONF_HW_RXTX_RATE_24   */
2121
2122         /* TI-specific rate */
2123         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
2124
2125         3,                             /* CONF_HW_RXTX_RATE_18   */
2126         2,                             /* CONF_HW_RXTX_RATE_12   */
2127         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
2128         1,                             /* CONF_HW_RXTX_RATE_9    */
2129         0,                             /* CONF_HW_RXTX_RATE_6    */
2130         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
2131         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
2132         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
2133 };
2134
2135 static struct ieee80211_supported_band wl1271_band_5ghz = {
2136         .channels = wl1271_channels_5ghz,
2137         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
2138         .bitrates = wl1271_rates_5ghz,
2139         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
2140 };
2141
2142 const static u8 *wl1271_band_rate_to_idx[] = {
2143         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
2144         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
2145 };
2146
2147 static const struct ieee80211_ops wl1271_ops = {
2148         .start = wl1271_op_start,
2149         .stop = wl1271_op_stop,
2150         .add_interface = wl1271_op_add_interface,
2151         .remove_interface = wl1271_op_remove_interface,
2152         .config = wl1271_op_config,
2153         .prepare_multicast = wl1271_op_prepare_multicast,
2154         .configure_filter = wl1271_op_configure_filter,
2155         .tx = wl1271_op_tx,
2156         .set_key = wl1271_op_set_key,
2157         .hw_scan = wl1271_op_hw_scan,
2158         .bss_info_changed = wl1271_op_bss_info_changed,
2159         .set_rts_threshold = wl1271_op_set_rts_threshold,
2160         .conf_tx = wl1271_op_conf_tx,
2161         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
2162 };
2163
2164
2165 u8 wl1271_rate_to_idx(struct wl1271 *wl, int rate)
2166 {
2167         u8 idx;
2168
2169         BUG_ON(wl->band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
2170
2171         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
2172                 wl1271_error("Illegal RX rate from HW: %d", rate);
2173                 return 0;
2174         }
2175
2176         idx = wl1271_band_rate_to_idx[wl->band][rate];
2177         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
2178                 wl1271_error("Unsupported RX rate from HW: %d", rate);
2179                 return 0;
2180         }
2181
2182         return idx;
2183 }
2184
2185 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
2186                                                struct device_attribute *attr,
2187                                                char *buf)
2188 {
2189         struct wl1271 *wl = dev_get_drvdata(dev);
2190         ssize_t len;
2191
2192         /* FIXME: what's the maximum length of buf? page size?*/
2193         len = 500;
2194
2195         mutex_lock(&wl->mutex);
2196         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
2197                        wl->sg_enabled);
2198         mutex_unlock(&wl->mutex);
2199
2200         return len;
2201
2202 }
2203
2204 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
2205                                                 struct device_attribute *attr,
2206                                                 const char *buf, size_t count)
2207 {
2208         struct wl1271 *wl = dev_get_drvdata(dev);
2209         unsigned long res;
2210         int ret;
2211
2212         ret = strict_strtoul(buf, 10, &res);
2213
2214         if (ret < 0) {
2215                 wl1271_warning("incorrect value written to bt_coex_mode");
2216                 return count;
2217         }
2218
2219         mutex_lock(&wl->mutex);
2220
2221         res = !!res;
2222
2223         if (res == wl->sg_enabled)
2224                 goto out;
2225
2226         wl->sg_enabled = res;
2227
2228         if (wl->state == WL1271_STATE_OFF)
2229                 goto out;
2230
2231         ret = wl1271_ps_elp_wakeup(wl, false);
2232         if (ret < 0)
2233                 goto out;
2234
2235         wl1271_acx_sg_enable(wl, wl->sg_enabled);
2236         wl1271_ps_elp_sleep(wl);
2237
2238  out:
2239         mutex_unlock(&wl->mutex);
2240         return count;
2241 }
2242
2243 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
2244                    wl1271_sysfs_show_bt_coex_state,
2245                    wl1271_sysfs_store_bt_coex_state);
2246
2247 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
2248                                            struct device_attribute *attr,
2249                                            char *buf)
2250 {
2251         struct wl1271 *wl = dev_get_drvdata(dev);
2252         ssize_t len;
2253
2254         /* FIXME: what's the maximum length of buf? page size?*/
2255         len = 500;
2256
2257         mutex_lock(&wl->mutex);
2258         if (wl->hw_pg_ver >= 0)
2259                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
2260         else
2261                 len = snprintf(buf, len, "n/a\n");
2262         mutex_unlock(&wl->mutex);
2263
2264         return len;
2265 }
2266
2267 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
2268                    wl1271_sysfs_show_hw_pg_ver, NULL);
2269
2270 int wl1271_register_hw(struct wl1271 *wl)
2271 {
2272         int ret;
2273
2274         if (wl->mac80211_registered)
2275                 return 0;
2276
2277         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
2278
2279         ret = ieee80211_register_hw(wl->hw);
2280         if (ret < 0) {
2281                 wl1271_error("unable to register mac80211 hw: %d", ret);
2282                 return ret;
2283         }
2284
2285         wl->mac80211_registered = true;
2286
2287         wl1271_notice("loaded");
2288
2289         return 0;
2290 }
2291 EXPORT_SYMBOL_GPL(wl1271_register_hw);
2292
2293 void wl1271_unregister_hw(struct wl1271 *wl)
2294 {
2295         ieee80211_unregister_hw(wl->hw);
2296         wl->mac80211_registered = false;
2297
2298 }
2299 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
2300
2301 int wl1271_init_ieee80211(struct wl1271 *wl)
2302 {
2303         /* The tx descriptor buffer and the TKIP space. */
2304         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
2305                 sizeof(struct wl1271_tx_hw_descr);
2306
2307         /* unit us */
2308         /* FIXME: find a proper value */
2309         wl->hw->channel_change_time = 10000;
2310         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
2311
2312         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
2313                 IEEE80211_HW_BEACON_FILTER |
2314                 IEEE80211_HW_SUPPORTS_PS |
2315                 IEEE80211_HW_SUPPORTS_UAPSD |
2316                 IEEE80211_HW_HAS_RATE_CONTROL |
2317                 IEEE80211_HW_CONNECTION_MONITOR |
2318                 IEEE80211_HW_SUPPORTS_CQM_RSSI;
2319
2320         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2321                 BIT(NL80211_IFTYPE_ADHOC);
2322         wl->hw->wiphy->max_scan_ssids = 1;
2323         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &wl1271_band_2ghz;
2324
2325         if (wl1271_11a_enabled())
2326                 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &wl1271_band_5ghz;
2327
2328         wl->hw->queues = 4;
2329         wl->hw->max_rates = 1;
2330
2331         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
2332
2333         return 0;
2334 }
2335 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
2336
2337 #define WL1271_DEFAULT_CHANNEL 0
2338
2339 struct ieee80211_hw *wl1271_alloc_hw(void)
2340 {
2341         struct ieee80211_hw *hw;
2342         struct platform_device *plat_dev = NULL;
2343         struct wl1271 *wl;
2344         int i, ret;
2345
2346         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
2347         if (!hw) {
2348                 wl1271_error("could not alloc ieee80211_hw");
2349                 ret = -ENOMEM;
2350                 goto err_hw_alloc;
2351         }
2352
2353         plat_dev = kmalloc(sizeof(wl1271_device), GFP_KERNEL);
2354         if (!plat_dev) {
2355                 wl1271_error("could not allocate platform_device");
2356                 ret = -ENOMEM;
2357                 goto err_plat_alloc;
2358         }
2359
2360         memcpy(plat_dev, &wl1271_device, sizeof(wl1271_device));
2361
2362         wl = hw->priv;
2363         memset(wl, 0, sizeof(*wl));
2364
2365         INIT_LIST_HEAD(&wl->list);
2366
2367         wl->hw = hw;
2368         wl->plat_dev = plat_dev;
2369
2370         skb_queue_head_init(&wl->tx_queue);
2371
2372         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
2373         wl->channel = WL1271_DEFAULT_CHANNEL;
2374         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
2375         wl->default_key = 0;
2376         wl->rx_counter = 0;
2377         wl->rx_config = WL1271_DEFAULT_RX_CONFIG;
2378         wl->rx_filter = WL1271_DEFAULT_RX_FILTER;
2379         wl->psm_entry_retry = 0;
2380         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2381         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2382         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
2383         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
2384         wl->sta_rate_set = 0;
2385         wl->band = IEEE80211_BAND_2GHZ;
2386         wl->vif = NULL;
2387         wl->flags = 0;
2388         wl->sg_enabled = true;
2389         wl->hw_pg_ver = -1;
2390
2391         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
2392                 wl->tx_frames[i] = NULL;
2393
2394         spin_lock_init(&wl->wl_lock);
2395
2396         wl->state = WL1271_STATE_OFF;
2397         mutex_init(&wl->mutex);
2398
2399         /* Apply default driver configuration. */
2400         wl1271_conf_init(wl);
2401
2402         wl1271_debugfs_init(wl);
2403
2404         /* Register platform device */
2405         ret = platform_device_register(wl->plat_dev);
2406         if (ret) {
2407                 wl1271_error("couldn't register platform device");
2408                 goto err_hw;
2409         }
2410         dev_set_drvdata(&wl->plat_dev->dev, wl);
2411
2412         /* Create sysfs file to control bt coex state */
2413         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2414         if (ret < 0) {
2415                 wl1271_error("failed to create sysfs file bt_coex_state");
2416                 goto err_platform;
2417         }
2418
2419         /* Create sysfs file to get HW PG version */
2420         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
2421         if (ret < 0) {
2422                 wl1271_error("failed to create sysfs file hw_pg_ver");
2423                 goto err_bt_coex_state;
2424         }
2425
2426         return hw;
2427
2428 err_bt_coex_state:
2429         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
2430
2431 err_platform:
2432         platform_device_unregister(wl->plat_dev);
2433
2434 err_hw:
2435         wl1271_debugfs_exit(wl);
2436         kfree(plat_dev);
2437
2438 err_plat_alloc:
2439         ieee80211_free_hw(hw);
2440
2441 err_hw_alloc:
2442
2443         return ERR_PTR(ret);
2444 }
2445 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
2446
2447 int wl1271_free_hw(struct wl1271 *wl)
2448 {
2449         platform_device_unregister(wl->plat_dev);
2450         kfree(wl->plat_dev);
2451
2452         wl1271_debugfs_exit(wl);
2453
2454         vfree(wl->fw);
2455         wl->fw = NULL;
2456         kfree(wl->nvs);
2457         wl->nvs = NULL;
2458
2459         kfree(wl->fw_status);
2460         kfree(wl->tx_res_if);
2461
2462         ieee80211_free_hw(wl->hw);
2463
2464         return 0;
2465 }
2466 EXPORT_SYMBOL_GPL(wl1271_free_hw);
2467
2468 MODULE_LICENSE("GPL");
2469 MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
2470 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");