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