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