FreeBSD/Linux Kernel Cross Reference
sys/dev/rtwn/if_rtwn.c
1 /* $OpenBSD: if_urtwn.c,v 1.16 2011/02/10 17:26:40 jakemsr Exp $ */
2
3 /*-
4 * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr>
5 * Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org>
6 * Copyright (c) 2015-2016 Andriy Voskoboinyk <avos@FreeBSD.org>
7 *
8 * Permission to use, copy, modify, and distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above
10 * copyright notice and this permission notice appear in all copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 */
20
21 #include <sys/cdefs.h>
22 __FBSDID("$FreeBSD$");
23
24 /*
25 * Driver for Realtek RTL8188CE-VAU/RTL8188CUS/RTL8188EU/RTL8188RU/RTL8192CU/RTL8812AU/RTL8821AU.
26 */
27 #include "opt_wlan.h"
28
29 #include <sys/param.h>
30 #include <sys/sockio.h>
31 #include <sys/sysctl.h>
32 #include <sys/lock.h>
33 #include <sys/mutex.h>
34 #include <sys/mbuf.h>
35 #include <sys/kernel.h>
36 #include <sys/socket.h>
37 #include <sys/systm.h>
38 #include <sys/malloc.h>
39 #include <sys/module.h>
40 #include <sys/bus.h>
41 #include <sys/endian.h>
42 #include <sys/linker.h>
43 #include <sys/firmware.h>
44 #include <sys/kdb.h>
45
46 #include <net/bpf.h>
47 #include <net/if.h>
48 #include <net/if_var.h>
49 #include <net/if_arp.h>
50 #include <net/ethernet.h>
51 #include <net/if_dl.h>
52 #include <net/if_media.h>
53 #include <net/if_types.h>
54
55 #include <netinet/in.h>
56 #include <netinet/in_systm.h>
57 #include <netinet/in_var.h>
58 #include <netinet/if_ether.h>
59 #include <netinet/ip.h>
60
61 #include <net80211/ieee80211_var.h>
62 #include <net80211/ieee80211_regdomain.h>
63 #include <net80211/ieee80211_radiotap.h>
64 #include <net80211/ieee80211_ratectl.h>
65
66 #include <dev/rtwn/if_rtwnreg.h>
67 #include <dev/rtwn/if_rtwnvar.h>
68
69 #include <dev/rtwn/if_rtwn_beacon.h>
70 #include <dev/rtwn/if_rtwn_calib.h>
71 #include <dev/rtwn/if_rtwn_cam.h>
72 #include <dev/rtwn/if_rtwn_debug.h>
73 #include <dev/rtwn/if_rtwn_efuse.h>
74 #include <dev/rtwn/if_rtwn_fw.h>
75 #include <dev/rtwn/if_rtwn_ridx.h>
76 #include <dev/rtwn/if_rtwn_rx.h>
77 #include <dev/rtwn/if_rtwn_task.h>
78 #include <dev/rtwn/if_rtwn_tx.h>
79
80 #include <dev/rtwn/rtl8192c/r92c_reg.h>
81
82 static void rtwn_radiotap_attach(struct rtwn_softc *);
83 static void rtwn_vap_decrement_counters(struct rtwn_softc *,
84 enum ieee80211_opmode, int);
85 static void rtwn_set_ic_opmode(struct rtwn_softc *);
86 static struct ieee80211vap *rtwn_vap_create(struct ieee80211com *,
87 const char [IFNAMSIZ], int, enum ieee80211_opmode,
88 int, const uint8_t [IEEE80211_ADDR_LEN],
89 const uint8_t [IEEE80211_ADDR_LEN]);
90 static void rtwn_vap_delete(struct ieee80211vap *);
91 static int rtwn_read_chipid(struct rtwn_softc *);
92 static int rtwn_ioctl_reset(struct ieee80211vap *, u_long);
93 static void rtwn_set_media_status(struct rtwn_softc *,
94 union sec_param *);
95 #ifndef RTWN_WITHOUT_UCODE
96 static int rtwn_tx_fwpkt_check(struct rtwn_softc *,
97 struct ieee80211vap *);
98 static int rtwn_construct_nulldata(struct rtwn_softc *,
99 struct ieee80211vap *, uint8_t *, int);
100 static int rtwn_push_nulldata(struct rtwn_softc *,
101 struct ieee80211vap *);
102 static void rtwn_pwrmode_init(void *);
103 static void rtwn_set_pwrmode_cb(struct rtwn_softc *,
104 union sec_param *);
105 #endif
106 static void rtwn_tsf_sync_adhoc(void *);
107 static void rtwn_tsf_sync_adhoc_task(void *, int);
108 static void rtwn_tsf_sync_enable(struct rtwn_softc *,
109 struct ieee80211vap *);
110 static void rtwn_set_ack_preamble(struct rtwn_softc *);
111 static void rtwn_set_mode(struct rtwn_softc *, uint8_t, int);
112 static int rtwn_monitor_newstate(struct ieee80211vap *,
113 enum ieee80211_state, int);
114 static int rtwn_newstate(struct ieee80211vap *,
115 enum ieee80211_state, int);
116 static void rtwn_calc_basicrates(struct rtwn_softc *);
117 static int rtwn_run(struct rtwn_softc *,
118 struct ieee80211vap *);
119 #ifndef D4054
120 static void rtwn_watchdog(void *);
121 #endif
122 static void rtwn_parent(struct ieee80211com *);
123 static int rtwn_dma_init(struct rtwn_softc *);
124 static int rtwn_mac_init(struct rtwn_softc *);
125 static void rtwn_mrr_init(struct rtwn_softc *);
126 static void rtwn_scan_start(struct ieee80211com *);
127 static void rtwn_scan_curchan(struct ieee80211_scan_state *,
128 unsigned long);
129 static void rtwn_scan_end(struct ieee80211com *);
130 static void rtwn_getradiocaps(struct ieee80211com *, int, int *,
131 struct ieee80211_channel[]);
132 static void rtwn_update_chw(struct ieee80211com *);
133 static void rtwn_set_channel(struct ieee80211com *);
134 static int rtwn_wme_update(struct ieee80211com *);
135 static void rtwn_update_slot(struct ieee80211com *);
136 static void rtwn_update_slot_cb(struct rtwn_softc *,
137 union sec_param *);
138 static void rtwn_update_aifs(struct rtwn_softc *, uint8_t);
139 static void rtwn_update_promisc(struct ieee80211com *);
140 static void rtwn_update_mcast(struct ieee80211com *);
141 static int rtwn_set_bssid(struct rtwn_softc *,
142 const uint8_t *, int);
143 static int rtwn_set_macaddr(struct rtwn_softc *,
144 const uint8_t *, int);
145 static struct ieee80211_node *rtwn_node_alloc(struct ieee80211vap *,
146 const uint8_t mac[IEEE80211_ADDR_LEN]);
147 static void rtwn_newassoc(struct ieee80211_node *, int);
148 static void rtwn_node_free(struct ieee80211_node *);
149 static void rtwn_init_beacon_reg(struct rtwn_softc *);
150 static int rtwn_init(struct rtwn_softc *);
151 static void rtwn_stop(struct rtwn_softc *);
152
153 MALLOC_DEFINE(M_RTWN_PRIV, "rtwn_priv", "rtwn driver private state");
154
155 static const uint16_t wme2reg[] =
156 { R92C_EDCA_BE_PARAM, R92C_EDCA_BK_PARAM,
157 R92C_EDCA_VI_PARAM, R92C_EDCA_VO_PARAM };
158
159 int
160 rtwn_attach(struct rtwn_softc *sc)
161 {
162 struct ieee80211com *ic = &sc->sc_ic;
163 int error;
164
165 sc->cur_bcnq_id = RTWN_VAP_ID_INVALID;
166
167 RTWN_NT_LOCK_INIT(sc);
168 rtwn_cmdq_init(sc);
169 #ifndef D4054
170 callout_init_mtx(&sc->sc_watchdog_to, &sc->sc_mtx, 0);
171 #endif
172 callout_init(&sc->sc_calib_to, 0);
173 callout_init(&sc->sc_pwrmode_init, 0);
174 mbufq_init(&sc->sc_snd, ifqmaxlen);
175
176 RTWN_LOCK(sc);
177 error = rtwn_read_chipid(sc);
178 RTWN_UNLOCK(sc);
179 if (error != 0) {
180 device_printf(sc->sc_dev, "unsupported test chip\n");
181 goto detach;
182 }
183
184 error = rtwn_read_rom(sc);
185 if (error != 0) {
186 device_printf(sc->sc_dev, "%s: cannot read rom, error %d\n",
187 __func__, error);
188 goto detach;
189 }
190
191 if (sc->macid_limit > RTWN_MACID_LIMIT) {
192 device_printf(sc->sc_dev,
193 "macid limit will be reduced from %d to %d\n",
194 sc->macid_limit, RTWN_MACID_LIMIT);
195 sc->macid_limit = RTWN_MACID_LIMIT;
196 }
197 if (sc->cam_entry_limit > RTWN_CAM_ENTRY_LIMIT) {
198 device_printf(sc->sc_dev,
199 "cam entry limit will be reduced from %d to %d\n",
200 sc->cam_entry_limit, RTWN_CAM_ENTRY_LIMIT);
201 sc->cam_entry_limit = RTWN_CAM_ENTRY_LIMIT;
202 }
203 if (sc->txdesc_len > RTWN_TX_DESC_SIZE) {
204 device_printf(sc->sc_dev,
205 "adjust size for Tx descriptor (current %d, needed %d)\n",
206 RTWN_TX_DESC_SIZE, sc->txdesc_len);
207 goto detach;
208 }
209
210 device_printf(sc->sc_dev, "MAC/BB %s, RF 6052 %dT%dR\n",
211 sc->name, sc->ntxchains, sc->nrxchains);
212
213 ic->ic_softc = sc;
214 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
215 ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
216
217 /* set device capabilities */
218 ic->ic_caps =
219 IEEE80211_C_STA /* station mode */
220 | IEEE80211_C_MONITOR /* monitor mode */
221 | IEEE80211_C_IBSS /* adhoc mode */
222 | IEEE80211_C_HOSTAP /* hostap mode */
223 #if 0 /* TODO: HRPWM register setup */
224 #ifndef RTWN_WITHOUT_UCODE
225 | IEEE80211_C_PMGT /* Station-side power mgmt */
226 #endif
227 #endif
228 | IEEE80211_C_SHPREAMBLE /* short preamble supported */
229 | IEEE80211_C_SHSLOT /* short slot time supported */
230 #if 0
231 | IEEE80211_C_BGSCAN /* capable of bg scanning */
232 #endif
233 | IEEE80211_C_WPA /* 802.11i */
234 | IEEE80211_C_WME /* 802.11e */
235 | IEEE80211_C_SWAMSDUTX /* Do software A-MSDU TX */
236 | IEEE80211_C_FF /* Atheros fast-frames */
237 ;
238
239 if (sc->sc_hwcrypto != RTWN_CRYPTO_SW) {
240 ic->ic_cryptocaps =
241 IEEE80211_CRYPTO_WEP |
242 IEEE80211_CRYPTO_TKIP |
243 IEEE80211_CRYPTO_AES_CCM;
244 }
245
246 ic->ic_htcaps =
247 IEEE80211_HTCAP_SHORTGI20 /* short GI in 20MHz */
248 | IEEE80211_HTCAP_MAXAMSDU_3839 /* max A-MSDU length */
249 | IEEE80211_HTCAP_SMPS_OFF /* SM PS mode disabled */
250 /* s/w capabilities */
251 | IEEE80211_HTC_HT /* HT operation */
252 | IEEE80211_HTC_AMPDU /* A-MPDU tx */
253 | IEEE80211_HTC_AMSDU /* A-MSDU tx */
254 ;
255
256 if (sc->sc_ht40) {
257 ic->ic_htcaps |=
258 IEEE80211_HTCAP_CHWIDTH40 /* 40 MHz channel width */
259 | IEEE80211_HTCAP_SHORTGI40 /* short GI in 40MHz */
260 ;
261 }
262
263 ic->ic_txstream = sc->ntxchains;
264 ic->ic_rxstream = sc->nrxchains;
265
266 /* Enable TX watchdog */
267 #ifdef D4054
268 ic->ic_flags_ext |= IEEE80211_FEXT_WATCHDOG;
269 #endif
270
271 /* Adjust capabilities. */
272 rtwn_adj_devcaps(sc);
273
274 rtwn_getradiocaps(ic, IEEE80211_CHAN_MAX, &ic->ic_nchans,
275 ic->ic_channels);
276
277 /* XXX TODO: setup regdomain if R92C_CHANNEL_PLAN_BY_HW bit is set. */
278
279 ieee80211_ifattach(ic);
280 ic->ic_raw_xmit = rtwn_raw_xmit;
281 ic->ic_scan_start = rtwn_scan_start;
282 sc->sc_scan_curchan = ic->ic_scan_curchan;
283 ic->ic_scan_curchan = rtwn_scan_curchan;
284 ic->ic_scan_end = rtwn_scan_end;
285 ic->ic_getradiocaps = rtwn_getradiocaps;
286 ic->ic_update_chw = rtwn_update_chw;
287 ic->ic_set_channel = rtwn_set_channel;
288 ic->ic_transmit = rtwn_transmit;
289 ic->ic_parent = rtwn_parent;
290 ic->ic_vap_create = rtwn_vap_create;
291 ic->ic_vap_delete = rtwn_vap_delete;
292 ic->ic_wme.wme_update = rtwn_wme_update;
293 ic->ic_updateslot = rtwn_update_slot;
294 ic->ic_update_promisc = rtwn_update_promisc;
295 ic->ic_update_mcast = rtwn_update_mcast;
296 ic->ic_node_alloc = rtwn_node_alloc;
297 ic->ic_newassoc = rtwn_newassoc;
298 sc->sc_node_free = ic->ic_node_free;
299 ic->ic_node_free = rtwn_node_free;
300
301 rtwn_postattach(sc);
302 rtwn_radiotap_attach(sc);
303
304 if (bootverbose)
305 ieee80211_announce(ic);
306
307 return (0);
308
309 detach:
310 return (ENXIO); /* failure */
311 }
312
313 static void
314 rtwn_radiotap_attach(struct rtwn_softc *sc)
315 {
316 struct rtwn_rx_radiotap_header *rxtap = &sc->sc_rxtap;
317 struct rtwn_tx_radiotap_header *txtap = &sc->sc_txtap;
318
319 ieee80211_radiotap_attach(&sc->sc_ic,
320 &txtap->wt_ihdr, sizeof(*txtap), RTWN_TX_RADIOTAP_PRESENT,
321 &rxtap->wr_ihdr, sizeof(*rxtap), RTWN_RX_RADIOTAP_PRESENT);
322 }
323
324 void
325 rtwn_sysctlattach(struct rtwn_softc *sc)
326 {
327 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
328 struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
329
330 #if 1
331 sc->sc_ht40 = 0;
332 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
333 "ht40", CTLFLAG_RDTUN, &sc->sc_ht40,
334 sc->sc_ht40, "Enable 40 MHz mode support");
335 #endif
336
337 #ifdef RTWN_DEBUG
338 SYSCTL_ADD_U32(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
339 "debug", CTLFLAG_RWTUN, &sc->sc_debug, sc->sc_debug,
340 "Control debugging printfs");
341 #endif
342
343 sc->sc_hwcrypto = RTWN_CRYPTO_PAIR;
344 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
345 "hwcrypto", CTLFLAG_RDTUN, &sc->sc_hwcrypto,
346 sc->sc_hwcrypto, "Enable h/w crypto: "
347 "0 - disable, 1 - pairwise keys, 2 - all keys");
348 if (sc->sc_hwcrypto >= RTWN_CRYPTO_MAX)
349 sc->sc_hwcrypto = RTWN_CRYPTO_FULL;
350
351 sc->sc_ratectl_sysctl = RTWN_RATECTL_NET80211;
352 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
353 "ratectl", CTLFLAG_RDTUN, &sc->sc_ratectl_sysctl,
354 sc->sc_ratectl_sysctl, "Select rate control mechanism: "
355 "0 - disabled, 1 - via net80211, 2 - via firmware");
356 if (sc->sc_ratectl_sysctl >= RTWN_RATECTL_MAX)
357 sc->sc_ratectl_sysctl = RTWN_RATECTL_FW;
358
359 sc->sc_ratectl = sc->sc_ratectl_sysctl;
360 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
361 "ratectl_selected", CTLFLAG_RD, &sc->sc_ratectl,
362 sc->sc_ratectl,
363 "Currently selected rate control mechanism (by the driver)");
364 }
365
366 void
367 rtwn_detach(struct rtwn_softc *sc)
368 {
369 struct ieee80211com *ic = &sc->sc_ic;
370
371 if (ic->ic_softc == sc) {
372 /* Stop command queue. */
373 RTWN_CMDQ_LOCK(sc);
374 sc->sc_detached = 1;
375 RTWN_CMDQ_UNLOCK(sc);
376
377 ieee80211_draintask(ic, &sc->cmdq_task);
378 ieee80211_ifdetach(ic);
379 }
380
381 rtwn_cmdq_destroy(sc);
382 if (RTWN_NT_LOCK_INITIALIZED(sc))
383 RTWN_NT_LOCK_DESTROY(sc);
384 }
385
386 void
387 rtwn_suspend(struct rtwn_softc *sc)
388 {
389 struct ieee80211com *ic = &sc->sc_ic;
390
391 ieee80211_suspend_all(ic);
392 }
393
394 void
395 rtwn_resume(struct rtwn_softc *sc)
396 {
397 struct ieee80211com *ic = &sc->sc_ic;
398
399 ieee80211_resume_all(ic);
400 }
401
402 static void
403 rtwn_vap_decrement_counters(struct rtwn_softc *sc,
404 enum ieee80211_opmode opmode, int id)
405 {
406
407 RTWN_ASSERT_LOCKED(sc);
408
409 if (id != RTWN_VAP_ID_INVALID) {
410 KASSERT(id == 0 || id == 1, ("wrong vap id %d!\n", id));
411 KASSERT(sc->vaps[id] != NULL, ("vap pointer is NULL\n"));
412 sc->vaps[id] = NULL;
413 }
414
415 switch (opmode) {
416 case IEEE80211_M_HOSTAP:
417 sc->ap_vaps--;
418 /* FALLTHROUGH */
419 case IEEE80211_M_IBSS:
420 sc->bcn_vaps--;
421 /* FALLTHROUGH */
422 case IEEE80211_M_STA:
423 sc->nvaps--;
424 break;
425 case IEEE80211_M_MONITOR:
426 sc->mon_vaps--;
427 break;
428 default:
429 KASSERT(0, ("wrong opmode %d\n", opmode));
430 break;
431 }
432
433 KASSERT(sc->vaps_running >= 0 && sc->monvaps_running >= 0,
434 ("number of running vaps is negative (vaps %d, monvaps %d)\n",
435 sc->vaps_running, sc->monvaps_running));
436 KASSERT(sc->vaps_running - sc->monvaps_running <= RTWN_PORT_COUNT,
437 ("number of running vaps is too big (vaps %d, monvaps %d)\n",
438 sc->vaps_running, sc->monvaps_running));
439
440 KASSERT(sc->nvaps >= 0 && sc->nvaps <= RTWN_PORT_COUNT,
441 ("wrong value %d for nvaps\n", sc->nvaps));
442 KASSERT(sc->mon_vaps >= 0, ("mon_vaps is negative (%d)\n",
443 sc->mon_vaps));
444 KASSERT(sc->bcn_vaps >= 0 && ((RTWN_CHIP_HAS_BCNQ1(sc) &&
445 sc->bcn_vaps <= RTWN_PORT_COUNT) || sc->bcn_vaps <= 1),
446 ("bcn_vaps value %d is wrong\n", sc->bcn_vaps));
447 KASSERT(sc->ap_vaps >= 0 && ((RTWN_CHIP_HAS_BCNQ1(sc) &&
448 sc->ap_vaps <= RTWN_PORT_COUNT) || sc->ap_vaps <= 1),
449 ("ap_vaps value %d is wrong\n", sc->ap_vaps));
450 }
451
452 static void
453 rtwn_set_ic_opmode(struct rtwn_softc *sc)
454 {
455 struct ieee80211com *ic = &sc->sc_ic;
456
457 RTWN_ASSERT_LOCKED(sc);
458
459 /* for ieee80211_reset_erp() */
460 if (sc->bcn_vaps - sc->ap_vaps > 0)
461 ic->ic_opmode = IEEE80211_M_IBSS;
462 else if (sc->ap_vaps > 0)
463 ic->ic_opmode = IEEE80211_M_HOSTAP;
464 else if (sc->nvaps > 0)
465 ic->ic_opmode = IEEE80211_M_STA;
466 else
467 ic->ic_opmode = IEEE80211_M_MONITOR;
468 }
469
470 static struct ieee80211vap *
471 rtwn_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
472 enum ieee80211_opmode opmode, int flags,
473 const uint8_t bssid[IEEE80211_ADDR_LEN],
474 const uint8_t mac[IEEE80211_ADDR_LEN])
475 {
476 struct rtwn_softc *sc = ic->ic_softc;
477 struct rtwn_vap *uvp;
478 struct ieee80211vap *vap;
479 int id = RTWN_VAP_ID_INVALID;
480
481 RTWN_LOCK(sc);
482 KASSERT(sc->nvaps <= RTWN_PORT_COUNT,
483 ("nvaps overflow (%d > %d)\n", sc->nvaps, RTWN_PORT_COUNT));
484 KASSERT(sc->ap_vaps <= RTWN_PORT_COUNT,
485 ("ap_vaps overflow (%d > %d)\n", sc->ap_vaps, RTWN_PORT_COUNT));
486 KASSERT(sc->bcn_vaps <= RTWN_PORT_COUNT,
487 ("bcn_vaps overflow (%d > %d)\n", sc->bcn_vaps, RTWN_PORT_COUNT));
488
489 if (opmode != IEEE80211_M_MONITOR) {
490 switch (sc->nvaps) {
491 case 0:
492 id = 0;
493 break;
494 case 1:
495 if (sc->vaps[1] == NULL)
496 id = 1;
497 else if (sc->vaps[0] == NULL)
498 id = 0;
499 KASSERT(id != RTWN_VAP_ID_INVALID,
500 ("no free ports left\n"));
501 break;
502 case 2:
503 default:
504 goto fail;
505 }
506
507 if (opmode == IEEE80211_M_IBSS ||
508 opmode == IEEE80211_M_HOSTAP) {
509 if ((sc->bcn_vaps == 1 && !RTWN_CHIP_HAS_BCNQ1(sc)) ||
510 sc->bcn_vaps == RTWN_PORT_COUNT)
511 goto fail;
512 }
513 }
514
515 switch (opmode) {
516 case IEEE80211_M_HOSTAP:
517 sc->ap_vaps++;
518 /* FALLTHROUGH */
519 case IEEE80211_M_IBSS:
520 sc->bcn_vaps++;
521 /* FALLTHROUGH */
522 case IEEE80211_M_STA:
523 sc->nvaps++;
524 break;
525 case IEEE80211_M_MONITOR:
526 sc->mon_vaps++;
527 break;
528 default:
529 KASSERT(0, ("unknown opmode %d\n", opmode));
530 goto fail;
531 }
532 RTWN_UNLOCK(sc);
533
534 uvp = malloc(sizeof(struct rtwn_vap), M_80211_VAP, M_WAITOK | M_ZERO);
535 uvp->id = id;
536 if (id != RTWN_VAP_ID_INVALID) {
537 RTWN_LOCK(sc);
538 sc->vaps[id] = uvp;
539 RTWN_UNLOCK(sc);
540 }
541 vap = &uvp->vap;
542 /* enable s/w bmiss handling for sta mode */
543
544 if (ieee80211_vap_setup(ic, vap, name, unit, opmode,
545 flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) {
546 /* out of memory */
547 free(uvp, M_80211_VAP);
548
549 RTWN_LOCK(sc);
550 rtwn_vap_decrement_counters(sc, opmode, id);
551 RTWN_UNLOCK(sc);
552
553 return (NULL);
554 }
555
556 rtwn_beacon_init(sc, &uvp->bcn_desc.txd[0], uvp->id);
557 rtwn_vap_preattach(sc, vap);
558
559 /* override state transition machine */
560 uvp->newstate = vap->iv_newstate;
561 if (opmode == IEEE80211_M_MONITOR)
562 vap->iv_newstate = rtwn_monitor_newstate;
563 else
564 vap->iv_newstate = rtwn_newstate;
565 vap->iv_update_beacon = rtwn_update_beacon;
566 vap->iv_reset = rtwn_ioctl_reset;
567 vap->iv_key_alloc = rtwn_key_alloc;
568 vap->iv_key_set = rtwn_key_set;
569 vap->iv_key_delete = rtwn_key_delete;
570 vap->iv_max_aid = sc->macid_limit;
571
572 /* 802.11n parameters */
573 vap->iv_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_16;
574 vap->iv_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_64K;
575
576 TIMEOUT_TASK_INIT(taskqueue_thread, &uvp->tx_beacon_csa, 0,
577 rtwn_tx_beacon_csa, vap);
578 if (opmode == IEEE80211_M_IBSS) {
579 uvp->recv_mgmt = vap->iv_recv_mgmt;
580 vap->iv_recv_mgmt = rtwn_adhoc_recv_mgmt;
581 TASK_INIT(&uvp->tsf_sync_adhoc_task, 0,
582 rtwn_tsf_sync_adhoc_task, vap);
583 callout_init(&uvp->tsf_sync_adhoc, 0);
584 }
585
586 /*
587 * NB: driver can select net80211 RA even when user requests
588 * another mechanism.
589 */
590 ieee80211_ratectl_init(vap);
591
592 /* complete setup */
593 ieee80211_vap_attach(vap, ieee80211_media_change,
594 ieee80211_media_status, mac);
595
596 RTWN_LOCK(sc);
597 rtwn_set_ic_opmode(sc);
598 if (sc->sc_flags & RTWN_RUNNING) {
599 if (uvp->id != RTWN_VAP_ID_INVALID)
600 rtwn_set_macaddr(sc, vap->iv_myaddr, uvp->id);
601
602 rtwn_rxfilter_update(sc);
603 }
604 RTWN_UNLOCK(sc);
605
606 return (vap);
607
608 fail:
609 RTWN_UNLOCK(sc);
610 return (NULL);
611 }
612
613 static void
614 rtwn_vap_delete(struct ieee80211vap *vap)
615 {
616 struct ieee80211com *ic = vap->iv_ic;
617 struct rtwn_softc *sc = ic->ic_softc;
618 struct rtwn_vap *uvp = RTWN_VAP(vap);
619
620 /* Put vap into INIT state + stop device if needed. */
621 ieee80211_stop(vap);
622 ieee80211_draintask(ic, &vap->iv_nstate_task);
623 ieee80211_draintask(ic, &ic->ic_parent_task);
624
625 RTWN_LOCK(sc);
626 /* Cancel any unfinished Tx. */
627 rtwn_reset_lists(sc, vap);
628 if (uvp->bcn_mbuf != NULL)
629 m_freem(uvp->bcn_mbuf);
630 rtwn_vap_decrement_counters(sc, vap->iv_opmode, uvp->id);
631 rtwn_set_ic_opmode(sc);
632 if (sc->sc_flags & RTWN_RUNNING)
633 rtwn_rxfilter_update(sc);
634 RTWN_UNLOCK(sc);
635
636 if (vap->iv_opmode == IEEE80211_M_IBSS) {
637 ieee80211_draintask(ic, &uvp->tsf_sync_adhoc_task);
638 callout_drain(&uvp->tsf_sync_adhoc);
639 }
640
641 ieee80211_ratectl_deinit(vap);
642 ieee80211_vap_detach(vap);
643 free(uvp, M_80211_VAP);
644 }
645
646 static int
647 rtwn_read_chipid(struct rtwn_softc *sc)
648 {
649 uint32_t reg;
650
651 reg = rtwn_read_4(sc, R92C_SYS_CFG);
652 if (reg & R92C_SYS_CFG_TRP_VAUX_EN) /* test chip */
653 return (EOPNOTSUPP);
654
655 rtwn_read_chipid_vendor(sc, reg);
656
657 return (0);
658 }
659
660 static int
661 rtwn_ioctl_reset(struct ieee80211vap *vap, u_long cmd)
662 {
663 int error;
664
665 switch (cmd) {
666 #ifndef RTWN_WITHOUT_UCODE
667 case IEEE80211_IOC_POWERSAVE:
668 case IEEE80211_IOC_POWERSAVESLEEP:
669 {
670 struct rtwn_softc *sc = vap->iv_ic->ic_softc;
671 struct rtwn_vap *uvp = RTWN_VAP(vap);
672
673 if (vap->iv_opmode == IEEE80211_M_STA && uvp->id == 0) {
674 RTWN_LOCK(sc);
675 if (sc->sc_flags & RTWN_RUNNING)
676 error = rtwn_set_pwrmode(sc, vap, 1);
677 else
678 error = 0;
679 RTWN_UNLOCK(sc);
680 if (error != 0)
681 error = ENETRESET;
682 } else
683 error = EOPNOTSUPP;
684 break;
685 }
686 #endif
687 case IEEE80211_IOC_SHORTGI:
688 case IEEE80211_IOC_RTSTHRESHOLD:
689 case IEEE80211_IOC_PROTMODE:
690 case IEEE80211_IOC_HTPROTMODE:
691 case IEEE80211_IOC_LDPC:
692 error = 0;
693 break;
694 default:
695 error = ENETRESET;
696 break;
697 }
698
699 return (error);
700 }
701
702 static void
703 rtwn_set_media_status(struct rtwn_softc *sc, union sec_param *data)
704 {
705 sc->sc_set_media_status(sc, data->macid);
706 }
707
708 #ifndef RTWN_WITHOUT_UCODE
709 static int
710 rtwn_tx_fwpkt_check(struct rtwn_softc *sc, struct ieee80211vap *vap)
711 {
712 int ntries, error;
713
714 for (ntries = 0; ntries < 5; ntries++) {
715 error = rtwn_push_nulldata(sc, vap);
716 if (error == 0)
717 break;
718 }
719 if (ntries == 5) {
720 device_printf(sc->sc_dev,
721 "%s: cannot push f/w frames into chip, error %d!\n",
722 __func__, error);
723 return (error);
724 }
725
726 return (0);
727 }
728
729 static int
730 rtwn_construct_nulldata(struct rtwn_softc *sc, struct ieee80211vap *vap,
731 uint8_t *ptr, int qos)
732 {
733 struct rtwn_vap *uvp = RTWN_VAP(vap);
734 struct ieee80211com *ic = &sc->sc_ic;
735 struct rtwn_tx_desc_common *txd;
736 struct ieee80211_frame *wh;
737 int pktlen;
738
739 /* XXX obtain from net80211 */
740 wh = (struct ieee80211_frame *)(ptr + sc->txdesc_len);
741 wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA;
742 wh->i_fc[1] = IEEE80211_FC1_DIR_TODS;
743 IEEE80211_ADDR_COPY(wh->i_addr1, vap->iv_bss->ni_bssid);
744 IEEE80211_ADDR_COPY(wh->i_addr2, vap->iv_myaddr);
745 IEEE80211_ADDR_COPY(wh->i_addr3, vap->iv_bss->ni_macaddr);
746
747 txd = (struct rtwn_tx_desc_common *)ptr;
748 txd->offset = sc->txdesc_len;
749 pktlen = sc->txdesc_len;
750 if (qos) {
751 struct ieee80211_qosframe *qwh;
752 const int tid = WME_AC_TO_TID(WME_AC_BE);
753
754 qwh = (struct ieee80211_qosframe *)wh;
755 qwh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_QOS_NULL;
756 qwh->i_qos[0] = tid & IEEE80211_QOS_TID;
757
758 txd->pktlen = htole16(sizeof(struct ieee80211_qosframe));
759 pktlen += sizeof(struct ieee80211_qosframe);
760 } else {
761 wh->i_fc[0] |= IEEE80211_FC0_SUBTYPE_NODATA;
762
763 txd->pktlen = htole16(sizeof(struct ieee80211_frame));
764 pktlen += sizeof(struct ieee80211_frame);
765 }
766
767 rtwn_fill_tx_desc_null(sc, ptr,
768 ic->ic_curmode == IEEE80211_MODE_11B, qos, uvp->id);
769
770 return (pktlen);
771 }
772
773 static int
774 rtwn_push_nulldata(struct rtwn_softc *sc, struct ieee80211vap *vap)
775 {
776 struct rtwn_vap *uvp = RTWN_VAP(vap);
777 struct ieee80211com *ic = vap->iv_ic;
778 struct ieee80211_channel *c = ic->ic_curchan;
779 struct mbuf *m;
780 uint8_t *ptr;
781 int required_size, bcn_size, null_size, null_data, error;
782
783 if (!(sc->sc_flags & RTWN_FW_LOADED))
784 return (0); /* requires firmware */
785
786 KASSERT(sc->page_size > 0, ("page size was not set!\n"));
787
788 /* Leave some space for beacon (multi-vap) */
789 bcn_size = roundup(RTWN_BCN_MAX_SIZE, sc->page_size);
790 /* 1 page for Null Data + 1 page for Qos Null Data frames. */
791 required_size = bcn_size + sc->page_size * 2;
792
793 m = m_get2(required_size, M_NOWAIT, MT_DATA, M_PKTHDR);
794 if (m == NULL)
795 return (ENOMEM);
796
797 /* Setup beacon descriptor. */
798 rtwn_beacon_set_rate(sc, &uvp->bcn_desc.txd[0],
799 IEEE80211_IS_CHAN_5GHZ(c));
800
801 ptr = mtod(m, uint8_t *);
802 memset(ptr, 0, required_size - sc->txdesc_len);
803
804 /* Construct Null Data frame. */
805 ptr += bcn_size - sc->txdesc_len;
806 null_size = rtwn_construct_nulldata(sc, vap, ptr, 0);
807 KASSERT(null_size < sc->page_size,
808 ("recalculate size for Null Data frame\n"));
809
810 /* Construct Qos Null Data frame. */
811 ptr += roundup(null_size, sc->page_size);
812 null_size = rtwn_construct_nulldata(sc, vap, ptr, 1);
813 KASSERT(null_size < sc->page_size,
814 ("recalculate size for Qos Null Data frame\n"));
815
816 /* Do not try to detect a beacon here. */
817 rtwn_setbits_1_shift(sc, R92C_CR, 0, R92C_CR_ENSWBCN, 1);
818 rtwn_setbits_1_shift(sc, R92C_FWHW_TXQ_CTRL,
819 R92C_FWHW_TXQ_CTRL_REAL_BEACON, 0, 2);
820
821 if (uvp->bcn_mbuf != NULL) {
822 rtwn_beacon_unload(sc, uvp->id);
823 m_freem(uvp->bcn_mbuf);
824 }
825
826 m->m_pkthdr.len = m->m_len = required_size - sc->txdesc_len;
827 uvp->bcn_mbuf = m;
828
829 error = rtwn_tx_beacon_check(sc, uvp);
830 if (error != 0) {
831 RTWN_DPRINTF(sc, RTWN_DEBUG_BEACON,
832 "%s: frame was not recognized!\n", __func__);
833 goto fail;
834 }
835
836 /* Setup addresses in firmware. */
837 null_data = howmany(bcn_size, sc->page_size);
838 error = rtwn_set_rsvd_page(sc, 0, null_data, null_data + 1);
839 if (error != 0) {
840 device_printf(sc->sc_dev,
841 "%s: CMD_RSVD_PAGE was not sent, error %d\n",
842 __func__, error);
843 goto fail;
844 }
845
846 fail:
847 /* Re-enable beacon detection. */
848 rtwn_setbits_1_shift(sc, R92C_FWHW_TXQ_CTRL,
849 0, R92C_FWHW_TXQ_CTRL_REAL_BEACON, 2);
850 rtwn_setbits_1_shift(sc, R92C_CR, R92C_CR_ENSWBCN, 0, 1);
851
852 /* Restore beacon (if present). */
853 if (sc->bcn_vaps > 0 && sc->vaps[!uvp->id] != NULL) {
854 struct rtwn_vap *uvp2 = sc->vaps[!uvp->id];
855
856 if (uvp2->curr_mode != R92C_MSR_NOLINK)
857 error = rtwn_tx_beacon_check(sc, uvp2);
858 }
859
860 return (error);
861 }
862
863 static void
864 rtwn_pwrmode_init(void *arg)
865 {
866 struct rtwn_softc *sc = arg;
867
868 rtwn_cmd_sleepable(sc, NULL, 0, rtwn_set_pwrmode_cb);
869 }
870
871 static void
872 rtwn_set_pwrmode_cb(struct rtwn_softc *sc, union sec_param *data)
873 {
874 struct ieee80211vap *vap = &sc->vaps[0]->vap;
875
876 if (vap != NULL)
877 rtwn_set_pwrmode(sc, vap, 1);
878 }
879 #endif
880
881 static void
882 rtwn_tsf_sync_adhoc(void *arg)
883 {
884 struct ieee80211vap *vap = arg;
885 struct ieee80211com *ic = vap->iv_ic;
886 struct rtwn_vap *uvp = RTWN_VAP(vap);
887
888 if (uvp->curr_mode != R92C_MSR_NOLINK) {
889 /* Do it in process context. */
890 ieee80211_runtask(ic, &uvp->tsf_sync_adhoc_task);
891 }
892 }
893
894 /*
895 * Workaround for TSF synchronization:
896 * when BSSID filter in IBSS mode is not set
897 * (and TSF synchronization is enabled), then any beacon may update it.
898 * This routine synchronizes it when BSSID matching is enabled (IBSS merge
899 * is not possible during this period).
900 *
901 * NOTE: there is no race with rtwn_newstate(), since it uses the same
902 * taskqueue.
903 */
904 static void
905 rtwn_tsf_sync_adhoc_task(void *arg, int pending)
906 {
907 struct ieee80211vap *vap = arg;
908 struct rtwn_vap *uvp = RTWN_VAP(vap);
909 struct rtwn_softc *sc = vap->iv_ic->ic_softc;
910 struct ieee80211_node *ni;
911
912 RTWN_LOCK(sc);
913 ni = ieee80211_ref_node(vap->iv_bss);
914
915 /* Accept beacons with the same BSSID. */
916 rtwn_set_rx_bssid_all(sc, 0);
917
918 /* Deny RCR updates. */
919 sc->sc_flags |= RTWN_RCR_LOCKED;
920
921 /* Enable synchronization. */
922 rtwn_setbits_1(sc, R92C_BCN_CTRL(uvp->id),
923 R92C_BCN_CTRL_DIS_TSF_UDT0, 0);
924
925 /* Synchronize. */
926 rtwn_delay(sc, ni->ni_intval * 5 * 1000);
927
928 /* Disable synchronization. */
929 rtwn_setbits_1(sc, R92C_BCN_CTRL(uvp->id),
930 0, R92C_BCN_CTRL_DIS_TSF_UDT0);
931
932 /* Accept all beacons. */
933 sc->sc_flags &= ~RTWN_RCR_LOCKED;
934 rtwn_set_rx_bssid_all(sc, 1);
935
936 /* Schedule next TSF synchronization. */
937 callout_reset(&uvp->tsf_sync_adhoc, 60*hz, rtwn_tsf_sync_adhoc, vap);
938
939 ieee80211_free_node(ni);
940 RTWN_UNLOCK(sc);
941 }
942
943 static void
944 rtwn_tsf_sync_enable(struct rtwn_softc *sc, struct ieee80211vap *vap)
945 {
946 struct ieee80211com *ic = &sc->sc_ic;
947 struct rtwn_vap *uvp = RTWN_VAP(vap);
948
949 /* Reset TSF. */
950 rtwn_write_1(sc, R92C_DUAL_TSF_RST, R92C_DUAL_TSF_RESET(uvp->id));
951
952 switch (vap->iv_opmode) {
953 case IEEE80211_M_STA:
954 /* Enable TSF synchronization. */
955 rtwn_setbits_1(sc, R92C_BCN_CTRL(uvp->id),
956 R92C_BCN_CTRL_DIS_TSF_UDT0, 0);
957 break;
958 case IEEE80211_M_IBSS:
959 ieee80211_runtask(ic, &uvp->tsf_sync_adhoc_task);
960 /* FALLTHROUGH */
961 case IEEE80211_M_HOSTAP:
962 /* Enable beaconing. */
963 rtwn_beacon_enable(sc, uvp->id, 1);
964 break;
965 default:
966 device_printf(sc->sc_dev, "undefined opmode %d\n",
967 vap->iv_opmode);
968 return;
969 }
970 }
971
972 static void
973 rtwn_set_ack_preamble(struct rtwn_softc *sc)
974 {
975 struct ieee80211com *ic = &sc->sc_ic;
976 uint32_t reg;
977
978 reg = rtwn_read_4(sc, R92C_WMAC_TRXPTCL_CTL);
979 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
980 reg |= R92C_WMAC_TRXPTCL_SHPRE;
981 else
982 reg &= ~R92C_WMAC_TRXPTCL_SHPRE;
983 rtwn_write_4(sc, R92C_WMAC_TRXPTCL_CTL, reg);
984 }
985
986 static void
987 rtwn_set_mode(struct rtwn_softc *sc, uint8_t mode, int id)
988 {
989
990 rtwn_setbits_1(sc, R92C_MSR, R92C_MSR_MASK << id * 2, mode << id * 2);
991 if (sc->vaps[id] != NULL)
992 sc->vaps[id]->curr_mode = mode;
993 }
994
995 static int
996 rtwn_monitor_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate,
997 int arg)
998 {
999 struct ieee80211com *ic = vap->iv_ic;
1000 struct rtwn_softc *sc = ic->ic_softc;
1001 struct rtwn_vap *uvp = RTWN_VAP(vap);
1002
1003 RTWN_DPRINTF(sc, RTWN_DEBUG_STATE, "%s -> %s\n",
1004 ieee80211_state_name[vap->iv_state],
1005 ieee80211_state_name[nstate]);
1006
1007 if (vap->iv_state != nstate) {
1008 IEEE80211_UNLOCK(ic);
1009 RTWN_LOCK(sc);
1010
1011 switch (nstate) {
1012 case IEEE80211_S_INIT:
1013 sc->vaps_running--;
1014 sc->monvaps_running--;
1015
1016 if (sc->vaps_running == 0) {
1017 /* Turn link LED off. */
1018 rtwn_set_led(sc, RTWN_LED_LINK, 0);
1019 }
1020 break;
1021 case IEEE80211_S_RUN:
1022 sc->vaps_running++;
1023 sc->monvaps_running++;
1024
1025 if (sc->vaps_running == 1) {
1026 /* Turn link LED on. */
1027 rtwn_set_led(sc, RTWN_LED_LINK, 1);
1028 }
1029 break;
1030 default:
1031 /* NOTREACHED */
1032 break;
1033 }
1034
1035 RTWN_UNLOCK(sc);
1036 IEEE80211_LOCK(ic);
1037 }
1038
1039 return (uvp->newstate(vap, nstate, arg));
1040 }
1041
1042 static int
1043 rtwn_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
1044 {
1045 struct rtwn_vap *uvp = RTWN_VAP(vap);
1046 struct ieee80211com *ic = vap->iv_ic;
1047 struct rtwn_softc *sc = ic->ic_softc;
1048 enum ieee80211_state ostate;
1049 int error, early_newstate;
1050
1051 ostate = vap->iv_state;
1052 RTWN_DPRINTF(sc, RTWN_DEBUG_STATE, "%s -> %s\n",
1053 ieee80211_state_name[ostate], ieee80211_state_name[nstate]);
1054
1055 if (vap->iv_bss->ni_chan == IEEE80211_CHAN_ANYC &&
1056 ostate == IEEE80211_S_INIT && nstate == IEEE80211_S_RUN) {
1057 /* need to call iv_newstate() firstly */
1058 error = uvp->newstate(vap, nstate, arg);
1059 if (error != 0)
1060 return (error);
1061
1062 early_newstate = 1;
1063 } else
1064 early_newstate = 0;
1065
1066 if (ostate == IEEE80211_S_CSA) {
1067 taskqueue_cancel_timeout(taskqueue_thread,
1068 &uvp->tx_beacon_csa, NULL);
1069
1070 /*
1071 * In multi-vap case second counter may not be cleared
1072 * properly.
1073 */
1074 vap->iv_csa_count = 0;
1075 }
1076 IEEE80211_UNLOCK(ic);
1077 RTWN_LOCK(sc);
1078
1079 if (ostate == IEEE80211_S_CSA) {
1080 /* Unblock all queues (multi-vap case). */
1081 rtwn_write_1(sc, R92C_TXPAUSE, 0);
1082 }
1083
1084 if ((ostate == IEEE80211_S_RUN && nstate != IEEE80211_S_CSA) ||
1085 ostate == IEEE80211_S_CSA) {
1086 sc->vaps_running--;
1087
1088 /* Set media status to 'No Link'. */
1089 rtwn_set_mode(sc, R92C_MSR_NOLINK, uvp->id);
1090
1091 if (vap->iv_opmode == IEEE80211_M_IBSS) {
1092 /* Stop periodical TSF synchronization. */
1093 callout_stop(&uvp->tsf_sync_adhoc);
1094 }
1095
1096 /* Disable TSF synchronization / beaconing. */
1097 rtwn_beacon_enable(sc, uvp->id, 0);
1098 rtwn_setbits_1(sc, R92C_BCN_CTRL(uvp->id),
1099 0, R92C_BCN_CTRL_DIS_TSF_UDT0);
1100
1101 /* NB: monitor mode vaps are using port 0. */
1102 if (uvp->id != 0 || sc->monvaps_running == 0) {
1103 /* Reset TSF. */
1104 rtwn_write_1(sc, R92C_DUAL_TSF_RST,
1105 R92C_DUAL_TSF_RESET(uvp->id));
1106 }
1107
1108 #ifndef RTWN_WITHOUT_UCODE
1109 if ((ic->ic_caps & IEEE80211_C_PMGT) != 0 && uvp->id == 0) {
1110 /* Disable power management. */
1111 callout_stop(&sc->sc_pwrmode_init);
1112 rtwn_set_pwrmode(sc, vap, 0);
1113 }
1114 #endif
1115 if (sc->vaps_running - sc->monvaps_running > 0) {
1116 /* Recalculate basic rates bitmap. */
1117 rtwn_calc_basicrates(sc);
1118 }
1119
1120 if (sc->vaps_running == sc->monvaps_running) {
1121 /* Stop calibration. */
1122 callout_stop(&sc->sc_calib_to);
1123
1124 /* Stop Rx of data frames. */
1125 rtwn_write_2(sc, R92C_RXFLTMAP2, 0);
1126
1127 /* Reset EDCA parameters. */
1128 rtwn_write_4(sc, R92C_EDCA_VO_PARAM, 0x002f3217);
1129 rtwn_write_4(sc, R92C_EDCA_VI_PARAM, 0x005e4317);
1130 rtwn_write_4(sc, R92C_EDCA_BE_PARAM, 0x00105320);
1131 rtwn_write_4(sc, R92C_EDCA_BK_PARAM, 0x0000a444);
1132
1133 if (sc->vaps_running == 0) {
1134 /* Turn link LED off. */
1135 rtwn_set_led(sc, RTWN_LED_LINK, 0);
1136 }
1137 }
1138 }
1139
1140 error = 0;
1141 switch (nstate) {
1142 case IEEE80211_S_SCAN:
1143 /* Pause AC Tx queues. */
1144 if (sc->vaps_running == 0)
1145 rtwn_setbits_1(sc, R92C_TXPAUSE, 0, R92C_TX_QUEUE_AC);
1146 break;
1147 case IEEE80211_S_RUN:
1148 error = rtwn_run(sc, vap);
1149 if (error != 0) {
1150 device_printf(sc->sc_dev,
1151 "%s: could not move to RUN state\n", __func__);
1152 break;
1153 }
1154
1155 sc->vaps_running++;
1156 break;
1157 case IEEE80211_S_CSA:
1158 /* Block all Tx queues (except beacon queue). */
1159 rtwn_setbits_1(sc, R92C_TXPAUSE, 0,
1160 R92C_TX_QUEUE_AC | R92C_TX_QUEUE_MGT | R92C_TX_QUEUE_HIGH);
1161 break;
1162 default:
1163 break;
1164 }
1165
1166 RTWN_UNLOCK(sc);
1167 IEEE80211_LOCK(ic);
1168 if (error != 0)
1169 return (error);
1170
1171 return (early_newstate ? 0 : uvp->newstate(vap, nstate, arg));
1172 }
1173
1174 static void
1175 rtwn_calc_basicrates(struct rtwn_softc *sc)
1176 {
1177 struct ieee80211com *ic = &sc->sc_ic;
1178 uint32_t basicrates;
1179 int i;
1180
1181 RTWN_ASSERT_LOCKED(sc);
1182
1183 if (ic->ic_flags & IEEE80211_F_SCAN)
1184 return; /* will be done by rtwn_scan_end(). */
1185
1186 basicrates = 0;
1187 for (i = 0; i < nitems(sc->vaps); i++) {
1188 struct rtwn_vap *rvp;
1189 struct ieee80211vap *vap;
1190 struct ieee80211_node *ni;
1191 uint32_t rates;
1192
1193 rvp = sc->vaps[i];
1194 if (rvp == NULL || rvp->curr_mode == R92C_MSR_NOLINK)
1195 continue;
1196
1197 vap = &rvp->vap;
1198 if (vap->iv_bss == NULL)
1199 continue;
1200
1201 ni = ieee80211_ref_node(vap->iv_bss);
1202 rtwn_get_rates(sc, &ni->ni_rates, NULL, &rates, NULL, 1);
1203 basicrates |= rates;
1204 ieee80211_free_node(ni);
1205 }
1206
1207 if (basicrates == 0)
1208 return;
1209
1210 /* XXX initial RTS rate? */
1211 rtwn_set_basicrates(sc, basicrates);
1212 }
1213
1214 static int
1215 rtwn_run(struct rtwn_softc *sc, struct ieee80211vap *vap)
1216 {
1217 struct ieee80211com *ic = vap->iv_ic;
1218 struct rtwn_vap *uvp = RTWN_VAP(vap);
1219 struct ieee80211_node *ni;
1220 uint8_t mode;
1221 int error;
1222
1223 RTWN_ASSERT_LOCKED(sc);
1224
1225 error = 0;
1226 ni = ieee80211_ref_node(vap->iv_bss);
1227
1228 if (ic->ic_bsschan == IEEE80211_CHAN_ANYC ||
1229 ni->ni_chan == IEEE80211_CHAN_ANYC) {
1230 error = EINVAL;
1231 goto fail;
1232 }
1233
1234 switch (vap->iv_opmode) {
1235 case IEEE80211_M_STA:
1236 mode = R92C_MSR_INFRA;
1237 break;
1238 case IEEE80211_M_IBSS:
1239 mode = R92C_MSR_ADHOC;
1240 break;
1241 case IEEE80211_M_HOSTAP:
1242 mode = R92C_MSR_AP;
1243 break;
1244 default:
1245 KASSERT(0, ("undefined opmode %d\n", vap->iv_opmode));
1246 error = EINVAL;
1247 goto fail;
1248 }
1249
1250 /* Set media status to 'Associated'. */
1251 rtwn_set_mode(sc, mode, uvp->id);
1252
1253 /* Set AssocID. */
1254 /* XXX multi-vap? */
1255 rtwn_write_2(sc, R92C_BCN_PSR_RPT,
1256 0xc000 | IEEE80211_NODE_AID(ni));
1257
1258 /* Set BSSID. */
1259 rtwn_set_bssid(sc, ni->ni_bssid, uvp->id);
1260
1261 /* Set beacon interval. */
1262 rtwn_write_2(sc, R92C_BCN_INTERVAL(uvp->id), ni->ni_intval);
1263
1264 if (sc->vaps_running == sc->monvaps_running) {
1265 /* Enable Rx of data frames. */
1266 rtwn_write_2(sc, R92C_RXFLTMAP2, 0xffff);
1267
1268 /* Flush all AC queues. */
1269 rtwn_write_1(sc, R92C_TXPAUSE, 0);
1270 }
1271
1272 #ifndef RTWN_WITHOUT_UCODE
1273 /* Upload (QoS) Null Data frame to firmware. */
1274 /* Note: do this for port 0 only. */
1275 if ((ic->ic_caps & IEEE80211_C_PMGT) != 0 &&
1276 vap->iv_opmode == IEEE80211_M_STA && uvp->id == 0) {
1277 error = rtwn_tx_fwpkt_check(sc, vap);
1278 if (error != 0)
1279 goto fail;
1280
1281 /* Setup power management. */
1282 /*
1283 * NB: it will be enabled immediately - delay it,
1284 * so 4-Way handshake will not be interrupted.
1285 */
1286 callout_reset(&sc->sc_pwrmode_init, 5*hz,
1287 rtwn_pwrmode_init, sc);
1288 }
1289 #endif
1290
1291 /* Enable TSF synchronization. */
1292 rtwn_tsf_sync_enable(sc, vap);
1293
1294 if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
1295 vap->iv_opmode == IEEE80211_M_IBSS) {
1296 error = rtwn_setup_beacon(sc, ni);
1297 if (error != 0) {
1298 device_printf(sc->sc_dev,
1299 "unable to push beacon into the chip, "
1300 "error %d\n", error);
1301 goto fail;
1302 }
1303 }
1304
1305 /* Set ACK preamble type. */
1306 rtwn_set_ack_preamble(sc);
1307
1308 /* Set basic rates mask. */
1309 rtwn_calc_basicrates(sc);
1310
1311 #ifdef RTWN_TODO
1312 rtwn_write_1(sc, R92C_SIFS_CCK + 1, 10);
1313 rtwn_write_1(sc, R92C_SIFS_OFDM + 1, 10);
1314 rtwn_write_1(sc, R92C_SPEC_SIFS + 1, 10);
1315 rtwn_write_1(sc, R92C_MAC_SPEC_SIFS + 1, 10);
1316 rtwn_write_1(sc, R92C_R2T_SIFS + 1, 10);
1317 rtwn_write_1(sc, R92C_T2T_SIFS + 1, 10);
1318 #endif
1319
1320 if (sc->vaps_running == sc->monvaps_running) {
1321 /* Reset temperature calibration state machine. */
1322 sc->sc_flags &= ~RTWN_TEMP_MEASURED;
1323 sc->thcal_temp = sc->thermal_meter;
1324
1325 /* Start periodic calibration. */
1326 callout_reset(&sc->sc_calib_to, 2*hz, rtwn_calib_to,
1327 sc);
1328
1329 if (sc->vaps_running == 0) {
1330 /* Turn link LED on. */
1331 rtwn_set_led(sc, RTWN_LED_LINK, 1);
1332 }
1333 }
1334
1335 fail:
1336 ieee80211_free_node(ni);
1337
1338 return (error);
1339 }
1340
1341 #ifndef D4054
1342 static void
1343 rtwn_watchdog(void *arg)
1344 {
1345 struct rtwn_softc *sc = arg;
1346 struct ieee80211com *ic = &sc->sc_ic;
1347
1348 RTWN_ASSERT_LOCKED(sc);
1349
1350 KASSERT(sc->sc_flags & RTWN_RUNNING, ("not running"));
1351
1352 if (sc->sc_tx_timer != 0 && --sc->sc_tx_timer == 0) {
1353 ic_printf(ic, "device timeout\n");
1354 ieee80211_restart_all(ic);
1355 return;
1356 }
1357 callout_reset(&sc->sc_watchdog_to, hz, rtwn_watchdog, sc);
1358 }
1359 #endif
1360
1361 static void
1362 rtwn_parent(struct ieee80211com *ic)
1363 {
1364 struct rtwn_softc *sc = ic->ic_softc;
1365 struct ieee80211vap *vap;
1366
1367 if (ic->ic_nrunning > 0) {
1368 if (rtwn_init(sc) != 0) {
1369 IEEE80211_LOCK(ic);
1370 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
1371 ieee80211_stop_locked(vap);
1372 IEEE80211_UNLOCK(ic);
1373 } else
1374 ieee80211_start_all(ic);
1375 } else
1376 rtwn_stop(sc);
1377 }
1378
1379 static int
1380 rtwn_dma_init(struct rtwn_softc *sc)
1381 {
1382 #define RTWN_CHK(res) do { \
1383 if (res != 0) \
1384 return (EIO); \
1385 } while(0)
1386 uint16_t reg;
1387 uint8_t tx_boundary;
1388 int error;
1389
1390 /* Initialize LLT table. */
1391 error = rtwn_llt_init(sc);
1392 if (error != 0)
1393 return (error);
1394
1395 /* Set the number of pages for each queue. */
1396 RTWN_DPRINTF(sc, RTWN_DEBUG_RESET,
1397 "%s: pages per queue: high %d, normal %d, low %d, public %d\n",
1398 __func__, sc->nhqpages, sc->nnqpages, sc->nlqpages,
1399 sc->npubqpages);
1400
1401 RTWN_CHK(rtwn_write_1(sc, R92C_RQPN_NPQ, sc->nnqpages));
1402 RTWN_CHK(rtwn_write_4(sc, R92C_RQPN,
1403 /* Set number of pages for public queue. */
1404 SM(R92C_RQPN_PUBQ, sc->npubqpages) |
1405 /* Set number of pages for high priority queue. */
1406 SM(R92C_RQPN_HPQ, sc->nhqpages) |
1407 /* Set number of pages for low priority queue. */
1408 SM(R92C_RQPN_LPQ, sc->nlqpages) |
1409 /* Load values. */
1410 R92C_RQPN_LD));
1411
1412 /* Initialize TX buffer boundary. */
1413 KASSERT(sc->page_count < 255 && sc->page_count > 0,
1414 ("page_count is %d\n", sc->page_count));
1415 tx_boundary = sc->page_count + 1;
1416 RTWN_CHK(rtwn_write_1(sc, R92C_TXPKTBUF_BCNQ_BDNY, tx_boundary));
1417 RTWN_CHK(rtwn_write_1(sc, R92C_TXPKTBUF_MGQ_BDNY, tx_boundary));
1418 RTWN_CHK(rtwn_write_1(sc, R92C_TXPKTBUF_WMAC_LBK_BF_HD, tx_boundary));
1419 RTWN_CHK(rtwn_write_1(sc, R92C_TRXFF_BNDY, tx_boundary));
1420 RTWN_CHK(rtwn_write_1(sc, R92C_TDECTRL + 1, tx_boundary));
1421
1422 error = rtwn_init_bcnq1_boundary(sc);
1423 if (error != 0)
1424 return (error);
1425
1426 /* Set queue to USB pipe mapping. */
1427 /* Note: PCIe devices are using some magic number here. */
1428 reg = rtwn_get_qmap(sc);
1429 RTWN_CHK(rtwn_setbits_2(sc, R92C_TRXDMA_CTRL,
1430 R92C_TRXDMA_CTRL_QMAP_M, reg));
1431
1432 /* Configure Tx/Rx DMA (PCIe). */
1433 rtwn_set_desc_addr(sc);
1434
1435 /* Set Tx/Rx transfer page boundary. */
1436 RTWN_CHK(rtwn_write_2(sc, R92C_TRXFF_BNDY + 2,
1437 sc->rx_dma_size - 1));
1438
1439 /* Set Tx/Rx transfer page size. */
1440 rtwn_set_page_size(sc);
1441
1442 return (0);
1443 }
1444
1445 static int
1446 rtwn_mac_init(struct rtwn_softc *sc)
1447 {
1448 int i, error;
1449
1450 /* Write MAC initialization values. */
1451 for (i = 0; i < sc->mac_size; i++) {
1452 error = rtwn_write_1(sc, sc->mac_prog[i].reg,
1453 sc->mac_prog[i].val);
1454 if (error != 0)
1455 return (error);
1456 }
1457
1458 return (0);
1459 }
1460
1461 static void
1462 rtwn_mrr_init(struct rtwn_softc *sc)
1463 {
1464 int i;
1465
1466 /* Drop rate index by 1 per retry. */
1467 for (i = 0; i < R92C_DARFRC_SIZE; i++) {
1468 rtwn_write_1(sc, R92C_DARFRC + i, i + 1);
1469 rtwn_write_1(sc, R92C_RARFRC + i, i + 1);
1470 }
1471 }
1472
1473 static void
1474 rtwn_scan_start(struct ieee80211com *ic)
1475 {
1476 struct rtwn_softc *sc = ic->ic_softc;
1477
1478 RTWN_LOCK(sc);
1479 /* Pause beaconing. */
1480 rtwn_setbits_1(sc, R92C_TXPAUSE, 0, R92C_TX_QUEUE_BCN);
1481 /* Receive beacons / probe responses from any BSSID. */
1482 if (sc->bcn_vaps == 0)
1483 rtwn_set_rx_bssid_all(sc, 1);
1484 RTWN_UNLOCK(sc);
1485 }
1486
1487 static void
1488 rtwn_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell)
1489 {
1490 struct rtwn_softc *sc = ss->ss_ic->ic_softc;
1491
1492 /* Make link LED blink during scan. */
1493 RTWN_LOCK(sc);
1494 rtwn_set_led(sc, RTWN_LED_LINK, !sc->ledlink);
1495 RTWN_UNLOCK(sc);
1496
1497 sc->sc_scan_curchan(ss, maxdwell);
1498 }
1499
1500 static void
1501 rtwn_scan_end(struct ieee80211com *ic)
1502 {
1503 struct rtwn_softc *sc = ic->ic_softc;
1504
1505 RTWN_LOCK(sc);
1506 /* Restore limitations. */
1507 if (ic->ic_promisc == 0 && sc->bcn_vaps == 0)
1508 rtwn_set_rx_bssid_all(sc, 0);
1509
1510 /* Restore LED state. */
1511 rtwn_set_led(sc, RTWN_LED_LINK, (sc->vaps_running != 0));
1512
1513 /* Restore basic rates mask. */
1514 rtwn_calc_basicrates(sc);
1515
1516 /* Resume beaconing. */
1517 rtwn_setbits_1(sc, R92C_TXPAUSE, R92C_TX_QUEUE_BCN, 0);
1518 RTWN_UNLOCK(sc);
1519 }
1520
1521 static void
1522 rtwn_getradiocaps(struct ieee80211com *ic,
1523 int maxchans, int *nchans, struct ieee80211_channel chans[])
1524 {
1525 struct rtwn_softc *sc = ic->ic_softc;
1526 uint8_t bands[IEEE80211_MODE_BYTES];
1527 int cbw_flags, i;
1528
1529 cbw_flags = (ic->ic_htcaps & IEEE80211_HTCAP_CHWIDTH40) ?
1530 NET80211_CBW_FLAG_HT40 : 0;
1531
1532 memset(bands, 0, sizeof(bands));
1533 setbit(bands, IEEE80211_MODE_11B);
1534 setbit(bands, IEEE80211_MODE_11G);
1535 setbit(bands, IEEE80211_MODE_11NG);
1536 ieee80211_add_channels_default_2ghz(chans, maxchans, nchans,
1537 bands, cbw_flags);
1538
1539 /* XXX workaround add_channel_list() limitations */
1540 setbit(bands, IEEE80211_MODE_11A);
1541 setbit(bands, IEEE80211_MODE_11NA);
1542 for (i = 0; i < nitems(sc->chan_num_5ghz); i++) {
1543 if (sc->chan_num_5ghz[i] == 0)
1544 continue;
1545
1546 ieee80211_add_channel_list_5ghz(chans, maxchans, nchans,
1547 sc->chan_list_5ghz[i], sc->chan_num_5ghz[i], bands,
1548 cbw_flags);
1549 }
1550 }
1551
1552 static void
1553 rtwn_update_chw(struct ieee80211com *ic)
1554 {
1555 }
1556
1557 static void
1558 rtwn_set_channel(struct ieee80211com *ic)
1559 {
1560 struct rtwn_softc *sc = ic->ic_softc;
1561 struct ieee80211_channel *c = ic->ic_curchan;
1562
1563 RTWN_LOCK(sc);
1564 rtwn_set_chan(sc, c);
1565 RTWN_UNLOCK(sc);
1566 }
1567
1568 static int
1569 rtwn_wme_update(struct ieee80211com *ic)
1570 {
1571 struct chanAccParams chp;
1572 struct ieee80211_channel *c = ic->ic_curchan;
1573 struct rtwn_softc *sc = ic->ic_softc;
1574 struct wmeParams *wmep = sc->cap_wmeParams;
1575 uint8_t aifs, acm, slottime;
1576 int ac;
1577
1578 ieee80211_wme_ic_getparams(ic, &chp);
1579
1580 /* Prevent possible races. */
1581 IEEE80211_LOCK(ic); /* XXX */
1582 RTWN_LOCK(sc);
1583 memcpy(wmep, chp.cap_wmeParams, sizeof(sc->cap_wmeParams));
1584 RTWN_UNLOCK(sc);
1585 IEEE80211_UNLOCK(ic);
1586
1587 acm = 0;
1588 slottime = IEEE80211_GET_SLOTTIME(ic);
1589
1590 RTWN_LOCK(sc);
1591 for (ac = WME_AC_BE; ac < WME_NUM_AC; ac++) {
1592 /* AIFS[AC] = AIFSN[AC] * aSlotTime + aSIFSTime. */
1593 aifs = wmep[ac].wmep_aifsn * slottime +
1594 (IEEE80211_IS_CHAN_5GHZ(c) ?
1595 IEEE80211_DUR_OFDM_SIFS : IEEE80211_DUR_SIFS);
1596 rtwn_write_4(sc, wme2reg[ac],
1597 SM(R92C_EDCA_PARAM_TXOP, wmep[ac].wmep_txopLimit) |
1598 SM(R92C_EDCA_PARAM_ECWMIN, wmep[ac].wmep_logcwmin) |
1599 SM(R92C_EDCA_PARAM_ECWMAX, wmep[ac].wmep_logcwmax) |
1600 SM(R92C_EDCA_PARAM_AIFS, aifs));
1601 if (ac != WME_AC_BE)
1602 acm |= wmep[ac].wmep_acm << ac;
1603 }
1604
1605 if (acm != 0)
1606 acm |= R92C_ACMHWCTRL_EN;
1607 rtwn_setbits_1(sc, R92C_ACMHWCTRL, R92C_ACMHWCTRL_ACM_MASK, acm);
1608 RTWN_UNLOCK(sc);
1609
1610 return 0;
1611 }
1612
1613 static void
1614 rtwn_update_slot(struct ieee80211com *ic)
1615 {
1616 rtwn_cmd_sleepable(ic->ic_softc, NULL, 0, rtwn_update_slot_cb);
1617 }
1618
1619 static void
1620 rtwn_update_slot_cb(struct rtwn_softc *sc, union sec_param *data)
1621 {
1622 struct ieee80211com *ic = &sc->sc_ic;
1623 uint8_t slottime;
1624
1625 slottime = IEEE80211_GET_SLOTTIME(ic);
1626
1627 RTWN_DPRINTF(sc, RTWN_DEBUG_STATE, "%s: setting slot time to %uus\n",
1628 __func__, slottime);
1629
1630 rtwn_write_1(sc, R92C_SLOT, slottime);
1631 rtwn_update_aifs(sc, slottime);
1632 }
1633
1634 static void
1635 rtwn_update_aifs(struct rtwn_softc *sc, uint8_t slottime)
1636 {
1637 struct ieee80211_channel *c = sc->sc_ic.ic_curchan;
1638 const struct wmeParams *wmep = sc->cap_wmeParams;
1639 uint8_t aifs, ac;
1640
1641 for (ac = WME_AC_BE; ac < WME_NUM_AC; ac++) {
1642 /* AIFS[AC] = AIFSN[AC] * aSlotTime + aSIFSTime. */
1643 aifs = wmep[ac].wmep_aifsn * slottime +
1644 (IEEE80211_IS_CHAN_5GHZ(c) ?
1645 IEEE80211_DUR_OFDM_SIFS : IEEE80211_DUR_SIFS);
1646 rtwn_write_1(sc, wme2reg[ac], aifs);
1647 }
1648 }
1649
1650 static void
1651 rtwn_update_promisc(struct ieee80211com *ic)
1652 {
1653 struct rtwn_softc *sc = ic->ic_softc;
1654
1655 RTWN_LOCK(sc);
1656 if (sc->sc_flags & RTWN_RUNNING)
1657 rtwn_set_promisc(sc);
1658 RTWN_UNLOCK(sc);
1659 }
1660
1661 static void
1662 rtwn_update_mcast(struct ieee80211com *ic)
1663 {
1664 struct rtwn_softc *sc = ic->ic_softc;
1665
1666 RTWN_LOCK(sc);
1667 if (sc->sc_flags & RTWN_RUNNING)
1668 rtwn_set_multi(sc);
1669 RTWN_UNLOCK(sc);
1670 }
1671
1672 static int
1673 rtwn_set_bssid(struct rtwn_softc *sc, const uint8_t *bssid, int id)
1674 {
1675 int error;
1676
1677 error = rtwn_write_4(sc, R92C_BSSID(id), le32dec(&bssid[0]));
1678 if (error != 0)
1679 return (error);
1680 error = rtwn_write_2(sc, R92C_BSSID(id) + 4, le16dec(&bssid[4]));
1681
1682 return (error);
1683 }
1684
1685 static int
1686 rtwn_set_macaddr(struct rtwn_softc *sc, const uint8_t *addr, int id)
1687 {
1688 int error;
1689
1690 error = rtwn_write_4(sc, R92C_MACID(id), le32dec(&addr[0]));
1691 if (error != 0)
1692 return (error);
1693 error = rtwn_write_2(sc, R92C_MACID(id) + 4, le16dec(&addr[4]));
1694
1695 return (error);
1696 }
1697
1698 static struct ieee80211_node *
1699 rtwn_node_alloc(struct ieee80211vap *vap,
1700 const uint8_t mac[IEEE80211_ADDR_LEN])
1701 {
1702 struct rtwn_node *un;
1703
1704 un = malloc(sizeof (struct rtwn_node), M_80211_NODE,
1705 M_NOWAIT | M_ZERO);
1706
1707 if (un == NULL)
1708 return NULL;
1709
1710 un->id = RTWN_MACID_UNDEFINED;
1711 un->avg_pwdb = -1;
1712
1713 return &un->ni;
1714 }
1715
1716 static void
1717 rtwn_newassoc(struct ieee80211_node *ni, int isnew __unused)
1718 {
1719 struct rtwn_softc *sc = ni->ni_ic->ic_softc;
1720 struct rtwn_node *un = RTWN_NODE(ni);
1721 int id;
1722
1723 if (un->id != RTWN_MACID_UNDEFINED)
1724 return;
1725
1726 RTWN_NT_LOCK(sc);
1727 for (id = 0; id <= sc->macid_limit; id++) {
1728 if (id != RTWN_MACID_BC && sc->node_list[id] == NULL) {
1729 un->id = id;
1730 sc->node_list[id] = ni;
1731 break;
1732 }
1733 }
1734 RTWN_NT_UNLOCK(sc);
1735
1736 if (id > sc->macid_limit) {
1737 device_printf(sc->sc_dev, "%s: node table is full\n",
1738 __func__);
1739 return;
1740 }
1741
1742 /* Notify firmware. */
1743 id |= RTWN_MACID_VALID;
1744 rtwn_cmd_sleepable(sc, &id, sizeof(id), rtwn_set_media_status);
1745 }
1746
1747 static void
1748 rtwn_node_free(struct ieee80211_node *ni)
1749 {
1750 struct rtwn_softc *sc = ni->ni_ic->ic_softc;
1751 struct rtwn_node *un = RTWN_NODE(ni);
1752
1753 RTWN_NT_LOCK(sc);
1754 if (un->id != RTWN_MACID_UNDEFINED) {
1755 sc->node_list[un->id] = NULL;
1756 rtwn_cmd_sleepable(sc, &un->id, sizeof(un->id),
1757 rtwn_set_media_status);
1758 }
1759 RTWN_NT_UNLOCK(sc);
1760
1761 sc->sc_node_free(ni);
1762 }
1763
1764 static void
1765 rtwn_init_beacon_reg(struct rtwn_softc *sc)
1766 {
1767 rtwn_write_1(sc, R92C_BCN_CTRL(0), R92C_BCN_CTRL_DIS_TSF_UDT0);
1768 rtwn_write_1(sc, R92C_BCN_CTRL(1), R92C_BCN_CTRL_DIS_TSF_UDT0);
1769 rtwn_write_2(sc, R92C_TBTT_PROHIBIT, 0x6404);
1770 rtwn_write_1(sc, R92C_DRVERLYINT, 0x05);
1771 rtwn_write_1(sc, R92C_BCNDMATIM, 0x02);
1772 rtwn_write_2(sc, R92C_BCNTCFG, 0x660f);
1773 }
1774
1775 static int
1776 rtwn_init(struct rtwn_softc *sc)
1777 {
1778 struct ieee80211com *ic = &sc->sc_ic;
1779 int i, error;
1780
1781 RTWN_LOCK(sc);
1782 if (sc->sc_flags & RTWN_RUNNING) {
1783 RTWN_UNLOCK(sc);
1784 return (0);
1785 }
1786 sc->sc_flags |= RTWN_STARTED;
1787
1788 /* Power on adapter. */
1789 error = rtwn_power_on(sc);
1790 if (error != 0)
1791 goto fail;
1792
1793 #ifndef RTWN_WITHOUT_UCODE
1794 /* Load 8051 microcode. */
1795 error = rtwn_load_firmware(sc);
1796 if (error == 0)
1797 sc->sc_flags |= RTWN_FW_LOADED;
1798
1799 /* Init firmware commands ring. */
1800 sc->fwcur = 0;
1801 #endif
1802
1803 /* Initialize MAC block. */
1804 error = rtwn_mac_init(sc);
1805 if (error != 0) {
1806 device_printf(sc->sc_dev,
1807 "%s: error while initializing MAC block\n", __func__);
1808 goto fail;
1809 }
1810
1811 /* Initialize DMA. */
1812 error = rtwn_dma_init(sc);
1813 if (error != 0)
1814 goto fail;
1815
1816 /* Drop incorrect TX (USB). */
1817 rtwn_drop_incorrect_tx(sc);
1818
1819 /* Set info size in Rx descriptors (in 64-bit words). */
1820 rtwn_write_1(sc, R92C_RX_DRVINFO_SZ, R92C_RX_DRVINFO_SZ_DEF);
1821
1822 /* Init interrupts. */
1823 rtwn_init_intr(sc);
1824
1825 for (i = 0; i < nitems(sc->vaps); i++) {
1826 struct rtwn_vap *uvp = sc->vaps[i];
1827
1828 /* Set initial network type. */
1829 rtwn_set_mode(sc, R92C_MSR_NOLINK, i);
1830
1831 if (uvp == NULL)
1832 continue;
1833
1834 /* Set MAC address. */
1835 error = rtwn_set_macaddr(sc, uvp->vap.iv_myaddr, uvp->id);
1836 if (error != 0)
1837 goto fail;
1838 }
1839
1840 /* Initialize Rx filter. */
1841 rtwn_rxfilter_init(sc);
1842
1843 /* Set short/long retry limits. */
1844 rtwn_write_2(sc, R92C_RL,
1845 SM(R92C_RL_SRL, 0x30) | SM(R92C_RL_LRL, 0x30));
1846
1847 /* Initialize EDCA parameters. */
1848 rtwn_init_edca(sc);
1849
1850 rtwn_setbits_1(sc, R92C_FWHW_TXQ_CTRL, 0,
1851 R92C_FWHW_TXQ_CTRL_AMPDU_RTY_NEW);
1852 /* Set ACK timeout. */
1853 rtwn_write_1(sc, R92C_ACKTO, sc->ackto);
1854
1855 /* Setup aggregation. */
1856 /* Tx aggregation. */
1857 rtwn_init_tx_agg(sc);
1858 rtwn_init_rx_agg(sc);
1859
1860 /* Initialize beacon parameters. */
1861 rtwn_init_beacon_reg(sc);
1862
1863 /* Init A-MPDU parameters. */
1864 rtwn_init_ampdu(sc);
1865
1866 /* Init MACTXEN / MACRXEN after setting RxFF boundary. */
1867 rtwn_setbits_1(sc, R92C_CR, 0, R92C_CR_MACTXEN | R92C_CR_MACRXEN);
1868
1869 /* Initialize BB/RF blocks. */
1870 rtwn_init_bb(sc);
1871 rtwn_init_rf(sc);
1872
1873 /* Initialize wireless band. */
1874 rtwn_set_chan(sc, ic->ic_curchan);
1875
1876 /* Clear per-station keys table. */
1877 rtwn_init_cam(sc);
1878
1879 /* Enable decryption / encryption. */
1880 rtwn_init_seccfg(sc);
1881
1882 /* Install static keys (if any). */
1883 for (i = 0; i < nitems(sc->vaps); i++) {
1884 if (sc->vaps[i] != NULL) {
1885 error = rtwn_init_static_keys(sc, sc->vaps[i]);
1886 if (error != 0)
1887 goto fail;
1888 }
1889 }
1890
1891 /* Initialize antenna selection. */
1892 rtwn_init_antsel(sc);
1893
1894 /* Enable hardware sequence numbering. */
1895 rtwn_write_1(sc, R92C_HWSEQ_CTRL, R92C_TX_QUEUE_ALL);
1896
1897 /* Disable BAR. */
1898 rtwn_write_4(sc, R92C_BAR_MODE_CTRL, 0x0201ffff);
1899
1900 /* NAV limit. */
1901 rtwn_write_1(sc, R92C_NAV_UPPER, 0);
1902
1903 /* Initialize GPIO setting. */
1904 rtwn_setbits_1(sc, R92C_GPIO_MUXCFG, R92C_GPIO_MUXCFG_ENBT, 0);
1905
1906 /* Initialize MRR. */
1907 rtwn_mrr_init(sc);
1908
1909 /* Device-specific post initialization. */
1910 rtwn_post_init(sc);
1911
1912 rtwn_start_xfers(sc);
1913
1914 #ifndef D4054
1915 callout_reset(&sc->sc_watchdog_to, hz, rtwn_watchdog, sc);
1916 #endif
1917
1918 sc->sc_flags |= RTWN_RUNNING;
1919 fail:
1920 RTWN_UNLOCK(sc);
1921
1922 return (error);
1923 }
1924
1925 static void
1926 rtwn_stop(struct rtwn_softc *sc)
1927 {
1928
1929 RTWN_LOCK(sc);
1930 if (!(sc->sc_flags & RTWN_STARTED)) {
1931 RTWN_UNLOCK(sc);
1932 return;
1933 }
1934
1935 #ifndef D4054
1936 callout_stop(&sc->sc_watchdog_to);
1937 sc->sc_tx_timer = 0;
1938 #endif
1939 sc->sc_flags &= ~(RTWN_STARTED | RTWN_RUNNING | RTWN_FW_LOADED);
1940 sc->sc_flags &= ~RTWN_TEMP_MEASURED;
1941 sc->fwver = 0;
1942 sc->thcal_temp = 0;
1943 sc->cur_bcnq_id = RTWN_VAP_ID_INVALID;
1944 bzero(&sc->last_physt, sizeof(sc->last_physt));
1945
1946 #ifdef D4054
1947 ieee80211_tx_watchdog_stop(&sc->sc_ic);
1948 #endif
1949
1950 rtwn_abort_xfers(sc);
1951 rtwn_drain_mbufq(sc);
1952 rtwn_power_off(sc);
1953 rtwn_reset_lists(sc, NULL);
1954 RTWN_UNLOCK(sc);
1955 }
1956
1957 MODULE_VERSION(rtwn, 2);
1958 MODULE_DEPEND(rtwn, wlan, 1, 1, 1);
1959 #ifndef RTWN_WITHOUT_UCODE
1960 MODULE_DEPEND(rtwn, firmware, 1, 1, 1);
1961 #endif
Cache object: 9469736955639c890048bdbffd2a12bf
|