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