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