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