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