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