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