diff options
author | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
---|---|---|
committer | Jonathan Herman <hermanjl@cs.unc.edu> | 2013-01-22 10:38:37 -0500 |
commit | fcc9d2e5a6c89d22b8b773a64fb4ad21ac318446 (patch) | |
tree | a57612d1888735a2ec7972891b68c1ac5ec8faea /drivers/net/wireless/wl12xx/init.c | |
parent | 8dea78da5cee153b8af9c07a2745f6c55057fe12 (diff) |
Diffstat (limited to 'drivers/net/wireless/wl12xx/init.c')
-rw-r--r-- | drivers/net/wireless/wl12xx/init.c | 748 |
1 files changed, 748 insertions, 0 deletions
diff --git a/drivers/net/wireless/wl12xx/init.c b/drivers/net/wireless/wl12xx/init.c new file mode 100644 index 00000000000..c3e9a2e4410 --- /dev/null +++ b/drivers/net/wireless/wl12xx/init.c | |||
@@ -0,0 +1,748 @@ | |||
1 | /* | ||
2 | * This file is part of wl1271 | ||
3 | * | ||
4 | * Copyright (C) 2009 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/kernel.h> | ||
25 | #include <linux/module.h> | ||
26 | #include <linux/slab.h> | ||
27 | |||
28 | #include "init.h" | ||
29 | #include "wl12xx_80211.h" | ||
30 | #include "acx.h" | ||
31 | #include "cmd.h" | ||
32 | #include "reg.h" | ||
33 | #include "tx.h" | ||
34 | #include "io.h" | ||
35 | |||
36 | int wl1271_sta_init_templates_config(struct wl1271 *wl) | ||
37 | { | ||
38 | int ret, i; | ||
39 | |||
40 | /* send empty templates for fw memory reservation */ | ||
41 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4, NULL, | ||
42 | WL1271_CMD_TEMPL_MAX_SIZE, | ||
43 | 0, WL1271_RATE_AUTOMATIC); | ||
44 | if (ret < 0) | ||
45 | return ret; | ||
46 | |||
47 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5, | ||
48 | NULL, WL1271_CMD_TEMPL_MAX_SIZE, 0, | ||
49 | WL1271_RATE_AUTOMATIC); | ||
50 | if (ret < 0) | ||
51 | return ret; | ||
52 | |||
53 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL, | ||
54 | sizeof(struct wl12xx_null_data_template), | ||
55 | 0, WL1271_RATE_AUTOMATIC); | ||
56 | if (ret < 0) | ||
57 | return ret; | ||
58 | |||
59 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PS_POLL, NULL, | ||
60 | sizeof(struct wl12xx_ps_poll_template), | ||
61 | 0, WL1271_RATE_AUTOMATIC); | ||
62 | if (ret < 0) | ||
63 | return ret; | ||
64 | |||
65 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL, | ||
66 | sizeof | ||
67 | (struct wl12xx_qos_null_data_template), | ||
68 | 0, WL1271_RATE_AUTOMATIC); | ||
69 | if (ret < 0) | ||
70 | return ret; | ||
71 | |||
72 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PROBE_RESPONSE, NULL, | ||
73 | sizeof | ||
74 | (struct wl12xx_probe_resp_template), | ||
75 | 0, WL1271_RATE_AUTOMATIC); | ||
76 | if (ret < 0) | ||
77 | return ret; | ||
78 | |||
79 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_BEACON, NULL, | ||
80 | sizeof | ||
81 | (struct wl12xx_beacon_template), | ||
82 | 0, WL1271_RATE_AUTOMATIC); | ||
83 | if (ret < 0) | ||
84 | return ret; | ||
85 | |||
86 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_ARP_RSP, NULL, | ||
87 | sizeof | ||
88 | (struct wl12xx_arp_rsp_template), | ||
89 | 0, WL1271_RATE_AUTOMATIC); | ||
90 | if (ret < 0) | ||
91 | return ret; | ||
92 | |||
93 | for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) { | ||
94 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_KLV, NULL, | ||
95 | WL1271_CMD_TEMPL_MAX_SIZE, i, | ||
96 | WL1271_RATE_AUTOMATIC); | ||
97 | if (ret < 0) | ||
98 | return ret; | ||
99 | } | ||
100 | |||
101 | return 0; | ||
102 | } | ||
103 | |||
104 | static int wl1271_ap_init_deauth_template(struct wl1271 *wl) | ||
105 | { | ||
106 | struct wl12xx_disconn_template *tmpl; | ||
107 | int ret; | ||
108 | |||
109 | tmpl = kzalloc(sizeof(*tmpl), GFP_KERNEL); | ||
110 | if (!tmpl) { | ||
111 | ret = -ENOMEM; | ||
112 | goto out; | ||
113 | } | ||
114 | |||
115 | tmpl->header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | | ||
116 | IEEE80211_STYPE_DEAUTH); | ||
117 | |||
118 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_DEAUTH_AP, | ||
119 | tmpl, sizeof(*tmpl), 0, | ||
120 | wl1271_tx_min_rate_get(wl)); | ||
121 | |||
122 | out: | ||
123 | kfree(tmpl); | ||
124 | return ret; | ||
125 | } | ||
126 | |||
127 | static int wl1271_ap_init_null_template(struct wl1271 *wl) | ||
128 | { | ||
129 | struct ieee80211_hdr_3addr *nullfunc; | ||
130 | int ret; | ||
131 | |||
132 | nullfunc = kzalloc(sizeof(*nullfunc), GFP_KERNEL); | ||
133 | if (!nullfunc) { | ||
134 | ret = -ENOMEM; | ||
135 | goto out; | ||
136 | } | ||
137 | |||
138 | nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | | ||
139 | IEEE80211_STYPE_NULLFUNC | | ||
140 | IEEE80211_FCTL_FROMDS); | ||
141 | |||
142 | /* nullfunc->addr1 is filled by FW */ | ||
143 | |||
144 | memcpy(nullfunc->addr2, wl->mac_addr, ETH_ALEN); | ||
145 | memcpy(nullfunc->addr3, wl->mac_addr, ETH_ALEN); | ||
146 | |||
147 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, nullfunc, | ||
148 | sizeof(*nullfunc), 0, | ||
149 | wl1271_tx_min_rate_get(wl)); | ||
150 | |||
151 | out: | ||
152 | kfree(nullfunc); | ||
153 | return ret; | ||
154 | } | ||
155 | |||
156 | static int wl1271_ap_init_qos_null_template(struct wl1271 *wl) | ||
157 | { | ||
158 | struct ieee80211_qos_hdr *qosnull; | ||
159 | int ret; | ||
160 | |||
161 | qosnull = kzalloc(sizeof(*qosnull), GFP_KERNEL); | ||
162 | if (!qosnull) { | ||
163 | ret = -ENOMEM; | ||
164 | goto out; | ||
165 | } | ||
166 | |||
167 | qosnull->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | | ||
168 | IEEE80211_STYPE_QOS_NULLFUNC | | ||
169 | IEEE80211_FCTL_FROMDS); | ||
170 | |||
171 | /* qosnull->addr1 is filled by FW */ | ||
172 | |||
173 | memcpy(qosnull->addr2, wl->mac_addr, ETH_ALEN); | ||
174 | memcpy(qosnull->addr3, wl->mac_addr, ETH_ALEN); | ||
175 | |||
176 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, qosnull, | ||
177 | sizeof(*qosnull), 0, | ||
178 | wl1271_tx_min_rate_get(wl)); | ||
179 | |||
180 | out: | ||
181 | kfree(qosnull); | ||
182 | return ret; | ||
183 | } | ||
184 | |||
185 | static int wl1271_ap_init_templates_config(struct wl1271 *wl) | ||
186 | { | ||
187 | int ret; | ||
188 | |||
189 | /* | ||
190 | * Put very large empty placeholders for all templates. These | ||
191 | * reserve memory for later. | ||
192 | */ | ||
193 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_AP_PROBE_RESPONSE, NULL, | ||
194 | sizeof | ||
195 | (struct wl12xx_probe_resp_template), | ||
196 | 0, WL1271_RATE_AUTOMATIC); | ||
197 | if (ret < 0) | ||
198 | return ret; | ||
199 | |||
200 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_AP_BEACON, NULL, | ||
201 | sizeof | ||
202 | (struct wl12xx_beacon_template), | ||
203 | 0, WL1271_RATE_AUTOMATIC); | ||
204 | if (ret < 0) | ||
205 | return ret; | ||
206 | |||
207 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_DEAUTH_AP, NULL, | ||
208 | sizeof | ||
209 | (struct wl12xx_disconn_template), | ||
210 | 0, WL1271_RATE_AUTOMATIC); | ||
211 | if (ret < 0) | ||
212 | return ret; | ||
213 | |||
214 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, NULL, | ||
215 | sizeof(struct wl12xx_null_data_template), | ||
216 | 0, WL1271_RATE_AUTOMATIC); | ||
217 | if (ret < 0) | ||
218 | return ret; | ||
219 | |||
220 | ret = wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, NULL, | ||
221 | sizeof | ||
222 | (struct wl12xx_qos_null_data_template), | ||
223 | 0, WL1271_RATE_AUTOMATIC); | ||
224 | if (ret < 0) | ||
225 | return ret; | ||
226 | |||
227 | return 0; | ||
228 | } | ||
229 | |||
230 | static int wl1271_init_rx_config(struct wl1271 *wl, u32 config, u32 filter) | ||
231 | { | ||
232 | int ret; | ||
233 | |||
234 | ret = wl1271_acx_rx_msdu_life_time(wl); | ||
235 | if (ret < 0) | ||
236 | return ret; | ||
237 | |||
238 | ret = wl1271_acx_rx_config(wl, config, filter); | ||
239 | if (ret < 0) | ||
240 | return ret; | ||
241 | |||
242 | return 0; | ||
243 | } | ||
244 | |||
245 | int wl1271_init_phy_config(struct wl1271 *wl) | ||
246 | { | ||
247 | int ret; | ||
248 | |||
249 | ret = wl1271_acx_pd_threshold(wl); | ||
250 | if (ret < 0) | ||
251 | return ret; | ||
252 | |||
253 | ret = wl1271_acx_slot(wl, DEFAULT_SLOT_TIME); | ||
254 | if (ret < 0) | ||
255 | return ret; | ||
256 | |||
257 | ret = wl1271_acx_service_period_timeout(wl); | ||
258 | if (ret < 0) | ||
259 | return ret; | ||
260 | |||
261 | ret = wl1271_acx_rts_threshold(wl, wl->hw->wiphy->rts_threshold); | ||
262 | if (ret < 0) | ||
263 | return ret; | ||
264 | |||
265 | return 0; | ||
266 | } | ||
267 | |||
268 | static int wl1271_init_beacon_filter(struct wl1271 *wl) | ||
269 | { | ||
270 | int ret; | ||
271 | |||
272 | /* disable beacon filtering at this stage */ | ||
273 | ret = wl1271_acx_beacon_filter_opt(wl, false); | ||
274 | if (ret < 0) | ||
275 | return ret; | ||
276 | |||
277 | ret = wl1271_acx_beacon_filter_table(wl); | ||
278 | if (ret < 0) | ||
279 | return ret; | ||
280 | |||
281 | return 0; | ||
282 | } | ||
283 | |||
284 | int wl1271_init_pta(struct wl1271 *wl) | ||
285 | { | ||
286 | int ret; | ||
287 | |||
288 | if (wl->bss_type == BSS_TYPE_AP_BSS) | ||
289 | ret = wl1271_acx_ap_sg_cfg(wl); | ||
290 | else | ||
291 | ret = wl1271_acx_sta_sg_cfg(wl); | ||
292 | if (ret < 0) | ||
293 | return ret; | ||
294 | |||
295 | ret = wl1271_acx_sg_enable(wl, wl->sg_enabled); | ||
296 | if (ret < 0) | ||
297 | return ret; | ||
298 | |||
299 | return 0; | ||
300 | } | ||
301 | |||
302 | int wl1271_init_energy_detection(struct wl1271 *wl) | ||
303 | { | ||
304 | int ret; | ||
305 | |||
306 | ret = wl1271_acx_cca_threshold(wl); | ||
307 | if (ret < 0) | ||
308 | return ret; | ||
309 | |||
310 | return 0; | ||
311 | } | ||
312 | |||
313 | static int wl1271_init_beacon_broadcast(struct wl1271 *wl) | ||
314 | { | ||
315 | int ret; | ||
316 | |||
317 | ret = wl1271_acx_bcn_dtim_options(wl); | ||
318 | if (ret < 0) | ||
319 | return ret; | ||
320 | |||
321 | return 0; | ||
322 | } | ||
323 | |||
324 | static int wl12xx_init_fwlog(struct wl1271 *wl) | ||
325 | { | ||
326 | int ret; | ||
327 | |||
328 | if (wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) | ||
329 | return 0; | ||
330 | |||
331 | ret = wl12xx_cmd_config_fwlog(wl); | ||
332 | if (ret < 0) | ||
333 | return ret; | ||
334 | |||
335 | return 0; | ||
336 | } | ||
337 | |||
338 | static int wl1271_sta_hw_init(struct wl1271 *wl) | ||
339 | { | ||
340 | int ret; | ||
341 | |||
342 | if (wl->chip.id != CHIP_ID_1283_PG20) { | ||
343 | ret = wl1271_cmd_ext_radio_parms(wl); | ||
344 | if (ret < 0) | ||
345 | return ret; | ||
346 | } | ||
347 | |||
348 | /* PS config */ | ||
349 | ret = wl1271_acx_config_ps(wl); | ||
350 | if (ret < 0) | ||
351 | return ret; | ||
352 | |||
353 | ret = wl1271_sta_init_templates_config(wl); | ||
354 | if (ret < 0) | ||
355 | return ret; | ||
356 | |||
357 | ret = wl1271_acx_group_address_tbl(wl, true, NULL, 0); | ||
358 | if (ret < 0) | ||
359 | return ret; | ||
360 | |||
361 | /* Initialize connection monitoring thresholds */ | ||
362 | ret = wl1271_acx_conn_monit_params(wl, false); | ||
363 | if (ret < 0) | ||
364 | return ret; | ||
365 | |||
366 | /* Beacon filtering */ | ||
367 | ret = wl1271_init_beacon_filter(wl); | ||
368 | if (ret < 0) | ||
369 | return ret; | ||
370 | |||
371 | /* FM WLAN coexistence */ | ||
372 | ret = wl1271_acx_fm_coex(wl); | ||
373 | if (ret < 0) | ||
374 | return ret; | ||
375 | |||
376 | /* Beacons and broadcast settings */ | ||
377 | ret = wl1271_init_beacon_broadcast(wl); | ||
378 | if (ret < 0) | ||
379 | return ret; | ||
380 | |||
381 | /* Configure for ELP power saving */ | ||
382 | ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP); | ||
383 | if (ret < 0) | ||
384 | return ret; | ||
385 | |||
386 | /* Configure rssi/snr averaging weights */ | ||
387 | ret = wl1271_acx_rssi_snr_avg_weights(wl); | ||
388 | if (ret < 0) | ||
389 | return ret; | ||
390 | |||
391 | ret = wl1271_acx_sta_rate_policies(wl); | ||
392 | if (ret < 0) | ||
393 | return ret; | ||
394 | |||
395 | ret = wl1271_acx_sta_mem_cfg(wl); | ||
396 | if (ret < 0) | ||
397 | return ret; | ||
398 | |||
399 | /* Configure the FW logger */ | ||
400 | ret = wl12xx_init_fwlog(wl); | ||
401 | if (ret < 0) | ||
402 | return ret; | ||
403 | |||
404 | return 0; | ||
405 | } | ||
406 | |||
407 | static int wl1271_sta_hw_init_post_mem(struct wl1271 *wl) | ||
408 | { | ||
409 | int ret, i; | ||
410 | |||
411 | ret = wl1271_cmd_set_sta_default_wep_key(wl, wl->default_key); | ||
412 | if (ret < 0) { | ||
413 | wl1271_warning("couldn't set default key"); | ||
414 | return ret; | ||
415 | } | ||
416 | |||
417 | /* disable all keep-alive templates */ | ||
418 | for (i = 0; i < CMD_TEMPL_KLV_IDX_MAX; i++) { | ||
419 | ret = wl1271_acx_keep_alive_config(wl, i, | ||
420 | ACX_KEEP_ALIVE_TPL_INVALID); | ||
421 | if (ret < 0) | ||
422 | return ret; | ||
423 | } | ||
424 | |||
425 | /* disable the keep-alive feature */ | ||
426 | ret = wl1271_acx_keep_alive_mode(wl, false); | ||
427 | if (ret < 0) | ||
428 | return ret; | ||
429 | |||
430 | return 0; | ||
431 | } | ||
432 | |||
433 | static int wl1271_ap_hw_init(struct wl1271 *wl) | ||
434 | { | ||
435 | int ret; | ||
436 | |||
437 | ret = wl1271_ap_init_templates_config(wl); | ||
438 | if (ret < 0) | ||
439 | return ret; | ||
440 | |||
441 | /* Configure for power always on */ | ||
442 | ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM); | ||
443 | if (ret < 0) | ||
444 | return ret; | ||
445 | |||
446 | ret = wl1271_init_ap_rates(wl); | ||
447 | if (ret < 0) | ||
448 | return ret; | ||
449 | |||
450 | ret = wl1271_acx_ap_max_tx_retry(wl); | ||
451 | if (ret < 0) | ||
452 | return ret; | ||
453 | |||
454 | ret = wl1271_acx_ap_mem_cfg(wl); | ||
455 | if (ret < 0) | ||
456 | return ret; | ||
457 | |||
458 | /* initialize Tx power */ | ||
459 | ret = wl1271_acx_tx_power(wl, wl->power_level); | ||
460 | if (ret < 0) | ||
461 | return ret; | ||
462 | |||
463 | return 0; | ||
464 | } | ||
465 | |||
466 | int wl1271_ap_init_templates(struct wl1271 *wl) | ||
467 | { | ||
468 | int ret; | ||
469 | |||
470 | ret = wl1271_ap_init_deauth_template(wl); | ||
471 | if (ret < 0) | ||
472 | return ret; | ||
473 | |||
474 | ret = wl1271_ap_init_null_template(wl); | ||
475 | if (ret < 0) | ||
476 | return ret; | ||
477 | |||
478 | ret = wl1271_ap_init_qos_null_template(wl); | ||
479 | if (ret < 0) | ||
480 | return ret; | ||
481 | |||
482 | /* | ||
483 | * when operating as AP we want to receive external beacons for | ||
484 | * configuring ERP protection. | ||
485 | */ | ||
486 | ret = wl1271_acx_set_ap_beacon_filter(wl, false); | ||
487 | if (ret < 0) | ||
488 | return ret; | ||
489 | |||
490 | return 0; | ||
491 | } | ||
492 | |||
493 | static int wl1271_ap_hw_init_post_mem(struct wl1271 *wl) | ||
494 | { | ||
495 | return wl1271_ap_init_templates(wl); | ||
496 | } | ||
497 | |||
498 | int wl1271_init_ap_rates(struct wl1271 *wl) | ||
499 | { | ||
500 | int i, ret; | ||
501 | struct conf_tx_rate_class rc; | ||
502 | u32 supported_rates; | ||
503 | |||
504 | wl1271_debug(DEBUG_AP, "AP basic rate set: 0x%x", wl->basic_rate_set); | ||
505 | |||
506 | if (wl->basic_rate_set == 0) | ||
507 | return -EINVAL; | ||
508 | |||
509 | rc.enabled_rates = wl->basic_rate_set; | ||
510 | rc.long_retry_limit = 10; | ||
511 | rc.short_retry_limit = 10; | ||
512 | rc.aflags = 0; | ||
513 | ret = wl1271_acx_ap_rate_policy(wl, &rc, ACX_TX_AP_MODE_MGMT_RATE); | ||
514 | if (ret < 0) | ||
515 | return ret; | ||
516 | |||
517 | /* use the min basic rate for AP broadcast/multicast */ | ||
518 | rc.enabled_rates = wl1271_tx_min_rate_get(wl); | ||
519 | rc.short_retry_limit = 10; | ||
520 | rc.long_retry_limit = 10; | ||
521 | rc.aflags = 0; | ||
522 | ret = wl1271_acx_ap_rate_policy(wl, &rc, ACX_TX_AP_MODE_BCST_RATE); | ||
523 | if (ret < 0) | ||
524 | return ret; | ||
525 | |||
526 | /* | ||
527 | * If the basic rates contain OFDM rates, use OFDM only | ||
528 | * rates for unicast TX as well. Else use all supported rates. | ||
529 | */ | ||
530 | if ((wl->basic_rate_set & CONF_TX_OFDM_RATES)) | ||
531 | supported_rates = CONF_TX_OFDM_RATES; | ||
532 | else | ||
533 | supported_rates = CONF_TX_AP_ENABLED_RATES; | ||
534 | |||
535 | /* configure unicast TX rate classes */ | ||
536 | for (i = 0; i < wl->conf.tx.ac_conf_count; i++) { | ||
537 | rc.enabled_rates = supported_rates; | ||
538 | rc.short_retry_limit = 10; | ||
539 | rc.long_retry_limit = 10; | ||
540 | rc.aflags = 0; | ||
541 | ret = wl1271_acx_ap_rate_policy(wl, &rc, i); | ||
542 | if (ret < 0) | ||
543 | return ret; | ||
544 | } | ||
545 | |||
546 | return 0; | ||
547 | } | ||
548 | |||
549 | static void wl1271_check_ba_support(struct wl1271 *wl) | ||
550 | { | ||
551 | /* validate FW cose ver x.x.x.50-60.x */ | ||
552 | if ((wl->chip.fw_ver[3] >= WL12XX_BA_SUPPORT_FW_COST_VER2_START) && | ||
553 | (wl->chip.fw_ver[3] < WL12XX_BA_SUPPORT_FW_COST_VER2_END)) { | ||
554 | wl->ba_support = true; | ||
555 | return; | ||
556 | } | ||
557 | |||
558 | wl->ba_support = false; | ||
559 | } | ||
560 | |||
561 | static int wl1271_set_ba_policies(struct wl1271 *wl) | ||
562 | { | ||
563 | u8 tid_index; | ||
564 | int ret = 0; | ||
565 | |||
566 | /* Reset the BA RX indicators */ | ||
567 | wl->ba_rx_bitmap = 0; | ||
568 | wl->ba_allowed = true; | ||
569 | |||
570 | /* validate that FW support BA */ | ||
571 | wl1271_check_ba_support(wl); | ||
572 | |||
573 | if (wl->ba_support) | ||
574 | /* 802.11n initiator BA session setting */ | ||
575 | for (tid_index = 0; tid_index < CONF_TX_MAX_TID_COUNT; | ||
576 | ++tid_index) { | ||
577 | ret = wl1271_acx_set_ba_session(wl, WLAN_BACK_INITIATOR, | ||
578 | tid_index, true); | ||
579 | if (ret < 0) | ||
580 | break; | ||
581 | } | ||
582 | |||
583 | return ret; | ||
584 | } | ||
585 | |||
586 | int wl1271_chip_specific_init(struct wl1271 *wl) | ||
587 | { | ||
588 | int ret = 0; | ||
589 | |||
590 | if (wl->chip.id == CHIP_ID_1283_PG20) { | ||
591 | u32 host_cfg_bitmap = HOST_IF_CFG_RX_FIFO_ENABLE; | ||
592 | |||
593 | if (wl->quirks & WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT) | ||
594 | /* Enable SDIO padding */ | ||
595 | host_cfg_bitmap |= HOST_IF_CFG_TX_PAD_TO_SDIO_BLK; | ||
596 | |||
597 | /* Must be before wl1271_acx_init_mem_config() */ | ||
598 | ret = wl1271_acx_host_if_cfg_bitmap(wl, host_cfg_bitmap); | ||
599 | if (ret < 0) | ||
600 | goto out; | ||
601 | } | ||
602 | out: | ||
603 | return ret; | ||
604 | } | ||
605 | |||
606 | |||
607 | int wl1271_hw_init(struct wl1271 *wl) | ||
608 | { | ||
609 | struct conf_tx_ac_category *conf_ac; | ||
610 | struct conf_tx_tid *conf_tid; | ||
611 | int ret, i; | ||
612 | bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS); | ||
613 | |||
614 | if (wl->chip.id == CHIP_ID_1283_PG20) | ||
615 | ret = wl128x_cmd_general_parms(wl); | ||
616 | else | ||
617 | ret = wl1271_cmd_general_parms(wl); | ||
618 | if (ret < 0) | ||
619 | return ret; | ||
620 | |||
621 | if (wl->chip.id == CHIP_ID_1283_PG20) | ||
622 | ret = wl128x_cmd_radio_parms(wl); | ||
623 | else | ||
624 | ret = wl1271_cmd_radio_parms(wl); | ||
625 | if (ret < 0) | ||
626 | return ret; | ||
627 | |||
628 | /* Chip-specific init */ | ||
629 | ret = wl1271_chip_specific_init(wl); | ||
630 | if (ret < 0) | ||
631 | return ret; | ||
632 | |||
633 | /* Mode specific init */ | ||
634 | if (is_ap) | ||
635 | ret = wl1271_ap_hw_init(wl); | ||
636 | else | ||
637 | ret = wl1271_sta_hw_init(wl); | ||
638 | |||
639 | if (ret < 0) | ||
640 | return ret; | ||
641 | |||
642 | /* Bluetooth WLAN coexistence */ | ||
643 | ret = wl1271_init_pta(wl); | ||
644 | if (ret < 0) | ||
645 | return ret; | ||
646 | |||
647 | /* Default memory configuration */ | ||
648 | ret = wl1271_acx_init_mem_config(wl); | ||
649 | if (ret < 0) | ||
650 | return ret; | ||
651 | |||
652 | /* RX config */ | ||
653 | ret = wl1271_init_rx_config(wl, | ||
654 | RX_CFG_PROMISCUOUS | RX_CFG_TSF, | ||
655 | RX_FILTER_OPTION_DEF); | ||
656 | /* RX_CONFIG_OPTION_ANY_DST_ANY_BSS, | ||
657 | RX_FILTER_OPTION_FILTER_ALL); */ | ||
658 | if (ret < 0) | ||
659 | goto out_free_memmap; | ||
660 | |||
661 | /* PHY layer config */ | ||
662 | ret = wl1271_init_phy_config(wl); | ||
663 | if (ret < 0) | ||
664 | goto out_free_memmap; | ||
665 | |||
666 | ret = wl1271_acx_dco_itrim_params(wl); | ||
667 | if (ret < 0) | ||
668 | goto out_free_memmap; | ||
669 | |||
670 | /* Configure TX patch complete interrupt behavior */ | ||
671 | ret = wl1271_acx_tx_config_options(wl); | ||
672 | if (ret < 0) | ||
673 | goto out_free_memmap; | ||
674 | |||
675 | /* RX complete interrupt pacing */ | ||
676 | ret = wl1271_acx_init_rx_interrupt(wl); | ||
677 | if (ret < 0) | ||
678 | goto out_free_memmap; | ||
679 | |||
680 | /* Energy detection */ | ||
681 | ret = wl1271_init_energy_detection(wl); | ||
682 | if (ret < 0) | ||
683 | goto out_free_memmap; | ||
684 | |||
685 | /* Default fragmentation threshold */ | ||
686 | ret = wl1271_acx_frag_threshold(wl, wl->hw->wiphy->frag_threshold); | ||
687 | if (ret < 0) | ||
688 | goto out_free_memmap; | ||
689 | |||
690 | /* Default TID/AC configuration */ | ||
691 | BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count); | ||
692 | for (i = 0; i < wl->conf.tx.tid_conf_count; i++) { | ||
693 | conf_ac = &wl->conf.tx.ac_conf[i]; | ||
694 | ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min, | ||
695 | conf_ac->cw_max, conf_ac->aifsn, | ||
696 | conf_ac->tx_op_limit); | ||
697 | if (ret < 0) | ||
698 | goto out_free_memmap; | ||
699 | |||
700 | conf_tid = &wl->conf.tx.tid_conf[i]; | ||
701 | ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id, | ||
702 | conf_tid->channel_type, | ||
703 | conf_tid->tsid, | ||
704 | conf_tid->ps_scheme, | ||
705 | conf_tid->ack_policy, | ||
706 | conf_tid->apsd_conf[0], | ||
707 | conf_tid->apsd_conf[1]); | ||
708 | if (ret < 0) | ||
709 | goto out_free_memmap; | ||
710 | } | ||
711 | |||
712 | /* Enable data path */ | ||
713 | ret = wl1271_cmd_data_path(wl, 1); | ||
714 | if (ret < 0) | ||
715 | goto out_free_memmap; | ||
716 | |||
717 | /* Configure HW encryption */ | ||
718 | ret = wl1271_acx_feature_cfg(wl); | ||
719 | if (ret < 0) | ||
720 | goto out_free_memmap; | ||
721 | |||
722 | /* configure PM */ | ||
723 | ret = wl1271_acx_pm_config(wl); | ||
724 | if (ret < 0) | ||
725 | goto out_free_memmap; | ||
726 | |||
727 | /* Mode specific init - post mem init */ | ||
728 | if (is_ap) | ||
729 | ret = wl1271_ap_hw_init_post_mem(wl); | ||
730 | else | ||
731 | ret = wl1271_sta_hw_init_post_mem(wl); | ||
732 | |||
733 | if (ret < 0) | ||
734 | goto out_free_memmap; | ||
735 | |||
736 | /* Configure initiator BA sessions policies */ | ||
737 | ret = wl1271_set_ba_policies(wl); | ||
738 | if (ret < 0) | ||
739 | goto out_free_memmap; | ||
740 | |||
741 | return 0; | ||
742 | |||
743 | out_free_memmap: | ||
744 | kfree(wl->target_mem_map); | ||
745 | wl->target_mem_map = NULL; | ||
746 | |||
747 | return ret; | ||
748 | } | ||