Merge branch 'for-linus' of git://git.kernel.dk/linux-block
[linux-2.6.git] / drivers / net / wireless / wl12xx / main.c
1 /*
2  * This file is part of wl1271
3  *
4  * Copyright (C) 2008-2010 Nokia Corporation
5  *
6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/delay.h>
27 #include <linux/spi/spi.h>
28 #include <linux/crc32.h>
29 #include <linux/etherdevice.h>
30 #include <linux/vmalloc.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
33 #include <linux/wl12xx.h>
34
35 #include "wl12xx.h"
36 #include "wl12xx_80211.h"
37 #include "reg.h"
38 #include "io.h"
39 #include "event.h"
40 #include "tx.h"
41 #include "rx.h"
42 #include "ps.h"
43 #include "init.h"
44 #include "debugfs.h"
45 #include "cmd.h"
46 #include "boot.h"
47 #include "testmode.h"
48 #include "scan.h"
49
50 #define WL1271_BOOT_RETRIES 3
51
52 static struct conf_drv_settings default_conf = {
53         .sg = {
54                 .sta_params = {
55                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
56                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
57                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
58                         [CONF_SG_BT_LOAD_RATIO]                     = 200,
59                         [CONF_SG_AUTO_PS_MODE]                      = 1,
60                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
61                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
62                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
63                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
64                         [CONF_SG_RATE_ADAPT_THRESH]                 = 12,
65                         [CONF_SG_RATE_ADAPT_SNR]                    = 0,
66                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
67                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 30,
68                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 8,
69                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
70                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 50,
71                         /* Note: with UPSD, this should be 4 */
72                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 8,
73                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
74                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
75                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 20,
76                         /* Note: with UPDS, this should be 15 */
77                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
78                         /* Note: with UPDS, this should be 50 */
79                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 40,
80                         /* Note: with UPDS, this should be 10 */
81                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 20,
82                         [CONF_SG_RXT]                               = 1200,
83                         [CONF_SG_TXT]                               = 1000,
84                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
85                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
86                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
87                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
88                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
89                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
90                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
91                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
92                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
93                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
94                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
95                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
96                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
97                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
98                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
99                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
100                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
101                         [CONF_SG_DHCP_TIME]                         = 5000,
102                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
103                 },
104                 .ap_params = {
105                         [CONF_SG_BT_PER_THRESHOLD]                  = 7500,
106                         [CONF_SG_HV3_MAX_OVERRIDE]                  = 0,
107                         [CONF_SG_BT_NFS_SAMPLE_INTERVAL]            = 400,
108                         [CONF_SG_BT_LOAD_RATIO]                     = 50,
109                         [CONF_SG_AUTO_PS_MODE]                      = 1,
110                         [CONF_SG_AUTO_SCAN_PROBE_REQ]               = 170,
111                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3]   = 50,
112                         [CONF_SG_ANTENNA_CONFIGURATION]             = 0,
113                         [CONF_SG_BEACON_MISS_PERCENT]               = 60,
114                         [CONF_SG_RATE_ADAPT_THRESH]                 = 64,
115                         [CONF_SG_RATE_ADAPT_SNR]                    = 1,
116                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR]      = 10,
117                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR]      = 25,
118                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR]      = 25,
119                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR]       = 20,
120                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR]       = 25,
121                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR]       = 25,
122                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR]     = 7,
123                         [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR]     = 25,
124                         [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR]     = 25,
125                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR]      = 8,
126                         [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR]      = 25,
127                         [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR]      = 25,
128                         [CONF_SG_RXT]                               = 1200,
129                         [CONF_SG_TXT]                               = 1000,
130                         [CONF_SG_ADAPTIVE_RXT_TXT]                  = 1,
131                         [CONF_SG_PS_POLL_TIMEOUT]                   = 10,
132                         [CONF_SG_UPSD_TIMEOUT]                      = 10,
133                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
134                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
135                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
136                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR]  = 8,
137                         [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR]  = 20,
138                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR]  = 15,
139                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR]         = 20,
140                         [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR]         = 50,
141                         [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR]         = 10,
142                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3]  = 200,
143                         [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
144                         [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME]         = 75,
145                         [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME]       = 15,
146                         [CONF_SG_HV3_MAX_SERVED]                    = 6,
147                         [CONF_SG_DHCP_TIME]                         = 5000,
148                         [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP]  = 100,
149                         [CONF_SG_TEMP_PARAM_1]                      = 0,
150                         [CONF_SG_TEMP_PARAM_2]                      = 0,
151                         [CONF_SG_TEMP_PARAM_3]                      = 0,
152                         [CONF_SG_TEMP_PARAM_4]                      = 0,
153                         [CONF_SG_TEMP_PARAM_5]                      = 0,
154                         [CONF_SG_AP_BEACON_MISS_TX]                 = 3,
155                         [CONF_SG_RX_WINDOW_LENGTH]                  = 6,
156                         [CONF_SG_AP_CONNECTION_PROTECTION_TIME]     = 50,
157                         [CONF_SG_TEMP_PARAM_6]                      = 1,
158                 },
159                 .state = CONF_SG_PROTECTIVE,
160         },
161         .rx = {
162                 .rx_msdu_life_time           = 512000,
163                 .packet_detection_threshold  = 0,
164                 .ps_poll_timeout             = 15,
165                 .upsd_timeout                = 15,
166                 .rts_threshold               = IEEE80211_MAX_RTS_THRESHOLD,
167                 .rx_cca_threshold            = 0,
168                 .irq_blk_threshold           = 0xFFFF,
169                 .irq_pkt_threshold           = 0,
170                 .irq_timeout                 = 600,
171                 .queue_type                  = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
172         },
173         .tx = {
174                 .tx_energy_detection         = 0,
175                 .sta_rc_conf                 = {
176                         .enabled_rates       = 0,
177                         .short_retry_limit   = 10,
178                         .long_retry_limit    = 10,
179                         .aflags              = 0,
180                 },
181                 .ac_conf_count               = 4,
182                 .ac_conf                     = {
183                         [CONF_TX_AC_BE] = {
184                                 .ac          = CONF_TX_AC_BE,
185                                 .cw_min      = 15,
186                                 .cw_max      = 63,
187                                 .aifsn       = 3,
188                                 .tx_op_limit = 0,
189                         },
190                         [CONF_TX_AC_BK] = {
191                                 .ac          = CONF_TX_AC_BK,
192                                 .cw_min      = 15,
193                                 .cw_max      = 63,
194                                 .aifsn       = 7,
195                                 .tx_op_limit = 0,
196                         },
197                         [CONF_TX_AC_VI] = {
198                                 .ac          = CONF_TX_AC_VI,
199                                 .cw_min      = 15,
200                                 .cw_max      = 63,
201                                 .aifsn       = CONF_TX_AIFS_PIFS,
202                                 .tx_op_limit = 3008,
203                         },
204                         [CONF_TX_AC_VO] = {
205                                 .ac          = CONF_TX_AC_VO,
206                                 .cw_min      = 15,
207                                 .cw_max      = 63,
208                                 .aifsn       = CONF_TX_AIFS_PIFS,
209                                 .tx_op_limit = 1504,
210                         },
211                 },
212                 .ap_max_tx_retries = 100,
213                 .tid_conf_count = 4,
214                 .tid_conf = {
215                         [CONF_TX_AC_BE] = {
216                                 .queue_id    = CONF_TX_AC_BE,
217                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
218                                 .tsid        = CONF_TX_AC_BE,
219                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
220                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
221                                 .apsd_conf   = {0, 0},
222                         },
223                         [CONF_TX_AC_BK] = {
224                                 .queue_id    = CONF_TX_AC_BK,
225                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
226                                 .tsid        = CONF_TX_AC_BK,
227                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
228                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
229                                 .apsd_conf   = {0, 0},
230                         },
231                         [CONF_TX_AC_VI] = {
232                                 .queue_id    = CONF_TX_AC_VI,
233                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
234                                 .tsid        = CONF_TX_AC_VI,
235                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
236                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
237                                 .apsd_conf   = {0, 0},
238                         },
239                         [CONF_TX_AC_VO] = {
240                                 .queue_id    = CONF_TX_AC_VO,
241                                 .channel_type = CONF_CHANNEL_TYPE_EDCF,
242                                 .tsid        = CONF_TX_AC_VO,
243                                 .ps_scheme   = CONF_PS_SCHEME_LEGACY,
244                                 .ack_policy  = CONF_ACK_POLICY_LEGACY,
245                                 .apsd_conf   = {0, 0},
246                         },
247                 },
248                 .frag_threshold              = IEEE80211_MAX_FRAG_THRESHOLD,
249                 .tx_compl_timeout            = 700,
250                 .tx_compl_threshold          = 4,
251                 .basic_rate                  = CONF_HW_BIT_RATE_1MBPS,
252                 .basic_rate_5                = CONF_HW_BIT_RATE_6MBPS,
253                 .tmpl_short_retry_limit      = 10,
254                 .tmpl_long_retry_limit       = 10,
255         },
256         .conn = {
257                 .wake_up_event               = CONF_WAKE_UP_EVENT_DTIM,
258                 .listen_interval             = 1,
259                 .bcn_filt_mode               = CONF_BCN_FILT_MODE_ENABLED,
260                 .bcn_filt_ie_count           = 2,
261                 .bcn_filt_ie = {
262                         [0] = {
263                                 .ie          = WLAN_EID_CHANNEL_SWITCH,
264                                 .rule        = CONF_BCN_RULE_PASS_ON_APPEARANCE,
265                         },
266                         [1] = {
267                                 .ie          = WLAN_EID_HT_INFORMATION,
268                                 .rule        = CONF_BCN_RULE_PASS_ON_CHANGE,
269                         },
270                 },
271                 .synch_fail_thold            = 10,
272                 .bss_lose_timeout            = 100,
273                 .beacon_rx_timeout           = 10000,
274                 .broadcast_timeout           = 20000,
275                 .rx_broadcast_in_ps          = 1,
276                 .ps_poll_threshold           = 10,
277                 .ps_poll_recovery_period     = 700,
278                 .bet_enable                  = CONF_BET_MODE_ENABLE,
279                 .bet_max_consecutive         = 50,
280                 .psm_entry_retries           = 5,
281                 .psm_exit_retries            = 16,
282                 .psm_entry_nullfunc_retries  = 3,
283                 .psm_entry_hangover_period   = 1,
284                 .keep_alive_interval         = 55000,
285                 .max_listen_interval         = 20,
286         },
287         .itrim = {
288                 .enable = false,
289                 .timeout = 50000,
290         },
291         .pm_config = {
292                 .host_clk_settling_time = 5000,
293                 .host_fast_wakeup_support = false
294         },
295         .roam_trigger = {
296                 .trigger_pacing               = 1,
297                 .avg_weight_rssi_beacon       = 20,
298                 .avg_weight_rssi_data         = 10,
299                 .avg_weight_snr_beacon        = 20,
300                 .avg_weight_snr_data          = 10,
301         },
302         .scan = {
303                 .min_dwell_time_active        = 7500,
304                 .max_dwell_time_active        = 30000,
305                 .min_dwell_time_passive       = 100000,
306                 .max_dwell_time_passive       = 100000,
307                 .num_probe_reqs               = 2,
308         },
309         .sched_scan = {
310                 /* sched_scan requires dwell times in TU instead of TU/1000 */
311                 .min_dwell_time_active = 8,
312                 .max_dwell_time_active = 30,
313                 .dwell_time_passive    = 100,
314                 .num_probe_reqs        = 2,
315                 .rssi_threshold        = -90,
316                 .snr_threshold         = 0,
317         },
318         .rf = {
319                 .tx_per_channel_power_compensation_2 = {
320                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321                 },
322                 .tx_per_channel_power_compensation_5 = {
323                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
325                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326                 },
327         },
328         .ht = {
329                 .tx_ba_win_size = 64,
330                 .inactivity_timeout = 10000,
331         },
332         .mem_wl127x = {
333                 .num_stations                 = 1,
334                 .ssid_profiles                = 1,
335                 .rx_block_num                 = 70,
336                 .tx_min_block_num             = 40,
337                 .dynamic_memory               = 1,
338                 .min_req_tx_blocks            = 100,
339                 .min_req_rx_blocks            = 22,
340                 .tx_min                       = 27,
341         },
342         .mem_wl128x = {
343                 .num_stations                 = 1,
344                 .ssid_profiles                = 1,
345                 .rx_block_num                 = 40,
346                 .tx_min_block_num             = 40,
347                 .dynamic_memory               = 1,
348                 .min_req_tx_blocks            = 45,
349                 .min_req_rx_blocks            = 22,
350                 .tx_min                       = 27,
351         },
352         .fm_coex = {
353                 .enable                       = true,
354                 .swallow_period               = 5,
355                 .n_divider_fref_set_1         = 0xff,       /* default */
356                 .n_divider_fref_set_2         = 12,
357                 .m_divider_fref_set_1         = 148,
358                 .m_divider_fref_set_2         = 0xffff,     /* default */
359                 .coex_pll_stabilization_time  = 0xffffffff, /* default */
360                 .ldo_stabilization_time       = 0xffff,     /* default */
361                 .fm_disturbed_band_margin     = 0xff,       /* default */
362                 .swallow_clk_diff             = 0xff,       /* default */
363         },
364         .hci_io_ds = HCI_IO_DS_6MA,
365 };
366
367 static void __wl1271_op_remove_interface(struct wl1271 *wl,
368                                          bool reset_tx_queues);
369 static void wl1271_free_ap_keys(struct wl1271 *wl);
370
371
372 static void wl1271_device_release(struct device *dev)
373 {
374
375 }
376
377 static struct platform_device wl1271_device = {
378         .name           = "wl1271",
379         .id             = -1,
380
381         /* device model insists to have a release function */
382         .dev            = {
383                 .release = wl1271_device_release,
384         },
385 };
386
387 static DEFINE_MUTEX(wl_list_mutex);
388 static LIST_HEAD(wl_list);
389
390 static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
391                              void *arg)
392 {
393         struct net_device *dev = arg;
394         struct wireless_dev *wdev;
395         struct wiphy *wiphy;
396         struct ieee80211_hw *hw;
397         struct wl1271 *wl;
398         struct wl1271 *wl_temp;
399         int ret = 0;
400
401         /* Check that this notification is for us. */
402         if (what != NETDEV_CHANGE)
403                 return NOTIFY_DONE;
404
405         wdev = dev->ieee80211_ptr;
406         if (wdev == NULL)
407                 return NOTIFY_DONE;
408
409         wiphy = wdev->wiphy;
410         if (wiphy == NULL)
411                 return NOTIFY_DONE;
412
413         hw = wiphy_priv(wiphy);
414         if (hw == NULL)
415                 return NOTIFY_DONE;
416
417         wl_temp = hw->priv;
418         mutex_lock(&wl_list_mutex);
419         list_for_each_entry(wl, &wl_list, list) {
420                 if (wl == wl_temp)
421                         break;
422         }
423         mutex_unlock(&wl_list_mutex);
424         if (wl != wl_temp)
425                 return NOTIFY_DONE;
426
427         mutex_lock(&wl->mutex);
428
429         if (wl->state == WL1271_STATE_OFF)
430                 goto out;
431
432         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
433                 goto out;
434
435         ret = wl1271_ps_elp_wakeup(wl);
436         if (ret < 0)
437                 goto out;
438
439         if ((dev->operstate == IF_OPER_UP) &&
440             !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
441                 wl1271_cmd_set_sta_state(wl);
442                 wl1271_info("Association completed.");
443         }
444
445         wl1271_ps_elp_sleep(wl);
446
447 out:
448         mutex_unlock(&wl->mutex);
449
450         return NOTIFY_OK;
451 }
452
453 static int wl1271_reg_notify(struct wiphy *wiphy,
454                              struct regulatory_request *request)
455 {
456         struct ieee80211_supported_band *band;
457         struct ieee80211_channel *ch;
458         int i;
459
460         band = wiphy->bands[IEEE80211_BAND_5GHZ];
461         for (i = 0; i < band->n_channels; i++) {
462                 ch = &band->channels[i];
463                 if (ch->flags & IEEE80211_CHAN_DISABLED)
464                         continue;
465
466                 if (ch->flags & IEEE80211_CHAN_RADAR)
467                         ch->flags |= IEEE80211_CHAN_NO_IBSS |
468                                      IEEE80211_CHAN_PASSIVE_SCAN;
469
470         }
471
472         return 0;
473 }
474
475 static void wl1271_conf_init(struct wl1271 *wl)
476 {
477
478         /*
479          * This function applies the default configuration to the driver. This
480          * function is invoked upon driver load (spi probe.)
481          *
482          * The configuration is stored in a run-time structure in order to
483          * facilitate for run-time adjustment of any of the parameters. Making
484          * changes to the configuration structure will apply the new values on
485          * the next interface up (wl1271_op_start.)
486          */
487
488         /* apply driver default configuration */
489         memcpy(&wl->conf, &default_conf, sizeof(default_conf));
490 }
491
492
493 static int wl1271_plt_init(struct wl1271 *wl)
494 {
495         struct conf_tx_ac_category *conf_ac;
496         struct conf_tx_tid *conf_tid;
497         int ret, i;
498
499         if (wl->chip.id == CHIP_ID_1283_PG20)
500                 ret = wl128x_cmd_general_parms(wl);
501         else
502                 ret = wl1271_cmd_general_parms(wl);
503         if (ret < 0)
504                 return ret;
505
506         if (wl->chip.id == CHIP_ID_1283_PG20)
507                 ret = wl128x_cmd_radio_parms(wl);
508         else
509                 ret = wl1271_cmd_radio_parms(wl);
510         if (ret < 0)
511                 return ret;
512
513         if (wl->chip.id != CHIP_ID_1283_PG20) {
514                 ret = wl1271_cmd_ext_radio_parms(wl);
515                 if (ret < 0)
516                         return ret;
517         }
518         if (ret < 0)
519                 return ret;
520
521         /* Chip-specific initializations */
522         ret = wl1271_chip_specific_init(wl);
523         if (ret < 0)
524                 return ret;
525
526         ret = wl1271_sta_init_templates_config(wl);
527         if (ret < 0)
528                 return ret;
529
530         ret = wl1271_acx_init_mem_config(wl);
531         if (ret < 0)
532                 return ret;
533
534         /* PHY layer config */
535         ret = wl1271_init_phy_config(wl);
536         if (ret < 0)
537                 goto out_free_memmap;
538
539         ret = wl1271_acx_dco_itrim_params(wl);
540         if (ret < 0)
541                 goto out_free_memmap;
542
543         /* Initialize connection monitoring thresholds */
544         ret = wl1271_acx_conn_monit_params(wl, false);
545         if (ret < 0)
546                 goto out_free_memmap;
547
548         /* Bluetooth WLAN coexistence */
549         ret = wl1271_init_pta(wl);
550         if (ret < 0)
551                 goto out_free_memmap;
552
553         /* FM WLAN coexistence */
554         ret = wl1271_acx_fm_coex(wl);
555         if (ret < 0)
556                 goto out_free_memmap;
557
558         /* Energy detection */
559         ret = wl1271_init_energy_detection(wl);
560         if (ret < 0)
561                 goto out_free_memmap;
562
563         ret = wl1271_acx_sta_mem_cfg(wl);
564         if (ret < 0)
565                 goto out_free_memmap;
566
567         /* Default fragmentation threshold */
568         ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
569         if (ret < 0)
570                 goto out_free_memmap;
571
572         /* Default TID/AC configuration */
573         BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
574         for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
575                 conf_ac = &wl->conf.tx.ac_conf[i];
576                 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
577                                         conf_ac->cw_max, conf_ac->aifsn,
578                                         conf_ac->tx_op_limit);
579                 if (ret < 0)
580                         goto out_free_memmap;
581
582                 conf_tid = &wl->conf.tx.tid_conf[i];
583                 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
584                                          conf_tid->channel_type,
585                                          conf_tid->tsid,
586                                          conf_tid->ps_scheme,
587                                          conf_tid->ack_policy,
588                                          conf_tid->apsd_conf[0],
589                                          conf_tid->apsd_conf[1]);
590                 if (ret < 0)
591                         goto out_free_memmap;
592         }
593
594         /* Enable data path */
595         ret = wl1271_cmd_data_path(wl, 1);
596         if (ret < 0)
597                 goto out_free_memmap;
598
599         /* Configure for CAM power saving (ie. always active) */
600         ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
601         if (ret < 0)
602                 goto out_free_memmap;
603
604         /* configure PM */
605         ret = wl1271_acx_pm_config(wl);
606         if (ret < 0)
607                 goto out_free_memmap;
608
609         return 0;
610
611  out_free_memmap:
612         kfree(wl->target_mem_map);
613         wl->target_mem_map = NULL;
614
615         return ret;
616 }
617
618 static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
619 {
620         bool fw_ps;
621
622         /* only regulate station links */
623         if (hlid < WL1271_AP_STA_HLID_START)
624                 return;
625
626         fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
627
628         /*
629          * Wake up from high level PS if the STA is asleep with too little
630          * blocks in FW or if the STA is awake.
631          */
632         if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
633                 wl1271_ps_link_end(wl, hlid);
634
635         /* Start high-level PS if the STA is asleep with enough blocks in FW */
636         else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
637                 wl1271_ps_link_start(wl, hlid, true);
638 }
639
640 static void wl1271_irq_update_links_status(struct wl1271 *wl,
641                                        struct wl1271_fw_ap_status *status)
642 {
643         u32 cur_fw_ps_map;
644         u8 hlid;
645
646         cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
647         if (wl->ap_fw_ps_map != cur_fw_ps_map) {
648                 wl1271_debug(DEBUG_PSM,
649                              "link ps prev 0x%x cur 0x%x changed 0x%x",
650                              wl->ap_fw_ps_map, cur_fw_ps_map,
651                              wl->ap_fw_ps_map ^ cur_fw_ps_map);
652
653                 wl->ap_fw_ps_map = cur_fw_ps_map;
654         }
655
656         for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
657                 u8 cnt = status->tx_lnk_free_blks[hlid] -
658                         wl->links[hlid].prev_freed_blks;
659
660                 wl->links[hlid].prev_freed_blks =
661                         status->tx_lnk_free_blks[hlid];
662                 wl->links[hlid].allocated_blks -= cnt;
663
664                 wl1271_irq_ps_regulate_link(wl, hlid,
665                                             wl->links[hlid].allocated_blks);
666         }
667 }
668
669 static void wl1271_fw_status(struct wl1271 *wl,
670                              struct wl1271_fw_full_status *full_status)
671 {
672         struct wl1271_fw_common_status *status = &full_status->common;
673         struct timespec ts;
674         u32 old_tx_blk_count = wl->tx_blocks_available;
675         u32 freed_blocks = 0;
676         int i;
677
678         if (wl->bss_type == BSS_TYPE_AP_BSS) {
679                 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
680                                 sizeof(struct wl1271_fw_ap_status), false);
681         } else {
682                 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
683                                 sizeof(struct wl1271_fw_sta_status), false);
684         }
685
686         wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
687                      "drv_rx_counter = %d, tx_results_counter = %d)",
688                      status->intr,
689                      status->fw_rx_counter,
690                      status->drv_rx_counter,
691                      status->tx_results_counter);
692
693         /* update number of available TX blocks */
694         for (i = 0; i < NUM_TX_QUEUES; i++) {
695                 freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
696                                 wl->tx_blocks_freed[i];
697
698                 wl->tx_blocks_freed[i] =
699                         le32_to_cpu(status->tx_released_blks[i]);
700         }
701
702         wl->tx_allocated_blocks -= freed_blocks;
703
704         if (wl->bss_type == BSS_TYPE_AP_BSS) {
705                 /* Update num of allocated TX blocks per link and ps status */
706                 wl1271_irq_update_links_status(wl, &full_status->ap);
707                 wl->tx_blocks_available += freed_blocks;
708         } else {
709                 int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
710
711                 /*
712                  * The FW might change the total number of TX memblocks before
713                  * we get a notification about blocks being released. Thus, the
714                  * available blocks calculation might yield a temporary result
715                  * which is lower than the actual available blocks. Keeping in
716                  * mind that only blocks that were allocated can be moved from
717                  * TX to RX, tx_blocks_available should never decrease here.
718                  */
719                 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
720                                               avail);
721         }
722
723         /* if more blocks are available now, tx work can be scheduled */
724         if (wl->tx_blocks_available > old_tx_blk_count)
725                 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
726
727         /* update the host-chipset time offset */
728         getnstimeofday(&ts);
729         wl->time_offset = (timespec_to_ns(&ts) >> 10) -
730                 (s64)le32_to_cpu(status->fw_localtime);
731 }
732
733 static void wl1271_flush_deferred_work(struct wl1271 *wl)
734 {
735         struct sk_buff *skb;
736
737         /* Pass all received frames to the network stack */
738         while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
739                 ieee80211_rx_ni(wl->hw, skb);
740
741         /* Return sent skbs to the network stack */
742         while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
743                 ieee80211_tx_status(wl->hw, skb);
744 }
745
746 static void wl1271_netstack_work(struct work_struct *work)
747 {
748         struct wl1271 *wl =
749                 container_of(work, struct wl1271, netstack_work);
750
751         do {
752                 wl1271_flush_deferred_work(wl);
753         } while (skb_queue_len(&wl->deferred_rx_queue));
754 }
755
756 #define WL1271_IRQ_MAX_LOOPS 256
757
758 irqreturn_t wl1271_irq(int irq, void *cookie)
759 {
760         int ret;
761         u32 intr;
762         int loopcount = WL1271_IRQ_MAX_LOOPS;
763         struct wl1271 *wl = (struct wl1271 *)cookie;
764         bool done = false;
765         unsigned int defer_count;
766         unsigned long flags;
767
768         /* TX might be handled here, avoid redundant work */
769         set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
770         cancel_work_sync(&wl->tx_work);
771
772         /*
773          * In case edge triggered interrupt must be used, we cannot iterate
774          * more than once without introducing race conditions with the hardirq.
775          */
776         if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
777                 loopcount = 1;
778
779         mutex_lock(&wl->mutex);
780
781         wl1271_debug(DEBUG_IRQ, "IRQ work");
782
783         if (unlikely(wl->state == WL1271_STATE_OFF))
784                 goto out;
785
786         ret = wl1271_ps_elp_wakeup(wl);
787         if (ret < 0)
788                 goto out;
789
790         while (!done && loopcount--) {
791                 /*
792                  * In order to avoid a race with the hardirq, clear the flag
793                  * before acknowledging the chip. Since the mutex is held,
794                  * wl1271_ps_elp_wakeup cannot be called concurrently.
795                  */
796                 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
797                 smp_mb__after_clear_bit();
798
799                 wl1271_fw_status(wl, wl->fw_status);
800                 intr = le32_to_cpu(wl->fw_status->common.intr);
801                 intr &= WL1271_INTR_MASK;
802                 if (!intr) {
803                         done = true;
804                         continue;
805                 }
806
807                 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
808                         wl1271_error("watchdog interrupt received! "
809                                      "starting recovery.");
810                         ieee80211_queue_work(wl->hw, &wl->recovery_work);
811
812                         /* restarting the chip. ignore any other interrupt. */
813                         goto out;
814                 }
815
816                 if (likely(intr & WL1271_ACX_INTR_DATA)) {
817                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
818
819                         wl1271_rx(wl, &wl->fw_status->common);
820
821                         /* Check if any tx blocks were freed */
822                         spin_lock_irqsave(&wl->wl_lock, flags);
823                         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
824                             wl->tx_queue_count) {
825                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
826                                 /*
827                                  * In order to avoid starvation of the TX path,
828                                  * call the work function directly.
829                                  */
830                                 wl1271_tx_work_locked(wl);
831                         } else {
832                                 spin_unlock_irqrestore(&wl->wl_lock, flags);
833                         }
834
835                         /* check for tx results */
836                         if (wl->fw_status->common.tx_results_counter !=
837                             (wl->tx_results_count & 0xff))
838                                 wl1271_tx_complete(wl);
839
840                         /* Make sure the deferred queues don't get too long */
841                         defer_count = skb_queue_len(&wl->deferred_tx_queue) +
842                                       skb_queue_len(&wl->deferred_rx_queue);
843                         if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
844                                 wl1271_flush_deferred_work(wl);
845                 }
846
847                 if (intr & WL1271_ACX_INTR_EVENT_A) {
848                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
849                         wl1271_event_handle(wl, 0);
850                 }
851
852                 if (intr & WL1271_ACX_INTR_EVENT_B) {
853                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
854                         wl1271_event_handle(wl, 1);
855                 }
856
857                 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
858                         wl1271_debug(DEBUG_IRQ,
859                                      "WL1271_ACX_INTR_INIT_COMPLETE");
860
861                 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
862                         wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
863         }
864
865         wl1271_ps_elp_sleep(wl);
866
867 out:
868         spin_lock_irqsave(&wl->wl_lock, flags);
869         /* In case TX was not handled here, queue TX work */
870         clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
871         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
872             wl->tx_queue_count)
873                 ieee80211_queue_work(wl->hw, &wl->tx_work);
874         spin_unlock_irqrestore(&wl->wl_lock, flags);
875
876         mutex_unlock(&wl->mutex);
877
878         return IRQ_HANDLED;
879 }
880 EXPORT_SYMBOL_GPL(wl1271_irq);
881
882 static int wl1271_fetch_firmware(struct wl1271 *wl)
883 {
884         const struct firmware *fw;
885         const char *fw_name;
886         int ret;
887
888         switch (wl->bss_type) {
889         case BSS_TYPE_AP_BSS:
890                 if (wl->chip.id == CHIP_ID_1283_PG20)
891                         fw_name = WL128X_AP_FW_NAME;
892                 else
893                         fw_name = WL127X_AP_FW_NAME;
894                 break;
895         case BSS_TYPE_IBSS:
896         case BSS_TYPE_STA_BSS:
897                 if (wl->chip.id == CHIP_ID_1283_PG20)
898                         fw_name = WL128X_FW_NAME;
899                 else
900                         fw_name = WL1271_FW_NAME;
901                 break;
902         default:
903                 wl1271_error("no compatible firmware for bss_type %d",
904                              wl->bss_type);
905                 return -EINVAL;
906         }
907
908         wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
909
910         ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
911
912         if (ret < 0) {
913                 wl1271_error("could not get firmware: %d", ret);
914                 return ret;
915         }
916
917         if (fw->size % 4) {
918                 wl1271_error("firmware size is not multiple of 32 bits: %zu",
919                              fw->size);
920                 ret = -EILSEQ;
921                 goto out;
922         }
923
924         vfree(wl->fw);
925         wl->fw_len = fw->size;
926         wl->fw = vmalloc(wl->fw_len);
927
928         if (!wl->fw) {
929                 wl1271_error("could not allocate memory for the firmware");
930                 ret = -ENOMEM;
931                 goto out;
932         }
933
934         memcpy(wl->fw, fw->data, wl->fw_len);
935         wl->fw_bss_type = wl->bss_type;
936         ret = 0;
937
938 out:
939         release_firmware(fw);
940
941         return ret;
942 }
943
944 static int wl1271_fetch_nvs(struct wl1271 *wl)
945 {
946         const struct firmware *fw;
947         int ret;
948
949         ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
950
951         if (ret < 0) {
952                 wl1271_error("could not get nvs file: %d", ret);
953                 return ret;
954         }
955
956         wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
957
958         if (!wl->nvs) {
959                 wl1271_error("could not allocate memory for the nvs file");
960                 ret = -ENOMEM;
961                 goto out;
962         }
963
964         wl->nvs_len = fw->size;
965
966 out:
967         release_firmware(fw);
968
969         return ret;
970 }
971
972 static void wl1271_recovery_work(struct work_struct *work)
973 {
974         struct wl1271 *wl =
975                 container_of(work, struct wl1271, recovery_work);
976
977         mutex_lock(&wl->mutex);
978
979         if (wl->state != WL1271_STATE_ON)
980                 goto out;
981
982         wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
983                     wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
984
985         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
986                 ieee80211_connection_loss(wl->vif);
987
988         /* Prevent spurious TX during FW restart */
989         ieee80211_stop_queues(wl->hw);
990
991         if (wl->sched_scanning) {
992                 ieee80211_sched_scan_stopped(wl->hw);
993                 wl->sched_scanning = false;
994         }
995
996         /* reboot the chipset */
997         __wl1271_op_remove_interface(wl, false);
998         ieee80211_restart_hw(wl->hw);
999
1000         /*
1001          * Its safe to enable TX now - the queues are stopped after a request
1002          * to restart the HW.
1003          */
1004         ieee80211_wake_queues(wl->hw);
1005
1006 out:
1007         mutex_unlock(&wl->mutex);
1008 }
1009
1010 static void wl1271_fw_wakeup(struct wl1271 *wl)
1011 {
1012         u32 elp_reg;
1013
1014         elp_reg = ELPCTRL_WAKE_UP;
1015         wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
1016 }
1017
1018 static int wl1271_setup(struct wl1271 *wl)
1019 {
1020         wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1021         if (!wl->fw_status)
1022                 return -ENOMEM;
1023
1024         wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1025         if (!wl->tx_res_if) {
1026                 kfree(wl->fw_status);
1027                 return -ENOMEM;
1028         }
1029
1030         return 0;
1031 }
1032
1033 static int wl1271_chip_wakeup(struct wl1271 *wl)
1034 {
1035         struct wl1271_partition_set partition;
1036         int ret = 0;
1037
1038         msleep(WL1271_PRE_POWER_ON_SLEEP);
1039         ret = wl1271_power_on(wl);
1040         if (ret < 0)
1041                 goto out;
1042         msleep(WL1271_POWER_ON_SLEEP);
1043         wl1271_io_reset(wl);
1044         wl1271_io_init(wl);
1045
1046         /* We don't need a real memory partition here, because we only want
1047          * to use the registers at this point. */
1048         memset(&partition, 0, sizeof(partition));
1049         partition.reg.start = REGISTERS_BASE;
1050         partition.reg.size = REGISTERS_DOWN_SIZE;
1051         wl1271_set_partition(wl, &partition);
1052
1053         /* ELP module wake up */
1054         wl1271_fw_wakeup(wl);
1055
1056         /* whal_FwCtrl_BootSm() */
1057
1058         /* 0. read chip id from CHIP_ID */
1059         wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
1060
1061         /* 1. check if chip id is valid */
1062
1063         switch (wl->chip.id) {
1064         case CHIP_ID_1271_PG10:
1065                 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1066                                wl->chip.id);
1067
1068                 ret = wl1271_setup(wl);
1069                 if (ret < 0)
1070                         goto out;
1071                 break;
1072         case CHIP_ID_1271_PG20:
1073                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1074                              wl->chip.id);
1075
1076                 /* end-of-transaction flag should be set in wl127x AP mode */
1077                 if (wl->bss_type == BSS_TYPE_AP_BSS)
1078                         wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;
1079
1080                 ret = wl1271_setup(wl);
1081                 if (ret < 0)
1082                         goto out;
1083                 break;
1084         case CHIP_ID_1283_PG20:
1085                 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1086                              wl->chip.id);
1087
1088                 ret = wl1271_setup(wl);
1089                 if (ret < 0)
1090                         goto out;
1091                 if (wl1271_set_block_size(wl))
1092                         wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
1093                 break;
1094         case CHIP_ID_1283_PG10:
1095         default:
1096                 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
1097                 ret = -ENODEV;
1098                 goto out;
1099         }
1100
1101         /* Make sure the firmware type matches the BSS type */
1102         if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
1103                 ret = wl1271_fetch_firmware(wl);
1104                 if (ret < 0)
1105                         goto out;
1106         }
1107
1108         /* No NVS from netlink, try to get it from the filesystem */
1109         if (wl->nvs == NULL) {
1110                 ret = wl1271_fetch_nvs(wl);
1111                 if (ret < 0)
1112                         goto out;
1113         }
1114
1115 out:
1116         return ret;
1117 }
1118
1119 static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1120 {
1121         unsigned int quirks = 0;
1122         unsigned int *fw_ver = wl->chip.fw_ver;
1123
1124         /* Only for wl127x */
1125         if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1126             /* Check STA version */
1127             (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1128               (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1129              /* Check AP version */
1130              ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1131               (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1132                 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1133
1134         return quirks;
1135 }
1136
1137 int wl1271_plt_start(struct wl1271 *wl)
1138 {
1139         int retries = WL1271_BOOT_RETRIES;
1140         int ret;
1141
1142         mutex_lock(&wl->mutex);
1143
1144         wl1271_notice("power up");
1145
1146         if (wl->state != WL1271_STATE_OFF) {
1147                 wl1271_error("cannot go into PLT state because not "
1148                              "in off state: %d", wl->state);
1149                 ret = -EBUSY;
1150                 goto out;
1151         }
1152
1153         wl->bss_type = BSS_TYPE_STA_BSS;
1154
1155         while (retries) {
1156                 retries--;
1157                 ret = wl1271_chip_wakeup(wl);
1158                 if (ret < 0)
1159                         goto power_off;
1160
1161                 ret = wl1271_boot(wl);
1162                 if (ret < 0)
1163                         goto power_off;
1164
1165                 ret = wl1271_plt_init(wl);
1166                 if (ret < 0)
1167                         goto irq_disable;
1168
1169                 wl->state = WL1271_STATE_PLT;
1170                 wl1271_notice("firmware booted in PLT mode (%s)",
1171                               wl->chip.fw_ver_str);
1172
1173                 /* Check if any quirks are needed with older fw versions */
1174                 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1175                 goto out;
1176
1177 irq_disable:
1178                 mutex_unlock(&wl->mutex);
1179                 /* Unlocking the mutex in the middle of handling is
1180                    inherently unsafe. In this case we deem it safe to do,
1181                    because we need to let any possibly pending IRQ out of
1182                    the system (and while we are WL1271_STATE_OFF the IRQ
1183                    work function will not do anything.) Also, any other
1184                    possible concurrent operations will fail due to the
1185                    current state, hence the wl1271 struct should be safe. */
1186                 wl1271_disable_interrupts(wl);
1187                 wl1271_flush_deferred_work(wl);
1188                 cancel_work_sync(&wl->netstack_work);
1189                 mutex_lock(&wl->mutex);
1190 power_off:
1191                 wl1271_power_off(wl);
1192         }
1193
1194         wl1271_error("firmware boot in PLT mode failed despite %d retries",
1195                      WL1271_BOOT_RETRIES);
1196 out:
1197         mutex_unlock(&wl->mutex);
1198
1199         return ret;
1200 }
1201
1202 static int __wl1271_plt_stop(struct wl1271 *wl)
1203 {
1204         int ret = 0;
1205
1206         wl1271_notice("power down");
1207
1208         if (wl->state != WL1271_STATE_PLT) {
1209                 wl1271_error("cannot power down because not in PLT "
1210                              "state: %d", wl->state);
1211                 ret = -EBUSY;
1212                 goto out;
1213         }
1214
1215         wl1271_power_off(wl);
1216
1217         wl->state = WL1271_STATE_OFF;
1218         wl->rx_counter = 0;
1219
1220         mutex_unlock(&wl->mutex);
1221         wl1271_disable_interrupts(wl);
1222         wl1271_flush_deferred_work(wl);
1223         cancel_work_sync(&wl->netstack_work);
1224         cancel_work_sync(&wl->recovery_work);
1225         mutex_lock(&wl->mutex);
1226 out:
1227         return ret;
1228 }
1229
1230 int wl1271_plt_stop(struct wl1271 *wl)
1231 {
1232         int ret;
1233
1234         mutex_lock(&wl->mutex);
1235         ret = __wl1271_plt_stop(wl);
1236         mutex_unlock(&wl->mutex);
1237         return ret;
1238 }
1239
1240 static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
1241 {
1242         struct wl1271 *wl = hw->priv;
1243         unsigned long flags;
1244         int q;
1245         u8 hlid = 0;
1246
1247         q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1248
1249         if (wl->bss_type == BSS_TYPE_AP_BSS)
1250                 hlid = wl1271_tx_get_hlid(skb);
1251
1252         spin_lock_irqsave(&wl->wl_lock, flags);
1253
1254         wl->tx_queue_count++;
1255
1256         /*
1257          * The workqueue is slow to process the tx_queue and we need stop
1258          * the queue here, otherwise the queue will get too long.
1259          */
1260         if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1261                 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1262                 ieee80211_stop_queues(wl->hw);
1263                 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1264         }
1265
1266         /* queue the packet */
1267         if (wl->bss_type == BSS_TYPE_AP_BSS) {
1268                 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1269                 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1270         } else {
1271                 skb_queue_tail(&wl->tx_queue[q], skb);
1272         }
1273
1274         /*
1275          * The chip specific setup must run before the first TX packet -
1276          * before that, the tx_work will not be initialized!
1277          */
1278
1279         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1280             !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1281                 ieee80211_queue_work(wl->hw, &wl->tx_work);
1282
1283         spin_unlock_irqrestore(&wl->wl_lock, flags);
1284 }
1285
1286 int wl1271_tx_dummy_packet(struct wl1271 *wl)
1287 {
1288         unsigned long flags;
1289
1290         spin_lock_irqsave(&wl->wl_lock, flags);
1291         set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1292         wl->tx_queue_count++;
1293         spin_unlock_irqrestore(&wl->wl_lock, flags);
1294
1295         /* The FW is low on RX memory blocks, so send the dummy packet asap */
1296         if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1297                 wl1271_tx_work_locked(wl);
1298
1299         /*
1300          * If the FW TX is busy, TX work will be scheduled by the threaded
1301          * interrupt handler function
1302          */
1303         return 0;
1304 }
1305
1306 /*
1307  * The size of the dummy packet should be at least 1400 bytes. However, in
1308  * order to minimize the number of bus transactions, aligning it to 512 bytes
1309  * boundaries could be beneficial, performance wise
1310  */
1311 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1312
1313 static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1314 {
1315         struct sk_buff *skb;
1316         struct ieee80211_hdr_3addr *hdr;
1317         unsigned int dummy_packet_size;
1318
1319         dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1320                             sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1321
1322         skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1323         if (!skb) {
1324                 wl1271_warning("Failed to allocate a dummy packet skb");
1325                 return NULL;
1326         }
1327
1328         skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1329
1330         hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1331         memset(hdr, 0, sizeof(*hdr));
1332         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1333                                          IEEE80211_STYPE_NULLFUNC |
1334                                          IEEE80211_FCTL_TODS);
1335
1336         memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1337
1338         /* Dummy packets require the TID to be management */
1339         skb->priority = WL1271_TID_MGMT;
1340
1341         /* Initialize all fields that might be used */
1342         skb_set_queue_mapping(skb, 0);
1343         memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1344
1345         return skb;
1346 }
1347
1348
1349 static struct notifier_block wl1271_dev_notifier = {
1350         .notifier_call = wl1271_dev_notify,
1351 };
1352
1353 #ifdef CONFIG_PM
1354 static int wl1271_configure_suspend(struct wl1271 *wl)
1355 {
1356         int ret;
1357
1358         if (wl->bss_type != BSS_TYPE_STA_BSS)
1359                 return 0;
1360
1361         mutex_lock(&wl->mutex);
1362
1363         ret = wl1271_ps_elp_wakeup(wl);
1364         if (ret < 0)
1365                 goto out_unlock;
1366
1367         /* enter psm if needed*/
1368         if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) {
1369                 DECLARE_COMPLETION_ONSTACK(compl);
1370
1371                 wl->ps_compl = &compl;
1372                 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
1373                                    wl->basic_rate, true);
1374                 if (ret < 0)
1375                         goto out_sleep;
1376
1377                 /* we must unlock here so we will be able to get events */
1378                 wl1271_ps_elp_sleep(wl);
1379                 mutex_unlock(&wl->mutex);
1380
1381                 ret = wait_for_completion_timeout(
1382                         &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1383                 if (ret <= 0) {
1384                         wl1271_warning("couldn't enter ps mode!");
1385                         ret = -EBUSY;
1386                         goto out;
1387                 }
1388
1389                 /* take mutex again, and wakeup */
1390                 mutex_lock(&wl->mutex);
1391
1392                 ret = wl1271_ps_elp_wakeup(wl);
1393                 if (ret < 0)
1394                         goto out_unlock;
1395         }
1396 out_sleep:
1397         wl1271_ps_elp_sleep(wl);
1398 out_unlock:
1399         mutex_unlock(&wl->mutex);
1400 out:
1401         return ret;
1402
1403 }
1404
1405 static void wl1271_configure_resume(struct wl1271 *wl)
1406 {
1407         int ret;
1408
1409         if (wl->bss_type != BSS_TYPE_STA_BSS)
1410                 return;
1411
1412         mutex_lock(&wl->mutex);
1413         ret = wl1271_ps_elp_wakeup(wl);
1414         if (ret < 0)
1415                 goto out;
1416
1417         /* exit psm if it wasn't configured */
1418         if (!test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags))
1419                 wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
1420                                    wl->basic_rate, true);
1421
1422         wl1271_ps_elp_sleep(wl);
1423 out:
1424         mutex_unlock(&wl->mutex);
1425 }
1426
1427 static int wl1271_op_suspend(struct ieee80211_hw *hw,
1428                             struct cfg80211_wowlan *wow)
1429 {
1430         struct wl1271 *wl = hw->priv;
1431         wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1432         wl->wow_enabled = !!wow;
1433         if (wl->wow_enabled) {
1434                 int ret;
1435                 ret = wl1271_configure_suspend(wl);
1436                 if (ret < 0) {
1437                         wl1271_warning("couldn't prepare device to suspend");
1438                         return ret;
1439                 }
1440                 /* flush any remaining work */
1441                 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1442                 flush_delayed_work(&wl->scan_complete_work);
1443
1444                 /*
1445                  * disable and re-enable interrupts in order to flush
1446                  * the threaded_irq
1447                  */
1448                 wl1271_disable_interrupts(wl);
1449
1450                 /*
1451                  * set suspended flag to avoid triggering a new threaded_irq
1452                  * work. no need for spinlock as interrupts are disabled.
1453                  */
1454                 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1455
1456                 wl1271_enable_interrupts(wl);
1457                 flush_work(&wl->tx_work);
1458                 flush_delayed_work(&wl->pspoll_work);
1459                 flush_delayed_work(&wl->elp_work);
1460         }
1461         return 0;
1462 }
1463
1464 static int wl1271_op_resume(struct ieee80211_hw *hw)
1465 {
1466         struct wl1271 *wl = hw->priv;
1467         wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1468                      wl->wow_enabled);
1469
1470         /*
1471          * re-enable irq_work enqueuing, and call irq_work directly if
1472          * there is a pending work.
1473          */
1474         if (wl->wow_enabled) {
1475                 struct wl1271 *wl = hw->priv;
1476                 unsigned long flags;
1477                 bool run_irq_work = false;
1478
1479                 spin_lock_irqsave(&wl->wl_lock, flags);
1480                 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1481                 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1482                         run_irq_work = true;
1483                 spin_unlock_irqrestore(&wl->wl_lock, flags);
1484
1485                 if (run_irq_work) {
1486                         wl1271_debug(DEBUG_MAC80211,
1487                                      "run postponed irq_work directly");
1488                         wl1271_irq(0, wl);
1489                         wl1271_enable_interrupts(wl);
1490                 }
1491
1492                 wl1271_configure_resume(wl);
1493         }
1494
1495         return 0;
1496 }
1497 #endif
1498
1499 static int wl1271_op_start(struct ieee80211_hw *hw)
1500 {
1501         wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1502
1503         /*
1504          * We have to delay the booting of the hardware because
1505          * we need to know the local MAC address before downloading and
1506          * initializing the firmware. The MAC address cannot be changed
1507          * after boot, and without the proper MAC address, the firmware
1508          * will not function properly.
1509          *
1510          * The MAC address is first known when the corresponding interface
1511          * is added. That is where we will initialize the hardware.
1512          *
1513          * In addition, we currently have different firmwares for AP and managed
1514          * operation. We will know which to boot according to interface type.
1515          */
1516
1517         return 0;
1518 }
1519
1520 static void wl1271_op_stop(struct ieee80211_hw *hw)
1521 {
1522         wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1523 }
1524
1525 static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1526                                    struct ieee80211_vif *vif)
1527 {
1528         struct wl1271 *wl = hw->priv;
1529         struct wiphy *wiphy = hw->wiphy;
1530         int retries = WL1271_BOOT_RETRIES;
1531         int ret = 0;
1532         bool booted = false;
1533
1534         wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1535                      vif->type, vif->addr);
1536
1537         mutex_lock(&wl->mutex);
1538         if (wl->vif) {
1539                 wl1271_debug(DEBUG_MAC80211,
1540                              "multiple vifs are not supported yet");
1541                 ret = -EBUSY;
1542                 goto out;
1543         }
1544
1545         /*
1546          * in some very corner case HW recovery scenarios its possible to
1547          * get here before __wl1271_op_remove_interface is complete, so
1548          * opt out if that is the case.
1549          */
1550         if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1551                 ret = -EBUSY;
1552                 goto out;
1553         }
1554
1555         switch (vif->type) {
1556         case NL80211_IFTYPE_STATION:
1557                 wl->bss_type = BSS_TYPE_STA_BSS;
1558                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1559                 break;
1560         case NL80211_IFTYPE_ADHOC:
1561                 wl->bss_type = BSS_TYPE_IBSS;
1562                 wl->set_bss_type = BSS_TYPE_STA_BSS;
1563                 break;
1564         case NL80211_IFTYPE_AP:
1565                 wl->bss_type = BSS_TYPE_AP_BSS;
1566                 break;
1567         default:
1568                 ret = -EOPNOTSUPP;
1569                 goto out;
1570         }
1571
1572         memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
1573
1574         if (wl->state != WL1271_STATE_OFF) {
1575                 wl1271_error("cannot start because not in off state: %d",
1576                              wl->state);
1577                 ret = -EBUSY;
1578                 goto out;
1579         }
1580
1581         while (retries) {
1582                 retries--;
1583                 ret = wl1271_chip_wakeup(wl);
1584                 if (ret < 0)
1585                         goto power_off;
1586
1587                 ret = wl1271_boot(wl);
1588                 if (ret < 0)
1589                         goto power_off;
1590
1591                 ret = wl1271_hw_init(wl);
1592                 if (ret < 0)
1593                         goto irq_disable;
1594
1595                 booted = true;
1596                 break;
1597
1598 irq_disable:
1599                 mutex_unlock(&wl->mutex);
1600                 /* Unlocking the mutex in the middle of handling is
1601                    inherently unsafe. In this case we deem it safe to do,
1602                    because we need to let any possibly pending IRQ out of
1603                    the system (and while we are WL1271_STATE_OFF the IRQ
1604                    work function will not do anything.) Also, any other
1605                    possible concurrent operations will fail due to the
1606                    current state, hence the wl1271 struct should be safe. */
1607                 wl1271_disable_interrupts(wl);
1608                 wl1271_flush_deferred_work(wl);
1609                 cancel_work_sync(&wl->netstack_work);
1610                 mutex_lock(&wl->mutex);
1611 power_off:
1612                 wl1271_power_off(wl);
1613         }
1614
1615         if (!booted) {
1616                 wl1271_error("firmware boot failed despite %d retries",
1617                              WL1271_BOOT_RETRIES);
1618                 goto out;
1619         }
1620
1621         wl->vif = vif;
1622         wl->state = WL1271_STATE_ON;
1623         set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
1624         wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1625
1626         /* update hw/fw version info in wiphy struct */
1627         wiphy->hw_version = wl->chip.id;
1628         strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1629                 sizeof(wiphy->fw_version));
1630
1631         /* Check if any quirks are needed with older fw versions */
1632         wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1633
1634         /*
1635          * Now we know if 11a is supported (info from the NVS), so disable
1636          * 11a channels if not supported
1637          */
1638         if (!wl->enable_11a)
1639                 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1640
1641         wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1642                      wl->enable_11a ? "" : "not ");
1643
1644 out:
1645         mutex_unlock(&wl->mutex);
1646
1647         mutex_lock(&wl_list_mutex);
1648         if (!ret)
1649                 list_add(&wl->list, &wl_list);
1650         mutex_unlock(&wl_list_mutex);
1651
1652         return ret;
1653 }
1654
1655 static void __wl1271_op_remove_interface(struct wl1271 *wl,
1656                                          bool reset_tx_queues)
1657 {
1658         int i;
1659
1660         wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
1661
1662         /* because of hardware recovery, we may get here twice */
1663         if (wl->state != WL1271_STATE_ON)
1664                 return;
1665
1666         wl1271_info("down");
1667
1668         mutex_lock(&wl_list_mutex);
1669         list_del(&wl->list);
1670         mutex_unlock(&wl_list_mutex);
1671
1672         /* enable dyn ps just in case (if left on due to fw crash etc) */
1673         if (wl->bss_type == BSS_TYPE_STA_BSS)
1674                 ieee80211_enable_dyn_ps(wl->vif);
1675
1676         if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
1677                 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1678                 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
1679                 wl->scan.req = NULL;
1680                 ieee80211_scan_completed(wl->hw, true);
1681         }
1682
1683         /*
1684          * this must be before the cancel_work calls below, so that the work
1685          * functions don't perform further work.
1686          */
1687         wl->state = WL1271_STATE_OFF;
1688
1689         mutex_unlock(&wl->mutex);
1690
1691         wl1271_disable_interrupts(wl);
1692         wl1271_flush_deferred_work(wl);
1693         cancel_delayed_work_sync(&wl->scan_complete_work);
1694         cancel_work_sync(&wl->netstack_work);
1695         cancel_work_sync(&wl->tx_work);
1696         cancel_delayed_work_sync(&wl->pspoll_work);
1697         cancel_delayed_work_sync(&wl->elp_work);
1698
1699         mutex_lock(&wl->mutex);
1700
1701         /* let's notify MAC80211 about the remaining pending TX frames */
1702         wl1271_tx_reset(wl, reset_tx_queues);
1703         wl1271_power_off(wl);
1704
1705         memset(wl->bssid, 0, ETH_ALEN);
1706         memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1707         wl->ssid_len = 0;
1708         wl->bss_type = MAX_BSS_TYPE;
1709         wl->set_bss_type = MAX_BSS_TYPE;
1710         wl->band = IEEE80211_BAND_2GHZ;
1711
1712         wl->rx_counter = 0;
1713         wl->psm_entry_retry = 0;
1714         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1715         wl->tx_blocks_available = 0;
1716         wl->tx_allocated_blocks = 0;
1717         wl->tx_results_count = 0;
1718         wl->tx_packets_count = 0;
1719         wl->tx_security_last_seq = 0;
1720         wl->tx_security_seq = 0;
1721         wl->time_offset = 0;
1722         wl->session_counter = 0;
1723         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1724         wl->vif = NULL;
1725         wl->filters = 0;
1726         wl1271_free_ap_keys(wl);
1727         memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
1728         wl->ap_fw_ps_map = 0;
1729         wl->ap_ps_map = 0;
1730         wl->sched_scanning = false;
1731
1732         /*
1733          * this is performed after the cancel_work calls and the associated
1734          * mutex_lock, so that wl1271_op_add_interface does not accidentally
1735          * get executed before all these vars have been reset.
1736          */
1737         wl->flags = 0;
1738
1739         for (i = 0; i < NUM_TX_QUEUES; i++)
1740                 wl->tx_blocks_freed[i] = 0;
1741
1742         wl1271_debugfs_reset(wl);
1743
1744         kfree(wl->fw_status);
1745         wl->fw_status = NULL;
1746         kfree(wl->tx_res_if);
1747         wl->tx_res_if = NULL;
1748         kfree(wl->target_mem_map);
1749         wl->target_mem_map = NULL;
1750 }
1751
1752 static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1753                                        struct ieee80211_vif *vif)
1754 {
1755         struct wl1271 *wl = hw->priv;
1756
1757         mutex_lock(&wl->mutex);
1758         /*
1759          * wl->vif can be null here if someone shuts down the interface
1760          * just when hardware recovery has been started.
1761          */
1762         if (wl->vif) {
1763                 WARN_ON(wl->vif != vif);
1764                 __wl1271_op_remove_interface(wl, true);
1765         }
1766
1767         mutex_unlock(&wl->mutex);
1768         cancel_work_sync(&wl->recovery_work);
1769 }
1770
1771 void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1772 {
1773         wl1271_set_default_filters(wl);
1774
1775         /* combine requested filters with current filter config */
1776         filters = wl->filters | filters;
1777
1778         wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1779
1780         if (filters & FIF_PROMISC_IN_BSS) {
1781                 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1782                 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1783                 wl->rx_config |= CFG_BSSID_FILTER_EN;
1784         }
1785         if (filters & FIF_BCN_PRBRESP_PROMISC) {
1786                 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1787                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1788                 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1789         }
1790         if (filters & FIF_OTHER_BSS) {
1791                 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1792                 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1793         }
1794         if (filters & FIF_CONTROL) {
1795                 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1796                 wl->rx_filter |= CFG_RX_CTL_EN;
1797         }
1798         if (filters & FIF_FCSFAIL) {
1799                 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1800                 wl->rx_filter |= CFG_RX_FCS_ERROR;
1801         }
1802 }
1803
1804 static int wl1271_dummy_join(struct wl1271 *wl)
1805 {
1806         int ret = 0;
1807         /* we need to use a dummy BSSID for now */
1808         static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1809                                                   0xad, 0xbe, 0xef };
1810
1811         memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1812
1813         /* pass through frames from all BSS */
1814         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1815
1816         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1817         if (ret < 0)
1818                 goto out;
1819
1820         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1821
1822 out:
1823         return ret;
1824 }
1825
1826 static int wl1271_join(struct wl1271 *wl, bool set_assoc)
1827 {
1828         int ret;
1829
1830         /*
1831          * One of the side effects of the JOIN command is that is clears
1832          * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1833          * to a WPA/WPA2 access point will therefore kill the data-path.
1834          * Currently the only valid scenario for JOIN during association
1835          * is on roaming, in which case we will also be given new keys.
1836          * Keep the below message for now, unless it starts bothering
1837          * users who really like to roam a lot :)
1838          */
1839         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1840                 wl1271_info("JOIN while associated.");
1841
1842         if (set_assoc)
1843                 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1844
1845         ret = wl1271_cmd_join(wl, wl->set_bss_type);
1846         if (ret < 0)
1847                 goto out;
1848
1849         set_bit(WL1271_FLAG_JOINED, &wl->flags);
1850
1851         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1852                 goto out;
1853
1854         /*
1855          * The join command disable the keep-alive mode, shut down its process,
1856          * and also clear the template config, so we need to reset it all after
1857          * the join. The acx_aid starts the keep-alive process, and the order
1858          * of the commands below is relevant.
1859          */
1860         ret = wl1271_acx_keep_alive_mode(wl, true);
1861         if (ret < 0)
1862                 goto out;
1863
1864         ret = wl1271_acx_aid(wl, wl->aid);
1865         if (ret < 0)
1866                 goto out;
1867
1868         ret = wl1271_cmd_build_klv_null_data(wl);
1869         if (ret < 0)
1870                 goto out;
1871
1872         ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1873                                            ACX_KEEP_ALIVE_TPL_VALID);
1874         if (ret < 0)
1875                 goto out;
1876
1877 out:
1878         return ret;
1879 }
1880
1881 static int wl1271_unjoin(struct wl1271 *wl)
1882 {
1883         int ret;
1884
1885         /* to stop listening to a channel, we disconnect */
1886         ret = wl1271_cmd_disconnect(wl);
1887         if (ret < 0)
1888                 goto out;
1889
1890         clear_bit(WL1271_FLAG_JOINED, &wl->flags);
1891         memset(wl->bssid, 0, ETH_ALEN);
1892
1893         /* stop filtering packets based on bssid */
1894         wl1271_configure_filters(wl, FIF_OTHER_BSS);
1895
1896 out:
1897         return ret;
1898 }
1899
1900 static void wl1271_set_band_rate(struct wl1271 *wl)
1901 {
1902         if (wl->band == IEEE80211_BAND_2GHZ)
1903                 wl->basic_rate_set = wl->conf.tx.basic_rate;
1904         else
1905                 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1906 }
1907
1908 static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
1909 {
1910         int ret;
1911
1912         if (idle) {
1913                 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1914                         ret = wl1271_unjoin(wl);
1915                         if (ret < 0)
1916                                 goto out;
1917                 }
1918                 wl->rate_set = wl1271_tx_min_rate_get(wl);
1919                 ret = wl1271_acx_sta_rate_policies(wl);
1920                 if (ret < 0)
1921                         goto out;
1922                 ret = wl1271_acx_keep_alive_config(
1923                         wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1924                         ACX_KEEP_ALIVE_TPL_INVALID);
1925                 if (ret < 0)
1926                         goto out;
1927                 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1928         } else {
1929                 /* increment the session counter */
1930                 wl->session_counter++;
1931                 if (wl->session_counter >= SESSION_COUNTER_MAX)
1932                         wl->session_counter = 0;
1933
1934                 /* The current firmware only supports sched_scan in idle */
1935                 if (wl->sched_scanning) {
1936                         wl1271_scan_sched_scan_stop(wl);
1937                         ieee80211_sched_scan_stopped(wl->hw);
1938                 }
1939
1940                 ret = wl1271_dummy_join(wl);
1941                 if (ret < 0)
1942                         goto out;
1943                 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1944         }
1945
1946 out:
1947         return ret;
1948 }
1949
1950 static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1951 {
1952         struct wl1271 *wl = hw->priv;
1953         struct ieee80211_conf *conf = &hw->conf;
1954         int channel, ret = 0;
1955         bool is_ap;
1956
1957         channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1958
1959         wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1960                      " changed 0x%x",
1961                      channel,
1962                      conf->flags & IEEE80211_CONF_PS ? "on" : "off",
1963                      conf->power_level,
1964                      conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1965                          changed);
1966
1967         /*
1968          * mac80211 will go to idle nearly immediately after transmitting some
1969          * frames, such as the deauth. To make sure those frames reach the air,
1970          * wait here until the TX queue is fully flushed.
1971          */
1972         if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1973             (conf->flags & IEEE80211_CONF_IDLE))
1974                 wl1271_tx_flush(wl);
1975
1976         mutex_lock(&wl->mutex);
1977
1978         if (unlikely(wl->state == WL1271_STATE_OFF)) {
1979                 /* we support configuring the channel and band while off */
1980                 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1981                         wl->band = conf->channel->band;
1982                         wl->channel = channel;
1983                 }
1984
1985                 goto out;
1986         }
1987
1988         is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1989
1990         ret = wl1271_ps_elp_wakeup(wl);
1991         if (ret < 0)
1992                 goto out;
1993
1994         /* if the channel changes while joined, join again */
1995         if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1996             ((wl->band != conf->channel->band) ||
1997              (wl->channel != channel))) {
1998                 wl->band = conf->channel->band;
1999                 wl->channel = channel;
2000
2001                 if (!is_ap) {
2002                         /*
2003                          * FIXME: the mac80211 should really provide a fixed
2004                          * rate to use here. for now, just use the smallest
2005                          * possible rate for the band as a fixed rate for
2006                          * association frames and other control messages.
2007                          */
2008                         if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2009                                 wl1271_set_band_rate(wl);
2010
2011                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2012                         ret = wl1271_acx_sta_rate_policies(wl);
2013                         if (ret < 0)
2014                                 wl1271_warning("rate policy for channel "
2015                                                "failed %d", ret);
2016
2017                         if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2018                                 ret = wl1271_join(wl, false);
2019                                 if (ret < 0)
2020                                         wl1271_warning("cmd join on channel "
2021                                                        "failed %d", ret);
2022                         }
2023                 }
2024         }
2025
2026         if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2027                 ret = wl1271_sta_handle_idle(wl,
2028                                         conf->flags & IEEE80211_CONF_IDLE);
2029                 if (ret < 0)
2030                         wl1271_warning("idle mode change failed %d", ret);
2031         }
2032
2033         /*
2034          * if mac80211 changes the PSM mode, make sure the mode is not
2035          * incorrectly changed after the pspoll failure active window.
2036          */
2037         if (changed & IEEE80211_CONF_CHANGE_PS)
2038                 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2039
2040         if (conf->flags & IEEE80211_CONF_PS &&
2041             !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2042                 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2043
2044                 /*
2045                  * We enter PSM only if we're already associated.
2046                  * If we're not, we'll enter it when joining an SSID,
2047                  * through the bss_info_changed() hook.
2048                  */
2049                 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2050                         wl1271_debug(DEBUG_PSM, "psm enabled");
2051                         ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
2052                                                  wl->basic_rate, true);
2053                 }
2054         } else if (!(conf->flags & IEEE80211_CONF_PS) &&
2055                    test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2056                 wl1271_debug(DEBUG_PSM, "psm disabled");
2057
2058                 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
2059
2060                 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
2061                         ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
2062                                                  wl->basic_rate, true);
2063         }
2064
2065         if (conf->power_level != wl->power_level) {
2066                 ret = wl1271_acx_tx_power(wl, conf->power_level);
2067                 if (ret < 0)
2068                         goto out_sleep;
2069
2070                 wl->power_level = conf->power_level;
2071         }
2072
2073 out_sleep:
2074         wl1271_ps_elp_sleep(wl);
2075
2076 out:
2077         mutex_unlock(&wl->mutex);
2078
2079         return ret;
2080 }
2081
2082 struct wl1271_filter_params {
2083         bool enabled;
2084         int mc_list_length;
2085         u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2086 };
2087
2088 static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2089                                        struct netdev_hw_addr_list *mc_list)
2090 {
2091         struct wl1271_filter_params *fp;
2092         struct netdev_hw_addr *ha;
2093         struct wl1271 *wl = hw->priv;
2094
2095         if (unlikely(wl->state == WL1271_STATE_OFF))
2096                 return 0;
2097
2098         fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2099         if (!fp) {
2100                 wl1271_error("Out of memory setting filters.");
2101                 return 0;
2102         }
2103
2104         /* update multicast filtering parameters */
2105         fp->mc_list_length = 0;
2106         if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2107                 fp->enabled = false;
2108         } else {
2109                 fp->enabled = true;
2110                 netdev_hw_addr_list_for_each(ha, mc_list) {
2111                         memcpy(fp->mc_list[fp->mc_list_length],
2112                                         ha->addr, ETH_ALEN);
2113                         fp->mc_list_length++;
2114                 }
2115         }
2116
2117         return (u64)(unsigned long)fp;
2118 }
2119
2120 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2121                                   FIF_ALLMULTI | \
2122                                   FIF_FCSFAIL | \
2123                                   FIF_BCN_PRBRESP_PROMISC | \
2124                                   FIF_CONTROL | \
2125                                   FIF_OTHER_BSS)
2126
2127 static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2128                                        unsigned int changed,
2129                                        unsigned int *total, u64 multicast)
2130 {
2131         struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
2132         struct wl1271 *wl = hw->priv;
2133         int ret;
2134
2135         wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2136                      " total %x", changed, *total);
2137
2138         mutex_lock(&wl->mutex);
2139
2140         *total &= WL1271_SUPPORTED_FILTERS;
2141         changed &= WL1271_SUPPORTED_FILTERS;
2142
2143         if (unlikely(wl->state == WL1271_STATE_OFF))
2144                 goto out;
2145
2146         ret = wl1271_ps_elp_wakeup(wl);
2147         if (ret < 0)
2148                 goto out;
2149
2150         if (wl->bss_type != BSS_TYPE_AP_BSS) {
2151                 if (*total & FIF_ALLMULTI)
2152                         ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2153                 else if (fp)
2154                         ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2155                                                            fp->mc_list,
2156                                                            fp->mc_list_length);
2157                 if (ret < 0)
2158                         goto out_sleep;
2159         }
2160
2161         /* determine, whether supported filter values have changed */
2162         if (changed == 0)
2163                 goto out_sleep;
2164
2165         /* configure filters */
2166         wl->filters = *total;
2167         wl1271_configure_filters(wl, 0);
2168
2169         /* apply configured filters */
2170         ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
2171         if (ret < 0)
2172                 goto out_sleep;
2173
2174 out_sleep:
2175         wl1271_ps_elp_sleep(wl);
2176
2177 out:
2178         mutex_unlock(&wl->mutex);
2179         kfree(fp);
2180 }
2181
2182 static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2183                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2184                         u16 tx_seq_16)
2185 {
2186         struct wl1271_ap_key *ap_key;
2187         int i;
2188
2189         wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2190
2191         if (key_size > MAX_KEY_SIZE)
2192                 return -EINVAL;
2193
2194         /*
2195          * Find next free entry in ap_keys. Also check we are not replacing
2196          * an existing key.
2197          */
2198         for (i = 0; i < MAX_NUM_KEYS; i++) {
2199                 if (wl->recorded_ap_keys[i] == NULL)
2200                         break;
2201
2202                 if (wl->recorded_ap_keys[i]->id == id) {
2203                         wl1271_warning("trying to record key replacement");
2204                         return -EINVAL;
2205                 }
2206         }
2207
2208         if (i == MAX_NUM_KEYS)
2209                 return -EBUSY;
2210
2211         ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2212         if (!ap_key)
2213                 return -ENOMEM;
2214
2215         ap_key->id = id;
2216         ap_key->key_type = key_type;
2217         ap_key->key_size = key_size;
2218         memcpy(ap_key->key, key, key_size);
2219         ap_key->hlid = hlid;
2220         ap_key->tx_seq_32 = tx_seq_32;
2221         ap_key->tx_seq_16 = tx_seq_16;
2222
2223         wl->recorded_ap_keys[i] = ap_key;
2224         return 0;
2225 }
2226
2227 static void wl1271_free_ap_keys(struct wl1271 *wl)
2228 {
2229         int i;
2230
2231         for (i = 0; i < MAX_NUM_KEYS; i++) {
2232                 kfree(wl->recorded_ap_keys[i]);
2233                 wl->recorded_ap_keys[i] = NULL;
2234         }
2235 }
2236
2237 static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2238 {
2239         int i, ret = 0;
2240         struct wl1271_ap_key *key;
2241         bool wep_key_added = false;
2242
2243         for (i = 0; i < MAX_NUM_KEYS; i++) {
2244                 if (wl->recorded_ap_keys[i] == NULL)
2245                         break;
2246
2247                 key = wl->recorded_ap_keys[i];
2248                 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2249                                             key->id, key->key_type,
2250                                             key->key_size, key->key,
2251                                             key->hlid, key->tx_seq_32,
2252                                             key->tx_seq_16);
2253                 if (ret < 0)
2254                         goto out;
2255
2256                 if (key->key_type == KEY_WEP)
2257                         wep_key_added = true;
2258         }
2259
2260         if (wep_key_added) {
2261                 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2262                 if (ret < 0)
2263                         goto out;
2264         }
2265
2266 out:
2267         wl1271_free_ap_keys(wl);
2268         return ret;
2269 }
2270
2271 static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2272                        u8 key_size, const u8 *key, u32 tx_seq_32,
2273                        u16 tx_seq_16, struct ieee80211_sta *sta)
2274 {
2275         int ret;
2276         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2277
2278         if (is_ap) {
2279                 struct wl1271_station *wl_sta;
2280                 u8 hlid;
2281
2282                 if (sta) {
2283                         wl_sta = (struct wl1271_station *)sta->drv_priv;
2284                         hlid = wl_sta->hlid;
2285                 } else {
2286                         hlid = WL1271_AP_BROADCAST_HLID;
2287                 }
2288
2289                 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2290                         /*
2291                          * We do not support removing keys after AP shutdown.
2292                          * Pretend we do to make mac80211 happy.
2293                          */
2294                         if (action != KEY_ADD_OR_REPLACE)
2295                                 return 0;
2296
2297                         ret = wl1271_record_ap_key(wl, id,
2298                                              key_type, key_size,
2299                                              key, hlid, tx_seq_32,
2300                                              tx_seq_16);
2301                 } else {
2302                         ret = wl1271_cmd_set_ap_key(wl, action,
2303                                              id, key_type, key_size,
2304                                              key, hlid, tx_seq_32,
2305                                              tx_seq_16);
2306                 }
2307
2308                 if (ret < 0)
2309                         return ret;
2310         } else {
2311                 const u8 *addr;
2312                 static const u8 bcast_addr[ETH_ALEN] = {
2313                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2314                 };
2315
2316                 addr = sta ? sta->addr : bcast_addr;
2317
2318                 if (is_zero_ether_addr(addr)) {
2319                         /* We dont support TX only encryption */
2320                         return -EOPNOTSUPP;
2321                 }
2322
2323                 /* The wl1271 does not allow to remove unicast keys - they
2324                    will be cleared automatically on next CMD_JOIN. Ignore the
2325                    request silently, as we dont want the mac80211 to emit
2326                    an error message. */
2327                 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2328                         return 0;
2329
2330                 ret = wl1271_cmd_set_sta_key(wl, action,
2331                                              id, key_type, key_size,
2332                                              key, addr, tx_seq_32,
2333                                              tx_seq_16);
2334                 if (ret < 0)
2335                         return ret;
2336
2337                 /* the default WEP key needs to be configured at least once */
2338                 if (key_type == KEY_WEP) {
2339                         ret = wl1271_cmd_set_sta_default_wep_key(wl,
2340                                                         wl->default_key);
2341                         if (ret < 0)
2342                                 return ret;
2343                 }
2344         }
2345
2346         return 0;
2347 }
2348
2349 static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2350                              struct ieee80211_vif *vif,
2351                              struct ieee80211_sta *sta,
2352                              struct ieee80211_key_conf *key_conf)
2353 {
2354         struct wl1271 *wl = hw->priv;
2355         int ret;
2356         u32 tx_seq_32 = 0;
2357         u16 tx_seq_16 = 0;
2358         u8 key_type;
2359
2360         wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2361
2362         wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
2363         wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2364                      key_conf->cipher, key_conf->keyidx,
2365                      key_conf->keylen, key_conf->flags);
2366         wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2367
2368         mutex_lock(&wl->mutex);
2369
2370         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2371                 ret = -EAGAIN;
2372                 goto out_unlock;
2373         }
2374
2375         ret = wl1271_ps_elp_wakeup(wl);
2376         if (ret < 0)
2377                 goto out_unlock;
2378
2379         switch (key_conf->cipher) {
2380         case WLAN_CIPHER_SUITE_WEP40:
2381         case WLAN_CIPHER_SUITE_WEP104:
2382                 key_type = KEY_WEP;
2383
2384                 key_conf->hw_key_idx = key_conf->keyidx;
2385                 break;
2386         case WLAN_CIPHER_SUITE_TKIP:
2387                 key_type = KEY_TKIP;
2388
2389                 key_conf->hw_key_idx = key_conf->keyidx;
2390                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2391                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2392                 break;
2393         case WLAN_CIPHER_SUITE_CCMP:
2394                 key_type = KEY_AES;
2395
2396                 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
2397                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2398                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2399                 break;
2400         case WL1271_CIPHER_SUITE_GEM:
2401                 key_type = KEY_GEM;
2402                 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2403                 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2404                 break;
2405         default:
2406                 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
2407
2408                 ret = -EOPNOTSUPP;
2409                 goto out_sleep;
2410         }
2411
2412         switch (cmd) {
2413         case SET_KEY:
2414                 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2415                                  key_conf->keyidx, key_type,
2416                                  key_conf->keylen, key_conf->key,
2417                                  tx_seq_32, tx_seq_16, sta);
2418                 if (ret < 0) {
2419                         wl1271_error("Could not add or replace key");
2420                         goto out_sleep;
2421                 }
2422                 break;
2423
2424         case DISABLE_KEY:
2425                 ret = wl1271_set_key(wl, KEY_REMOVE,
2426                                      key_conf->keyidx, key_type,
2427                                      key_conf->keylen, key_conf->key,
2428                                      0, 0, sta);
2429                 if (ret < 0) {
2430                         wl1271_error("Could not remove key");
2431                         goto out_sleep;
2432                 }
2433                 break;
2434
2435         default:
2436                 wl1271_error("Unsupported key cmd 0x%x", cmd);
2437                 ret = -EOPNOTSUPP;
2438                 break;
2439         }
2440
2441 out_sleep:
2442         wl1271_ps_elp_sleep(wl);
2443
2444 out_unlock:
2445         mutex_unlock(&wl->mutex);
2446
2447         return ret;
2448 }
2449
2450 static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
2451                              struct ieee80211_vif *vif,
2452                              struct cfg80211_scan_request *req)
2453 {
2454         struct wl1271 *wl = hw->priv;
2455         int ret;
2456         u8 *ssid = NULL;
2457         size_t len = 0;
2458
2459         wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2460
2461         if (req->n_ssids) {
2462                 ssid = req->ssids[0].ssid;
2463                 len = req->ssids[0].ssid_len;
2464         }
2465
2466         mutex_lock(&wl->mutex);
2467
2468         if (wl->state == WL1271_STATE_OFF) {
2469                 /*
2470                  * We cannot return -EBUSY here because cfg80211 will expect
2471                  * a call to ieee80211_scan_completed if we do - in this case
2472                  * there won't be any call.
2473                  */
2474                 ret = -EAGAIN;
2475                 goto out;
2476         }
2477
2478         ret = wl1271_ps_elp_wakeup(wl);
2479         if (ret < 0)
2480                 goto out;
2481
2482         ret = wl1271_scan(hw->priv, ssid, len, req);
2483
2484         wl1271_ps_elp_sleep(wl);
2485
2486 out:
2487         mutex_unlock(&wl->mutex);
2488
2489         return ret;
2490 }
2491
2492 static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2493                                       struct ieee80211_vif *vif,
2494                                       struct cfg80211_sched_scan_request *req,
2495                                       struct ieee80211_sched_scan_ies *ies)
2496 {
2497         struct wl1271 *wl = hw->priv;
2498         int ret;
2499
2500         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2501
2502         mutex_lock(&wl->mutex);
2503
2504         ret = wl1271_ps_elp_wakeup(wl);
2505         if (ret < 0)
2506                 goto out;
2507
2508         ret = wl1271_scan_sched_scan_config(wl, req, ies);
2509         if (ret < 0)
2510                 goto out_sleep;
2511
2512         ret = wl1271_scan_sched_scan_start(wl);
2513         if (ret < 0)
2514                 goto out_sleep;
2515
2516         wl->sched_scanning = true;
2517
2518 out_sleep:
2519         wl1271_ps_elp_sleep(wl);
2520 out:
2521         mutex_unlock(&wl->mutex);
2522         return ret;
2523 }
2524
2525 static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2526                                       struct ieee80211_vif *vif)
2527 {
2528         struct wl1271 *wl = hw->priv;
2529         int ret;
2530
2531         wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2532
2533         mutex_lock(&wl->mutex);
2534
2535         ret = wl1271_ps_elp_wakeup(wl);
2536         if (ret < 0)
2537                 goto out;
2538
2539         wl1271_scan_sched_scan_stop(wl);
2540
2541         wl1271_ps_elp_sleep(wl);
2542 out:
2543         mutex_unlock(&wl->mutex);
2544 }
2545
2546 static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2547 {
2548         struct wl1271 *wl = hw->priv;
2549         int ret = 0;
2550
2551         mutex_lock(&wl->mutex);
2552
2553         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2554                 ret = -EAGAIN;
2555                 goto out;
2556         }
2557
2558         ret = wl1271_ps_elp_wakeup(wl);
2559         if (ret < 0)
2560                 goto out;
2561
2562         ret = wl1271_acx_frag_threshold(wl, value);
2563         if (ret < 0)
2564                 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2565
2566         wl1271_ps_elp_sleep(wl);
2567
2568 out:
2569         mutex_unlock(&wl->mutex);
2570
2571         return ret;
2572 }
2573
2574 static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2575 {
2576         struct wl1271 *wl = hw->priv;
2577         int ret = 0;
2578
2579         mutex_lock(&wl->mutex);
2580
2581         if (unlikely(wl->state == WL1271_STATE_OFF)) {
2582                 ret = -EAGAIN;
2583                 goto out;
2584         }
2585
2586         ret = wl1271_ps_elp_wakeup(wl);
2587         if (ret < 0)
2588                 goto out;
2589
2590         ret = wl1271_acx_rts_threshold(wl, value);
2591         if (ret < 0)
2592                 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2593
2594         wl1271_ps_elp_sleep(wl);
2595
2596 out:
2597         mutex_unlock(&wl->mutex);
2598
2599         return ret;
2600 }
2601
2602 static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2603                             int offset)
2604 {
2605         u8 ssid_len;
2606         const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2607                                          skb->len - offset);
2608
2609         if (!ptr) {
2610                 wl1271_error("No SSID in IEs!");
2611                 return -ENOENT;
2612         }
2613
2614         ssid_len = ptr[1];
2615         if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2616                 wl1271_error("SSID is too long!");
2617                 return -EINVAL;
2618         }
2619
2620         wl->ssid_len = ssid_len;
2621         memcpy(wl->ssid, ptr+2, ssid_len);
2622         return 0;
2623 }
2624
2625 static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
2626                                        struct ieee80211_bss_conf *bss_conf,
2627                                        u32 changed)
2628 {
2629         int ret = 0;
2630
2631         if (changed & BSS_CHANGED_ERP_SLOT) {
2632                 if (bss_conf->use_short_slot)
2633                         ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2634                 else
2635                         ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2636                 if (ret < 0) {
2637                         wl1271_warning("Set slot time failed %d", ret);
2638                         goto out;
2639                 }
2640         }
2641
2642         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2643                 if (bss_conf->use_short_preamble)
2644                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2645                 else
2646                         wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2647         }
2648
2649         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2650                 if (bss_conf->use_cts_prot)
2651                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2652                 else
2653                         ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2654                 if (ret < 0) {
2655                         wl1271_warning("Set ctsprotect failed %d", ret);
2656                         goto out;
2657                 }
2658         }
2659
2660 out:
2661         return ret;
2662 }
2663
2664 static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2665                                           struct ieee80211_vif *vif,
2666                                           struct ieee80211_bss_conf *bss_conf,
2667                                           u32 changed)
2668 {
2669         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2670         int ret = 0;
2671
2672         if ((changed & BSS_CHANGED_BEACON_INT)) {
2673                 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
2674                         bss_conf->beacon_int);
2675
2676                 wl->beacon_int = bss_conf->beacon_int;
2677         }
2678
2679         if ((changed & BSS_CHANGED_BEACON)) {
2680                 struct ieee80211_hdr *hdr;
2681                 int ieoffset = offsetof(struct ieee80211_mgmt,
2682                                         u.beacon.variable);
2683                 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2684                 u16 tmpl_id;
2685
2686                 if (!beacon)
2687                         goto out;
2688
2689                 wl1271_debug(DEBUG_MASTER, "beacon updated");
2690
2691                 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2692                 if (ret < 0) {
2693                         dev_kfree_skb(beacon);
2694                         goto out;
2695                 }
2696                 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2697                                   CMD_TEMPL_BEACON;
2698                 ret = wl1271_cmd_template_set(wl, tmpl_id,
2699                                               beacon->data,
2700                                               beacon->len, 0,
2701                                               wl1271_tx_min_rate_get(wl));
2702                 if (ret < 0) {
2703                         dev_kfree_skb(beacon);
2704                         goto out;
2705                 }
2706
2707                 hdr = (struct ieee80211_hdr *) beacon->data;
2708                 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2709                                                  IEEE80211_STYPE_PROBE_RESP);
2710
2711                 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2712                                   CMD_TEMPL_PROBE_RESPONSE;
2713                 ret = wl1271_cmd_template_set(wl,
2714                                               tmpl_id,
2715                                               beacon->data,
2716                                               beacon->len, 0,
2717                                               wl1271_tx_min_rate_get(wl));
2718                 dev_kfree_skb(beacon);
2719                 if (ret < 0)
2720                         goto out;
2721         }
2722
2723 out:
2724         return ret;
2725 }
2726
2727 /* AP mode changes */
2728 static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2729                                        struct ieee80211_vif *vif,
2730                                        struct ieee80211_bss_conf *bss_conf,
2731                                        u32 changed)
2732 {
2733         int ret = 0;
2734
2735         if ((changed & BSS_CHANGED_BASIC_RATES)) {
2736                 u32 rates = bss_conf->basic_rates;
2737
2738                 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2739                 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2740
2741                 ret = wl1271_init_ap_rates(wl);
2742                 if (ret < 0) {
2743                         wl1271_error("AP rate policy change failed %d", ret);
2744                         goto out;
2745                 }
2746
2747                 ret = wl1271_ap_init_templates(wl);
2748                 if (ret < 0)
2749                         goto out;
2750         }
2751
2752         ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2753         if (ret < 0)
2754                 goto out;
2755
2756         if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2757                 if (bss_conf->enable_beacon) {
2758                         if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2759                                 ret = wl1271_cmd_start_bss(wl);
2760                                 if (ret < 0)
2761                                         goto out;
2762
2763                                 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2764                                 wl1271_debug(DEBUG_AP, "started AP");
2765
2766                                 ret = wl1271_ap_init_hwenc(wl);
2767                                 if (ret < 0)
2768                                         goto out;
2769                         }
2770                 } else {
2771                         if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2772                                 ret = wl1271_cmd_stop_bss(wl);
2773                                 if (ret < 0)
2774                                         goto out;
2775
2776                                 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2777                                 wl1271_debug(DEBUG_AP, "stopped AP");
2778                         }
2779                 }
2780         }
2781
2782         if (changed & BSS_CHANGED_IBSS) {
2783                 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
2784                              bss_conf->ibss_joined);
2785
2786                 if (bss_conf->ibss_joined) {
2787                         u32 rates = bss_conf->basic_rates;
2788                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2789                                                                          rates);
2790                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2791
2792                         /* by default, use 11b rates */
2793                         wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
2794                         ret = wl1271_acx_sta_rate_policies(wl);
2795                         if (ret < 0)
2796                                 goto out;
2797                 }
2798         }
2799
2800         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2801         if (ret < 0)
2802                 goto out;
2803 out:
2804         return;
2805 }
2806
2807 /* STA/IBSS mode changes */
2808 static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2809                                         struct ieee80211_vif *vif,
2810                                         struct ieee80211_bss_conf *bss_conf,
2811                                         u32 changed)
2812 {
2813         bool do_join = false, set_assoc = false;
2814         bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
2815         u32 sta_rate_set = 0;
2816         int ret;
2817         struct ieee80211_sta *sta;
2818         bool sta_exists = false;
2819         struct ieee80211_sta_ht_cap sta_ht_cap;
2820
2821         if (is_ibss) {
2822                 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2823                                                      changed);
2824                 if (ret < 0)
2825                         goto out;
2826         }
2827
2828         if ((changed & BSS_CHANGED_BEACON_INT)  && is_ibss)
2829                 do_join = true;
2830
2831         /* Need to update the SSID (for filtering etc) */
2832         if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2833                 do_join = true;
2834
2835         if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
2836                 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2837                              bss_conf->enable_beacon ? "enabled" : "disabled");
2838
2839                 if (bss_conf->enable_beacon)
2840                         wl->set_bss_type = BSS_TYPE_IBSS;
2841                 else
2842                         wl->set_bss_type = BSS_TYPE_STA_BSS;
2843                 do_join = true;
2844         }
2845
2846         if ((changed & BSS_CHANGED_CQM)) {
2847                 bool enable = false;
2848                 if (bss_conf->cqm_rssi_thold)
2849                         enable = true;
2850                 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2851                                                   bss_conf->cqm_rssi_thold,
2852                                                   bss_conf->cqm_rssi_hyst);
2853                 if (ret < 0)
2854                         goto out;
2855                 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2856         }
2857
2858         if ((changed & BSS_CHANGED_BSSID) &&
2859             /*
2860              * Now we know the correct bssid, so we send a new join command
2861              * and enable the BSSID filter
2862              */
2863             memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
2864                 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
2865
2866                 if (!is_zero_ether_addr(wl->bssid)) {
2867                         ret = wl1271_cmd_build_null_data(wl);
2868                         if (ret < 0)
2869                                 goto out;
2870
2871                         ret = wl1271_build_qos_null_data(wl);
2872                         if (ret < 0)
2873                                 goto out;
2874
2875                         /* filter out all packets not from this BSSID */
2876                         wl1271_configure_filters(wl, 0);
2877
2878                         /* Need to update the BSSID (for filtering etc) */
2879                         do_join = true;
2880                 }
2881         }
2882
2883         rcu_read_lock();
2884         sta = ieee80211_find_sta(vif, bss_conf->bssid);
2885         if (sta)  {
2886                 /* save the supp_rates of the ap */
2887                 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2888                 if (sta->ht_cap.ht_supported)
2889                         sta_rate_set |=
2890                             (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
2891                 sta_ht_cap = sta->ht_cap;
2892                 sta_exists = true;
2893         }
2894         rcu_read_unlock();
2895
2896         if (sta_exists) {
2897                 /* handle new association with HT and HT information change */
2898                 if ((changed & BSS_CHANGED_HT) &&
2899                     (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
2900                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2901                                                              true);
2902                         if (ret < 0) {
2903                                 wl1271_warning("Set ht cap true failed %d",
2904                                                ret);
2905                                 goto out;
2906                         }
2907                         ret = wl1271_acx_set_ht_information(wl,
2908                                                 bss_conf->ht_operation_mode);
2909                         if (ret < 0) {
2910                                 wl1271_warning("Set ht information failed %d",
2911                                                ret);
2912                                 goto out;
2913                         }
2914                 }
2915                 /* handle new association without HT and disassociation */
2916                 else if (changed & BSS_CHANGED_ASSOC) {
2917                         ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
2918                                                              false);
2919                         if (ret < 0) {
2920                                 wl1271_warning("Set ht cap false failed %d",
2921                                                ret);
2922                                 goto out;
2923                         }
2924                 }
2925         }
2926
2927         if ((changed & BSS_CHANGED_ASSOC)) {
2928                 if (bss_conf->assoc) {
2929                         u32 rates;
2930                         int ieoffset;
2931                         wl->aid = bss_conf->aid;
2932                         set_assoc = true;
2933
2934                         wl->ps_poll_failures = 0;
2935
2936                         /*
2937                          * use basic rates from AP, and determine lowest rate
2938                          * to use with control frames.
2939                          */
2940                         rates = bss_conf->basic_rates;
2941                         wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2942                                                                          rates);
2943                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
2944                         if (sta_rate_set)
2945                                 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2946                                                                 sta_rate_set);
2947                         ret = wl1271_acx_sta_rate_policies(wl);
2948                         if (ret < 0)
2949                                 goto out;
2950
2951                         /*
2952                          * with wl1271, we don't need to update the
2953                          * beacon_int and dtim_period, because the firmware
2954                          * updates it by itself when the first beacon is
2955                          * received after a join.
2956                          */
2957                         ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2958                         if (ret < 0)
2959                                 goto out;
2960
2961                         /*
2962                          * Get a template for hardware connection maintenance
2963                          */
2964                         dev_kfree_skb(wl->probereq);
2965                         wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2966                         ieoffset = offsetof(struct ieee80211_mgmt,
2967                                             u.probe_req.variable);
2968                         wl1271_ssid_set(wl, wl->probereq, ieoffset);
2969
2970                         /* enable the connection monitoring feature */
2971                         ret = wl1271_acx_conn_monit_params(wl, true);
2972                         if (ret < 0)
2973                                 goto out;
2974
2975                         /* If we want to go in PSM but we're not there yet */
2976                         if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2977                             !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
2978                                 enum wl1271_cmd_ps_mode mode;
2979
2980                                 mode = STATION_POWER_SAVE_MODE;
2981                                 ret = wl1271_ps_set_mode(wl, mode,
2982                                                          wl->basic_rate,
2983                                                          true);
2984                                 if (ret < 0)
2985                                         goto out;
2986                         }
2987                 } else {
2988                         /* use defaults when not associated */
2989                         bool was_assoc =
2990                             !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
2991                                                  &wl->flags);
2992                         clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
2993                         wl->aid = 0;
2994
2995                         /* free probe-request template */
2996                         dev_kfree_skb(wl->probereq);
2997                         wl->probereq = NULL;
2998
2999                         /* re-enable dynamic ps - just in case */
3000                         ieee80211_enable_dyn_ps(wl->vif);
3001
3002                         /* revert back to minimum rates for the current band */
3003                         wl1271_set_band_rate(wl);
3004                         wl->basic_rate = wl1271_tx_min_rate_get(wl);
3005                         ret = wl1271_acx_sta_rate_policies(wl);
3006                         if (ret < 0)
3007                                 goto out;
3008
3009                         /* disable connection monitor features */
3010                         ret = wl1271_acx_conn_monit_params(wl, false);
3011
3012                         /* Disable the keep-alive feature */
3013                         ret = wl1271_acx_keep_alive_mode(wl, false);
3014                         if (ret < 0)
3015                                 goto out;
3016
3017                         /* restore the bssid filter and go to dummy bssid */
3018                         if (was_assoc) {
3019                                 wl1271_unjoin(wl);
3020                                 wl1271_dummy_join(wl);
3021                         }
3022                 }
3023         }
3024
3025         ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3026         if (ret < 0)
3027                 goto out;
3028
3029         if (changed & BSS_CHANGED_ARP_FILTER) {
3030                 __be32 addr = bss_conf->arp_addr_list[0];
3031                 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3032
3033                 if (bss_conf->arp_addr_cnt == 1 &&
3034                     bss_conf->arp_filter_enabled) {
3035                         /*
3036                          * The template should have been configured only upon
3037                          * association. however, it seems that the correct ip
3038                          * isn't being set (when sending), so we have to
3039                          * reconfigure the template upon every ip change.
3040                          */
3041                         ret = wl1271_cmd_build_arp_rsp(wl, addr);
3042                         if (ret < 0) {
3043                                 wl1271_warning("build arp rsp failed: %d", ret);
3044                                 goto out;
3045                         }
3046
3047                         ret = wl1271_acx_arp_ip_filter(wl,
3048                                 ACX_ARP_FILTER_ARP_FILTERING,
3049                                 addr);
3050                 } else
3051                         ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
3052
3053                 if (ret < 0)
3054                         goto out;
3055         }
3056
3057         if (do_join) {
3058                 ret = wl1271_join(wl, set_assoc);
3059                 if (ret < 0) {
3060                         wl1271_warning("cmd join failed %d", ret);
3061                         goto out;
3062                 }
3063         }
3064
3065 out:
3066         return;
3067 }
3068
3069 static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3070                                        struct ieee80211_vif *vif,
3071                                        struct ieee80211_bss_conf *bss_conf,
3072                                        u32 changed)
3073 {
3074         struct wl1271 *wl = hw->priv;
3075         bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3076         int ret;
3077
3078         wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3079                      (int)changed);
3080
3081         mutex_lock(&wl->mutex);
3082
3083         if (unlikely(wl->state == WL1271_STATE_OFF))
3084                 goto out;
3085
3086         ret = wl1271_ps_elp_wakeup(wl);
3087         if (ret < 0)
3088                 goto out;
3089
3090         if (is_ap)
3091                 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3092         else
3093                 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3094
3095         wl1271_ps_elp_sleep(wl);
3096
3097 out:
3098         mutex_unlock(&wl->mutex);
3099 }
3100
3101 static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3102                              const struct ieee80211_tx_queue_params *params)
3103 {
3104         struct wl1271 *wl = hw->priv;
3105         u8 ps_scheme;
3106         int ret = 0;
3107
3108         mutex_lock(&wl->mutex);
3109
3110         wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3111
3112         if (params->uapsd)
3113                 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3114         else
3115                 ps_scheme = CONF_PS_SCHEME_LEGACY;
3116
3117         if (wl->state == WL1271_STATE_OFF) {
3118                 /*
3119                  * If the state is off, the parameters will be recorded and
3120                  * configured on init. This happens in AP-mode.
3121                  */
3122                 struct conf_tx_ac_category *conf_ac =
3123                         &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3124                 struct conf_tx_tid *conf_tid =
3125                         &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3126
3127                 conf_ac->ac = wl1271_tx_get_queue(queue);
3128                 conf_ac->cw_min = (u8)params->cw_min;
3129                 conf_ac->cw_max = params->cw_max;
3130                 conf_ac->aifsn = params->aifs;
3131                 conf_ac->tx_op_limit = params->txop << 5;
3132
3133                 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3134                 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3135                 conf_tid->tsid = wl1271_tx_get_queue(queue);
3136                 conf_tid->ps_scheme = ps_scheme;
3137                 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3138                 conf_tid->apsd_conf[0] = 0;
3139                 conf_tid->apsd_conf[1] = 0;
3140                 goto out;
3141         }
3142
3143         ret = wl1271_ps_elp_wakeup(wl);
3144         if (ret < 0)
3145                 goto out;
3146
3147         /*
3148          * the txop is confed in units of 32us by the mac80211,
3149          * we need us
3150          */
3151         ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3152                                 params->cw_min, params->cw_max,
3153                                 params->aifs, params->txop << 5);
3154         if (ret < 0)
3155                 goto out_sleep;
3156
3157         ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3158                                  CONF_CHANNEL_TYPE_EDCF,
3159                                  wl1271_tx_get_queue(queue),
3160                                  ps_scheme, CONF_ACK_POLICY_LEGACY,
3161                                  0, 0);
3162
3163 out_sleep:
3164         wl1271_ps_elp_sleep(wl);
3165
3166 out:
3167         mutex_unlock(&wl->mutex);
3168
3169         return ret;
3170 }
3171
3172 static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3173 {
3174
3175         struct wl1271 *wl = hw->priv;
3176         u64 mactime = ULLONG_MAX;
3177         int ret;
3178
3179         wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3180
3181         mutex_lock(&wl->mutex);
3182
3183         if (unlikely(wl->state == WL1271_STATE_OFF))
3184                 goto out;
3185
3186         ret = wl1271_ps_elp_wakeup(wl);
3187         if (ret < 0)
3188                 goto out;
3189
3190         ret = wl1271_acx_tsf_info(wl, &mactime);
3191         if (ret < 0)
3192                 goto out_sleep;
3193
3194 out_sleep:
3195         wl1271_ps_elp_sleep(wl);
3196
3197 out:
3198         mutex_unlock(&wl->mutex);
3199         return mactime;
3200 }
3201
3202 static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3203                                 struct survey_info *survey)
3204 {
3205         struct wl1271 *wl = hw->priv;
3206         struct ieee80211_conf *conf = &hw->conf;
3207
3208         if (idx != 0)
3209                 return -ENOENT;
3210
3211         survey->channel = conf->channel;
3212         survey->filled = SURVEY_INFO_NOISE_DBM;
3213         survey->noise = wl->noise;
3214
3215         return 0;
3216 }
3217
3218 static int wl1271_allocate_sta(struct wl1271 *wl,
3219                              struct ieee80211_sta *sta,
3220                              u8 *hlid)
3221 {
3222         struct wl1271_station *wl_sta;
3223         int id;
3224
3225         id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3226         if (id >= AP_MAX_STATIONS) {
3227                 wl1271_warning("could not allocate HLID - too much stations");
3228                 return -EBUSY;
3229         }
3230
3231         wl_sta = (struct wl1271_station *)sta->drv_priv;
3232         __set_bit(id, wl->ap_hlid_map);
3233         wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3234         *hlid = wl_sta->hlid;
3235         memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
3236         return 0;
3237 }
3238
3239 static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
3240 {
3241         int id = hlid - WL1271_AP_STA_HLID_START;
3242
3243         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3244                 return;
3245
3246         __clear_bit(id, wl->ap_hlid_map);
3247         memset(wl->links[hlid].addr, 0, ETH_ALEN);
3248         wl1271_tx_reset_link_queues(wl, hlid);
3249         __clear_bit(hlid, &wl->ap_ps_map);
3250         __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
3251 }
3252
3253 static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3254                              struct ieee80211_vif *vif,
3255                              struct ieee80211_sta *sta)
3256 {
3257         struct wl1271 *wl = hw->priv;
3258         int ret = 0;
3259         u8 hlid;
3260
3261         mutex_lock(&wl->mutex);
3262
3263         if (unlikely(wl->state == WL1271_STATE_OFF))
3264                 goto out;
3265
3266         if (wl->bss_type != BSS_TYPE_AP_BSS)
3267                 goto out;
3268
3269         wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3270
3271         ret = wl1271_allocate_sta(wl, sta, &hlid);
3272         if (ret < 0)
3273                 goto out;
3274
3275         ret = wl1271_ps_elp_wakeup(wl);
3276         if (ret < 0)
3277                 goto out_free_sta;
3278
3279         ret = wl1271_cmd_add_sta(wl, sta, hlid);
3280         if (ret < 0)
3281                 goto out_sleep;
3282
3283 out_sleep:
3284         wl1271_ps_elp_sleep(wl);
3285
3286 out_free_sta:
3287         if (ret < 0)
3288                 wl1271_free_sta(wl, hlid);
3289
3290 out:
3291         mutex_unlock(&wl->mutex);
3292         return ret;
3293 }
3294
3295 static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3296                                 struct ieee80211_vif *vif,
3297                                 struct ieee80211_sta *sta)
3298 {
3299         struct wl1271 *wl = hw->priv;
3300         struct wl1271_station *wl_sta;
3301         int ret = 0, id;
3302
3303         mutex_lock(&wl->mutex);
3304
3305         if (unlikely(wl->state == WL1271_STATE_OFF))
3306                 goto out;
3307
3308         if (wl->bss_type != BSS_TYPE_AP_BSS)
3309                 goto out;
3310
3311         wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3312
3313         wl_sta = (struct wl1271_station *)sta->drv_priv;
3314         id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3315         if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3316                 goto out;
3317
3318         ret = wl1271_ps_elp_wakeup(wl);
3319         if (ret < 0)
3320                 goto out;
3321
3322         ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3323         if (ret < 0)
3324                 goto out_sleep;
3325
3326         wl1271_free_sta(wl, wl_sta->hlid);
3327
3328 out_sleep:
3329         wl1271_ps_elp_sleep(wl);
3330
3331 out:
3332         mutex_unlock(&wl->mutex);
3333         return ret;
3334 }
3335
3336 static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3337                                   struct ieee80211_vif *vif,
3338                                   enum ieee80211_ampdu_mlme_action action,
3339                                   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3340                                   u8 buf_size)
3341 {
3342         struct wl1271 *wl = hw->priv;
3343         int ret;
3344
3345         mutex_lock(&wl->mutex);
3346
3347         if (unlikely(wl->state == WL1271_STATE_OFF)) {
3348                 ret = -EAGAIN;
3349                 goto out;
3350         }
3351
3352         ret = wl1271_ps_elp_wakeup(wl);
3353         if (ret < 0)
3354                 goto out;
3355
3356         switch (action) {
3357         case IEEE80211_AMPDU_RX_START:
3358                 if (wl->ba_support) {
3359                         ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3360                                                                  true);
3361                         if (!ret)
3362                                 wl->ba_rx_bitmap |= BIT(tid);
3363                 } else {
3364                         ret = -ENOTSUPP;
3365                 }
3366                 break;
3367
3368         case IEEE80211_AMPDU_RX_STOP:
3369                 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3370                 if (!ret)
3371                         wl->ba_rx_bitmap &= ~BIT(tid);
3372                 break;
3373
3374         /*
3375          * The BA initiator session management in FW independently.
3376          * Falling break here on purpose for all TX APDU commands.
3377          */
3378         case IEEE80211_AMPDU_TX_START:
3379         case IEEE80211_AMPDU_TX_STOP:
3380         case IEEE80211_AMPDU_TX_OPERATIONAL:
3381                 ret = -EINVAL;
3382                 break;
3383
3384         default:
3385                 wl1271_error("Incorrect ampdu action id=%x\n", action);
3386                 ret = -EINVAL;
3387         }
3388
3389         wl1271_ps_elp_sleep(wl);
3390
3391 out:
3392         mutex_unlock(&wl->mutex);
3393
3394         return ret;
3395 }
3396
3397 static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3398 {
3399         struct wl1271 *wl = hw->priv;
3400         bool ret = false;
3401
3402         mutex_lock(&wl->mutex);
3403
3404         if (unlikely(wl->state == WL1271_STATE_OFF))
3405                 goto out;
3406
3407         /* packets are considered pending if in the TX queue or the FW */
3408         ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
3409
3410         /* the above is appropriate for STA mode for PS purposes */
3411         WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3412
3413 out:
3414         mutex_unlock(&wl->mutex);
3415
3416         return ret;
3417 }
3418
3419 /* can't be const, mac80211 writes to this */
3420 static struct ieee80211_rate wl1271_rates[] = {
3421         { .bitrate = 10,
3422           .hw_value = CONF_HW_BIT_RATE_1MBPS,
3423           .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
3424         { .bitrate = 20,
3425           .hw_value = CONF_HW_BIT_RATE_2MBPS,
3426           .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
3427           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3428         { .bitrate = 55,
3429           .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3430           .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
3431           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3432         { .bitrate = 110,
3433           .hw_value = CONF_HW_BIT_RATE_11MBPS,
3434           .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
3435           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3436         { .bitrate = 60,
3437           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3438           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3439         { .bitrate = 90,
3440           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3441           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3442         { .bitrate = 120,
3443           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3444           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3445         { .bitrate = 180,
3446           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3447           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3448         { .bitrate = 240,
3449           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3450           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3451         { .bitrate = 360,
3452          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3453          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3454         { .bitrate = 480,
3455           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3456           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3457         { .bitrate = 540,
3458           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3459           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3460 };
3461
3462 /* can't be const, mac80211 writes to this */
3463 static struct ieee80211_channel wl1271_channels[] = {
3464         { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
3465         { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
3466         { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3467         { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3468         { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
3469         { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
3470         { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3471         { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3472         { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
3473         { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
3474         { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3475         { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3476         { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
3477         { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
3478 };
3479
3480 /* mapping to indexes for wl1271_rates */
3481 static const u8 wl1271_rate_to_idx_2ghz[] = {
3482         /* MCS rates are used only with 11n */
3483         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3484         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3485         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3486         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3487         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3488         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3489         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3490         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3491
3492         11,                            /* CONF_HW_RXTX_RATE_54   */
3493         10,                            /* CONF_HW_RXTX_RATE_48   */
3494         9,                             /* CONF_HW_RXTX_RATE_36   */
3495         8,                             /* CONF_HW_RXTX_RATE_24   */
3496
3497         /* TI-specific rate */
3498         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3499
3500         7,                             /* CONF_HW_RXTX_RATE_18   */
3501         6,                             /* CONF_HW_RXTX_RATE_12   */
3502         3,                             /* CONF_HW_RXTX_RATE_11   */
3503         5,                             /* CONF_HW_RXTX_RATE_9    */
3504         4,                             /* CONF_HW_RXTX_RATE_6    */
3505         2,                             /* CONF_HW_RXTX_RATE_5_5  */
3506         1,                             /* CONF_HW_RXTX_RATE_2    */
3507         0                              /* CONF_HW_RXTX_RATE_1    */
3508 };
3509
3510 /* 11n STA capabilities */
3511 #define HW_RX_HIGHEST_RATE      72
3512
3513 #ifdef CONFIG_WL12XX_HT
3514 #define WL12XX_HT_CAP { \
3515         .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3516                (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
3517         .ht_supported = true, \
3518         .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3519         .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3520         .mcs = { \
3521                 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3522                 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3523                 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3524                 }, \
3525 }
3526 #else
3527 #define WL12XX_HT_CAP { \
3528         .ht_supported = false, \
3529 }
3530 #endif
3531
3532 /* can't be const, mac80211 writes to this */
3533 static struct ieee80211_supported_band wl1271_band_2ghz = {
3534         .channels = wl1271_channels,
3535         .n_channels = ARRAY_SIZE(wl1271_channels),
3536         .bitrates = wl1271_rates,
3537         .n_bitrates = ARRAY_SIZE(wl1271_rates),
3538         .ht_cap = WL12XX_HT_CAP,
3539 };
3540
3541 /* 5 GHz data rates for WL1273 */
3542 static struct ieee80211_rate wl1271_rates_5ghz[] = {
3543         { .bitrate = 60,
3544           .hw_value = CONF_HW_BIT_RATE_6MBPS,
3545           .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3546         { .bitrate = 90,
3547           .hw_value = CONF_HW_BIT_RATE_9MBPS,
3548           .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3549         { .bitrate = 120,
3550           .hw_value = CONF_HW_BIT_RATE_12MBPS,
3551           .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3552         { .bitrate = 180,
3553           .hw_value = CONF_HW_BIT_RATE_18MBPS,
3554           .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3555         { .bitrate = 240,
3556           .hw_value = CONF_HW_BIT_RATE_24MBPS,
3557           .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3558         { .bitrate = 360,
3559          .hw_value = CONF_HW_BIT_RATE_36MBPS,
3560          .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3561         { .bitrate = 480,
3562           .hw_value = CONF_HW_BIT_RATE_48MBPS,
3563           .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3564         { .bitrate = 540,
3565           .hw_value = CONF_HW_BIT_RATE_54MBPS,
3566           .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3567 };
3568
3569 /* 5 GHz band channels for WL1273 */
3570 static struct ieee80211_channel wl1271_channels_5ghz[] = {
3571         { .hw_value = 7, .center_freq = 5035},
3572         { .hw_value = 8, .center_freq = 5040},
3573         { .hw_value = 9, .center_freq = 5045},
3574         { .hw_value = 11, .center_freq = 5055},
3575         { .hw_value = 12, .center_freq = 5060},
3576         { .hw_value = 16, .center_freq = 5080},
3577         { .hw_value = 34, .center_freq = 5170},
3578         { .hw_value = 36, .center_freq = 5180},
3579         { .hw_value = 38, .center_freq = 5190},
3580         { .hw_value = 40, .center_freq = 5200},
3581         { .hw_value = 42, .center_freq = 5210},
3582         { .hw_value = 44, .center_freq = 5220},
3583         { .hw_value = 46, .center_freq = 5230},
3584         { .hw_value = 48, .center_freq = 5240},
3585         { .hw_value = 52, .center_freq = 5260},
3586         { .hw_value = 56, .center_freq = 5280},
3587         { .hw_value = 60, .center_freq = 5300},
3588         { .hw_value = 64, .center_freq = 5320},
3589         { .hw_value = 100, .center_freq = 5500},
3590         { .hw_value = 104, .center_freq = 5520},
3591         { .hw_value = 108, .center_freq = 5540},
3592         { .hw_value = 112, .center_freq = 5560},
3593         { .hw_value = 116, .center_freq = 5580},
3594         { .hw_value = 120, .center_freq = 5600},
3595         { .hw_value = 124, .center_freq = 5620},
3596         { .hw_value = 128, .center_freq = 5640},
3597         { .hw_value = 132, .center_freq = 5660},
3598         { .hw_value = 136, .center_freq = 5680},
3599         { .hw_value = 140, .center_freq = 5700},
3600         { .hw_value = 149, .center_freq = 5745},
3601         { .hw_value = 153, .center_freq = 5765},
3602         { .hw_value = 157, .center_freq = 5785},
3603         { .hw_value = 161, .center_freq = 5805},
3604         { .hw_value = 165, .center_freq = 5825},
3605 };
3606
3607 /* mapping to indexes for wl1271_rates_5ghz */
3608 static const u8 wl1271_rate_to_idx_5ghz[] = {
3609         /* MCS rates are used only with 11n */
3610         7,                            /* CONF_HW_RXTX_RATE_MCS7 */
3611         6,                            /* CONF_HW_RXTX_RATE_MCS6 */
3612         5,                            /* CONF_HW_RXTX_RATE_MCS5 */
3613         4,                            /* CONF_HW_RXTX_RATE_MCS4 */
3614         3,                            /* CONF_HW_RXTX_RATE_MCS3 */
3615         2,                            /* CONF_HW_RXTX_RATE_MCS2 */
3616         1,                            /* CONF_HW_RXTX_RATE_MCS1 */
3617         0,                            /* CONF_HW_RXTX_RATE_MCS0 */
3618
3619         7,                             /* CONF_HW_RXTX_RATE_54   */
3620         6,                             /* CONF_HW_RXTX_RATE_48   */
3621         5,                             /* CONF_HW_RXTX_RATE_36   */
3622         4,                             /* CONF_HW_RXTX_RATE_24   */
3623
3624         /* TI-specific rate */
3625         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22   */
3626
3627         3,                             /* CONF_HW_RXTX_RATE_18   */
3628         2,                             /* CONF_HW_RXTX_RATE_12   */
3629         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11   */
3630         1,                             /* CONF_HW_RXTX_RATE_9    */
3631         0,                             /* CONF_HW_RXTX_RATE_6    */
3632         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5  */
3633         CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2    */
3634         CONF_HW_RXTX_RATE_UNSUPPORTED  /* CONF_HW_RXTX_RATE_1    */
3635 };
3636
3637 static struct ieee80211_supported_band wl1271_band_5ghz = {
3638         .channels = wl1271_channels_5ghz,
3639         .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3640         .bitrates = wl1271_rates_5ghz,
3641         .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
3642         .ht_cap = WL12XX_HT_CAP,
3643 };
3644
3645 static const u8 *wl1271_band_rate_to_idx[] = {
3646         [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3647         [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3648 };
3649
3650 static const struct ieee80211_ops wl1271_ops = {
3651         .start = wl1271_op_start,
3652         .stop = wl1271_op_stop,
3653         .add_interface = wl1271_op_add_interface,
3654         .remove_interface = wl1271_op_remove_interface,
3655 #ifdef CONFIG_PM
3656         .suspend = wl1271_op_suspend,
3657         .resume = wl1271_op_resume,
3658 #endif
3659         .config = wl1271_op_config,
3660         .prepare_multicast = wl1271_op_prepare_multicast,
3661         .configure_filter = wl1271_op_configure_filter,
3662         .tx = wl1271_op_tx,
3663         .set_key = wl1271_op_set_key,
3664         .hw_scan = wl1271_op_hw_scan,
3665         .sched_scan_start = wl1271_op_sched_scan_start,
3666         .sched_scan_stop = wl1271_op_sched_scan_stop,
3667         .bss_info_changed = wl1271_op_bss_info_changed,
3668         .set_frag_threshold = wl1271_op_set_frag_threshold,
3669         .set_rts_threshold = wl1271_op_set_rts_threshold,
3670         .conf_tx = wl1271_op_conf_tx,
3671         .get_tsf = wl1271_op_get_tsf,
3672         .get_survey = wl1271_op_get_survey,
3673         .sta_add = wl1271_op_sta_add,
3674         .sta_remove = wl1271_op_sta_remove,
3675         .ampdu_action = wl1271_op_ampdu_action,
3676         .tx_frames_pending = wl1271_tx_frames_pending,
3677         CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
3678 };
3679
3680
3681 u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
3682 {
3683         u8 idx;
3684
3685         BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
3686
3687         if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3688                 wl1271_error("Illegal RX rate from HW: %d", rate);
3689                 return 0;
3690         }
3691
3692         idx = wl1271_band_rate_to_idx[band][rate];
3693         if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3694                 wl1271_error("Unsupported RX rate from HW: %d", rate);
3695                 return 0;
3696         }
3697
3698         return idx;
3699 }
3700
3701 static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3702                                                struct device_attribute *attr,
3703                                                char *buf)
3704 {
3705         struct wl1271 *wl = dev_get_drvdata(dev);
3706         ssize_t len;
3707
3708         len = PAGE_SIZE;
3709
3710         mutex_lock(&wl->mutex);
3711         len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3712                        wl->sg_enabled);
3713         mutex_unlock(&wl->mutex);
3714
3715         return len;
3716
3717 }
3718
3719 static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3720                                                 struct device_attribute *attr,
3721                                                 const char *buf, size_t count)
3722 {
3723         struct wl1271 *wl = dev_get_drvdata(dev);
3724         unsigned long res;
3725         int ret;
3726
3727         ret = kstrtoul(buf, 10, &res);
3728         if (ret < 0) {
3729                 wl1271_warning("incorrect value written to bt_coex_mode");
3730                 return count;
3731         }
3732
3733         mutex_lock(&wl->mutex);
3734
3735         res = !!res;
3736
3737         if (res == wl->sg_enabled)
3738                 goto out;
3739
3740         wl->sg_enabled = res;
3741
3742         if (wl->state == WL1271_STATE_OFF)
3743                 goto out;
3744
3745         ret = wl1271_ps_elp_wakeup(wl);
3746         if (ret < 0)
3747                 goto out;
3748
3749         wl1271_acx_sg_enable(wl, wl->sg_enabled);
3750         wl1271_ps_elp_sleep(wl);
3751
3752  out:
3753         mutex_unlock(&wl->mutex);
3754         return count;
3755 }
3756
3757 static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3758                    wl1271_sysfs_show_bt_coex_state,
3759                    wl1271_sysfs_store_bt_coex_state);
3760
3761 static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3762                                            struct device_attribute *attr,
3763                                            char *buf)
3764 {
3765         struct wl1271 *wl = dev_get_drvdata(dev);
3766         ssize_t len;
3767
3768         len = PAGE_SIZE;
3769
3770         mutex_lock(&wl->mutex);
3771         if (wl->hw_pg_ver >= 0)
3772                 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3773         else
3774                 len = snprintf(buf, len, "n/a\n");
3775         mutex_unlock(&wl->mutex);
3776
3777         return len;
3778 }
3779
3780 static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3781                    wl1271_sysfs_show_hw_pg_ver, NULL);
3782
3783 int wl1271_register_hw(struct wl1271 *wl)
3784 {
3785         int ret;
3786
3787         if (wl->mac80211_registered)
3788                 return 0;
3789
3790         ret = wl1271_fetch_nvs(wl);
3791         if (ret == 0) {
3792                 /* NOTE: The wl->nvs->nvs element must be first, in
3793                  * order to simplify the casting, we assume it is at
3794                  * the beginning of the wl->nvs structure.
3795                  */
3796                 u8 *nvs_ptr = (u8 *)wl->nvs;
3797
3798                 wl->mac_addr[0] = nvs_ptr[11];
3799                 wl->mac_addr[1] = nvs_ptr[10];
3800                 wl->mac_addr[2] = nvs_ptr[6];
3801                 wl->mac_addr[3] = nvs_ptr[5];
3802                 wl->mac_addr[4] = nvs_ptr[4];
3803                 wl->mac_addr[5] = nvs_ptr[3];
3804         }
3805
3806         SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3807
3808         ret = ieee80211_register_hw(wl->hw);
3809         if (ret < 0) {
3810                 wl1271_error("unable to register mac80211 hw: %d", ret);
3811                 return ret;
3812         }
3813
3814         wl->mac80211_registered = true;
3815
3816         wl1271_debugfs_init(wl);
3817
3818         register_netdevice_notifier(&wl1271_dev_notifier);
3819
3820         wl1271_notice("loaded");
3821
3822         return 0;
3823 }
3824 EXPORT_SYMBOL_GPL(wl1271_register_hw);
3825
3826 void wl1271_unregister_hw(struct wl1271 *wl)
3827 {
3828         if (wl->state == WL1271_STATE_PLT)
3829                 __wl1271_plt_stop(wl);
3830
3831         unregister_netdevice_notifier(&wl1271_dev_notifier);
3832         ieee80211_unregister_hw(wl->hw);
3833         wl->mac80211_registered = false;
3834
3835 }
3836 EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3837
3838 int wl1271_init_ieee80211(struct wl1271 *wl)
3839 {
3840         static const u32 cipher_suites[] = {
3841                 WLAN_CIPHER_SUITE_WEP40,
3842                 WLAN_CIPHER_SUITE_WEP104,
3843                 WLAN_CIPHER_SUITE_TKIP,
3844                 WLAN_CIPHER_SUITE_CCMP,
3845                 WL1271_CIPHER_SUITE_GEM,
3846         };
3847
3848         /* The tx descriptor buffer and the TKIP space. */
3849         wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3850                 sizeof(struct wl1271_tx_hw_descr);
3851
3852         /* unit us */
3853         /* FIXME: find a proper value */
3854         wl->hw->channel_change_time = 10000;
3855         wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
3856
3857         wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3858                 IEEE80211_HW_BEACON_FILTER |
3859                 IEEE80211_HW_SUPPORTS_PS |
3860                 IEEE80211_HW_SUPPORTS_UAPSD |
3861                 IEEE80211_HW_HAS_RATE_CONTROL |
3862                 IEEE80211_HW_CONNECTION_MONITOR |
3863                 IEEE80211_HW_SUPPORTS_CQM_RSSI |
3864                 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3865                 IEEE80211_HW_SPECTRUM_MGMT |
3866                 IEEE80211_HW_AP_LINK_PS;
3867
3868         wl->hw->wiphy->cipher_suites = cipher_suites;
3869         wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3870
3871         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3872                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
3873         wl->hw->wiphy->max_scan_ssids = 1;
3874         /*
3875          * Maximum length of elements in scanning probe request templates
3876          * should be the maximum length possible for a template, without
3877          * the IEEE80211 header of the template
3878          */
3879         wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3880                         sizeof(struct ieee80211_header);
3881
3882         /* make sure all our channels fit in the scanned_ch bitmask */
3883         BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3884                      ARRAY_SIZE(wl1271_channels_5ghz) >
3885                      WL1271_MAX_CHANNELS);
3886         /*
3887          * We keep local copies of the band structs because we need to
3888          * modify them on a per-device basis.
3889          */
3890         memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3891                sizeof(wl1271_band_2ghz));
3892         memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3893                sizeof(wl1271_band_5ghz));
3894
3895         wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3896                 &wl->bands[IEEE80211_BAND_2GHZ];
3897         wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3898                 &wl->bands[IEEE80211_BAND_5GHZ];
3899
3900         wl->hw->queues = 4;
3901         wl->hw->max_rates = 1;
3902
3903         wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3904
3905         SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
3906
3907         wl->hw->sta_data_size = sizeof(struct wl1271_station);
3908
3909         wl->hw->max_rx_aggregation_subframes = 8;
3910
3911         return 0;
3912 }
3913 EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
3914
3915 #define WL1271_DEFAULT_CHANNEL 0
3916
3917 struct ieee80211_hw *wl1271_alloc_hw(void)
3918 {
3919         struct ieee80211_hw *hw;
3920         struct platform_device *plat_dev = NULL;
3921         struct wl1271 *wl;
3922         int i, j, ret;
3923         unsigned int order;
3924
3925         hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3926         if (!hw) {
3927                 wl1271_error("could not alloc ieee80211_hw");
3928                 ret = -ENOMEM;
3929                 goto err_hw_alloc;
3930         }
3931
3932         plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3933         if (!plat_dev) {
3934                 wl1271_error("could not allocate platform_device");
3935                 ret = -ENOMEM;
3936                 goto err_plat_alloc;
3937         }
3938
3939         wl = hw->priv;
3940         memset(wl, 0, sizeof(*wl));
3941
3942         INIT_LIST_HEAD(&wl->list);
3943
3944         wl->hw = hw;
3945         wl->plat_dev = plat_dev;
3946
3947         for (i = 0; i < NUM_TX_QUEUES; i++)
3948                 skb_queue_head_init(&wl->tx_queue[i]);
3949
3950         for (i = 0; i < NUM_TX_QUEUES; i++)
3951                 for (j = 0; j < AP_MAX_LINKS; j++)
3952                         skb_queue_head_init(&wl->links[j].tx_queue[i]);
3953
3954         skb_queue_head_init(&wl->deferred_rx_queue);
3955         skb_queue_head_init(&wl->deferred_tx_queue);
3956
3957         INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
3958         INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
3959         INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
3960         INIT_WORK(&wl->tx_work, wl1271_tx_work);
3961         INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3962         INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
3963         wl->channel = WL1271_DEFAULT_CHANNEL;
3964         wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
3965         wl->default_key = 0;
3966         wl->rx_counter = 0;
3967         wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3968         wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
3969         wl->psm_entry_retry = 0;
3970         wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
3971         wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
3972         wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
3973         wl->rate_set = CONF_TX_RATE_MASK_BASIC;
3974         wl->band = IEEE80211_BAND_2GHZ;
3975         wl->vif = NULL;
3976         wl->flags = 0;
3977         wl->sg_enabled = true;
3978         wl->hw_pg_ver = -1;
3979         wl->bss_type = MAX_BSS_TYPE;
3980         wl->set_bss_type = MAX_BSS_TYPE;
3981         wl->fw_bss_type = MAX_BSS_TYPE;
3982         wl->last_tx_hlid = 0;
3983         wl->ap_ps_map = 0;
3984         wl->ap_fw_ps_map = 0;
3985         wl->quirks = 0;
3986         wl->platform_quirks = 0;
3987         wl->sched_scanning = false;
3988
3989         memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
3990         for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
3991                 wl->tx_frames[i] = NULL;
3992
3993         spin_lock_init(&wl->wl_lock);
3994
3995         wl->state = WL1271_STATE_OFF;
3996         mutex_init(&wl->mutex);
3997
3998         /* Apply default driver configuration. */
3999         wl1271_conf_init(wl);
4000
4001         order = get_order(WL1271_AGGR_BUFFER_SIZE);
4002         wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4003         if (!wl->aggr_buf) {
4004                 ret = -ENOMEM;
4005                 goto err_hw;
4006         }
4007
4008         wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4009         if (!wl->dummy_packet) {
4010                 ret = -ENOMEM;
4011                 goto err_aggr;
4012         }
4013
4014         /* Register platform device */
4015         ret = platform_device_register(wl->plat_dev);
4016         if (ret) {
4017                 wl1271_error("couldn't register platform device");
4018                 goto err_dummy_packet;
4019         }
4020         dev_set_drvdata(&wl->plat_dev->dev, wl);
4021
4022         /* Create sysfs file to control bt coex state */
4023         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4024         if (ret < 0) {
4025                 wl1271_error("failed to create sysfs file bt_coex_state");
4026                 goto err_platform;
4027         }
4028
4029         /* Create sysfs file to get HW PG version */
4030         ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4031         if (ret < 0) {
4032                 wl1271_error("failed to create sysfs file hw_pg_ver");
4033                 goto err_bt_coex_state;
4034         }
4035
4036         return hw;
4037
4038 err_bt_coex_state:
4039         device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4040
4041 err_platform:
4042         platform_device_unregister(wl->plat_dev);
4043
4044 err_dummy_packet:
4045         dev_kfree_skb(wl->dummy_packet);
4046
4047 err_aggr:
4048         free_pages((unsigned long)wl->aggr_buf, order);
4049
4050 err_hw:
4051         wl1271_debugfs_exit(wl);
4052         kfree(plat_dev);
4053
4054 err_plat_alloc:
4055         ieee80211_free_hw(hw);
4056
4057 err_hw_alloc:
4058
4059         return ERR_PTR(ret);
4060 }
4061 EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
4062
4063 int wl1271_free_hw(struct wl1271 *wl)
4064 {
4065         platform_device_unregister(wl->plat_dev);
4066         dev_kfree_skb(wl->dummy_packet);
4067         free_pages((unsigned long)wl->aggr_buf,
4068                         get_order(WL1271_AGGR_BUFFER_SIZE));
4069         kfree(wl->plat_dev);
4070
4071         wl1271_debugfs_exit(wl);
4072
4073         vfree(wl->fw);
4074         wl->fw = NULL;
4075         kfree(wl->nvs);
4076         wl->nvs = NULL;
4077
4078         kfree(wl->fw_status);
4079         kfree(wl->tx_res_if);
4080
4081         ieee80211_free_hw(wl->hw);
4082
4083         return 0;
4084 }
4085 EXPORT_SYMBOL_GPL(wl1271_free_hw);
4086
4087 u32 wl12xx_debug_level = DEBUG_NONE;
4088 EXPORT_SYMBOL_GPL(wl12xx_debug_level);
4089 module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
4090 MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4091
4092 MODULE_LICENSE("GPL");
4093 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
4094 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");