?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Tx HT frames with STBC only if we have 2 or more Tx antennas
[ralink_drivers/rt2870_fbsd8.git] / rt2870.c
blob566ef6825f3128ffb70107ecdf66eeb6c7de6991
1
2 /*-
3 * Copyright (c) 2009-2010 Alexander Egorenkov <egorenar@gmail.com>
4 * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include "rt2870_softc.h"
20 #include "rt2870_reg.h"
21 #include "rt2870_eeprom.h"
22 #include "rt2870_ucode.h"
23 #include "rt2870_rxwi.h"
24 #include "rt2870_rxinfo.h"
25 #include "rt2870_txinfo.h"
26 #include "rt2870_txwi.h"
27 #include "rt2870_read_eeprom.h"
28 #include "rt2870_io.h"
29 #include "rt2870_rf.h"
30 #include "rt2870_led.h"
31 #include "rt2870_debug.h"
32
33 /*
34 * Defines and macros
35 */
36
37 #define USB_PRODUCT_LINKSYS4_WUSB600N 0x0071
38 #define USB_PRODUCT_DLINK2_DWA140 0x3c09
39 #define USB_PRODUCT_DLINK2_DWA160AREVB 0x3c11
40 #define USB_PRODUCT_ASUS_RT2770F 0x1742
41 #define USB_PRODUCT_RALINK_RT2770 0x2770
42
43 #define RT2870_USB_CONFIG_INDEX 0
44 #define RT2870_USB_IFACE_INDEX 0
45
46 #define RT2870_USB_REQ_MAC_READ_MULTI 0x07
47
48 /* packet length + Rx wireless info + Rx info */
49 #define RT2870_RX_DESC_SIZE \
50 (sizeof(uint32_t) + sizeof(struct rt2870_rxwi) + sizeof(struct rt2870_rxinfo))
51
52 /* Tx info + Tx wireless info + max padding */
53 #define RT2870_TX_DESC_SIZE \
54 (sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + 11)
55
56 #define RT2870_MAX_AGG_SIZE 3840
57
58 #define RT2870_USB_RX_BULK_BUFLEN (2048 * 12)
59
60 #define RT2870_NOISE_FLOOR -95
61
62 #define RT2870_AID2WCID(aid) ((aid) & 0xff)
63
64 #define RT2870_ACK_SIZE 14
65
66 #define IEEE80211_HAS_ADDR4(wh) \
67 (((wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS)
68
69 #define RT2870_MS(_v, _f) (((_v) & _f) >> _f##_S)
70 #define RT2870_SM(_v, _f) (((_v) << _f##_S) & _f)
71
72 #define RT2870_USB_XFER_TIMEOUT 5000
73
74 #define RT2870_TX_WATCHDOG_TIMEOUT 5
75
76 /*
77 * Data structures and types
78 */
79
80 struct rt2870_cmd_argv_keyset
81 {
82 struct ieee80211_key key;
83 uint16_t associd;
84 };
85
86 struct rt2870_cmd_argv_keydelete
87 {
88 struct ieee80211_key key;
89 uint16_t associd;
90 };
91
92 /*
93 * Static function prototypes
94 */
95
96 static void rt2870_init_channels(struct rt2870_softc *sc);
97
98 static void rt2870_init_channels_ht40(struct rt2870_softc *sc);
99
100 static void rt2870_init_locked(void *priv);
101
102 static void rt2870_init(void *priv);
103
104 static int rt2870_init_bbp(struct rt2870_softc *sc);
105
106 static void rt2870_stop_locked(void *priv);
107
108 static void rt2870_stop(void *priv);
109
110 static void rt2870_start(struct ifnet *ifp);
111
112 static int rt2870_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
113
114 static struct ieee80211vap *rt2870_vap_create(struct ieee80211com *ic,
115 const char name[IFNAMSIZ], int unit, int opmode, int flags,
116 const uint8_t bssid[IEEE80211_ADDR_LEN],
117 const uint8_t mac[IEEE80211_ADDR_LEN]);
118
119 static void rt2870_vap_delete(struct ieee80211vap *vap);
120
121 static int rt2870_vap_reset(struct ieee80211vap *vap, u_long cmd);
122
123 static int rt2870_vap_newstate(struct ieee80211vap *vap,
124 enum ieee80211_state nstate, int arg);
125
126 static void rt2870_vap_key_update_begin(struct ieee80211vap *vap);
127
128 static void rt2870_vap_key_update_end(struct ieee80211vap *vap);
129
130 static int rt2870_vap_key_set(struct ieee80211vap *vap,
131 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN]);
132
133 static int rt2870_vap_key_delete(struct ieee80211vap *vap,
134 const struct ieee80211_key *k);
135
136 static void rt2870_vap_update_beacon(struct ieee80211vap *vap, int what);
137
138 static struct ieee80211_node *rt2870_node_alloc(struct ieee80211vap *vap,
139 const uint8_t mac[IEEE80211_ADDR_LEN]);
140
141 static int rt2870_setregdomain(struct ieee80211com *ic,
142 struct ieee80211_regdomain *reg,
143 int nchans, struct ieee80211_channel chans[]);
144
145 static void rt2870_getradiocaps(struct ieee80211com *ic,
146 int maxchans, int *nchans, struct ieee80211_channel chans[]);
147
148 static void rt2870_scan_start(struct ieee80211com *ic);
149
150 static void rt2870_scan_end(struct ieee80211com *ic);
151
152 static void rt2870_set_channel(struct ieee80211com *ic);
153
154 static void rt2870_newassoc(struct ieee80211_node *ni, int isnew);
155
156 static void rt2870_updateslot(struct ifnet *ifp);
157
158 static void rt2870_update_promisc(struct ifnet *ifp);
159
160 static void rt2870_update_mcast(struct ifnet *ifp);
161
162 static int rt2870_wme_update(struct ieee80211com *ic);
163
164 static int rt2870_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
165 const struct ieee80211_bpf_params *params);
166
167 static int rt2870_recv_action(struct ieee80211_node *ni,
168 const struct ieee80211_frame *wh,
169 const uint8_t *frm, const uint8_t *efrm);
170
171 static int rt2870_send_action(struct ieee80211_node *ni,
172 int cat, int act, void *sa);
173
174 static void rt2870_amrr_update_iter_func(void *arg, struct ieee80211_node *ni);
175
176 static void rt2870_periodic(void *arg);
177
178 static void rt2870_tx_watchdog(void *arg);
179
180 static int rt2870_do_async(struct rt2870_softc *sc,
181 void (*cb)(struct rt2870_softc *sc, void *arg),
182 void *arg, int len);
183
184 static void rt2870_updateslot_cb(struct rt2870_softc *sc, void *arg);
185
186 static void rt2870_wme_update_cb(struct rt2870_softc *sc, void *arg);
187
188 static void rt2870_vap_key_set_cb(struct rt2870_softc *sc, void *arg);
189
190 static void rt2870_vap_key_delete_cb(struct rt2870_softc *sc, void *arg);
191
192 static void rt2870_vap_update_beacon_cb(struct rt2870_softc *sc, void *arg);
193
194 static void rt2870_asic_set_bssid(struct rt2870_softc *sc,
195 const uint8_t *bssid);
196
197 static void rt2870_asic_set_macaddr(struct rt2870_softc *sc,
198 const uint8_t *addr);
199
200 static void rt2870_asic_enable_tsf_sync(struct rt2870_softc *sc);
201
202 static void rt2870_asic_disable_tsf_sync(struct rt2870_softc *sc);
203
204 static void rt2870_asic_enable_mrr(struct rt2870_softc *sc);
205
206 static void rt2870_asic_set_txpreamble(struct rt2870_softc *sc);
207
208 static void rt2870_asic_set_basicrates(struct rt2870_softc *sc);
209
210 static void rt2870_asic_update_rtsthreshold(struct rt2870_softc *sc);
211
212 static void rt2870_asic_update_txpower(struct rt2870_softc *sc);
213
214 static void rt2870_asic_update_promisc(struct rt2870_softc *sc);
215
216 static void rt2870_asic_updateprot(struct rt2870_softc *sc);
217
218 static void rt2870_asic_updateslot(struct rt2870_softc *sc);
219
220 static void rt2870_asic_wme_update(struct rt2870_softc *sc);
221
222 static int rt2870_asic_update_beacon(struct rt2870_softc *sc,
223 struct ieee80211vap *vap);
224
225 static void rt2870_asic_clear_keytables(struct rt2870_softc *sc);
226
227 static uint8_t rt2870_rxrate(struct rt2870_rxwi *rxwi);
228
229 static uint8_t rt2870_maxrssi_rxpath(struct rt2870_softc *sc,
230 const struct rt2870_rxwi *rxwi);
231
232 static int8_t rt2870_rssi2dbm(struct rt2870_softc *sc,
233 uint8_t rssi, uint8_t rxpath);
234
235 static uint8_t rt2870_rate2mcs(uint8_t rate);
236
237 static void rt2870_rx_frame(struct rt2870_softc *sc,
238 uint8_t *buf, uint32_t dmalen);
239
240 static int rt2870_tx_mgmt(struct rt2870_softc *sc,
241 struct mbuf *m, struct ieee80211_node *ni, int qid);
242
243 static int rt2870_tx_data(struct rt2870_softc *sc,
244 struct mbuf *m, struct ieee80211_node *ni, int qid);
245
246 static int rt2870_tx_raw(struct rt2870_softc *sc,
247 struct mbuf *m, struct ieee80211_node *ni,
248 const struct ieee80211_bpf_params *params);
249
250 static void rt2870_rx_intr(struct usb_xfer *xfer, usb_error_t error);
251
252 static void rt2870_tx_intr(struct usb_xfer *xfer, usb_error_t error);
253
254 static void rt2870_rx_done_task(void *context, int pending);
255
256 static void rt2870_tx_done_task(void *context, int pending);
257
258 static void rt2870_periodic_task(void *context, int pending);
259
260 static void rt2870_cmd_task(void *context, int pending);
261
262 static int rt2870_rx_eof(struct rt2870_softc *sc, int limit);
263
264 static void rt2870_tx_eof(struct rt2870_softc *sc,
265 struct rt2870_softc_tx_ring *ring);
266
267 static void rt2870_update_stats(struct rt2870_softc *sc);
268
269 static void rt2870_bbp_tuning(struct rt2870_softc *sc);
270
271 static void rt2870_watchdog(struct rt2870_softc *sc);
272
273 static void rt2870_drain_fifo_stats(struct rt2870_softc *sc);
274
275 static void rt2870_update_raw_counters(struct rt2870_softc *sc);
276
277 static int rt2870_txrx_enable(struct rt2870_softc *sc);
278
279 static int rt2870_alloc_rx_ring(struct rt2870_softc *sc,
280 struct rt2870_softc_rx_ring *ring);
281
282 static void rt2870_reset_rx_ring(struct rt2870_softc *sc,
283 struct rt2870_softc_rx_ring *ring);
284
285 static void rt2870_free_rx_ring(struct rt2870_softc *sc,
286 struct rt2870_softc_rx_ring *ring);
287
288 static int rt2870_alloc_tx_ring(struct rt2870_softc *sc,
289 struct rt2870_softc_tx_ring *ring, int qid);
290
291 static void rt2870_reset_tx_ring(struct rt2870_softc *sc,
292 struct rt2870_softc_tx_ring *ring);
293
294 static void rt2870_free_tx_ring(struct rt2870_softc *sc,
295 struct rt2870_softc_tx_ring *ring);
296
297 static void rt2870_reset_cmd_ring(struct rt2870_softc *sc,
298 struct rt2870_softc_cmd_ring *ring);
299
300 static void rt2870_sysctl_attach(struct rt2870_softc *sc);
301
302 /*
303 * Static variables
304 */
305
306 static const struct usb_device_id rt2870_usb_devid[] =
307 {
308 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_WUSB600N) }, /* Linksys WUSB600N */
309 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA140) }, /* D-Link DWA-140 */
310 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA160AREVB) }, /* D-Link DWA-160A Rev. B */
311 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2770F) }, /* Asus RT2770F */
312 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT2770) }, /* Ralink RT2770 */
313 };
314
315 static const struct usb_config rt2870_usb_config[RT2870_SOFTC_USB_XFER_COUNT] =
316 {
317 {
318 .type = UE_BULK,
319 .endpoint = 0x01,
320 .direction = UE_DIR_IN,
321 .bufsize = RT2870_USB_RX_BULK_BUFLEN,
322 .flags = { .ext_buffer = 1, .pipe_bof = 1, .short_xfer_ok = 1, },
323 .callback = rt2870_rx_intr,
324 },
325 {
326 .type = UE_BULK,
327 .endpoint = 0x01,
328 .direction = UE_DIR_OUT,
329 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
330 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
331 .callback = rt2870_tx_intr,
332 .timeout = RT2870_USB_XFER_TIMEOUT,
333 },
334 {
335 .type = UE_BULK,
336 .endpoint = 0x02,
337 .direction = UE_DIR_OUT,
338 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
339 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
340 .callback = rt2870_tx_intr,
341 .timeout = RT2870_USB_XFER_TIMEOUT,
342 },
343 {
344 .type = UE_BULK,
345 .endpoint = 0x03,
346 .direction = UE_DIR_OUT,
347 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
348 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
349 .callback = rt2870_tx_intr,
350 .timeout = RT2870_USB_XFER_TIMEOUT,
351 },
352 {
353 .type = UE_BULK,
354 .endpoint = 0x04,
355 .direction = UE_DIR_OUT,
356 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
357 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
358 .callback = rt2870_tx_intr,
359 .timeout = RT2870_USB_XFER_TIMEOUT,
360 },
361 {
362 .type = UE_BULK,
363 .endpoint = 0x05,
364 .direction = UE_DIR_OUT,
365 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
366 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
367 .callback = rt2870_tx_intr,
368 .timeout = RT2870_USB_XFER_TIMEOUT,
369 },
370 {
371 .type = UE_BULK,
372 .endpoint = 0x06,
373 .direction = UE_DIR_OUT,
374 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
375 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
376 .callback = rt2870_tx_intr,
377 .timeout = RT2870_USB_XFER_TIMEOUT,
378 },
379 };
380
381 static const struct
382 {
383 uint32_t reg;
384 uint32_t val;
385 } rt2870_def_mac[] =
386 {
387 { RT2870_REG_PBF_BCN_OFFSET0, 0xf8f0e8e0 },
388 { RT2870_REG_PBF_BCN_OFFSET1, 0x6f77d0c8 },
389 { RT2870_REG_LEGACY_BASIC_RATE, 0x0000013f },
390 { RT2870_REG_HT_BASIC_RATE, 0x00008003 },
391 { RT2870_REG_SYS_CTRL, 0x00000000 },
392 { RT2870_REG_RX_FILTER_CFG, 0x00017f97 },
393 { RT2870_REG_BKOFF_SLOT_CFG, 0x00000209 },
394 { RT2870_REG_TX_SW_CFG0, 0x00000000 },
395 { RT2870_REG_TX_SW_CFG1, 0x00080606 },
396 { RT2870_REG_TX_LINK_CFG, 0x00001020 },
397 { RT2870_REG_TX_TIMEOUT_CFG, 0x000a2090 },
398 { RT2870_REG_MAX_LEN_CFG, (1 << 12) | RT2870_MAX_AGG_SIZE },
399 { RT2870_REG_LED_CFG, 0x7f031e46 },
400 { RT2870_REG_PBF_MAX_PCNT, 0x1f3fbf9f },
401 { RT2870_REG_TX_RTY_CFG, 0x47d01f0f },
402 { RT2870_REG_AUTO_RSP_CFG, 0x00000013 },
403 { RT2870_REG_TX_CCK_PROT_CFG, 0x05740003 },
404 { RT2870_REG_TX_OFDM_PROT_CFG, 0x05740003 },
405 { RT2870_REG_PBF_CFG, 0x00f40006 },
406 { RT2870_REG_TX_MM40_PROT_CFG, 0x03f44084 },
407 { RT2870_REG_SCHDMA_WPDMA_GLO_CFG, 0x00000030 },
408 { RT2870_REG_TX_GF20_PROT_CFG, 0x01744004 },
409 { RT2870_REG_TX_GF40_PROT_CFG, 0x03f44084 },
410 { RT2870_REG_TX_MM20_PROT_CFG, 0x01744004 },
411 { RT2870_REG_TX_TXOP_CTRL_CFG, 0x0000583f },
412 { RT2870_REG_TX_RTS_CFG, 0x00092b20 },
413 { RT2870_REG_TX_EXP_ACK_TIME, 0x002400ca },
414 { RT2870_REG_HCCAPSMP_TXOP_HLDR_ET, 0x00000002 },
415 { RT2870_REG_XIFS_TIME_CFG, 0x33a41010 },
416 { RT2870_REG_PWR_PIN_CFG, 0x00000003 },
417 { RT2870_REG_SCHDMA_WMM_AIFSN_CFG, 0x00002273 },
418 { RT2870_REG_SCHDMA_WMM_CWMIN_CFG, 0x00002344 },
419 { RT2870_REG_SCHDMA_WMM_CWMAX_CFG, 0x000034aa },
420 };
421
422 #define RT2870_DEF_MAC_SIZE (sizeof(rt2870_def_mac) / sizeof(rt2870_def_mac[0]))
423
424 static const struct
425 {
426 uint8_t reg;
427 uint8_t val;
428 } rt2870_def_bbp[] =
429 {
430 { 65, 0x2c },
431 { 66, 0x38 },
432 { 69, 0x12 },
433 { 70, 0x0a },
434 { 73, 0x10 },
435 { 81, 0x37 },
436 { 82, 0x62 },
437 { 83, 0x6a },
438 { 84, 0x99 },
439 { 86, 0x00 },
440 { 91, 0x04 },
441 { 92, 0x00 },
442 { 103, 0x00 },
443 { 105, 0x05 },
444 { 106, 0x35 },
445 };
446
447 #define RT2870_DEF_BBP_SIZE (sizeof(rt2870_def_bbp) / sizeof(rt2870_def_bbp[0]))
448
449 SYSCTL_NODE(_hw, OID_AUTO, rt2870, CTLFLAG_RD, 0, "RT2870 driver parameters");
450
451 #ifdef RT2870_DEBUG
452 static int rt2870_debug = 0;
453 SYSCTL_INT(_hw_rt2870, OID_AUTO, debug, CTLFLAG_RW, &rt2870_debug, 0, "rt2870 debug level");
454 TUNABLE_INT("hw.rt2870.debug", &rt2870_debug);
455 #endif
456
457 /*
458 * rt2870_probe
459 */
460 static int rt2870_probe(device_t dev)
461 {
462 struct usb_attach_arg *uaa;
463
464 uaa = device_get_ivars(dev);
465
466 if (uaa->usb_mode != USB_MODE_HOST)
467 return ENXIO;
468
469 if (uaa->info.bConfigIndex != RT2870_USB_CONFIG_INDEX)
470 return ENXIO;
471
472 if (uaa->info.bIfaceIndex != RT2870_USB_IFACE_INDEX)
473 return ENXIO;
474
475 return (usbd_lookup_id_by_uaa(rt2870_usb_devid,
476 sizeof(rt2870_usb_devid), uaa));
477 }
478
479 /*
480 * rt2870_attach
481 */
482 static int rt2870_attach(device_t dev)
483 {
484 struct rt2870_softc *sc;
485 struct usb_attach_arg *uaa;
486 usb_error_t usb_error;
487 struct ieee80211com *ic;
488 struct ifnet *ifp;
489 struct usb_interface *iface;
490 struct usb_interface_descriptor *iface_desc;
491 uint8_t iface_index;
492 int error, ntries, i;
493
494 sc = device_get_softc(dev);
495 uaa = device_get_ivars(dev);
496
497 sc->dev = dev;
498 sc->usb_dev = uaa->device;
499
500 device_set_usb_desc(dev);
501
502 #ifdef RT2870_DEBUG
503 sc->debug = rt2870_debug;
504
505 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
506 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
507 "debug", CTLFLAG_RW, &sc->debug, 0, "rt2870 debug level");
508 #endif
509
510 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
511 "%s: attaching\n",
512 device_get_nameunit(sc->dev));
513
514 iface_index = RT2870_USB_IFACE_INDEX;
515
516 iface = usbd_get_iface(uaa->device, iface_index);
517 if (iface == NULL)
518 {
519 printf("%s: could not get USB interface\n",
520 device_get_nameunit(sc->dev));
521 return ENXIO;
522 }
523
524 iface_desc = usbd_get_interface_descriptor(iface);
525 if (iface_desc == NULL)
526 {
527 printf("%s: could not get USB interface descriptor\n",
528 device_get_nameunit(sc->dev));
529 return ENXIO;
530 }
531
532 sc->usb_endpoints = iface_desc->bNumEndpoints;
533 if ((sc->usb_endpoints != RT2870_SOFTC_USB_XFER_COUNT) &&
534 (sc->usb_endpoints != RT2870_SOFTC_USB_XFER_COUNT - 2))
535 {
536 printf("%s: wrong number of USB endpoints=%d\n",
537 device_get_nameunit(sc->dev), sc->usb_endpoints);
538 return ENXIO;
539 }
540
541 mtx_init(&sc->lock, device_get_nameunit(dev),
542 MTX_NETWORK_LOCK, MTX_DEF);
543
544 usb_error = usbd_transfer_setup(uaa->device, &iface_index,
545 sc->usb_xfer, rt2870_usb_config, sc->usb_endpoints,
546 sc, &sc->lock);
547 if (usb_error != 0)
548 {
549 printf("%s: could not allocate USB transfers: error=%s\n",
550 device_get_nameunit(sc->dev), usbd_errstr(usb_error));
551 error = ENXIO;
552 goto fail;
553 }
554
555 RT2870_SOFTC_LOCK(sc);
556
557 for (ntries = 0; ntries < 100; ntries++)
558 {
559 sc->mac_rev = rt2870_io_mac_read(sc, RT2870_REG_MAC_CSR0);
560 if (sc->mac_rev != 0x00000000 && sc->mac_rev != 0xffffffff)
561 break;
562
563 DELAY(10);
564 }
565
566 if (ntries == 100)
567 {
568 printf("%s: timeout waiting for NIC to initialize\n",
569 device_get_nameunit(sc->dev));
570 error = ENXIO;
571 goto fail;
572 }
573
574 rt2870_read_eeprom(sc);
575
576 RT2870_SOFTC_UNLOCK(sc);
577
578 printf("%s: MAC/BBP RT2870 (rev 0x%08x), RF %s\n",
579 device_get_nameunit(sc->dev), sc->mac_rev,
580 rt2870_rf_name(sc->rf_rev));
581
582 /* allocate Tx and Rx rings */
583
584 for (i = 0; i < sc->usb_endpoints - 1; i++)
585 {
586 error = rt2870_alloc_tx_ring(sc, &sc->tx_ring[i], i);
587 if (error != 0)
588 {
589 printf("%s: could not allocate Tx ring #%d\n",
590 device_get_nameunit(sc->dev), i);
591 goto fail;
592 }
593 }
594
595 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
596 sc->tx_ring_mgtqid = 5;
597 else
598 sc->tx_ring_mgtqid = 0;
599
600 error = rt2870_alloc_rx_ring(sc, &sc->rx_ring);
601 if (error != 0)
602 {
603 printf("%s: could not allocate Rx ring\n",
604 device_get_nameunit(sc->dev));
605 goto fail;
606 }
607
608 callout_init(&sc->periodic_ch, 0);
609 callout_init_mtx(&sc->tx_watchdog_ch, &sc->lock, 0);
610
611 ifp = sc->ifp = if_alloc(IFT_IEEE80211);
612 if (ifp == NULL)
613 {
614 printf("%s: could not if_alloc()\n",
615 device_get_nameunit(sc->dev));
616 error = ENOMEM;
617 goto fail;
618 }
619
620 ifp->if_softc = sc;
621
622 if_initname(ifp, "rt2870", device_get_unit(sc->dev));
623
624 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
625
626 ifp->if_init = rt2870_init;
627 ifp->if_ioctl = rt2870_ioctl;
628 ifp->if_start = rt2870_start;
629
630 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
631 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
632 IFQ_SET_READY(&ifp->if_snd);
633
634 ic = ifp->if_l2com;
635
636 ic->ic_ifp = ifp;
637
638 ic->ic_phytype = IEEE80211_T_HT;
639 ic->ic_opmode = IEEE80211_M_STA;
640
641 ic->ic_caps = IEEE80211_C_MONITOR |
642 IEEE80211_C_IBSS |
643 IEEE80211_C_STA |
644 IEEE80211_C_AHDEMO |
645 IEEE80211_C_HOSTAP |
646 IEEE80211_C_WDS |
647 IEEE80211_C_MBSS |
648 IEEE80211_C_BGSCAN |
649 IEEE80211_C_TXPMGT |
650 IEEE80211_C_SHPREAMBLE |
651 IEEE80211_C_SHSLOT |
652 IEEE80211_C_TXFRAG |
653 IEEE80211_C_BURST |
654 IEEE80211_C_WME |
655 IEEE80211_C_WPA;
656
657 ic->ic_cryptocaps |= IEEE80211_CRYPTO_WEP |
658 IEEE80211_CRYPTO_TKIP |
659 IEEE80211_CRYPTO_TKIPMIC |
660 IEEE80211_CRYPTO_AES_CCM;
661
662 ic->ic_htcaps = IEEE80211_HTC_HT |
663 IEEE80211_HTC_AMSDU | /* A-MSDU Tx */
664 IEEE80211_HTC_AMPDU | /* A-MPDU Tx */
665 IEEE80211_HTCAP_MAXAMSDU_3839 | /* max. A-MSDU Rx length */
666 IEEE80211_HTCAP_CHWIDTH40 | /* HT 40MHz channel width */
667 IEEE80211_HTCAP_GREENFIELD | /* HT greenfield */
668 IEEE80211_HTCAP_SHORTGI20 | /* HT 20MHz short GI */
669 IEEE80211_HTCAP_SHORTGI40 | /* HT 40MHz short GI */
670 IEEE80211_HTCAP_SMPS_OFF | /* SM power save mode */
671 IEEE80211_HTCAP_MCSFBACK_UNSOL | /* unsolicited MCS feedback */
672 IEEE80211_HTCAP_HTC; /* HTC+ */
673
674 /* spatial streams */
675
676 if (sc->nrxpath == 2)
677 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_2STREAM;
678 else if (sc->nrxpath == 3)
679 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_3STREAM;
680 else
681 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_1STREAM;
682
683 if (sc->ntxpath > 1)
684 ic->ic_htcaps |= IEEE80211_HTCAP_TXSTBC;
685
686 /* delayed BA */
687
688 if (sc->mac_rev != 0x28600100)
689 ic->ic_htcaps |= IEEE80211_HTCAP_DELBA;
690
691 /* init channels */
692
693 ic->ic_nchans = 0;
694
695 rt2870_init_channels(sc);
696
697 rt2870_init_channels_ht40(sc);
698
699 ieee80211_ifattach(ic, sc->mac_addr);
700
701 ic->ic_vap_create = rt2870_vap_create;
702 ic->ic_vap_delete = rt2870_vap_delete;
703
704 ic->ic_node_alloc = rt2870_node_alloc;
705 ic->ic_setregdomain = rt2870_setregdomain;
706 ic->ic_getradiocaps = rt2870_getradiocaps;
707 ic->ic_scan_start = rt2870_scan_start;
708 ic->ic_scan_end = rt2870_scan_end;
709 ic->ic_set_channel = rt2870_set_channel;
710 ic->ic_newassoc = rt2870_newassoc;
711 ic->ic_updateslot = rt2870_updateslot;
712 ic->ic_update_promisc = rt2870_update_promisc;
713 ic->ic_update_mcast = rt2870_update_mcast;
714 ic->ic_wme.wme_update = rt2870_wme_update;
715 ic->ic_raw_xmit = rt2870_raw_xmit;
716
717 sc->recv_action = ic->ic_recv_action;
718 ic->ic_recv_action = rt2870_recv_action;
719
720 sc->send_action = ic->ic_send_action;
721 ic->ic_send_action = rt2870_send_action;
722
723 /* hardware requires padding between 802.11 frame header and body */
724
725 ic->ic_flags |= IEEE80211_F_DATAPAD | IEEE80211_F_DOTH;
726
727 ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS;
728
729 ieee80211_radiotap_attach(ic,
730 &sc->txtap.ihdr, sizeof(sc->txtap),
731 RT2870_SOFTC_TX_RADIOTAP_PRESENT,
732 &sc->rxtap.ihdr, sizeof(sc->rxtap),
733 RT2870_SOFTC_RX_RADIOTAP_PRESENT);
734
735 /* init task queue */
736
737 TASK_INIT(&sc->rx_done_task, 0, rt2870_rx_done_task, sc);
738 TASK_INIT(&sc->tx_done_task, 0, rt2870_tx_done_task, sc);
739 TASK_INIT(&sc->periodic_task, 0, rt2870_periodic_task, sc);
740 TASK_INIT(&sc->cmd_task, 0, rt2870_cmd_task, sc);
741
742 sc->rx_process_limit = 100;
743
744 sc->taskqueue = taskqueue_create("rt2870_taskq", M_NOWAIT,
745 taskqueue_thread_enqueue, &sc->taskqueue);
746
747 taskqueue_start_threads(&sc->taskqueue, 1, PI_NET, "%s taskq",
748 device_get_nameunit(sc->dev));
749
750 rt2870_sysctl_attach(sc);
751
752 if (bootverbose)
753 ieee80211_announce(ic);
754
755 return 0;
756
757 fail:
758
759 /* stop all USB transfers */
760
761 usbd_transfer_unsetup(sc->usb_xfer, sc->usb_endpoints);
762
763 /* free Tx and Rx rings */
764
765 for (i = 0; i < sc->usb_endpoints - 1; i++)
766 rt2870_free_tx_ring(sc, &sc->tx_ring[i]);
767
768 rt2870_free_rx_ring(sc, &sc->rx_ring);
769
770 mtx_destroy(&sc->lock);
771
772 return error;
773 }
774
775 /*
776 * rt2870_detach
777 */
778 static int rt2870_detach(device_t dev)
779 {
780 struct rt2870_softc *sc;
781 struct ieee80211com *ic;
782 struct ifnet *ifp;
783 int i;
784
785 if (!device_is_attached(dev))
786 return 0;
787
788 sc = device_get_softc(dev);
789 ifp = sc->ifp;
790 ic = ifp->if_l2com;
791
792 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
793 "%s: detaching\n",
794 device_get_nameunit(sc->dev));
795
796 RT2870_SOFTC_LOCK(sc);
797
798 sc->tx_timer = 0;
799
800 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
801
802 callout_stop(&sc->periodic_ch);
803 callout_stop(&sc->tx_watchdog_ch);
804
805 RT2870_SOFTC_UNLOCK(sc);
806
807 taskqueue_block(sc->taskqueue);
808
809 taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
810 taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
811 taskqueue_drain(sc->taskqueue, &sc->periodic_task);
812 taskqueue_drain(sc->taskqueue, &sc->cmd_task);
813
814 /* stop all USB transfers */
815
816 usbd_transfer_unsetup(sc->usb_xfer, sc->usb_endpoints);
817
818 RT2870_SOFTC_LOCK(sc);
819
820 /* free Tx and Rx rings */
821
822 for (i = 0; i < sc->usb_endpoints - 1; i++)
823 rt2870_free_tx_ring(sc, &sc->tx_ring[i]);
824
825 rt2870_free_rx_ring(sc, &sc->rx_ring);
826
827 RT2870_SOFTC_UNLOCK(sc);
828
829 ieee80211_ifdetach(ic);
830
831 if_free(ifp);
832
833 taskqueue_free(sc->taskqueue);
834
835 mtx_destroy(&sc->lock);
836
837 return 0;
838 }
839
840 /*
841 * rt2870_init_channels
842 */
843 static void rt2870_init_channels(struct rt2870_softc *sc)
844 {
845 struct ifnet *ifp;
846 struct ieee80211com *ic;
847 struct ieee80211_channel *c;
848 int i, flags;
849
850 ifp = sc->ifp;
851 ic = ifp->if_l2com;
852
853 /* set supported channels for 2GHz band */
854
855 for (i = 1; i <= 14; i++)
856 {
857 c = &ic->ic_channels[ic->ic_nchans++];
858 flags = IEEE80211_CHAN_B;
859
860 c->ic_freq = ieee80211_ieee2mhz(i, flags);
861 c->ic_ieee = i;
862 c->ic_flags = flags;
863
864 c = &ic->ic_channels[ic->ic_nchans++];
865 flags = IEEE80211_CHAN_B | IEEE80211_CHAN_HT20;
866
867 c->ic_freq = ieee80211_ieee2mhz(i, flags);
868 c->ic_ieee = i;
869 c->ic_flags = flags;
870
871 c = &ic->ic_channels[ic->ic_nchans++];
872 flags = IEEE80211_CHAN_G;
873
874 c->ic_freq = ieee80211_ieee2mhz(i, flags);
875 c->ic_ieee = i;
876 c->ic_flags = flags;
877
878 c = &ic->ic_channels[ic->ic_nchans++];
879 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT20;
880
881 c->ic_freq = ieee80211_ieee2mhz(i, flags);
882 c->ic_ieee = i;
883 c->ic_flags = flags;
884 }
885
886 /* set supported channels for 5GHz band */
887
888 if (sc->rf_rev == RT2870_EEPROM_RF_2850 ||
889 sc->rf_rev == RT2870_EEPROM_RF_2750)
890 {
891 for (i = 36; i <= 64; i += 4)
892 {
893 c = &ic->ic_channels[ic->ic_nchans++];
894 flags = IEEE80211_CHAN_A;
895
896 c->ic_freq = ieee80211_ieee2mhz(i, flags);
897 c->ic_ieee = i;
898 c->ic_flags = flags;
899
900 c = &ic->ic_channels[ic->ic_nchans++];
901 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
902
903 c->ic_freq = ieee80211_ieee2mhz(i, flags);
904 c->ic_ieee = i;
905 c->ic_flags = flags;
906 }
907
908 for (i = 100; i <= 140; i += 4)
909 {
910 c = &ic->ic_channels[ic->ic_nchans++];
911 flags = IEEE80211_CHAN_A;
912
913 c->ic_freq = ieee80211_ieee2mhz(i, flags);
914 c->ic_ieee = i;
915 c->ic_flags = flags;
916
917 c = &ic->ic_channels[ic->ic_nchans++];
918 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
919
920 c->ic_freq = ieee80211_ieee2mhz(i, flags);
921 c->ic_ieee = i;
922 c->ic_flags = flags;
923 }
924
925 for (i = 149; i <= 165; i += 4)
926 {
927 c = &ic->ic_channels[ic->ic_nchans++];
928 flags = IEEE80211_CHAN_A;
929
930 c->ic_freq = ieee80211_ieee2mhz(i, flags);
931 c->ic_ieee = i;
932 c->ic_flags = flags;
933
934 c = &ic->ic_channels[ic->ic_nchans++];
935 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
936
937 c->ic_freq = ieee80211_ieee2mhz(i, flags);
938 c->ic_ieee = i;
939 c->ic_flags = flags;
940 }
941 }
942 }
943
944 /*
945 * rt2870_init_channels_ht40
946 */
947 static void rt2870_init_channels_ht40(struct rt2870_softc *sc)
948 {
949 struct ifnet *ifp;
950 struct ieee80211com *ic;
951 struct ieee80211_channel *c, *cent, *ext;
952 int i, flags;
953
954 ifp = sc->ifp;
955 ic = ifp->if_l2com;
956
957 /* set supported channels for 2GHz band */
958
959 for (i = 1; i <= 14; i++)
960 {
961 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40;
962
963 /* find the center channel */
964
965 cent = ieee80211_find_channel_byieee(ic, i,
966 flags & ~IEEE80211_CHAN_HT);
967 if (cent == NULL)
968 {
969 printf("%s: skip channel %d, could not find center channel\n",
970 device_get_nameunit(sc->dev), i);
971 continue;
972 }
973
974 /* find the extension channel */
975
976 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
977 flags & ~IEEE80211_CHAN_HT);
978 if (ext == NULL)
979 {
980 printf("%s: skip channel %d, could not find extension channel\n",
981 device_get_nameunit(sc->dev), i);
982 continue;
983 }
984
985 c = &ic->ic_channels[ic->ic_nchans++];
986
987 *c = *cent;
988 c->ic_extieee = ext->ic_ieee;
989 c->ic_flags &= ~IEEE80211_CHAN_HT;
990 c->ic_flags |= IEEE80211_CHAN_HT40U;
991
992 c = &ic->ic_channels[ic->ic_nchans++];
993
994 *c = *ext;
995 c->ic_extieee = cent->ic_ieee;
996 c->ic_flags &= ~IEEE80211_CHAN_HT;
997 c->ic_flags |= IEEE80211_CHAN_HT40D;
998 }
999
1000 /* set supported channels for 5GHz band */
1001
1002 if (sc->rf_rev == RT2870_EEPROM_RF_2850 ||
1003 sc->rf_rev == RT2870_EEPROM_RF_2750)
1004 {
1005 for (i = 36; i <= 64; i += 4)
1006 {
1007 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1008
1009 /* find the center channel */
1010
1011 cent = ieee80211_find_channel_byieee(ic, i,
1012 flags & ~IEEE80211_CHAN_HT);
1013 if (cent == NULL)
1014 {
1015 printf("%s: skip channel %d, could not find center channel\n",
1016 device_get_nameunit(sc->dev), i);
1017 continue;
1018 }
1019
1020 /* find the extension channel */
1021
1022 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1023 flags & ~IEEE80211_CHAN_HT);
1024 if (ext == NULL)
1025 {
1026 printf("%s: skip channel %d, could not find extension channel\n",
1027 device_get_nameunit(sc->dev), i);
1028 continue;
1029 }
1030
1031 c = &ic->ic_channels[ic->ic_nchans++];
1032
1033 *c = *cent;
1034 c->ic_extieee = ext->ic_ieee;
1035 c->ic_flags &= ~IEEE80211_CHAN_HT;
1036 c->ic_flags |= IEEE80211_CHAN_HT40U;
1037
1038 c = &ic->ic_channels[ic->ic_nchans++];
1039
1040 *c = *ext;
1041 c->ic_extieee = cent->ic_ieee;
1042 c->ic_flags &= ~IEEE80211_CHAN_HT;
1043 c->ic_flags |= IEEE80211_CHAN_HT40D;
1044 }
1045
1046 for (i = 100; i <= 140; i += 4)
1047 {
1048 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1049
1050 /* find the center channel */
1051
1052 cent = ieee80211_find_channel_byieee(ic, i,
1053 flags & ~IEEE80211_CHAN_HT);
1054 if (cent == NULL)
1055 {
1056 printf("%s: skip channel %d, could not find center channel\n",
1057 device_get_nameunit(sc->dev), i);
1058 continue;
1059 }
1060
1061 /* find the extension channel */
1062
1063 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1064 flags & ~IEEE80211_CHAN_HT);
1065 if (ext == NULL)
1066 {
1067 printf("%s: skip channel %d, could not find extension channel\n",
1068 device_get_nameunit(sc->dev), i);
1069 continue;
1070 }
1071
1072 c = &ic->ic_channels[ic->ic_nchans++];
1073
1074 *c = *cent;
1075 c->ic_extieee = ext->ic_ieee;
1076 c->ic_flags &= ~IEEE80211_CHAN_HT;
1077 c->ic_flags |= IEEE80211_CHAN_HT40U;
1078
1079 c = &ic->ic_channels[ic->ic_nchans++];
1080
1081 *c = *ext;
1082 c->ic_extieee = cent->ic_ieee;
1083 c->ic_flags &= ~IEEE80211_CHAN_HT;
1084 c->ic_flags |= IEEE80211_CHAN_HT40D;
1085 }
1086
1087 for (i = 149; i <= 165; i += 4)
1088 {
1089 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1090
1091 /* find the center channel */
1092
1093 cent = ieee80211_find_channel_byieee(ic, i,
1094 flags & ~IEEE80211_CHAN_HT);
1095 if (cent == NULL)
1096 {
1097 printf("%s: skip channel %d, could not find center channel\n",
1098 device_get_nameunit(sc->dev), i);
1099 continue;
1100 }
1101
1102 /* find the extension channel */
1103
1104 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1105 flags & ~IEEE80211_CHAN_HT);
1106 if (ext == NULL)
1107 {
1108 printf("%s: skip channel %d, could not find extension channel\n",
1109 device_get_nameunit(sc->dev), i);
1110 continue;
1111 }
1112
1113 c = &ic->ic_channels[ic->ic_nchans++];
1114
1115 *c = *cent;
1116 c->ic_extieee = ext->ic_ieee;
1117 c->ic_flags &= ~IEEE80211_CHAN_HT;
1118 c->ic_flags |= IEEE80211_CHAN_HT40U;
1119
1120 c = &ic->ic_channels[ic->ic_nchans++];
1121
1122 *c = *ext;
1123 c->ic_extieee = cent->ic_ieee;
1124 c->ic_flags &= ~IEEE80211_CHAN_HT;
1125 c->ic_flags |= IEEE80211_CHAN_HT40D;
1126 }
1127 }
1128 }
1129
1130 /*
1131 * rt2870_init_locked
1132 */
1133 static void rt2870_init_locked(void *priv)
1134 {
1135 struct rt2870_softc *sc;
1136 struct ifnet *ifp;
1137 struct ieee80211com *ic;
1138 int ntries, error, i;
1139 uint32_t tmp, stacnt[6];
1140
1141 sc = priv;
1142 ifp = sc->ifp;
1143 ic = ifp->if_l2com;
1144
1145 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1146 "%s: initializing\n",
1147 device_get_nameunit(sc->dev));
1148
1149 RT2870_SOFTC_ASSERT_LOCKED(sc);
1150
1151 if (!(sc->flags & RT2870_SOFTC_FLAGS_UCODE_LOADED))
1152 {
1153 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1154 "%s: loading 8051 microcode\n",
1155 device_get_nameunit(sc->dev));
1156
1157 error = rt2870_io_mcu_load_ucode(sc, rt2870_ucode, sizeof(rt2870_ucode));
1158 if (error != 0)
1159 {
1160 printf("%s: could not load 8051 microcode\n",
1161 device_get_nameunit(sc->dev));
1162 goto fail;
1163 }
1164
1165 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1166 "%s: 8051 microcode was successfully loaded\n",
1167 device_get_nameunit(sc->dev));
1168
1169 sc->flags |= RT2870_SOFTC_FLAGS_UCODE_LOADED;
1170 }
1171
1172 /* wait while DMA engine is busy */
1173
1174 for (ntries = 0; ntries < 100; ntries++)
1175 {
1176 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG);
1177 if (!(tmp & (RT2870_REG_TX_DMA_BUSY | RT2870_REG_RX_DMA_BUSY)))
1178 break;
1179
1180 DELAY(1000);
1181 }
1182
1183 if (ntries == 100)
1184 {
1185 printf("%s: timeout waiting for DMA engine\n",
1186 device_get_nameunit(sc->dev));
1187 goto fail;
1188 }
1189
1190 tmp &= 0xff0;
1191 tmp |= RT2870_REG_TX_WB_DDONE;
1192
1193 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
1194
1195 /* PBF hardware reset */
1196
1197 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_SYS_CTRL);
1198
1199 tmp &= ~(1 << 13);
1200
1201 rt2870_io_mac_write(sc, RT2870_REG_PBF_SYS_CTRL, tmp);
1202
1203 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
1204 RT2870_REG_MAC_SRST | RT2870_REG_BBP_HRST);
1205
1206 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, 0);
1207
1208 rt2870_io_mcu_reset(sc);
1209
1210 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, 0);
1211
1212 /* init Tx power per rate */
1213
1214 for (i = 0; i < RT2870_SOFTC_TXPOW_RATE_COUNT; i++)
1215 {
1216 if (sc->txpow_rate_20mhz[i] == 0xffffffff)
1217 continue;
1218
1219 rt2870_io_mac_write(sc, RT2870_REG_TX_PWR_CFG(i),
1220 sc->txpow_rate_20mhz[i]);
1221 }
1222
1223 for (i = 0; i < RT2870_DEF_MAC_SIZE; i++)
1224 rt2870_io_mac_write(sc, rt2870_def_mac[i].reg,
1225 rt2870_def_mac[i].val);
1226
1227 /* wait while MAC is busy */
1228
1229 for (ntries = 0; ntries < 100; ntries++)
1230 {
1231 if (!(rt2870_io_mac_read(sc, RT2870_REG_STATUS_CFG) &
1232 (RT2870_REG_STATUS_TX_BUSY | RT2870_REG_STATUS_RX_BUSY)))
1233 break;
1234
1235 DELAY(1000);
1236 }
1237
1238 if (ntries == 100)
1239 {
1240 printf("%s: timeout waiting for MAC\n",
1241 device_get_nameunit(sc->dev));
1242 goto fail;
1243 }
1244
1245 /* clear Host to MCU mailbox */
1246
1247 rt2870_io_mac_write(sc, RT2870_REG_H2M_MAILBOX_BBP_AGENT, 0);
1248 rt2870_io_mac_write(sc, RT2870_REG_H2M_MAILBOX, 0);
1249
1250 DELAY(1000);
1251
1252 error = rt2870_init_bbp(sc);
1253 if (error != 0)
1254 goto fail;
1255
1256 /* set up maximum buffer sizes */
1257
1258 tmp = (1 << 12) | RT2870_MAX_AGG_SIZE;
1259
1260 rt2870_io_mac_write(sc, RT2870_REG_MAX_LEN_CFG, tmp);
1261
1262 if (sc->mac_rev == 0x28720200)
1263 {
1264 /* set max. PSDU length from 16K to 32K bytes */
1265
1266 tmp = rt2870_io_mac_read(sc, RT2870_REG_MAX_LEN_CFG);
1267
1268 tmp &= ~(3 << 12);
1269 tmp |= (2 << 12);
1270
1271 rt2870_io_mac_write(sc, RT2870_REG_MAX_LEN_CFG, tmp);
1272 }
1273
1274 if (sc->mac_rev >= 0x28720200 && sc->mac_rev < 0x30700200)
1275 {
1276 tmp = rt2870_io_mac_read(sc, RT2870_REG_MAX_LEN_CFG);
1277
1278 tmp &= 0xfff;
1279 tmp |= 0x2000;
1280
1281 rt2870_io_mac_write(sc, RT2870_REG_MAX_LEN_CFG, tmp);
1282 }
1283
1284 /* set mac address */
1285
1286 rt2870_asic_set_macaddr(sc, IF_LLADDR(ifp));
1287
1288 /* clear statistic registers */
1289
1290 rt2870_io_mac_read_multi(sc, RT2870_REG_RX_STA_CNT0,
1291 stacnt, sizeof(stacnt));
1292
1293 /* send LEDs operating mode to microcontroller */
1294
1295 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_LED1,
1296 RT2870_REG_H2M_TOKEN_NO_INTR, sc->led_off[0]);
1297 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_LED2,
1298 RT2870_REG_H2M_TOKEN_NO_INTR, sc->led_off[1]);
1299 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_LED3,
1300 RT2870_REG_H2M_TOKEN_NO_INTR, sc->led_off[2]);
1301
1302 /* write vendor-specific BBP values (from EEPROM) */
1303
1304 for (i = 0; i < RT2870_SOFTC_BBP_EEPROM_COUNT; i++)
1305 {
1306 if (sc->bbp_eeprom[i].reg == 0x00 ||
1307 sc->bbp_eeprom[i].reg == 0xff)
1308 continue;
1309
1310 rt2870_io_bbp_write(sc, sc->bbp_eeprom[i].reg,
1311 sc->bbp_eeprom[i].val);
1312 }
1313
1314 /* disable non-existing Rx chains */
1315
1316 tmp = rt2870_io_bbp_read(sc, 3);
1317
1318 tmp &= ~((1 << 4) | (1 << 3));
1319
1320 if (sc->nrxpath == 3)
1321 tmp |= (1 << 4);
1322 else if (sc->nrxpath == 2)
1323 tmp |= (1 << 3);
1324
1325 rt2870_io_bbp_write(sc, 3, tmp);
1326
1327 /* disable non-existing Tx chains */
1328
1329 tmp = rt2870_io_bbp_read(sc, 1);
1330
1331 tmp &= ~((1 << 4) | (1 << 3));
1332
1333 if (sc->ntxpath == 2)
1334 tmp |= (1 << 4);
1335
1336 rt2870_io_bbp_write(sc, 1, tmp);
1337
1338 /* set current channel */
1339
1340 rt2870_rf_set_chan(sc, ic->ic_curchan);
1341
1342 /* turn radio LED on */
1343
1344 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_ON);
1345
1346 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_BOOT,
1347 RT2870_REG_H2M_TOKEN_NO_INTR, 0);
1348
1349 /* set RTS threshold */
1350
1351 rt2870_asic_update_rtsthreshold(sc);
1352
1353 /* set Tx power */
1354
1355 rt2870_asic_update_txpower(sc);
1356
1357 /* set up protection mode */
1358
1359 rt2870_asic_updateprot(sc);
1360
1361 /* clear key tables */
1362
1363 rt2870_asic_clear_keytables(sc);
1364
1365 /* clear beacon frame space (entries = 8, entry size = 512) */
1366
1367 rt2870_io_mac_set_region_4(sc, RT2870_REG_BEACON_BASE(0), 0, 1024);
1368
1369 if (rt2870_txrx_enable(sc) != 0)
1370 goto fail;
1371
1372 /* clear garbage interrupts */
1373
1374 tmp = rt2870_io_mac_read(sc, 0x1300);
1375
1376 taskqueue_unblock(sc->taskqueue);
1377
1378 /* init Tx and Rx rings */
1379
1380 for(i = 0; i < sc->usb_endpoints - 1; i++)
1381 rt2870_reset_tx_ring(sc, &sc->tx_ring[i]);
1382
1383 rt2870_reset_rx_ring(sc, &sc->rx_ring);
1384
1385 rt2870_reset_cmd_ring(sc, &sc->cmd_ring);
1386
1387 for(i = 0; i < sc->usb_endpoints - 1; i++)
1388 {
1389 usbd_xfer_set_priv(sc->usb_xfer[i + 1], &sc->tx_ring[i]);
1390 usbd_xfer_set_stall(sc->usb_xfer[i + 1]);
1391 }
1392
1393 /* start up the receive pipe */
1394
1395 for(i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
1396 usbd_transfer_start(sc->usb_xfer[0]);
1397
1398 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1399 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1400
1401 sc->periodic_round = 0;
1402
1403 callout_reset(&sc->periodic_ch, hz / 10, rt2870_periodic, sc);
1404
1405 return;
1406
1407 fail:
1408
1409 rt2870_stop_locked(sc);
1410 }
1411
1412 /*
1413 * rt2870_init
1414 */
1415 static void rt2870_init(void *priv)
1416 {
1417 struct rt2870_softc *sc;
1418
1419 sc = priv;
1420
1421 RT2870_SOFTC_LOCK(sc);
1422
1423 rt2870_init_locked(sc);
1424
1425 RT2870_SOFTC_UNLOCK(sc);
1426 }
1427
1428 /*
1429 * rt2870_init_bbp
1430 */
1431 static int rt2870_init_bbp(struct rt2870_softc *sc)
1432 {
1433 int ntries, i;
1434 uint8_t tmp;
1435
1436 for (ntries = 0; ntries < 20; ntries++)
1437 {
1438 tmp = rt2870_io_bbp_read(sc, 0);
1439 if (tmp != 0x00 && tmp != 0xff)
1440 break;
1441 }
1442
1443 if (tmp == 0x00 || tmp == 0xff)
1444 {
1445 printf("%s: timeout waiting for BBP to wakeup\n",
1446 device_get_nameunit(sc->dev));
1447 return ETIMEDOUT;
1448 }
1449
1450 for (i = 0; i < RT2870_DEF_BBP_SIZE; i++)
1451 rt2870_io_bbp_write(sc, rt2870_def_bbp[i].reg,
1452 rt2870_def_bbp[i].val);
1453
1454 if ((sc->mac_rev & 0xffff) != 0x0101)
1455 rt2870_io_bbp_write(sc, 84, 0x19);
1456
1457 if (sc->mac_rev == 0x28600100)
1458 {
1459 rt2870_io_bbp_write(sc, 69, 0x16);
1460 rt2870_io_bbp_write(sc, 73, 0x12);
1461 }
1462
1463 return 0;
1464 }
1465
1466 /*
1467 * rt2870_stop_locked
1468 */
1469 static void rt2870_stop_locked(void *priv)
1470 {
1471 struct rt2870_softc *sc;
1472 struct ifnet *ifp;
1473 struct ieee80211com *ic;
1474 uint32_t tmp;
1475 int i;
1476
1477 sc = priv;
1478 ifp = sc->ifp;
1479 ic = ifp->if_l2com;
1480
1481 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1482 "%s: stopping\n",
1483 device_get_nameunit(sc->dev));
1484
1485 RT2870_SOFTC_ASSERT_LOCKED(sc);
1486
1487 sc->tx_timer = 0;
1488
1489 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1490 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_OFF);
1491
1492 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1493
1494 callout_stop(&sc->periodic_ch);
1495 callout_stop(&sc->tx_watchdog_ch);
1496
1497 RT2870_SOFTC_UNLOCK(sc);
1498
1499 taskqueue_block(sc->taskqueue);
1500
1501 taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
1502 taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
1503 taskqueue_drain(sc->taskqueue, &sc->periodic_task);
1504 taskqueue_drain(sc->taskqueue, &sc->cmd_task);
1505
1506 RT2870_SOFTC_LOCK(sc);
1507
1508 /* clear key tables */
1509
1510 rt2870_asic_clear_keytables(sc);
1511
1512 /* disable Tx/Rx */
1513
1514 tmp = rt2870_io_mac_read(sc, RT2870_REG_SYS_CTRL);
1515
1516 tmp &= ~(RT2870_REG_RX_ENABLE | RT2870_REG_TX_ENABLE);
1517
1518 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, tmp);
1519
1520 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, 0);
1521
1522 /* reset adapter */
1523
1524 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
1525 RT2870_REG_MAC_SRST | RT2870_REG_BBP_HRST);
1526 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, 0);
1527
1528 /* abort any pending transfers */
1529
1530 for (i = 0; i < sc->usb_endpoints; i++)
1531 usbd_transfer_stop(sc->usb_xfer[i]);
1532 }
1533
1534 /*
1535 * rt2870_stop
1536 */
1537 static void rt2870_stop(void *priv)
1538 {
1539 struct rt2870_softc *sc;
1540
1541 sc = priv;
1542
1543 RT2870_SOFTC_LOCK(sc);
1544
1545 rt2870_stop_locked(sc);
1546
1547 RT2870_SOFTC_UNLOCK(sc);
1548 }
1549
1550 /*
1551 * rt2870_start
1552 */
1553 static void rt2870_start(struct ifnet *ifp)
1554 {
1555 struct rt2870_softc *sc;
1556 struct ieee80211_node *ni;
1557 struct mbuf *m;
1558 int qid;
1559
1560 sc = ifp->if_softc;
1561
1562 RT2870_SOFTC_LOCK(sc);
1563
1564 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1565 {
1566 RT2870_SOFTC_UNLOCK(sc);
1567 return;
1568 }
1569
1570 for (;;)
1571 {
1572 IF_POLL(&ifp->if_snd, m);
1573 if (m == NULL)
1574 break;
1575
1576 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1577
1578 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1579
1580 qid = M_WME_GETAC(m);
1581
1582 if (sc->tx_ring[qid].queued >= RT2870_SOFTC_TX_RING_DATA_COUNT)
1583 {
1584 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
1585 "%s: if_start: Tx ring with qid=%d is full\n",
1586 device_get_nameunit(sc->dev), qid);
1587
1588 m_freem(m);
1589 ieee80211_free_node(ni);
1590
1591 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1592 ifp->if_oerrors++;
1593
1594 sc->tx_data_queue_full[qid]++;
1595
1596 break;
1597 }
1598
1599 if (rt2870_tx_data(sc, m, ni, qid) != 0)
1600 {
1601 ieee80211_free_node(ni);
1602 ifp->if_oerrors++;
1603 break;
1604 }
1605
1606 sc->tx_timer = RT2870_TX_WATCHDOG_TIMEOUT;
1607
1608 callout_reset(&sc->tx_watchdog_ch, hz, rt2870_tx_watchdog, sc);
1609 }
1610
1611 RT2870_SOFTC_UNLOCK(sc);
1612 }
1613
1614 /*
1615 * rt2870_ioctl
1616 */
1617 static int rt2870_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1618 {
1619 struct rt2870_softc *sc;
1620 struct ieee80211com *ic;
1621 struct ifreq *ifr;
1622 int error, startall;
1623
1624 sc = ifp->if_softc;
1625 ic = ifp->if_l2com;
1626 ifr = (struct ifreq *) data;
1627
1628 error = 0;
1629
1630 switch (cmd)
1631 {
1632 case SIOCSIFFLAGS:
1633 startall = 0;
1634
1635 RT2870_SOFTC_LOCK(sc);
1636
1637 if (ifp->if_flags & IFF_UP)
1638 {
1639 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1640 {
1641 if ((ifp->if_flags ^ sc->if_flags) & IFF_PROMISC)
1642 rt2870_asic_update_promisc(sc);
1643 }
1644 else
1645 {
1646 rt2870_init_locked(sc);
1647 startall = 1;
1648 }
1649 }
1650 else
1651 {
1652 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1653 rt2870_stop_locked(sc);
1654 }
1655
1656 sc->if_flags = ifp->if_flags;
1657
1658 RT2870_SOFTC_UNLOCK(sc);
1659
1660 if (startall)
1661 ieee80211_start_all(ic);
1662 break;
1663
1664 case SIOCGIFMEDIA:
1665 case SIOCSIFMEDIA:
1666 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
1667 break;
1668
1669 case SIOCGIFADDR:
1670 error = ether_ioctl(ifp, cmd, data);
1671 break;
1672
1673 default:
1674 error = EINVAL;
1675 break;
1676 }
1677
1678 return error;
1679 }
1680
1681 /*
1682 * rt2870_vap_create
1683 */
1684 static struct ieee80211vap *rt2870_vap_create(struct ieee80211com *ic,
1685 const char name[IFNAMSIZ], int unit, int opmode, int flags,
1686 const uint8_t bssid[IEEE80211_ADDR_LEN],
1687 const uint8_t mac[IEEE80211_ADDR_LEN])
1688 {
1689 struct rt2870_softc *sc;
1690 struct ifnet *ifp;
1691 struct rt2870_softc_vap *rvap;
1692 struct ieee80211vap *vap;
1693
1694 ifp = ic->ic_ifp;
1695 sc = ifp->if_softc;
1696
1697 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1698 "%s: VAP create: opmode=%s\n",
1699 device_get_nameunit(sc->dev),
1700 ieee80211_opmode_name[opmode]);
1701
1702 switch (opmode)
1703 {
1704 case IEEE80211_M_MONITOR:
1705 case IEEE80211_M_IBSS:
1706 case IEEE80211_M_STA:
1707 case IEEE80211_M_AHDEMO:
1708 case IEEE80211_M_HOSTAP:
1709 case IEEE80211_M_MBSS:
1710 if (!TAILQ_EMPTY(&ic->ic_vaps))
1711 {
1712 if_printf(ifp, "only 1 VAP supported\n");
1713 return NULL;
1714 }
1715
1716 if (opmode == IEEE80211_M_STA)
1717 flags |= IEEE80211_CLONE_NOBEACONS;
1718 break;
1719
1720 case IEEE80211_M_WDS:
1721 if (TAILQ_EMPTY(&ic->ic_vaps) || ic->ic_opmode != IEEE80211_M_HOSTAP)
1722 {
1723 if_printf(ifp, "WDS only supported in AP mode\n");
1724 return NULL;
1725 }
1726
1727 flags &= ~IEEE80211_CLONE_BSSID;
1728 break;
1729
1730 default:
1731 if_printf(ifp, "unknown opmode %d\n", opmode);
1732 return NULL;
1733 }
1734
1735 rvap = (struct rt2870_softc_vap *) malloc(sizeof(struct rt2870_softc_vap),
1736 M_80211_VAP, M_NOWAIT | M_ZERO);
1737 if (rvap == NULL)
1738 return NULL;
1739
1740 vap = &rvap->vap;
1741
1742 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac);
1743
1744 rvap->newstate = vap->iv_newstate;
1745 vap->iv_newstate = rt2870_vap_newstate;
1746
1747 vap->iv_reset = rt2870_vap_reset;
1748 vap->iv_key_update_begin = rt2870_vap_key_update_begin;
1749 vap->iv_key_update_end = rt2870_vap_key_update_end;
1750 vap->iv_key_set = rt2870_vap_key_set;
1751 vap->iv_key_delete = rt2870_vap_key_delete;
1752 vap->iv_update_beacon = rt2870_vap_update_beacon;
1753
1754 rt2870_amrr_init(&rvap->amrr, vap,
1755 sc->ntxpath,
1756 RT2870_AMRR_MIN_SUCCESS_THRESHOLD,
1757 RT2870_AMRR_MAX_SUCCESS_THRESHOLD,
1758 500);
1759
1760 ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
1761
1762 /* override default Rx A-MPDU factor */
1763
1764 vap->iv_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_32K;
1765 vap->iv_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_NA;
1766 vap->iv_ampdu_limit = vap->iv_ampdu_rxmax;
1767
1768 ic->ic_opmode = opmode;
1769
1770 return vap;
1771 }
1772
1773 /*
1774 * rt2870_vap_delete
1775 */
1776 static void rt2870_vap_delete(struct ieee80211vap *vap)
1777 {
1778 struct rt2870_softc *sc;
1779 struct ieee80211com *ic;
1780 struct ifnet *ifp;
1781 struct rt2870_softc_vap *rvap;
1782
1783 ic = vap->iv_ic;
1784 ifp = ic->ic_ifp;
1785 sc = ifp->if_softc;
1786 rvap = (struct rt2870_softc_vap *) vap;
1787
1788 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1789 "%s: VAP delete: opmode=%s\n",
1790 device_get_nameunit(sc->dev),
1791 ieee80211_opmode_name[vap->iv_opmode]);
1792
1793 rt2870_amrr_cleanup(&rvap->amrr);
1794
1795 ieee80211_vap_detach(vap);
1796
1797 free(rvap, M_80211_VAP);
1798 }
1799
1800 /*
1801 * rt2870_reset_vap
1802 */
1803 static int rt2870_vap_reset(struct ieee80211vap *vap, u_long cmd)
1804 {
1805 struct rt2870_softc *sc;
1806 struct ieee80211com *ic;
1807 struct ifnet *ifp;
1808 struct rt2870_softc_vap *rvap;
1809 int error;
1810
1811 ic = vap->iv_ic;
1812 ifp = ic->ic_ifp;
1813 sc = ifp->if_softc;
1814 rvap = (struct rt2870_softc_vap *) vap;
1815
1816 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1817 "%s: VAP reset: cmd=%lu\n",
1818 device_get_nameunit(sc->dev), cmd);
1819
1820 error = 0;
1821
1822 RT2870_SOFTC_LOCK(sc);
1823
1824 switch (cmd)
1825 {
1826 case IEEE80211_IOC_RTSTHRESHOLD:
1827 case IEEE80211_IOC_AMSDU:
1828 rt2870_asic_update_rtsthreshold(sc);
1829 break;
1830
1831 case IEEE80211_IOC_PROTMODE:
1832 case IEEE80211_IOC_HTPROTMODE:
1833 rt2870_asic_updateprot(sc);
1834 break;
1835
1836 case IEEE80211_IOC_TXPOWER:
1837 rt2870_asic_update_txpower(sc);
1838 break;
1839
1840 case IEEE80211_IOC_BURST:
1841 rt2870_asic_updateslot(sc);
1842 break;
1843
1844 case IEEE80211_IOC_SHORTGI:
1845 case IEEE80211_IOC_AMPDU_DENSITY:
1846 break;
1847
1848 default:
1849 error = ENETRESET;
1850 break;
1851 }
1852
1853 RT2870_SOFTC_UNLOCK(sc);
1854
1855 return error;
1856 }
1857
1858 /*
1859 * rt2870_vap_newstate
1860 */
1861 static int rt2870_vap_newstate(struct ieee80211vap *vap,
1862 enum ieee80211_state nstate, int arg)
1863 {
1864 struct rt2870_softc *sc;
1865 struct ieee80211com *ic;
1866 struct ifnet *ifp;
1867 struct rt2870_softc_vap *rvap;
1868 struct ieee80211_node *ni;
1869 int error;
1870
1871 ic = vap->iv_ic;
1872 ifp = ic->ic_ifp;
1873 sc = ifp->if_softc;
1874 rvap = (struct rt2870_softc_vap *) vap;
1875
1876 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1877 "%s: VAP newstate: %s -> %s\n",
1878 device_get_nameunit(sc->dev),
1879 ieee80211_state_name[vap->iv_state], ieee80211_state_name[nstate]);
1880
1881 error = rvap->newstate(vap, nstate, arg);
1882 if (error != 0)
1883 return error;
1884
1885 IEEE80211_UNLOCK(ic);
1886
1887 RT2870_SOFTC_LOCK(sc);
1888
1889 /* turn link LED off */
1890
1891 if (nstate != IEEE80211_S_RUN)
1892 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_OFF);
1893
1894 switch (nstate)
1895 {
1896 case IEEE80211_S_INIT:
1897 rt2870_asic_disable_tsf_sync(sc);
1898 break;
1899
1900 case IEEE80211_S_RUN:
1901 ni = vap->iv_bss;
1902
1903 rt2870_rf_set_chan(sc, ni->ni_chan);
1904
1905 if (vap->iv_opmode != IEEE80211_M_MONITOR)
1906 {
1907 rt2870_asic_enable_mrr(sc);
1908 rt2870_asic_set_txpreamble(sc);
1909 rt2870_asic_set_basicrates(sc);
1910 rt2870_asic_update_txpower(sc);
1911 rt2870_asic_set_bssid(sc, ni->ni_bssid);
1912 }
1913
1914 if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
1915 vap->iv_opmode == IEEE80211_M_IBSS ||
1916 vap->iv_opmode == IEEE80211_M_MBSS)
1917 {
1918 error = rt2870_asic_update_beacon(sc, vap);
1919 if (error != 0)
1920 break;
1921 }
1922
1923 if (vap->iv_opmode != IEEE80211_M_MONITOR)
1924 rt2870_asic_enable_tsf_sync(sc);
1925
1926 /* turn link LED on */
1927
1928 if (vap->iv_opmode != IEEE80211_M_MONITOR)
1929 {
1930 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_ON |
1931 (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan) ?
1932 RT2870_LED_CMD_LINK_2GHZ : RT2870_LED_CMD_LINK_5GHZ));
1933 }
1934 break;
1935
1936 default:
1937 break;
1938 }
1939
1940 RT2870_SOFTC_UNLOCK(sc);
1941
1942 IEEE80211_LOCK(ic);
1943
1944 return error;
1945 }
1946
1947 /*
1948 * rt2870_vap_key_update_begin
1949 */
1950 static void rt2870_vap_key_update_begin(struct ieee80211vap *vap)
1951 {
1952 struct rt2870_softc *sc;
1953 struct ieee80211com *ic;
1954 struct ifnet *ifp;
1955
1956 ic = vap->iv_ic;
1957 ifp = ic->ic_ifp;
1958 sc = ifp->if_softc;
1959
1960 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
1961 "%s: VAP key update begin\n",
1962 device_get_nameunit(sc->dev));
1963
1964 taskqueue_block(sc->taskqueue);
1965
1966 IF_LOCK(&ifp->if_snd);
1967 }
1968
1969 /*
1970 * rt2870_vap_key_update_end
1971 */
1972 static void rt2870_vap_key_update_end(struct ieee80211vap *vap)
1973 {
1974 struct rt2870_softc *sc;
1975 struct ieee80211com *ic;
1976 struct ifnet *ifp;
1977
1978 ic = vap->iv_ic;
1979 ifp = ic->ic_ifp;
1980 sc = ifp->if_softc;
1981
1982 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
1983 "%s: VAP key update end\n",
1984 device_get_nameunit(sc->dev));
1985
1986 IF_UNLOCK(&ifp->if_snd);
1987
1988 taskqueue_unblock(sc->taskqueue);
1989 }
1990
1991 /*
1992 * rt2870_vap_key_set
1993 */
1994 static int rt2870_vap_key_set(struct ieee80211vap *vap,
1995 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN])
1996 {
1997 struct rt2870_softc *sc;
1998 struct ieee80211com *ic;
1999 struct ifnet *ifp;
2000 struct ieee80211_node *ni;
2001 struct rt2870_cmd_argv_keyset cmd_argv;
2002 uint16_t associd;
2003
2004 if (k->wk_cipher->ic_cipher != IEEE80211_CIPHER_WEP &&
2005 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_TKIP &&
2006 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_AES_CCM)
2007 return EINVAL;
2008
2009 ic = vap->iv_ic;
2010 ifp = ic->ic_ifp;
2011 sc = ifp->if_softc;
2012
2013 if (vap->iv_opmode != IEEE80211_M_HOSTAP)
2014 ni = vap->iv_bss;
2015 else
2016 ni = ieee80211_find_vap_node(&ic->ic_sta, vap, mac);
2017
2018 associd = (ni != NULL) ? ni->ni_associd : 0;
2019
2020 if ((vap->iv_opmode == IEEE80211_M_HOSTAP) && (ni != NULL))
2021 ieee80211_free_node(ni);
2022
2023 memcpy(&cmd_argv.key, k, sizeof(struct ieee80211_key));
2024 cmd_argv.associd = associd;
2025
2026 rt2870_do_async(sc, rt2870_vap_key_set_cb,
2027 &cmd_argv, sizeof(struct rt2870_cmd_argv_keyset));
2028
2029 return 1;
2030 }
2031
2032 /*
2033 * rt2870_vap_key_delete
2034 */
2035 static int rt2870_vap_key_delete(struct ieee80211vap *vap,
2036 const struct ieee80211_key *k)
2037 {
2038 struct rt2870_softc *sc;
2039 struct ieee80211com *ic;
2040 struct ifnet *ifp;
2041 struct ieee80211_node *ni;
2042 struct rt2870_cmd_argv_keydelete cmd_argv;
2043 uint16_t associd;
2044
2045 ic = vap->iv_ic;
2046 ifp = ic->ic_ifp;
2047 sc = ifp->if_softc;
2048 ni = vap->iv_bss;
2049 associd = (ni != NULL) ? ni->ni_associd : 0;
2050
2051 memcpy(&cmd_argv.key, k, sizeof(struct ieee80211_key));
2052 cmd_argv.associd = associd;
2053
2054 rt2870_do_async(sc, rt2870_vap_key_delete_cb,
2055 &cmd_argv, sizeof(struct rt2870_cmd_argv_keydelete));
2056
2057 return 1;
2058 }
2059
2060 /*
2061 * rt2870_vap_update_beacon
2062 */
2063 static void rt2870_vap_update_beacon(struct ieee80211vap *vap, int what)
2064 {
2065 struct rt2870_softc *sc;
2066 struct ieee80211com *ic;
2067 struct ifnet *ifp;
2068
2069 ic = vap->iv_ic;
2070 ifp = ic->ic_ifp;
2071 sc = ifp->if_softc;
2072
2073 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
2074 "%s: VAP update beacon\n",
2075 device_get_nameunit(sc->dev));
2076
2077 rt2870_do_async(sc, rt2870_vap_update_beacon_cb, NULL, 0);
2078 }
2079
2080 /*
2081 * rt2870_node_alloc
2082 */
2083 static struct ieee80211_node *rt2870_node_alloc(struct ieee80211vap *vap,
2084 const uint8_t mac[IEEE80211_ADDR_LEN])
2085 {
2086 return malloc(sizeof(struct rt2870_softc_node),
2087 M_80211_NODE, M_NOWAIT | M_ZERO);
2088 }
2089
2090 /*
2091 * rt2870_setregdomain
2092 */
2093 static int rt2870_setregdomain(struct ieee80211com *ic,
2094 struct ieee80211_regdomain *reg,
2095 int nchans, struct ieee80211_channel chans[])
2096 {
2097 struct rt2870_softc *sc;
2098 struct ifnet *ifp;
2099
2100 ifp = ic->ic_ifp;
2101 sc = ifp->if_softc;
2102
2103 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
2104 "%s: set regulatory domain: country=%d, country code string=%c%c, location=%c\n",
2105 device_get_nameunit(sc->dev),
2106 reg->country, reg->isocc[0], reg->isocc[1], reg->location);
2107
2108 return 0;
2109 }
2110
2111 /*
2112 * rt2870_getradiocaps
2113 */
2114 static void rt2870_getradiocaps(struct ieee80211com *ic,
2115 int maxchans, int *nchans, struct ieee80211_channel chans[])
2116 {
2117 *nchans = (ic->ic_nchans >= maxchans) ? maxchans : ic->ic_nchans;
2118
2119 memcpy(chans, ic->ic_channels, (*nchans) * sizeof(struct ieee80211_channel));
2120 }
2121
2122 /*
2123 * rt2870_scan_start
2124 */
2125 static void rt2870_scan_start(struct ieee80211com *ic)
2126 {
2127 struct rt2870_softc *sc;
2128 struct ifnet *ifp;
2129
2130 ifp = ic->ic_ifp;
2131 sc = ifp->if_softc;
2132
2133 RT2870_SOFTC_LOCK(sc);
2134
2135 rt2870_asic_disable_tsf_sync(sc);
2136
2137 RT2870_SOFTC_UNLOCK(sc);
2138 }
2139
2140 /*
2141 * rt2870_scan_end
2142 */
2143 static void rt2870_scan_end(struct ieee80211com *ic)
2144 {
2145 struct rt2870_softc *sc;
2146 struct ifnet *ifp;
2147
2148 ifp = ic->ic_ifp;
2149 sc = ifp->if_softc;
2150
2151 RT2870_SOFTC_LOCK(sc);
2152
2153 rt2870_asic_enable_tsf_sync(sc);
2154
2155 RT2870_SOFTC_UNLOCK(sc);
2156 }
2157
2158 /*
2159 * rt2870_set_channel
2160 */
2161 static void rt2870_set_channel(struct ieee80211com *ic)
2162 {
2163 struct rt2870_softc *sc;
2164 struct ifnet *ifp;
2165
2166 ifp = ic->ic_ifp;
2167 sc = ifp->if_softc;
2168
2169 RT2870_DPRINTF(sc, RT2870_DEBUG_CHAN,
2170 "%s: set channel: channel=%u, HT%s%s\n",
2171 device_get_nameunit(sc->dev),
2172 ieee80211_chan2ieee(ic, ic->ic_curchan),
2173 !IEEE80211_IS_CHAN_HT(ic->ic_curchan) ? " disabled" :
2174 IEEE80211_IS_CHAN_HT20(ic->ic_curchan) ? "20":
2175 IEEE80211_IS_CHAN_HT40U(ic->ic_curchan) ? "40U" : "40D",
2176 (ic->ic_flags & IEEE80211_F_SCAN) ? ", scanning" : "");
2177
2178 RT2870_SOFTC_LOCK(sc);
2179
2180 rt2870_rf_set_chan(sc, ic->ic_curchan);
2181
2182 RT2870_SOFTC_UNLOCK(sc);
2183 }
2184
2185 /*
2186 * rt2870_newassoc
2187 */
2188 static void rt2870_newassoc(struct ieee80211_node *ni, int isnew)
2189 {
2190 struct rt2870_softc *sc;
2191 struct ieee80211com *ic;
2192 struct ifnet *ifp;
2193 struct ieee80211vap *vap;
2194 struct rt2870_softc_vap *rvap;
2195 uint16_t associd;
2196 uint8_t wcid;
2197
2198 vap = ni->ni_vap;
2199 ic = vap->iv_ic;
2200 ifp = ic->ic_ifp;
2201 sc = ifp->if_softc;
2202 rvap = (struct rt2870_softc_vap *) vap;
2203
2204 associd = (ni != NULL) ? ni->ni_associd : 0;
2205 wcid = RT2870_AID2WCID(associd);
2206
2207 RT2870_DPRINTF(sc, RT2870_DEBUG_NODE,
2208 "%s: new association: wcid=0x%02x, "
2209 "mac addr=%s, QoS %s, ERP %s, HT %s\n",
2210 device_get_nameunit(sc->dev), wcid,
2211 ether_sprintf(ni->ni_macaddr),
2212 (ni->ni_flags & IEEE80211_NODE_QOS) ? "enabled" : "disabled",
2213 (ni->ni_flags & IEEE80211_NODE_ERP) ? "enabled" : "disabled",
2214 (ni->ni_flags & IEEE80211_NODE_HT) ? "enabled" : "disabled");
2215
2216 RT2870_SOFTC_LOCK(sc);
2217
2218 rt2870_io_mac_write_multi(sc, RT2870_REG_WCID(wcid),
2219 ni->ni_macaddr, IEEE80211_ADDR_LEN);
2220
2221 rt2870_amrr_node_init(&rvap->amrr, &sc->amrr_node[wcid], ni);
2222
2223 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2224 "%s: initial%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2225 device_get_nameunit(sc->dev),
2226 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2227 ni->ni_associd, ni->ni_txrate,
2228 (ni->ni_flags & IEEE80211_NODE_HT) ?
2229 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2230 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2231
2232 rt2870_asic_updateprot(sc);
2233 rt2870_asic_updateslot(sc);
2234 rt2870_asic_set_txpreamble(sc);
2235
2236 RT2870_SOFTC_UNLOCK(sc);
2237 }
2238
2239 /*
2240 * rt2870_updateslot
2241 */
2242 static void rt2870_updateslot(struct ifnet *ifp)
2243 {
2244 struct rt2870_softc *sc;
2245
2246 sc = ifp->if_softc;
2247
2248 rt2870_do_async(sc, rt2870_updateslot_cb, NULL, 0);
2249 }
2250
2251 /*
2252 * rt2870_update_promisc
2253 */
2254 static void rt2870_update_promisc(struct ifnet *ifp)
2255 {
2256 struct rt2870_softc *sc;
2257
2258 sc = ifp->if_softc;
2259
2260 RT2870_SOFTC_LOCK(sc);
2261
2262 rt2870_asic_update_promisc(sc);
2263
2264 RT2870_SOFTC_UNLOCK(sc);
2265 }
2266
2267 /*
2268 * rt2870_update_mcast
2269 */
2270 static void rt2870_update_mcast(struct ifnet *ifp)
2271 {
2272 struct rt2870_softc *sc;
2273
2274 sc = ifp->if_softc;
2275 }
2276
2277 /*
2278 * rt2870_wme_update
2279 */
2280 static int rt2870_wme_update(struct ieee80211com *ic)
2281 {
2282 struct rt2870_softc *sc;
2283 struct ifnet *ifp;
2284
2285 ifp = ic->ic_ifp;
2286 sc = ifp->if_softc;
2287
2288 rt2870_do_async(sc, rt2870_wme_update_cb, NULL, 0);
2289
2290 return 0;
2291 }
2292
2293 /*
2294 * rt2870_raw_xmit
2295 */
2296 static int rt2870_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
2297 const struct ieee80211_bpf_params *params)
2298 {
2299 struct rt2870_softc *sc;
2300 struct ieee80211com *ic;
2301 struct ifnet *ifp;
2302
2303 ic = ni->ni_ic;
2304 ifp = ic->ic_ifp;
2305 sc = ifp->if_softc;
2306
2307 RT2870_SOFTC_LOCK(sc);
2308
2309 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2310 {
2311 RT2870_SOFTC_UNLOCK(sc);
2312
2313 m_freem(m);
2314 ieee80211_free_node(ni);
2315
2316 return ENETDOWN;
2317 }
2318
2319 if (sc->tx_ring[sc->tx_ring_mgtqid].queued >= RT2870_SOFTC_TX_RING_DATA_COUNT)
2320 {
2321 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
2322 "%s: raw xmit: Tx ring with qid=%d is full\n",
2323 device_get_nameunit(sc->dev), sc->tx_ring_mgtqid);
2324
2325 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
2326
2327 RT2870_SOFTC_UNLOCK(sc);
2328
2329 m_freem(m);
2330 ieee80211_free_node(ni);
2331
2332 sc->tx_data_queue_full[sc->tx_ring_mgtqid]++;
2333
2334 return ENOBUFS;
2335 }
2336
2337 if (rt2870_tx_mgmt(sc, m, ni, sc->tx_ring_mgtqid) != 0)
2338 {
2339 ifp->if_oerrors++;
2340
2341 RT2870_SOFTC_UNLOCK(sc);
2342
2343 ieee80211_free_node(ni);
2344
2345 return EIO;
2346 }
2347
2348 sc->tx_timer = RT2870_TX_WATCHDOG_TIMEOUT;
2349
2350 RT2870_SOFTC_UNLOCK(sc);
2351
2352 return 0;
2353 }
2354
2355 /*
2356 * rt2870_recv_action
2357 */
2358 static int rt2870_recv_action(struct ieee80211_node *ni,
2359 const struct ieee80211_frame *wh,
2360 const uint8_t *frm, const uint8_t *efrm)
2361 {
2362 struct rt2870_softc *sc;
2363 struct ieee80211com *ic;
2364 struct ifnet *ifp;
2365 const struct ieee80211_action *ia;
2366 struct ieee80211_tx_ampdu *tx_ampdu;
2367 uint16_t associd, status, baparamset;
2368 uint8_t wcid;
2369 int ret, tid, bufsize, ac;
2370 uint32_t tmp;
2371
2372 ic = ni->ni_ic;
2373 ifp = ic->ic_ifp;
2374 sc = ifp->if_softc;
2375
2376 ia = (const struct ieee80211_action *) frm;
2377
2378 ret = sc->recv_action(ni, wh, frm, efrm);
2379
2380 if (ia->ia_category != IEEE80211_ACTION_CAT_BA)
2381 return ret;
2382
2383 associd = (ni != NULL) ? ni->ni_associd : 0;
2384 wcid = RT2870_AID2WCID(associd);
2385
2386 switch (ia->ia_action)
2387 {
2388 /* IEEE80211_ACTION_BA_ADDBA_REQUEST */
2389 case IEEE80211_ACTION_BA_ADDBA_REQUEST:
2390 baparamset = LE_READ_2(frm + 3);
2391 tid = RT2870_MS(baparamset, IEEE80211_BAPS_TID);
2392 bufsize = RT2870_MS(baparamset, IEEE80211_BAPS_BUFSIZ);
2393
2394 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2395 "%s: received ADDBA request: associd=0x%04x, tid=%d, bufsize=%d\n",
2396 device_get_nameunit(sc->dev), associd, tid, bufsize);
2397
2398 RT2870_SOFTC_LOCK(sc);
2399
2400 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID(wcid) + 4);
2401
2402 tmp |= (0x10000 << tid);
2403
2404 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, tmp);
2405
2406 RT2870_SOFTC_UNLOCK(sc);
2407 break;
2408
2409 /* IEEE80211_ACTION_BA_ADDBA_RESPONSE */
2410 case IEEE80211_ACTION_BA_ADDBA_RESPONSE:
2411 status = LE_READ_2(frm + 3);
2412 baparamset = LE_READ_2(frm + 4);
2413 tid = RT2870_MS(baparamset, IEEE80211_BAPS_TID);
2414 bufsize = RT2870_MS(baparamset, IEEE80211_BAPS_BUFSIZ);
2415 ac = TID_TO_WME_AC(tid);
2416 tx_ampdu = &ni->ni_tx_ampdu[ac];
2417
2418 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2419 "%s: received ADDBA response: associd=0x%04x, status=%d, tid=%d, bufsize=%d\n",
2420 device_get_nameunit(sc->dev), associd, status, tid, bufsize);
2421
2422 if (sc->mac_rev >= 0x28720200)
2423 {
2424 if (tx_ampdu->txa_wnd > 13)
2425 tx_ampdu->txa_wnd = 13;
2426 }
2427 else
2428 {
2429 if (tx_ampdu->txa_wnd > 7)
2430 tx_ampdu->txa_wnd = 7;
2431 }
2432
2433 if (status == IEEE80211_STATUS_SUCCESS)
2434 {
2435 sc->tx_ampdu_sessions++;
2436
2437 RT2870_SOFTC_LOCK(sc);
2438
2439 rt2870_asic_updateprot(sc);
2440
2441 RT2870_SOFTC_UNLOCK(sc);
2442 }
2443 break;
2444
2445 /* IEEE80211_ACTION_BA_DELBA */
2446 case IEEE80211_ACTION_BA_DELBA:
2447 baparamset = LE_READ_2(frm + 2);
2448 tid = RT2870_MS(baparamset, IEEE80211_BAPS_TID);
2449
2450 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2451 "%s: received DELBA request: associd=0x%04x, tid=%d\n",
2452 device_get_nameunit(sc->dev), associd, tid);
2453
2454 RT2870_SOFTC_LOCK(sc);
2455
2456 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID(wcid) + 4);
2457
2458 tmp &= ~(0x10000 << tid);
2459
2460 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, tmp);
2461
2462 RT2870_SOFTC_UNLOCK(sc);
2463 break;
2464 }
2465
2466 return ret;
2467 }
2468
2469 /*
2470 * rt2870_send_action
2471 */
2472 static int rt2870_send_action(struct ieee80211_node *ni,
2473 int cat, int act, void *sa)
2474 {
2475 struct rt2870_softc *sc;
2476 struct ieee80211com *ic;
2477 struct ifnet *ifp;
2478 uint16_t associd, *args, baparamset;
2479 uint8_t wcid;
2480 int ret, tid;
2481 uint32_t tmp;
2482
2483 ic = ni->ni_ic;
2484 ifp = ic->ic_ifp;
2485 sc = ifp->if_softc;
2486
2487 ret = sc->send_action(ni, cat, act, sa);
2488
2489 if (cat != IEEE80211_ACTION_CAT_BA)
2490 return ret;
2491
2492 associd = (ni != NULL) ? ni->ni_associd : 0;
2493 wcid = RT2870_AID2WCID(associd);
2494 args = sa;
2495
2496 switch (act)
2497 {
2498 /* IEEE80211_ACTION_BA_DELBA */
2499 case IEEE80211_ACTION_BA_DELBA:
2500 baparamset = RT2870_SM(args[0], IEEE80211_DELBAPS_TID) | args[1];
2501
2502 tid = RT2870_MS(baparamset, IEEE80211_DELBAPS_TID);
2503
2504 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2505 "%s: sending DELBA request: associd=0x%04x, tid=%d\n",
2506 device_get_nameunit(sc->dev), associd, tid);
2507
2508 RT2870_SOFTC_LOCK(sc);
2509
2510 if (RT2870_MS(baparamset, IEEE80211_DELBAPS_INIT) != IEEE80211_DELBAPS_INIT)
2511 {
2512 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID(wcid) + 4);
2513
2514 tmp &= ~(0x10000 << tid);
2515
2516 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, tmp);
2517 }
2518 else
2519 {
2520 sc->tx_ampdu_sessions--;
2521
2522 rt2870_asic_updateprot(sc);
2523 }
2524
2525 RT2870_SOFTC_UNLOCK(sc);
2526 break;
2527 }
2528
2529 return ret;
2530 }
2531
2532 /*
2533 * rt2870_amrr_update_iter_func
2534 */
2535 static void rt2870_amrr_update_iter_func(void *arg, struct ieee80211_node *ni)
2536 {
2537 struct rt2870_softc *sc;
2538 struct ieee80211com *ic;
2539 struct ifnet *ifp;
2540 struct ieee80211vap *vap;
2541 struct rt2870_softc_vap *rvap;
2542 uint8_t wcid;
2543
2544 vap = arg;
2545 ic = vap->iv_ic;
2546 ifp = ic->ic_ifp;
2547 sc = ifp->if_softc;
2548 rvap = (struct rt2870_softc_vap *) vap;
2549
2550 /* only associated stations */
2551
2552 if ((ni->ni_vap == vap) && (ni->ni_associd != 0))
2553 {
2554 wcid = RT2870_AID2WCID(ni->ni_associd);
2555
2556 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2557 "%s: AMRR node: wcid=0x%02x, txcnt=%d, success=%d, retrycnt=%d\n",
2558 device_get_nameunit(sc->dev),
2559 wcid, sc->amrr_node[wcid].txcnt, sc->amrr_node[wcid].success, sc->amrr_node[wcid].retrycnt);
2560
2561 rt2870_amrr_choose(ni, &sc->amrr_node[wcid]);
2562
2563 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2564 "%s:%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2565 device_get_nameunit(sc->dev),
2566 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2567 ni->ni_associd, ni->ni_txrate,
2568 (ni->ni_flags & IEEE80211_NODE_HT) ?
2569 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2570 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2571 }
2572 }
2573
2574 /*
2575 * rt2870_periodic
2576 */
2577 static void rt2870_periodic(void *arg)
2578 {
2579 struct rt2870_softc *sc;
2580 struct ifnet *ifp;
2581
2582 sc = arg;
2583 ifp = sc->ifp;
2584
2585 RT2870_DPRINTF(sc, RT2870_DEBUG_PERIODIC,
2586 "%s: periodic\n",
2587 device_get_nameunit(sc->dev));
2588
2589 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2590 return;
2591
2592 taskqueue_enqueue(sc->taskqueue, &sc->periodic_task);
2593 }
2594
2595 /*
2596 * rt2870_tx_watchdog
2597 */
2598 static void rt2870_tx_watchdog(void *arg)
2599 {
2600 struct rt2870_softc *sc;
2601 struct ifnet *ifp;
2602
2603 sc = arg;
2604 ifp = sc->ifp;
2605
2606 if (sc->tx_timer == 0)
2607 return;
2608
2609 if (--sc->tx_timer == 0)
2610 {
2611 printf("%s: Tx watchdog timeout: resetting\n",
2612 device_get_nameunit(sc->dev));
2613
2614 rt2870_stop_locked(sc);
2615 rt2870_init_locked(sc);
2616
2617 ifp->if_oerrors++;
2618
2619 sc->tx_watchdog_timeouts++;
2620 }
2621
2622 callout_reset(&sc->tx_watchdog_ch, hz, rt2870_tx_watchdog, sc);
2623 }
2624
2625 /*
2626 * rt2870_do_async
2627 */
2628 static int rt2870_do_async(struct rt2870_softc *sc,
2629 void (*cb)(struct rt2870_softc *sc, void *arg),
2630 void *arg, int len)
2631 {
2632 struct ifnet *ifp;
2633 struct rt2870_softc_cmd_ring *ring;
2634 struct rt2870_softc_cmd *cmd;
2635 int run_cmd_task;
2636
2637 ifp = sc->ifp;
2638 ring = &sc->cmd_ring;
2639
2640 RT2870_SOFTC_LOCK(sc);
2641
2642 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2643 {
2644 RT2870_SOFTC_UNLOCK(sc);
2645 return -1;
2646 }
2647
2648 if (ring->queued >= RT2870_SOFTC_CMD_RING_CMD_COUNT)
2649 {
2650 RT2870_SOFTC_UNLOCK(sc);
2651 return -1;
2652 }
2653
2654 cmd = STAILQ_FIRST(&ring->inactive);
2655 STAILQ_REMOVE_HEAD(&ring->inactive, next);
2656
2657 cmd->cb = cb;
2658
2659 if(arg != NULL)
2660 memcpy(cmd->data, arg, len);
2661
2662 STAILQ_INSERT_TAIL(&ring->active, cmd, next);
2663 ring->queued++;
2664
2665 run_cmd_task = (ring->queued == 1);
2666
2667 RT2870_SOFTC_UNLOCK(sc);
2668
2669 if (run_cmd_task)
2670 taskqueue_enqueue(sc->taskqueue, &sc->cmd_task);
2671
2672 return 0;
2673 }
2674
2675 /*
2676 * rt2870_updateslot_cb
2677 */
2678 static void rt2870_updateslot_cb(struct rt2870_softc *sc, void *arg)
2679 {
2680 RT2870_SOFTC_LOCK(sc);
2681
2682 rt2870_asic_updateslot(sc);
2683
2684 RT2870_SOFTC_UNLOCK(sc);
2685 }
2686
2687 /*
2688 * rt2870_wme_update_cb
2689 */
2690 static void rt2870_wme_update_cb(struct rt2870_softc *sc, void *arg)
2691 {
2692 RT2870_SOFTC_LOCK(sc);
2693
2694 rt2870_asic_wme_update(sc);
2695
2696 RT2870_SOFTC_UNLOCK(sc);
2697 }
2698
2699 /*
2700 * rt2870_vap_key_set_cb
2701 */
2702 static void rt2870_vap_key_set_cb(struct rt2870_softc *sc, void *arg)
2703 {
2704 struct ieee80211com *ic;
2705 struct ifnet *ifp;
2706 struct ieee80211vap *vap;
2707 struct ieee80211_key *k;
2708 struct rt2870_cmd_argv_keyset *cmd_argv;
2709 uint16_t associd, key_base, keymode_base;
2710 uint8_t mode, vapid, wcid, iv[8];
2711 uint32_t tmp;
2712
2713 ifp = sc->ifp;
2714 ic = ifp->if_l2com;
2715 vap = TAILQ_FIRST(&ic->ic_vaps);
2716 cmd_argv = arg;
2717 k = &cmd_argv->key;
2718 associd = cmd_argv->associd;
2719
2720 switch (k->wk_cipher->ic_cipher)
2721 {
2722 case IEEE80211_CIPHER_WEP:
2723 if(k->wk_keylen < 8)
2724 mode = RT2870_REG_CIPHER_MODE_WEP40;
2725 else
2726 mode = RT2870_REG_CIPHER_MODE_WEP104;
2727 break;
2728
2729 case IEEE80211_CIPHER_TKIP:
2730 mode = RT2870_REG_CIPHER_MODE_TKIP;
2731 break;
2732
2733 case IEEE80211_CIPHER_AES_CCM:
2734 mode = RT2870_REG_CIPHER_MODE_AES_CCMP;
2735 break;
2736
2737 default:
2738 return;
2739 }
2740
2741 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
2742 "%s: VAP key set: keyix=%d, keylen=%d, associd=0x%04x, mode=%d, group=%d\n",
2743 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, associd, mode,
2744 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
2745
2746 RT2870_SOFTC_LOCK(sc);
2747
2748 if (!(k->wk_flags & IEEE80211_KEY_GROUP))
2749 {
2750 /* install pairwise key */
2751
2752 vapid = 0;
2753 wcid = RT2870_AID2WCID(associd);
2754 key_base = RT2870_REG_PKEY(wcid);
2755
2756 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)
2757 {
2758 memset(iv, 0, 8);
2759
2760 iv[3] = (k->wk_keyix << 6);
2761 }
2762 else
2763 {
2764 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2765 {
2766 iv[0] = (k->wk_keytsc >> 8);
2767 iv[1] = ((iv[0] | 0x20) & 0x7f);
2768 iv[2] = k->wk_keytsc;
2769 }
2770 else
2771 {
2772 /* AES CCMP */
2773
2774 iv[0] = k->wk_keytsc;
2775 iv[1] = k->wk_keytsc >> 8;
2776 iv[2] = 0;
2777 }
2778
2779 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV);
2780 iv[4] = (k->wk_keytsc >> 16);
2781 iv[5] = (k->wk_keytsc >> 24);
2782 iv[6] = (k->wk_keytsc >> 32);
2783 iv[7] = (k->wk_keytsc >> 40);
2784
2785 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
2786 "%s: set key: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
2787 device_get_nameunit(sc->dev),
2788 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
2789 }
2790
2791 rt2870_io_mac_write_multi(sc, RT2870_REG_IVEIV(wcid), iv, 8);
2792
2793 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2794 {
2795 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, 16);
2796
2797 if (vap->iv_opmode != IEEE80211_M_HOSTAP)
2798 {
2799 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
2800 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
2801 }
2802 else
2803 {
2804 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
2805 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
2806 }
2807 }
2808 else
2809 {
2810 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
2811 }
2812
2813 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
2814 (mode << RT2870_REG_CIPHER_MODE_SHIFT) | RT2870_REG_PKEY_ENABLE;
2815
2816 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
2817 }
2818
2819 if ((k->wk_flags & IEEE80211_KEY_GROUP) ||
2820 (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP))
2821 {
2822 /* install group key */
2823
2824 vapid = 0;
2825 key_base = RT2870_REG_SKEY(vapid, k->wk_keyix);
2826 keymode_base = RT2870_REG_SKEY_MODE(vapid);
2827
2828 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2829 {
2830 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, 16);
2831
2832 if (vap->iv_opmode != IEEE80211_M_HOSTAP)
2833 {
2834 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
2835 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
2836 }
2837 else
2838 {
2839 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
2840 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
2841 }
2842 }
2843 else
2844 {
2845 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
2846 }
2847
2848 tmp = rt2870_io_mac_read(sc, keymode_base);
2849
2850 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2851 tmp |= (mode << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2852
2853 rt2870_io_mac_write(sc, keymode_base, tmp);
2854 }
2855
2856 RT2870_SOFTC_UNLOCK(sc);
2857 }
2858
2859 /*
2860 * rt2870_vap_key_delete_cb
2861 */
2862 static void rt2870_vap_key_delete_cb(struct rt2870_softc *sc, void *arg)
2863 {
2864 struct ieee80211_key *k;
2865 struct rt2870_cmd_argv_keydelete *cmd_argv;
2866 uint16_t associd;
2867 uint8_t vapid, wcid;
2868 uint32_t tmp;
2869
2870 cmd_argv = arg;
2871 k = &cmd_argv->key;
2872 associd = cmd_argv->associd;
2873
2874 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
2875 "%s: VAP key delete: keyix=%d, keylen=%d, associd=0x%04x, group=%d\n",
2876 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, associd,
2877 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
2878
2879 RT2870_SOFTC_LOCK(sc);
2880
2881 if (!(k->wk_flags & IEEE80211_KEY_GROUP))
2882 {
2883 /* remove pairwise key */
2884
2885 vapid = 0;
2886 wcid = RT2870_AID2WCID(associd);
2887
2888 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
2889 (RT2870_REG_CIPHER_MODE_NONE << RT2870_REG_CIPHER_MODE_SHIFT) | RT2870_REG_PKEY_ENABLE;
2890
2891 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
2892 }
2893 else
2894 {
2895 /* remove group key */
2896
2897 vapid = 0;
2898
2899 tmp = rt2870_io_mac_read(sc, RT2870_REG_SKEY_MODE(vapid));
2900
2901 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2902 tmp |= (RT2870_REG_CIPHER_MODE_NONE << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2903
2904 rt2870_io_mac_write(sc, RT2870_REG_SKEY_MODE(vapid), tmp);
2905 }
2906
2907 RT2870_SOFTC_UNLOCK(sc);
2908 }
2909
2910 /*
2911 * rt2870_vap_update_beacon_cb
2912 */
2913 static void rt2870_vap_update_beacon_cb(struct rt2870_softc *sc, void *arg)
2914 {
2915 struct ifnet *ifp;
2916 struct ieee80211com *ic;
2917 struct ieee80211vap *vap;
2918
2919 ifp = sc->ifp;
2920 ic = ifp->if_l2com;
2921 vap = TAILQ_FIRST(&ic->ic_vaps);
2922
2923 if (vap == NULL)
2924 return;
2925
2926 RT2870_SOFTC_LOCK(sc);
2927
2928 rt2870_asic_update_beacon(sc, vap);
2929
2930 RT2870_SOFTC_UNLOCK(sc);
2931 }
2932
2933 /*
2934 * rt2870_asic_set_bssid
2935 */
2936 static void rt2870_asic_set_bssid(struct rt2870_softc *sc,
2937 const uint8_t *bssid)
2938 {
2939 uint32_t tmp;
2940
2941 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
2942 "%s: set bssid: bssid=%s\n",
2943 device_get_nameunit(sc->dev),
2944 ether_sprintf(bssid));
2945
2946 tmp = bssid[0] | (bssid[1]) << 8 | (bssid[2] << 16) | (bssid[3] << 24);
2947
2948 rt2870_io_mac_write(sc, RT2870_REG_BSSID_DW0, tmp);
2949
2950 tmp = bssid[4] | (bssid[5] << 8);
2951
2952 rt2870_io_mac_write(sc, RT2870_REG_BSSID_DW1, tmp);
2953 }
2954
2955 /*
2956 * rt2870_asic_set_macaddr
2957 */
2958 static void rt2870_asic_set_macaddr(struct rt2870_softc *sc,
2959 const uint8_t *addr)
2960 {
2961 uint32_t tmp;
2962
2963 tmp = addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24);
2964
2965 rt2870_io_mac_write(sc, RT2870_REG_ADDR_DW0, tmp);
2966
2967 tmp = addr[4] | (addr[5] << 8);
2968
2969 rt2870_io_mac_write(sc, RT2870_REG_ADDR_DW1, tmp);
2970 }
2971
2972 /*
2973 * rt2870_asic_enable_tsf_sync
2974 */
2975 static void rt2870_asic_enable_tsf_sync(struct rt2870_softc *sc)
2976 {
2977 struct ifnet *ifp;
2978 struct ieee80211com *ic;
2979 struct ieee80211vap *vap;
2980 uint32_t tmp;
2981
2982 ifp = sc->ifp;
2983 ic = ifp->if_l2com;
2984 vap = TAILQ_FIRST(&ic->ic_vaps);
2985
2986 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
2987 "%s: enabling TSF\n",
2988 device_get_nameunit(sc->dev));
2989
2990 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
2991
2992 tmp &= ~0x1fffff;
2993 tmp |= vap->iv_bss->ni_intval * 16;
2994 tmp |= (RT2870_REG_TSF_TIMER_ENABLE | RT2870_REG_TBTT_TIMER_ENABLE);
2995
2996 if (vap->iv_opmode == IEEE80211_M_STA)
2997 {
2998 tmp |= (RT2870_REG_TSF_SYNC_MODE_STA << RT2870_REG_TSF_SYNC_MODE_SHIFT);
2999 }
3000 else if (vap->iv_opmode == IEEE80211_M_IBSS)
3001 {
3002 tmp |= RT2870_REG_BCN_TX_ENABLE;
3003 tmp |= (RT2870_REG_TSF_SYNC_MODE_IBSS << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3004 }
3005 else if (vap->iv_opmode == IEEE80211_M_HOSTAP)
3006 {
3007 tmp |= RT2870_REG_BCN_TX_ENABLE;
3008 tmp |= (RT2870_REG_TSF_SYNC_MODE_HOSTAP << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3009 }
3010
3011 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3012 }
3013
3014 /*
3015 * rt2870_asic_disable_tsf_sync
3016 */
3017 static void rt2870_asic_disable_tsf_sync(struct rt2870_softc *sc)
3018 {
3019 uint32_t tmp;
3020
3021 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
3022 "%s: disabling TSF\n",
3023 device_get_nameunit(sc->dev));
3024
3025 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3026
3027 tmp &= ~(RT2870_REG_BCN_TX_ENABLE |
3028 RT2870_REG_TSF_TIMER_ENABLE |
3029 RT2870_REG_TBTT_TIMER_ENABLE);
3030
3031 tmp &= ~(RT2870_REG_TSF_SYNC_MODE_MASK << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3032 tmp |= (RT2870_REG_TSF_SYNC_MODE_DISABLE << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3033
3034 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3035 }
3036
3037 /*
3038 * rt2870_asic_enable_mrr
3039 */
3040 static void rt2870_asic_enable_mrr(struct rt2870_softc *sc)
3041 {
3042 #define CCK(mcs) (mcs)
3043 #define OFDM(mcs) ((1 << 3) | (mcs))
3044 #define HT(mcs) (mcs)
3045
3046 rt2870_io_mac_write(sc, RT2870_REG_TX_LG_FBK_CFG0,
3047 (OFDM(6) << 28) | /* 54 -> 48 */
3048 (OFDM(5) << 24) | /* 48 -> 36 */
3049 (OFDM(4) << 20) | /* 36 -> 24 */
3050 (OFDM(3) << 16) | /* 24 -> 18 */
3051 (OFDM(2) << 12) | /* 18 -> 12 */
3052 (OFDM(1) << 8) | /* 12 -> 9 */
3053 (OFDM(0) << 4) | /* 9 -> 6 */
3054 OFDM(0)); /* 6 -> 6 */
3055
3056 rt2870_io_mac_write(sc, RT2870_REG_TX_LG_FBK_CFG1,
3057 (CCK(2) << 12) | /* 11 -> 5.5 */
3058 (CCK(1) << 8) | /* 5.5 -> 2 */
3059 (CCK(0) << 4) | /* 2 -> 1 */
3060 CCK(0)); /* 1 -> 1 */
3061
3062 rt2870_io_mac_write(sc, RT2870_REG_TX_HT_FBK_CFG0,
3063 (HT(6) << 28) |
3064 (HT(5) << 24) |
3065 (HT(4) << 20) |
3066 (HT(3) << 16) |
3067 (HT(2) << 12) |
3068 (HT(1) << 8) |
3069 (HT(0) << 4) |
3070 HT(0));
3071
3072 rt2870_io_mac_write(sc, RT2870_REG_TX_HT_FBK_CFG1,
3073 (HT(14) << 28) |
3074 (HT(13) << 24) |
3075 (HT(12) << 20) |
3076 (HT(11) << 16) |
3077 (HT(10) << 12) |
3078 (HT(9) << 8) |
3079 (HT(8) << 4) |
3080 HT(7));
3081
3082 #undef HT
3083 #undef OFDM
3084 #undef CCK
3085 }
3086
3087 /*
3088 * rt2870_asic_set_txpreamble
3089 */
3090 static void rt2870_asic_set_txpreamble(struct rt2870_softc *sc)
3091 {
3092 struct ifnet *ifp;
3093 struct ieee80211com *ic;
3094 uint32_t tmp;
3095
3096 ifp = sc->ifp;
3097 ic = ifp->if_l2com;
3098
3099 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3100 "%s: %s short Tx preamble\n",
3101 device_get_nameunit(sc->dev),
3102 (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "enabling" : "disabling");
3103
3104 tmp = rt2870_io_mac_read(sc, RT2870_REG_AUTO_RSP_CFG);
3105
3106 tmp &= ~RT2870_REG_CCK_SHORT_ENABLE;
3107
3108 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
3109 tmp |= RT2870_REG_CCK_SHORT_ENABLE;
3110
3111 rt2870_io_mac_write(sc, RT2870_REG_AUTO_RSP_CFG, tmp);
3112 }
3113
3114 /*
3115 * rt2870_asic_set_basicrates
3116 */
3117 static void rt2870_asic_set_basicrates(struct rt2870_softc *sc)
3118 {
3119 struct ifnet *ifp;
3120 struct ieee80211com *ic;
3121
3122 ifp = sc->ifp;
3123 ic = ifp->if_l2com;
3124
3125 if (ic->ic_curmode == IEEE80211_MODE_11B)
3126 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x3);
3127 else if (ic->ic_curmode == IEEE80211_MODE_11A)
3128 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x150);
3129 else
3130 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x15f);
3131 }
3132
3133 /*
3134 * rt2870_asic_update_rtsthreshold
3135 */
3136 static void rt2870_asic_update_rtsthreshold(struct rt2870_softc *sc)
3137 {
3138 struct ifnet *ifp;
3139 struct ieee80211com *ic;
3140 struct ieee80211vap *vap;
3141 uint32_t tmp;
3142 uint16_t threshold;
3143
3144 ifp = sc->ifp;
3145 ic = ifp->if_l2com;
3146 vap = TAILQ_FIRST(&ic->ic_vaps);
3147
3148 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3149 "%s: updating RTS threshold: %d\n",
3150 device_get_nameunit(sc->dev), vap->iv_rtsthreshold);
3151
3152 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_RTS_CFG);
3153
3154 tmp &= ~(RT2870_REG_TX_RTS_THRESHOLD_MASK << RT2870_REG_TX_RTS_THRESHOLD_SHIFT);
3155
3156 if (vap->iv_flags_ht & IEEE80211_FHT_AMSDU_TX)
3157 threshold = 0x1000;
3158 else
3159 threshold = vap->iv_rtsthreshold;
3160
3161 tmp |= ((threshold & RT2870_REG_TX_RTS_THRESHOLD_MASK) <<
3162 RT2870_REG_TX_RTS_THRESHOLD_SHIFT);
3163
3164 rt2870_io_mac_write(sc, RT2870_REG_TX_RTS_CFG, tmp);
3165 }
3166
3167 /*
3168 * rt2870_asic_update_txpower
3169 */
3170 static void rt2870_asic_update_txpower(struct rt2870_softc *sc)
3171 {
3172 struct ifnet *ifp;
3173 struct ieee80211com *ic;
3174 uint32_t *txpow_rate;
3175 int8_t delta;
3176 uint8_t val;
3177 uint32_t tmp;
3178 int i;
3179
3180 ifp = sc->ifp;
3181 ic = ifp->if_l2com;
3182
3183 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3184 "%s: updating Tx power: %d\n",
3185 device_get_nameunit(sc->dev), ic->ic_txpowlimit);
3186
3187 if (!IEEE80211_IS_CHAN_HT40(ic->ic_curchan))
3188 {
3189 txpow_rate = sc->txpow_rate_20mhz;
3190 }
3191 else
3192 {
3193 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
3194 txpow_rate = sc->txpow_rate_40mhz_2ghz;
3195 else
3196 txpow_rate = sc->txpow_rate_40mhz_5ghz;
3197 }
3198
3199 delta = 0;
3200
3201 val = rt2870_io_bbp_read(sc, 1);
3202 val &= 0xfc;
3203
3204 if (ic->ic_txpowlimit > 90)
3205 {
3206 /* do nothing */
3207 }
3208 else if (ic->ic_txpowlimit > 60)
3209 {
3210 delta -= 1;
3211 }
3212 else if (ic->ic_txpowlimit > 30)
3213 {
3214 delta -= 3;
3215 }
3216 else if (ic->ic_txpowlimit > 15)
3217 {
3218 val |= 0x1;
3219 }
3220 else if (ic->ic_txpowlimit > 9)
3221 {
3222 val |= 0x1;
3223 delta -= 3;
3224 }
3225 else
3226 {
3227 val |= 0x2;
3228 }
3229
3230 rt2870_io_bbp_write(sc, 1, val);
3231
3232 for (i = 0; i < RT2870_SOFTC_TXPOW_RATE_COUNT; i++)
3233 {
3234 if (txpow_rate[i] == 0xffffffff)
3235 continue;
3236
3237 tmp = rt2870_read_eeprom_txpow_rate_add_delta(txpow_rate[i], delta);
3238
3239 rt2870_io_mac_write(sc, RT2870_REG_TX_PWR_CFG(i), tmp);
3240 }
3241 }
3242
3243 /*
3244 * rt2870_asic_update_promisc
3245 */
3246 static void rt2870_asic_update_promisc(struct rt2870_softc *sc)
3247 {
3248 struct ifnet *ifp;
3249 uint32_t tmp;
3250
3251 ifp = sc->ifp;
3252
3253 printf("%s: %s promiscuous mode\n",
3254 device_get_nameunit(sc->dev),
3255 (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
3256
3257 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_FILTER_CFG);
3258
3259 tmp &= ~RT2870_REG_RX_FILTER_DROP_UC_NOME;
3260
3261 if (!(ifp->if_flags & IFF_PROMISC))
3262 tmp |= RT2870_REG_RX_FILTER_DROP_UC_NOME;
3263
3264 rt2870_io_mac_write(sc, RT2870_REG_RX_FILTER_CFG, tmp);
3265 }
3266
3267 /*
3268 * rt2870_asic_updateprot
3269 */
3270 static void rt2870_asic_updateprot(struct rt2870_softc *sc)
3271 {
3272 struct ifnet *ifp;
3273 struct ieee80211com *ic;
3274 struct ieee80211vap *vap;
3275 uint32_t cck_prot, ofdm_prot, mm20_prot, mm40_prot, gf20_prot, gf40_prot;
3276 uint8_t htopmode;
3277 enum ieee80211_protmode htprotmode;
3278
3279 ifp = sc->ifp;
3280 ic = ifp->if_l2com;
3281 vap = TAILQ_FIRST(&ic->ic_vaps);
3282
3283 /* CCK frame protection */
3284
3285 cck_prot = RT2870_REG_RTSTH_ENABLE | RT2870_REG_PROT_NAV_SHORT |
3286 RT2870_REG_TXOP_ALLOW_ALL | RT2870_REG_PROT_CTRL_NONE;
3287
3288 /* set up protection frame phy mode and rate (MCS code) */
3289
3290 if (ic->ic_curmode == IEEE80211_MODE_11A)
3291 cck_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3292 (0 << RT2870_REG_PROT_MCS_SHIFT);
3293 else
3294 cck_prot |= ((RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3295 (3 << RT2870_REG_PROT_MCS_SHIFT));
3296
3297 rt2870_io_mac_write(sc, RT2870_REG_TX_CCK_PROT_CFG, cck_prot);
3298
3299 /* OFDM frame protection */
3300
3301 ofdm_prot = RT2870_REG_RTSTH_ENABLE | RT2870_REG_PROT_NAV_SHORT |
3302 RT2870_REG_TXOP_ALLOW_ALL;
3303
3304 if (ic->ic_flags & IEEE80211_F_USEPROT)
3305 {
3306 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3307 "%s: updating protection mode: b/g protection mode=%s\n",
3308 device_get_nameunit(sc->dev),
3309 (ic->ic_protmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3310 ((ic->ic_protmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3311
3312 if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
3313 ofdm_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3314 else if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
3315 ofdm_prot |= RT2870_REG_PROT_CTRL_CTS;
3316 else
3317 ofdm_prot |= RT2870_REG_PROT_CTRL_NONE;
3318 }
3319 else
3320 {
3321 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3322 "%s: updating protection mode: b/g protection mode=%s\n",
3323 device_get_nameunit(sc->dev), "none");
3324
3325 ofdm_prot |= RT2870_REG_PROT_CTRL_NONE;
3326 }
3327
3328 rt2870_io_mac_write(sc, RT2870_REG_TX_OFDM_PROT_CFG, ofdm_prot);
3329
3330 /* HT frame protection */
3331
3332 if ((vap->iv_opmode == IEEE80211_M_STA) && (vap->iv_state == IEEE80211_S_RUN))
3333 htopmode = vap->iv_bss->ni_htopmode;
3334 else
3335 htopmode = ic->ic_curhtprotmode;
3336
3337 htprotmode = ic->ic_htprotmode;
3338
3339 /* force HT mixed mode and RTS/CTS protection if A-MPDU Tx aggregation is enabled */
3340
3341 if (sc->tx_ampdu_sessions > 0)
3342 {
3343 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3344 "%s: updating protection mode: forcing HT mixed mode and RTS/CTS protection\n",
3345 device_get_nameunit(sc->dev));
3346
3347 htopmode = IEEE80211_HTINFO_OPMODE_MIXED;
3348 htprotmode = IEEE80211_PROT_RTSCTS;
3349 }
3350
3351 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3352 "%s: updating protection mode: HT operation mode=0x%02x, protection mode=%s\n",
3353 device_get_nameunit(sc->dev),
3354 htopmode & IEEE80211_HTINFO_OPMODE,
3355 (htprotmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3356 ((htprotmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3357
3358 switch (htopmode & IEEE80211_HTINFO_OPMODE)
3359 {
3360 /* IEEE80211_HTINFO_OPMODE_HT20PR */
3361 case IEEE80211_HTINFO_OPMODE_HT20PR:
3362 mm20_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3363 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3364 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20 |
3365 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3366 (4 << RT2870_REG_PROT_MCS_SHIFT);
3367
3368 gf20_prot = mm20_prot;
3369
3370 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3371 RT2870_REG_TXOP_ALLOW_ALL |
3372 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3373 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3374
3375 if (htprotmode == IEEE80211_PROT_RTSCTS)
3376 mm40_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3377 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3378 mm40_prot |= RT2870_REG_PROT_CTRL_CTS;
3379 else
3380 mm40_prot |= RT2870_REG_PROT_CTRL_NONE;
3381
3382 gf40_prot = mm40_prot;
3383 break;
3384
3385 /* IEEE80211_HTINFO_OPMODE_MIXED */
3386 case IEEE80211_HTINFO_OPMODE_MIXED:
3387 mm20_prot = RT2870_REG_PROT_NAV_SHORT |
3388 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3389 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20;
3390
3391 if (ic->ic_flags & IEEE80211_F_USEPROT)
3392 mm20_prot |= (RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3393 (3 << RT2870_REG_PROT_MCS_SHIFT);
3394 else
3395 mm20_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3396 (4 << RT2870_REG_PROT_MCS_SHIFT);
3397
3398 if (htprotmode == IEEE80211_PROT_RTSCTS)
3399 mm20_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3400 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3401 mm20_prot |= RT2870_REG_PROT_CTRL_CTS;
3402 else
3403 mm20_prot |= RT2870_REG_PROT_CTRL_NONE;
3404
3405 gf20_prot = mm20_prot;
3406
3407 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_TXOP_ALLOW_ALL;
3408
3409 if (ic->ic_flags & IEEE80211_F_USEPROT)
3410 mm40_prot |= (RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3411 (3 << RT2870_REG_PROT_MCS_SHIFT);
3412 else
3413 mm40_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3414 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3415
3416 if (htprotmode == IEEE80211_PROT_RTSCTS)
3417 mm40_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3418 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3419 mm40_prot |= RT2870_REG_PROT_CTRL_CTS;
3420 else
3421 mm40_prot |= RT2870_REG_PROT_CTRL_NONE;
3422
3423 gf40_prot = mm40_prot;
3424 break;
3425
3426 /*
3427 * IEEE80211_HTINFO_OPMODE_PURE
3428 * IEEE80211_HTINFO_OPMODE_PROTOPT
3429 */
3430 case IEEE80211_HTINFO_OPMODE_PURE:
3431 case IEEE80211_HTINFO_OPMODE_PROTOPT:
3432 default:
3433 mm20_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3434 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3435 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20 |
3436 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3437 (4 << RT2870_REG_PROT_MCS_SHIFT);
3438
3439 gf20_prot = mm20_prot;
3440
3441 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3442 RT2870_REG_TXOP_ALLOW_ALL |
3443 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3444 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3445
3446 gf40_prot = mm40_prot;
3447 break;
3448 }
3449
3450 rt2870_io_mac_write(sc, RT2870_REG_TX_MM20_PROT_CFG, mm20_prot);
3451 rt2870_io_mac_write(sc, RT2870_REG_TX_MM40_PROT_CFG, mm40_prot);
3452 rt2870_io_mac_write(sc, RT2870_REG_TX_GF20_PROT_CFG, gf20_prot);
3453 rt2870_io_mac_write(sc, RT2870_REG_TX_GF40_PROT_CFG, gf40_prot);
3454 }
3455
3456 /*
3457 * rt2870_asic_updateslot
3458 */
3459 static void rt2870_asic_updateslot(struct rt2870_softc *sc)
3460 {
3461 struct ifnet *ifp;
3462 struct ieee80211com *ic;
3463 struct ieee80211vap *vap;
3464 uint32_t tmp;
3465
3466 ifp = sc->ifp;
3467 ic = ifp->if_l2com;
3468 vap = TAILQ_FIRST(&ic->ic_vaps);
3469
3470 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3471 "%s: %s short slot time\n",
3472 device_get_nameunit(sc->dev),
3473 ((ic->ic_flags & IEEE80211_F_SHSLOT) ||
3474 ((vap != NULL) && (vap->iv_flags & IEEE80211_F_BURST))) ? "enabling" : "disabling");
3475
3476 tmp = rt2870_io_mac_read(sc, RT2870_REG_BKOFF_SLOT_CFG);
3477
3478 tmp &= ~0xff;
3479
3480 if ((ic->ic_flags & IEEE80211_F_SHSLOT) ||
3481 ((vap != NULL) && (vap->iv_flags & IEEE80211_F_BURST)))
3482 tmp |= IEEE80211_DUR_SHSLOT;
3483 else
3484 tmp |= IEEE80211_DUR_SLOT;
3485
3486 rt2870_io_mac_write(sc, RT2870_REG_BKOFF_SLOT_CFG, tmp);
3487 }
3488
3489 /*
3490 * rt2870_asic_wme_update
3491 */
3492 static void rt2870_asic_wme_update(struct rt2870_softc *sc)
3493 {
3494 struct ifnet *ifp;
3495 struct ieee80211com *ic;
3496 struct ieee80211_wme_state *wme;
3497 const struct wmeParams *wmep;
3498 int i;
3499
3500 ifp = sc->ifp;
3501 ic = ifp->if_l2com;
3502 wme = &ic->ic_wme;
3503 wmep = wme->wme_chanParams.cap_wmeParams;
3504
3505 RT2870_DPRINTF(sc, RT2870_DEBUG_WME,
3506 "%s: wme update: WME_AC_VO=%d/%d/%d/%d, WME_AC_VI=%d/%d/%d/%d, "
3507 "WME_AC_BK=%d/%d/%d/%d, WME_AC_BE=%d/%d/%d/%d\n",
3508 device_get_nameunit(sc->dev),
3509 wmep[WME_AC_VO].wmep_aifsn,
3510 wmep[WME_AC_VO].wmep_logcwmin, wmep[WME_AC_VO].wmep_logcwmax,
3511 wmep[WME_AC_VO].wmep_txopLimit,
3512 wmep[WME_AC_VI].wmep_aifsn,
3513 wmep[WME_AC_VI].wmep_logcwmin, wmep[WME_AC_VI].wmep_logcwmax,
3514 wmep[WME_AC_VI].wmep_txopLimit,
3515 wmep[WME_AC_BK].wmep_aifsn,
3516 wmep[WME_AC_BK].wmep_logcwmin, wmep[WME_AC_BK].wmep_logcwmax,
3517 wmep[WME_AC_BK].wmep_txopLimit,
3518 wmep[WME_AC_BE].wmep_aifsn,
3519 wmep[WME_AC_BE].wmep_logcwmin, wmep[WME_AC_BE].wmep_logcwmax,
3520 wmep[WME_AC_BE].wmep_txopLimit);
3521
3522 for (i = 0; i < WME_NUM_AC; i++)
3523 rt2870_io_mac_write(sc, RT2870_REG_TX_EDCA_AC_CFG(i),
3524 (wmep[i].wmep_logcwmax << 16) | (wmep[i].wmep_logcwmin << 12) |
3525 (wmep[i].wmep_aifsn << 8) | wmep[i].wmep_txopLimit);
3526
3527 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_AIFSN_CFG,
3528 (wmep[WME_AC_VO].wmep_aifsn << 12) | (wmep[WME_AC_VI].wmep_aifsn << 8) |
3529 (wmep[WME_AC_BK].wmep_aifsn << 4) | wmep[WME_AC_BE].wmep_aifsn);
3530
3531 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_CWMIN_CFG,
3532 (wmep[WME_AC_VO].wmep_logcwmin << 12) | (wmep[WME_AC_VI].wmep_logcwmin << 8) |
3533 (wmep[WME_AC_BK].wmep_logcwmin << 4) | wmep[WME_AC_BE].wmep_logcwmin);
3534
3535 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_CWMAX_CFG,
3536 (wmep[WME_AC_VO].wmep_logcwmax << 12) | (wmep[WME_AC_VI].wmep_logcwmax << 8) |
3537 (wmep[WME_AC_BK].wmep_logcwmax << 4) | wmep[WME_AC_BE].wmep_logcwmax);
3538
3539 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP0_CFG,
3540 (wmep[WME_AC_BK].wmep_txopLimit << 16) | wmep[WME_AC_BE].wmep_txopLimit);
3541
3542 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP1_CFG,
3543 (wmep[WME_AC_VO].wmep_txopLimit << 16) | wmep[WME_AC_VI].wmep_txopLimit);
3544 }
3545
3546 /*
3547 * rt2870_asic_update_beacon
3548 */
3549 static int rt2870_asic_update_beacon(struct rt2870_softc *sc,
3550 struct ieee80211vap *vap)
3551 {
3552 struct ifnet *ifp;
3553 struct ieee80211com *ic;
3554 struct rt2870_softc_vap *rvap;
3555 const struct ieee80211_txparam *tp;
3556 struct mbuf *m;
3557 struct rt2870_txwi txwi;
3558 uint8_t rate, mcs;
3559 uint32_t tmp;
3560
3561 ifp = sc->ifp;
3562 ic = ifp->if_l2com;
3563 rvap = (struct rt2870_softc_vap *) vap;
3564 tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
3565
3566 m = ieee80211_beacon_alloc(vap->iv_bss, &rvap->beacon_offsets);
3567 if (m == NULL)
3568 return ENOMEM;
3569
3570 rate = tp->mgmtrate;
3571 mcs = rt2870_rate2mcs(rate);
3572
3573 memset(&txwi, 0, sizeof(struct rt2870_txwi));
3574
3575 txwi.wcid = 0xff;
3576 txwi.pid_mpdu_len = ((htole16(m->m_pkthdr.len) & RT2870_TXWI_MPDU_LEN_MASK) <<
3577 RT2870_TXWI_MPDU_LEN_SHIFT);
3578 txwi.txop = (RT2870_TXWI_TXOP_HT << RT2870_TXWI_TXOP_SHIFT);
3579 txwi.mpdu_density_flags |=
3580 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
3581 txwi.bawin_size_xflags |=
3582 (RT2870_TXWI_XFLAGS_NSEQ << RT2870_TXWI_XFLAGS_SHIFT);
3583
3584 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
3585 {
3586 txwi.phymode_ifs_stbc_shortgi =
3587 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
3588
3589 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
3590 mcs |= RT2870_TXWI_MCS_SHOTPRE;
3591 }
3592 else
3593 {
3594 txwi.phymode_ifs_stbc_shortgi =
3595 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
3596 }
3597
3598 txwi.bw_mcs = (RT2870_TXWI_BW_20 << RT2870_TXWI_BW_SHIFT) |
3599 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
3600
3601 /* disable temporarily TSF sync */
3602
3603 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3604
3605 tmp &= ~(RT2870_REG_BCN_TX_ENABLE |
3606 RT2870_REG_TSF_TIMER_ENABLE |
3607 RT2870_REG_TBTT_TIMER_ENABLE);
3608
3609 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3610
3611 /* write Tx wireless info and beacon frame to on-chip memory */
3612
3613 rt2870_io_mac_write_multi(sc, RT2870_REG_BEACON_BASE(0),
3614 &txwi, sizeof(struct rt2870_txwi));
3615
3616 rt2870_io_mac_write_multi(sc, RT2870_REG_BEACON_BASE(0) + sizeof(struct rt2870_txwi),
3617 mtod(m, uint8_t *), m->m_pkthdr.len);
3618
3619 /* enable again TSF sync */
3620
3621 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3622
3623 tmp |= (RT2870_REG_BCN_TX_ENABLE |
3624 RT2870_REG_TSF_TIMER_ENABLE |
3625 RT2870_REG_TBTT_TIMER_ENABLE);
3626
3627 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3628
3629 m_freem(m);
3630
3631 return 0;
3632 }
3633
3634 /*
3635 * rt2870_asic_clear_keytables
3636 */
3637 static void rt2870_asic_clear_keytables(struct rt2870_softc *sc)
3638 {
3639 int i;
3640
3641 /* clear Rx WCID search table (entries = 256, entry size = 8) */
3642
3643 for (i = 0; i < 256; i++)
3644 {
3645 rt2870_io_mac_write(sc, RT2870_REG_WCID(i), 0xffffffff);
3646 rt2870_io_mac_write(sc, RT2870_REG_WCID(i) + 4, 0x0000ffff);
3647 }
3648
3649 /* clear WCID attribute table (entries = 256, entry size = 4) */
3650
3651 rt2870_io_mac_set_region_4(sc, RT2870_REG_WCID_ATTR(0), 0, 256);
3652
3653 /* clear IV/EIV table (entries = 256, entry size = 8) */
3654
3655 rt2870_io_mac_set_region_4(sc, RT2870_REG_IVEIV(0), 0, 2 * 256);
3656
3657 /* clear pairwise key table (entries = 256, entry size = 32) */
3658
3659 rt2870_io_mac_set_region_4(sc, RT2870_REG_PKEY(0), 0, 8 * 256);
3660
3661 /* clear shared key table (entries = 32, entry size = 32) */
3662
3663 rt2870_io_mac_set_region_4(sc, RT2870_REG_SKEY(0, 0), 0, 8 * 32);
3664
3665 /* clear shared key mode (entries = 32, entry size = 2) */
3666
3667 rt2870_io_mac_set_region_4(sc, RT2870_REG_SKEY_MODE(0), 0, 16);
3668 }
3669
3670 /*
3671 * rt2870_rxrate
3672 */
3673 static uint8_t rt2870_rxrate(struct rt2870_rxwi *rxwi)
3674 {
3675 uint8_t mcs, phymode;
3676 uint8_t rate;
3677
3678 mcs = (rxwi->bw_mcs >> RT2870_RXWI_MCS_SHIFT) & RT2870_RXWI_MCS_MASK;
3679 phymode = (rxwi->phymode_stbc_shortgi >> RT2870_RXWI_PHYMODE_SHIFT) &
3680 RT2870_RXWI_PHYMODE_MASK;
3681
3682 rate = 2;
3683
3684 switch (phymode)
3685 {
3686 case RT2870_RXWI_PHYMODE_CCK:
3687 switch (mcs & ~RT2870_RXWI_MCS_SHOTPRE)
3688 {
3689 case 0: rate = 2; break; /* 1 Mbps */
3690 case 1: rate = 4; break; /* 2 MBps */
3691 case 2: rate = 11; break; /* 5.5 Mbps */
3692 case 3: rate = 22; break; /* 11 Mbps */
3693 }
3694 break;
3695
3696 case RT2870_RXWI_PHYMODE_OFDM:
3697 switch (mcs)
3698 {
3699 case 0: rate = 12; break; /* 6 Mbps */
3700 case 1: rate = 18; break; /* 9 Mbps */
3701 case 2: rate = 24; break; /* 12 Mbps */
3702 case 3: rate = 36; break; /* 18 Mbps */
3703 case 4: rate = 48; break; /* 24 Mbps */
3704 case 5: rate = 72; break; /* 36 Mbps */
3705 case 6: rate = 96; break; /* 48 Mbps */
3706 case 7: rate = 108; break; /* 54 Mbps */
3707 }
3708 break;
3709
3710 case RT2870_RXWI_PHYMODE_HT_MIXED:
3711 case RT2870_RXWI_PHYMODE_HT_GF:
3712 break;
3713 }
3714
3715 return rate;
3716 }
3717
3718 /*
3719 * rt2870_maxrssi_rxpath
3720 */
3721 static uint8_t rt2870_maxrssi_rxpath(struct rt2870_softc *sc,
3722 const struct rt2870_rxwi *rxwi)
3723 {
3724 uint8_t rxpath;
3725
3726 rxpath = 0;
3727
3728 if (sc->nrxpath > 1)
3729 if (rxwi->rssi[1] > rxwi->rssi[rxpath])
3730 rxpath = 1;
3731
3732 if (sc->nrxpath > 2)
3733 if (rxwi->rssi[2] > rxwi->rssi[rxpath])
3734 rxpath = 2;
3735
3736 return rxpath;
3737 }
3738
3739 /*
3740 * rt2870_rssi2dbm
3741 */
3742 static int8_t rt2870_rssi2dbm(struct rt2870_softc *sc,
3743 uint8_t rssi, uint8_t rxpath)
3744 {
3745 struct ifnet *ifp;
3746 struct ieee80211com *ic;
3747 struct ieee80211_channel *c;
3748 int chan;
3749 int8_t rssi_off, lna_gain;
3750
3751 if (rssi == 0)
3752 return -99;
3753
3754 ifp = sc->ifp;
3755 ic = ifp->if_l2com;
3756 c = ic->ic_curchan;
3757 chan = ieee80211_chan2ieee(ic, c);
3758
3759 if (IEEE80211_IS_CHAN_5GHZ(c))
3760 {
3761 rssi_off = sc->rssi_off_5ghz[rxpath];
3762
3763 if (chan <= 64)
3764 lna_gain = sc->lna_gain[1];
3765 else if (chan <= 128)
3766 lna_gain = sc->lna_gain[2];
3767 else
3768 lna_gain = sc->lna_gain[3];
3769 }
3770 else
3771 {
3772 rssi_off = sc->rssi_off_2ghz[rxpath];
3773 lna_gain = sc->lna_gain[0];
3774 }
3775
3776 return (-12 - rssi_off - lna_gain - rssi);
3777 }
3778
3779 /*
3780 * rt2870_rate2mcs
3781 */
3782 static uint8_t rt2870_rate2mcs(uint8_t rate)
3783 {
3784 switch (rate)
3785 {
3786 /* CCK rates */
3787 case 2: return 0;
3788 case 4: return 1;
3789 case 11: return 2;
3790 case 22: return 3;
3791
3792 /* OFDM rates */
3793 case 12: return 0;
3794 case 18: return 1;
3795 case 24: return 2;
3796 case 36: return 3;
3797 case 48: return 4;
3798 case 72: return 5;
3799 case 96: return 6;
3800 case 108: return 7;
3801 }
3802
3803 return 0;
3804 }
3805
3806 /*
3807 * rt2870_rx_frame
3808 */
3809 static void rt2870_rx_frame(struct rt2870_softc *sc,
3810 uint8_t *buf, uint32_t dmalen)
3811 {
3812 struct ifnet *ifp;
3813 struct ieee80211com *ic;
3814 struct ieee80211_frame *wh;
3815 struct ieee80211_node *ni;
3816 struct rt2870_softc_node *rni;
3817 struct rt2870_softc_rx_radiotap_header *tap;
3818 struct rt2870_rxwi *rxwi;
3819 struct rt2870_rxinfo *rxinfo;
3820 struct mbuf *m;
3821 uint32_t rxinfo_flags;
3822 uint8_t cipher_err, rssi, ant, phymode, bw, shortgi, mcs;
3823 int8_t rssi_dbm;
3824 int len, ampdu, amsdu, rssi_dbm_rel, i;
3825
3826 ifp = sc->ifp;
3827 ic = ifp->if_l2com;
3828
3829 /* get Rx wireless info */
3830
3831 rxwi = (struct rt2870_rxwi *) buf;
3832 len = (le16toh(rxwi->tid_size) >> RT2870_RXWI_SIZE_SHIFT) &
3833 RT2870_RXWI_SIZE_MASK;
3834
3835 if (len > dmalen)
3836 {
3837 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3838 "%s: bad rxwi len: DMA len=%d, rxwi len=%d\n",
3839 device_get_nameunit(sc->dev), dmalen, len);
3840 return;
3841 }
3842
3843 /* get Rx info */
3844
3845 rxinfo = (struct rt2870_rxinfo *) ((caddr_t) rxwi + dmalen);
3846 rxinfo_flags = le32toh(rxinfo->flags);
3847
3848 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3849 "%s: Rx frame: DMA len=%d, len=%d, rxinfo flags=0x%08x\n",
3850 device_get_nameunit(sc->dev), dmalen, len, rxinfo_flags);
3851
3852 /* check for crc errors */
3853
3854 if (rxinfo_flags & RT2870_RXINFO_FLAGS_CRC_ERR)
3855 {
3856 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3857 "%s: rxinfo: crc error\n",
3858 device_get_nameunit(sc->dev));
3859
3860 ifp->if_ierrors++;
3861
3862 if (!(ifp->if_flags & IFF_PROMISC))
3863 return;
3864 }
3865
3866 wh = (struct ieee80211_frame *) (rxwi + 1);
3867
3868 /* check for L2 padding between IEEE 802.11 frame header and body */
3869
3870 if (rxinfo_flags & RT2870_RXINFO_FLAGS_L2PAD)
3871 {
3872 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3873 "%s: L2 padding: DMA len=%d, len=%d\n",
3874 device_get_nameunit(sc->dev), dmalen, len);
3875
3876 len += 2;
3877 }
3878
3879 m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
3880 if (m == NULL)
3881 {
3882 sc->rx_mbuf_alloc_errors++;
3883 ifp->if_ierrors++;
3884 return;
3885 }
3886
3887 m->m_pkthdr.rcvif = ifp;
3888 m->m_pkthdr.len = m->m_len = len;
3889
3890 m_copyback(m, 0, len, (caddr_t) wh);
3891
3892 wh = mtod(m, struct ieee80211_frame *);
3893
3894 /* check for cipher errors */
3895
3896 if (rxinfo_flags & RT2870_RXINFO_FLAGS_DECRYPTED)
3897 {
3898 cipher_err = ((rxinfo_flags >> RT2870_RXINFO_FLAGS_CIPHER_ERR_SHIFT) &
3899 RT2870_RXINFO_FLAGS_CIPHER_ERR_MASK);
3900 if (cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_NONE)
3901 {
3902 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3903 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
3904
3905 m->m_flags |= M_WEP;
3906 }
3907 else
3908 {
3909 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3910 "%s: rxinfo: cipher error=0x%02x\n",
3911 device_get_nameunit(sc->dev), cipher_err);
3912
3913 ifp->if_ierrors++;
3914
3915 if (!(ifp->if_flags & IFF_PROMISC))
3916 {
3917 m_free(m);
3918 return;
3919 }
3920 }
3921 }
3922 else
3923 {
3924 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3925 {
3926 ifp->if_ierrors++;
3927
3928 if (!(ifp->if_flags & IFF_PROMISC))
3929 {
3930 m_free(m);
3931 return;
3932 }
3933 }
3934 }
3935
3936 /* check for A-MPDU */
3937
3938 if (rxinfo_flags & RT2870_RXINFO_FLAGS_AMPDU)
3939 {
3940 m->m_flags |= M_AMPDU;
3941
3942 sc->rx_ampdu++;
3943
3944 ampdu = 1;
3945 }
3946 else
3947 {
3948 ampdu = 0;
3949 }
3950
3951 /* check for A-MSDU */
3952
3953 if (rxinfo_flags & RT2870_RXINFO_FLAGS_AMSDU)
3954 {
3955 sc->rx_amsdu++;
3956
3957 amsdu = 1;
3958 }
3959 else
3960 {
3961 amsdu = 0;
3962 }
3963
3964 ant = rt2870_maxrssi_rxpath(sc, rxwi);
3965 rssi = rxwi->rssi[ant];
3966 rssi_dbm = rt2870_rssi2dbm(sc, rssi, ant);
3967 phymode = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_PHYMODE_SHIFT) &
3968 RT2870_RXWI_PHYMODE_MASK);
3969 bw = ((rxwi->bw_mcs >> RT2870_RXWI_BW_SHIFT) & RT2870_RXWI_BW_MASK);
3970 shortgi = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_SHORTGI_SHIFT) &
3971 RT2870_RXWI_SHORTGI_MASK);
3972 mcs = ((rxwi->bw_mcs >> RT2870_RXWI_MCS_SHIFT) & RT2870_RXWI_MCS_MASK);
3973
3974 if (ieee80211_radiotap_active(ic))
3975 {
3976 tap = &sc->rxtap;
3977
3978 tap->flags = (rxinfo_flags & RT2870_RXINFO_FLAGS_L2PAD) ? IEEE80211_RADIOTAP_F_DATAPAD : 0;
3979 tap->dbm_antsignal = rssi_dbm;
3980 tap->dbm_antnoise = RT2870_NOISE_FLOOR;
3981 tap->antenna = ant;
3982 tap->antsignal = rssi;
3983 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
3984 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
3985 tap->chan_ieee = ic->ic_curchan->ic_ieee;
3986 tap->chan_maxpow = 0;
3987
3988 if (phymode == RT2870_RXWI_PHYMODE_CCK || phymode == RT2870_RXWI_PHYMODE_OFDM)
3989 tap->rate = rt2870_rxrate(rxwi);
3990 else
3991 tap->rate = mcs | IEEE80211_RATE_MCS;
3992
3993 if (rxwi->bw_mcs & RT2870_RXWI_MCS_SHOTPRE)
3994 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
3995
3996 if (shortgi)
3997 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
3998 }
3999
4000 /*
4001 * net80211 assumes that RSSI data are in the range [-127..127] and
4002 * in .5 dBm units relative to the current noise floor
4003 */
4004
4005 rssi_dbm_rel = (rssi_dbm - RT2870_NOISE_FLOOR) * 2;
4006 if (rssi_dbm_rel > 127)
4007 rssi_dbm_rel = 127;
4008
4009 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4010 "%s: received frame: len=%d, phymode=%d, bw=%d, shortgi=%d, mcs=%d, "
4011 "ant=%d, rssi=%d/%d/%d, snr=%d/%d, wcid=0x%02x, ampdu=%d, amsdu=%d, "
4012 "rssi_dbm=%d, rssi_dbm_rel=%d\n",
4013 device_get_nameunit(sc->dev),
4014 len, phymode, bw, shortgi, mcs,
4015 ant, rxwi->rssi[0], rxwi->rssi[1], rxwi->rssi[2],
4016 rxwi->snr[0], rxwi->snr[1],
4017 rxwi->wcid, ampdu, amsdu, rssi_dbm, rssi_dbm_rel);
4018
4019 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *) wh);
4020 if (ni != NULL)
4021 {
4022 rni = (struct rt2870_softc_node *) ni;
4023
4024 for (i = 0; i < RT2870_SOFTC_RSSI_DBM_COUNT; i++)
4025 rni->last_rssi_dbm[i] = rt2870_rssi2dbm(sc, rxwi->rssi[i], i);
4026
4027 ieee80211_input(ni, m, rssi_dbm_rel, RT2870_NOISE_FLOOR);
4028 ieee80211_free_node(ni);
4029 }
4030 else
4031 {
4032 ieee80211_input_all(ic, m, rssi_dbm_rel, RT2870_NOISE_FLOOR);
4033 }
4034 }
4035
4036 /*
4037 * rt2870_tx_mgmt
4038 */
4039 static int rt2870_tx_mgmt(struct rt2870_softc *sc,
4040 struct mbuf *m, struct ieee80211_node *ni, int qid)
4041 {
4042 struct ifnet *ifp;
4043 struct ieee80211com *ic;
4044 struct ieee80211vap *vap;
4045 const struct ieee80211_txparam *tp;
4046 struct rt2870_softc_node *rni;
4047 struct rt2870_softc_tx_ring *ring;
4048 struct rt2870_softc_tx_data *data;
4049 struct rt2870_txinfo *txinfo;
4050 struct rt2870_txwi *txwi;
4051 struct ieee80211_frame *wh;
4052 struct rt2870_softc_tx_radiotap_header *tap;
4053 u_int hdrsize, hdrspace;
4054 uint8_t rate, stbc, shortgi, mcs, pid;
4055 uint16_t len, dmalen, mpdu_len, dur;
4056
4057 KASSERT(qid >= 0 && qid < (sc->usb_endpoints - 1),
4058 ("%s: Tx MGMT: invalid qid=%d\n",
4059 device_get_nameunit(sc->dev), qid));
4060
4061 ifp = sc->ifp;
4062 ic = ifp->if_l2com;
4063 vap = ni->ni_vap;
4064 rni = (struct rt2870_softc_node *) ni;
4065 tp = ni->ni_txparms;
4066
4067 ring = &sc->tx_ring[qid];
4068 data = STAILQ_FIRST(&ring->inactive);
4069 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4070 txinfo = (struct rt2870_txinfo *) data->buf;
4071 txwi = (struct rt2870_txwi *) (txinfo + 1);
4072
4073 wh = mtod(m, struct ieee80211_frame *);
4074
4075 rate = tp->mgmtrate & IEEE80211_RATE_VAL;
4076
4077 len = sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + m->m_pkthdr.len;
4078
4079 /* align end on a 4-bytes boundary */
4080
4081 dmalen = (len + 3) & ~3;
4082
4083 /* fill Tx info */
4084
4085 memset(txinfo, 0, sizeof(struct rt2870_txinfo));
4086
4087 txinfo->len = htole16(dmalen - sizeof(struct rt2870_txinfo));
4088
4089 txinfo->qsel_flags = (RT2870_TXINFO_QSEL_EDCA << RT2870_TXINFO_QSEL_SHIFT);
4090
4091 dmalen += 4;
4092
4093 memset((caddr_t) txinfo + len, 0, dmalen - len);
4094
4095 /* fill Tx wireless info */
4096
4097 if (ni->ni_flags & IEEE80211_NODE_HT)
4098 mcs = rate;
4099 else
4100 mcs = rt2870_rate2mcs(rate);
4101
4102 pid = mcs;
4103
4104 /* calculate MPDU length without padding */
4105
4106 hdrsize = ieee80211_hdrsize(wh);
4107 hdrspace = ieee80211_hdrspace(ic, wh);
4108 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
4109
4110 memset(txwi, 0, sizeof(struct rt2870_txwi));
4111
4112 /* management frames do not need encryption */
4113
4114 txwi->wcid = 0xff;
4115
4116 txwi->pid_mpdu_len = ((htole16(pid) & RT2870_TXWI_PID_MASK) <<
4117 RT2870_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2870_TXWI_MPDU_LEN_MASK) <<
4118 RT2870_TXWI_MPDU_LEN_SHIFT);
4119
4120 stbc = (ic->ic_htcaps & IEEE80211_HTCAP_TXSTBC) &&
4121 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC);
4122
4123 shortgi = (vap->iv_flags_ht & (IEEE80211_FHT_SHORTGI20 | IEEE80211_FHT_SHORTGI40)) &&
4124 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_flags & (IEEE80211_NODE_SGI20 | IEEE80211_NODE_SGI40));
4125
4126 txwi->phymode_ifs_stbc_shortgi |=
4127 ((stbc & RT2870_TXWI_STBC_MASK) << RT2870_TXWI_STBC_SHIFT) |
4128 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4129
4130 txwi->phymode_ifs_stbc_shortgi |=
4131 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4132
4133 if (ni->ni_flags & IEEE80211_NODE_HT)
4134 {
4135 txwi->phymode_ifs_stbc_shortgi |=
4136 (RT2870_TXWI_PHYMODE_HT_MIXED << RT2870_TXWI_PHYMODE_SHIFT);
4137 }
4138 else
4139 {
4140 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
4141 {
4142 txwi->phymode_ifs_stbc_shortgi |=
4143 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
4144
4145 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
4146 mcs |= RT2870_TXWI_MCS_SHOTPRE;
4147 }
4148 else
4149 {
4150 txwi->phymode_ifs_stbc_shortgi |=
4151 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
4152 }
4153 }
4154
4155 txwi->bw_mcs = (RT2870_TXWI_BW_20 << RT2870_TXWI_BW_SHIFT) |
4156 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
4157
4158 txwi->txop = (RT2870_TXWI_TXOP_BACKOFF << RT2870_TXWI_TXOP_SHIFT);
4159
4160 /* skip ACKs for multicast frames */
4161
4162 if (!IEEE80211_IS_MULTICAST(wh->i_addr1))
4163 {
4164 txwi->bawin_size_xflags |=
4165 (RT2870_TXWI_XFLAGS_ACK << RT2870_TXWI_XFLAGS_SHIFT);
4166
4167 if (ni->ni_flags & IEEE80211_NODE_HT)
4168 {
4169 /* preamble + plcp + signal extension + SIFS */
4170
4171 dur = 16 + 4 + 6 + 10;
4172 }
4173 else
4174 {
4175 dur = ieee80211_ack_duration(ic->ic_rt, rate,
4176 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
4177 }
4178
4179 *(uint16_t *) wh->i_dur = htole16(dur);
4180 }
4181
4182 /* ask MAC to insert timestamp into probe responses */
4183
4184 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
4185 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
4186 txwi->mpdu_density_flags |=
4187 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4188
4189 if (ieee80211_radiotap_active_vap(vap))
4190 {
4191 tap = &sc->txtap;
4192
4193 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
4194 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4195 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4196 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4197 tap->chan_maxpow = 0;
4198
4199 if (ni->ni_flags & IEEE80211_NODE_HT)
4200 tap->rate = mcs | IEEE80211_RATE_MCS;
4201 else
4202 tap->rate = rate;
4203
4204 if (mcs & RT2870_TXWI_MCS_SHOTPRE)
4205 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4206
4207 if (shortgi)
4208 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4209
4210 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4211 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4212
4213 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4214 {
4215 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4216
4217 ieee80211_radiotap_tx(vap, m);
4218
4219 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4220 }
4221 else
4222 {
4223 ieee80211_radiotap_tx(vap, m);
4224 }
4225 }
4226
4227 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t) (txwi + 1));
4228
4229 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4230 "%s: sending MGMT frame: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4231 "stbc=%d, shortgi=%d, mcs=%d, DMA len=%d\n",
4232 device_get_nameunit(sc->dev),
4233 qid, hdrsize, hdrspace, m->m_pkthdr.len, stbc, shortgi, mcs, dmalen);
4234
4235 data->len = dmalen;
4236 data->m = m;
4237 data->ni = ni;
4238
4239 STAILQ_INSERT_TAIL(&ring->pending, data, next);
4240 ring->queued++;
4241
4242 usbd_transfer_start(sc->usb_xfer[1 + qid]);
4243
4244 return 0;
4245 }
4246
4247 /*
4248 * rt2870_tx_data
4249 */
4250 static int rt2870_tx_data(struct rt2870_softc *sc,
4251 struct mbuf *m, struct ieee80211_node *ni, int qid)
4252 {
4253 struct ifnet *ifp;
4254 struct ieee80211com *ic;
4255 struct ieee80211vap *vap;
4256 const struct ieee80211_txparam *tp;
4257 struct rt2870_softc_node *rni;
4258 struct rt2870_softc_tx_ring *ring;
4259 struct rt2870_softc_tx_data *data;
4260 struct rt2870_txinfo *txinfo;
4261 struct rt2870_txwi *txwi;
4262 struct ieee80211_frame *wh;
4263 struct ieee80211_tx_ampdu *tx_ampdu;
4264 ieee80211_seq seqno;
4265 struct rt2870_softc_tx_radiotap_header *tap;
4266 u_int hdrsize, hdrspace;
4267 uint8_t type, rate, bw, stbc, shortgi, mcs, pid, wcid, mpdu_density, bawin_size;
4268 uint16_t qos, len, dmalen, mpdu_len, dur;
4269 int hasqos, ac, tid, ampdu;
4270
4271 KASSERT(qid >= 0 && qid < (sc->usb_endpoints - 1),
4272 ("%s: Tx data: invalid qid=%d\n",
4273 device_get_nameunit(sc->dev), qid));
4274
4275 ifp = sc->ifp;
4276 ic = ifp->if_l2com;
4277 vap = ni->ni_vap;
4278 rni = (struct rt2870_softc_node *) ni;
4279 tp = ni->ni_txparms;
4280
4281 ring = &sc->tx_ring[qid];
4282 data = STAILQ_FIRST(&ring->inactive);
4283 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4284 txinfo = (struct rt2870_txinfo *) data->buf;
4285 txwi = (struct rt2870_txwi *) (txinfo + 1);
4286
4287 wh = mtod(m, struct ieee80211_frame *);
4288
4289 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
4290
4291 hasqos = IEEE80211_QOS_HAS_SEQ(wh);
4292 if (hasqos)
4293 {
4294 if (IEEE80211_HAS_ADDR4(wh))
4295 qos = le16toh(*(const uint16_t *)
4296 (((struct ieee80211_qosframe_addr4 *) wh)->i_qos));
4297 else
4298 qos = le16toh(*(const uint16_t *)
4299 (((struct ieee80211_qosframe *) wh)->i_qos));
4300 }
4301 else
4302 {
4303 qos = 0;
4304 }
4305
4306 if (IEEE80211_IS_MULTICAST(wh->i_addr1))
4307 rate = tp->mcastrate;
4308 else if (m->m_flags & M_EAPOL)
4309 rate = tp->mgmtrate;
4310 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
4311 rate = tp->ucastrate;
4312 else
4313 rate = ni->ni_txrate;
4314
4315 rate &= IEEE80211_RATE_VAL;
4316
4317 len = sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + m->m_pkthdr.len;
4318
4319 /* align end on a 4-bytes boundary */
4320
4321 dmalen = (len + 3) & ~3;
4322
4323 /* fill Tx info */
4324
4325 memset(txinfo, 0, sizeof(struct rt2870_txinfo));
4326
4327 txinfo->len = htole16(dmalen - sizeof(struct rt2870_txinfo));
4328
4329 txinfo->qsel_flags = (RT2870_TXINFO_QSEL_EDCA << RT2870_TXINFO_QSEL_SHIFT);
4330
4331 dmalen += 4;
4332
4333 memset((caddr_t) txinfo + len, 0, dmalen - len);
4334
4335 /* fill Tx wireless info */
4336
4337 if (ni->ni_flags & IEEE80211_NODE_HT)
4338 mcs = rate;
4339 else
4340 mcs = rt2870_rate2mcs(rate);
4341
4342 pid = mcs;
4343
4344 wcid = (type == IEEE80211_FC0_TYPE_DATA) ?
4345 RT2870_AID2WCID(ni->ni_associd) : 0xff;
4346
4347 /* calculate MPDU length without padding */
4348
4349 hdrsize = ieee80211_hdrsize(wh);
4350 hdrspace = ieee80211_hdrspace(ic, wh);
4351 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
4352
4353 memset(txwi, 0, sizeof(struct rt2870_txwi));
4354
4355 txwi->wcid = wcid;
4356
4357 txwi->pid_mpdu_len = ((htole16(pid) & RT2870_TXWI_PID_MASK) <<
4358 RT2870_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2870_TXWI_MPDU_LEN_MASK) <<
4359 RT2870_TXWI_MPDU_LEN_SHIFT);
4360
4361 stbc = (ic->ic_htcaps & IEEE80211_HTCAP_TXSTBC) &&
4362 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC);
4363
4364 shortgi = (vap->iv_flags_ht & (IEEE80211_FHT_SHORTGI20 | IEEE80211_FHT_SHORTGI40)) &&
4365 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_flags & (IEEE80211_NODE_SGI20 | IEEE80211_NODE_SGI40));
4366
4367 txwi->phymode_ifs_stbc_shortgi |=
4368 ((stbc & RT2870_TXWI_STBC_MASK) << RT2870_TXWI_STBC_SHIFT) |
4369 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4370
4371 if (ni->ni_flags & IEEE80211_NODE_HT)
4372 {
4373 txwi->phymode_ifs_stbc_shortgi |=
4374 (RT2870_TXWI_PHYMODE_HT_MIXED << RT2870_TXWI_PHYMODE_SHIFT);
4375 }
4376 else
4377 {
4378 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
4379 {
4380 txwi->phymode_ifs_stbc_shortgi |=
4381 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
4382
4383 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
4384 mcs |= RT2870_TXWI_MCS_SHOTPRE;
4385 }
4386 else
4387 {
4388 txwi->phymode_ifs_stbc_shortgi |=
4389 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
4390 }
4391 }
4392
4393 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_chw == 40))
4394 bw = RT2870_TXWI_BW_40;
4395 else
4396 bw = RT2870_TXWI_BW_20;
4397
4398 txwi->bw_mcs = ((bw & RT2870_TXWI_BW_MASK) << RT2870_TXWI_BW_SHIFT) |
4399 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
4400
4401 txwi->txop = (RT2870_TXWI_TXOP_HT << RT2870_TXWI_TXOP_SHIFT);
4402
4403 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
4404 (!hasqos || (qos & IEEE80211_QOS_ACKPOLICY) != IEEE80211_QOS_ACKPOLICY_NOACK))
4405 {
4406 txwi->bawin_size_xflags |=
4407 (RT2870_TXWI_XFLAGS_ACK << RT2870_TXWI_XFLAGS_SHIFT);
4408
4409 if (ni->ni_flags & IEEE80211_NODE_HT)
4410 {
4411 /* preamble + plcp + signal extension + SIFS */
4412
4413 dur = 16 + 4 + 6 + 10;
4414 }
4415 else
4416 {
4417 dur = ieee80211_ack_duration(ic->ic_rt, rate,
4418 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
4419 }
4420
4421 *(uint16_t *) wh->i_dur = htole16(dur);
4422 }
4423
4424 /* check fo A-MPDU */
4425
4426 if (m->m_flags & M_AMPDU_MPDU)
4427 {
4428 ac = M_WME_GETAC(m);
4429 tid = WME_AC_TO_TID(ac);
4430 tx_ampdu = &ni->ni_tx_ampdu[ac];
4431
4432 mpdu_density = RT2870_MS(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY);
4433 bawin_size = tx_ampdu->txa_wnd;
4434
4435 txwi->mpdu_density_flags |=
4436 ((mpdu_density & RT2870_TXWI_MPDU_DENSITY_MASK) << RT2870_TXWI_MPDU_DENSITY_SHIFT) |
4437 (RT2870_TXWI_FLAGS_AMPDU << RT2870_TXWI_FLAGS_SHIFT);
4438
4439 txwi->bawin_size_xflags |=
4440 ((bawin_size & RT2870_TXWI_BAWIN_SIZE_MASK) << RT2870_TXWI_BAWIN_SIZE_SHIFT);
4441
4442 seqno = ni->ni_txseqs[tid]++;
4443
4444 *(uint16_t *) &wh->i_seq[0] = htole16(seqno << IEEE80211_SEQ_SEQ_SHIFT);
4445
4446 ampdu = 1;
4447 }
4448 else
4449 {
4450 ampdu = 0;
4451 }
4452
4453 /* ask MAC to insert timestamp into probe responses */
4454
4455 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
4456 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
4457 txwi->mpdu_density_flags |=
4458 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4459
4460 if (ieee80211_radiotap_active_vap(vap))
4461 {
4462 tap = &sc->txtap;
4463
4464 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
4465 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4466 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4467 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4468 tap->chan_maxpow = 0;
4469
4470 if (ni->ni_flags & IEEE80211_NODE_HT)
4471 tap->rate = mcs | IEEE80211_RATE_MCS;
4472 else
4473 tap->rate = rate;
4474
4475 if (mcs & RT2870_TXWI_MCS_SHOTPRE)
4476 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4477
4478 if (shortgi)
4479 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4480
4481 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4482 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4483
4484 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4485 {
4486 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4487
4488 ieee80211_radiotap_tx(vap, m);
4489
4490 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4491 }
4492 else
4493 {
4494 ieee80211_radiotap_tx(vap, m);
4495 }
4496 }
4497
4498 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t) (txwi + 1));
4499
4500 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4501 "%s: sending data: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4502 "bw=%d, stbc=%d, shortgi=%d, mcs=%d, wcid=0x%02x, ampdu=%d, DMA len=%d\n",
4503 device_get_nameunit(sc->dev),
4504 qid, hdrsize, hdrspace, m->m_pkthdr.len,
4505 bw, stbc, shortgi, mcs, wcid, ampdu, dmalen);
4506
4507 data->len = dmalen;
4508 data->m = m;
4509 data->ni = ni;
4510
4511 STAILQ_INSERT_TAIL(&ring->pending, data, next);
4512 ring->queued++;
4513
4514 usbd_transfer_start(sc->usb_xfer[1 + qid]);
4515
4516 return 0;
4517 }
4518
4519 /*
4520 * rt2870_tx_raw
4521 */
4522 static int rt2870_tx_raw(struct rt2870_softc *sc,
4523 struct mbuf *m, struct ieee80211_node *ni,
4524 const struct ieee80211_bpf_params *params)
4525 {
4526 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4527 "%s: Tx raw\n",
4528 device_get_nameunit(sc->dev));
4529
4530 return 0;
4531 }
4532
4533 /*
4534 * rt2870_rx_intr
4535 */
4536 static void rt2870_rx_intr(struct usb_xfer *xfer, usb_error_t error)
4537 {
4538 struct rt2870_softc *sc;
4539 struct ifnet *ifp;
4540 struct rt2870_softc_rx_ring *ring;
4541 struct rt2870_softc_rx_data *data;
4542 int len;
4543
4544 sc = usbd_xfer_softc(xfer);
4545 ifp = sc->ifp;
4546 ring = &sc->rx_ring;
4547
4548 RT2870_DPRINTF(sc, RT2870_DEBUG_INTR,
4549 "%s: Rx interrupt: state=%d, error=%s\n",
4550 device_get_nameunit(sc->dev),
4551 USB_GET_STATE(xfer), usbd_errstr(error));
4552
4553 switch (USB_GET_STATE(xfer))
4554 {
4555 case USB_ST_TRANSFERRED:
4556 sc->interrupts++;
4557 sc->rx_interrupts++;
4558
4559 data = STAILQ_FIRST(&ring->active);
4560 if (data == NULL)
4561 goto setup;
4562
4563 STAILQ_REMOVE_HEAD(&ring->active, next);
4564
4565 usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
4566
4567 data->len = len;
4568
4569 STAILQ_INSERT_TAIL(&ring->done, data, next);
4570
4571 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
4572
4573 /* FALLTHROUGH */
4574
4575 setup:
4576
4577 case USB_ST_SETUP:
4578 data = STAILQ_FIRST(&ring->inactive);
4579 if (data == NULL)
4580 break;
4581
4582 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4583
4584 STAILQ_INSERT_TAIL(&ring->active, data, next);
4585
4586 usbd_xfer_set_frame_data(xfer, 0, data->buf, usbd_xfer_max_len(xfer));
4587 usbd_transfer_submit(xfer);
4588 break;
4589
4590 default:
4591 sc->interrupts++;
4592 sc->rx_interrupts++;
4593
4594 data = STAILQ_FIRST(&ring->active);
4595 if (data != NULL)
4596 {
4597 STAILQ_REMOVE_HEAD(&ring->active, next);
4598 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4599 }
4600
4601 if (error != USB_ERR_CANCELLED)
4602 {
4603 ifp->if_ierrors++;
4604
4605 usbd_xfer_set_stall(xfer);
4606
4607 goto setup;
4608 }
4609 break;
4610 }
4611 }
4612
4613 /*
4614 * rt2870_tx_intr
4615 */
4616 static void rt2870_tx_intr(struct usb_xfer *xfer, usb_error_t error)
4617 {
4618 struct rt2870_softc *sc;
4619 struct ifnet *ifp;
4620 struct rt2870_softc_tx_ring *ring;
4621 struct rt2870_softc_tx_data *data;
4622
4623 sc = usbd_xfer_softc(xfer);
4624 ifp = sc->ifp;
4625 ring = usbd_xfer_get_priv(xfer);
4626
4627 usbd_xfer_status(xfer, NULL, NULL, NULL, NULL);
4628
4629 RT2870_DPRINTF(sc, RT2870_DEBUG_INTR,
4630 "%s: Tx interrupt: state=%d, error=%s\n",
4631 device_get_nameunit(sc->dev),
4632 USB_GET_STATE(xfer), usbd_errstr(error));
4633
4634 switch (USB_GET_STATE(xfer))
4635 {
4636 case USB_ST_TRANSFERRED:
4637 sc->interrupts++;
4638 sc->tx_interrupts[ring->qid]++;
4639
4640 data = STAILQ_FIRST(&ring->active);
4641 if (data == NULL)
4642 goto setup;
4643
4644 STAILQ_REMOVE_HEAD(&ring->active, next);
4645
4646 STAILQ_INSERT_TAIL(&ring->done, data, next);
4647
4648 sc->tx_qid_pending_mask |= (1 << ring->qid);
4649
4650 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
4651
4652 /* FALLTHROUGH */
4653
4654 setup:
4655
4656 case USB_ST_SETUP:
4657 data = STAILQ_FIRST(&ring->pending);
4658 if (data == NULL)
4659 break;
4660
4661 STAILQ_REMOVE_HEAD(&ring->pending, next);
4662 STAILQ_INSERT_TAIL(&ring->active, data, next);
4663
4664 usbd_xfer_set_frame_data(xfer, 0, data->buf, data->len);
4665 usbd_transfer_submit(xfer);
4666
4667 RT2870_SOFTC_UNLOCK(sc);
4668
4669 rt2870_start(ifp);
4670
4671 RT2870_SOFTC_LOCK(sc);
4672 break;
4673
4674 default:
4675 sc->interrupts++;
4676 sc->tx_interrupts[ring->qid]++;
4677
4678 data = STAILQ_FIRST(&ring->active);
4679 if (data != NULL)
4680 {
4681 STAILQ_REMOVE_HEAD(&ring->active, next);
4682
4683 printf("%s: could not transmit buffer: qid=%d, error=%s\n",
4684 device_get_nameunit(sc->dev), ring->qid, usbd_errstr(error));
4685
4686 if (data->m != NULL)
4687 {
4688 m_freem(data->m);
4689 data->m = NULL;
4690 }
4691
4692 if (data->ni != NULL)
4693 {
4694 ieee80211_free_node(data->ni);
4695 data->ni = NULL;
4696 }
4697
4698 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4699
4700 ring->queued--;
4701 }
4702
4703 if (error != USB_ERR_CANCELLED)
4704 {
4705 ifp->if_oerrors++;
4706 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4707
4708 usbd_xfer_set_stall(xfer);
4709
4710 goto setup;
4711 }
4712 break;
4713 }
4714 }
4715
4716 /*
4717 * rt2870_rx_done_task
4718 */
4719 static void rt2870_rx_done_task(void *context, int pending)
4720 {
4721 struct rt2870_softc *sc;
4722 struct ifnet *ifp;
4723
4724 sc = context;
4725 ifp = sc->ifp;
4726
4727 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4728 "%s: Rx done task\n",
4729 device_get_nameunit(sc->dev));
4730
4731 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4732 return;
4733
4734 if (rt2870_rx_eof(sc, sc->rx_process_limit) != 0)
4735 {
4736 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4737 "%s: Rx done task: scheduling again\n",
4738 device_get_nameunit(sc->dev));
4739
4740 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
4741 }
4742 }
4743
4744 /*
4745 * rt2870_tx_done_task
4746 */
4747 static void rt2870_tx_done_task(void *context, int pending)
4748 {
4749 struct rt2870_softc *sc;
4750 struct ifnet *ifp;
4751 int i;
4752
4753 sc = context;
4754 ifp = sc->ifp;
4755
4756 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4757 "%s: Tx done task\n",
4758 device_get_nameunit(sc->dev));
4759
4760 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4761 return;
4762
4763 for (i = sc->usb_endpoints - 2; i >= 0; i--)
4764 {
4765 if (sc->tx_qid_pending_mask & (1 << i))
4766 {
4767 sc->tx_qid_pending_mask &= ~(1 << i);
4768
4769 rt2870_tx_eof(sc, &sc->tx_ring[i]);
4770 }
4771 }
4772
4773 if (sc->tx_qid_pending_mask != 0)
4774 {
4775 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4776 "%s: Tx done task: scheduling again\n",
4777 device_get_nameunit(sc->dev));
4778
4779 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
4780 }
4781
4782 sc->tx_timer = 0;
4783
4784 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4785 }
4786
4787 /*
4788 * rt2870_periodic_task
4789 */
4790 static void rt2870_periodic_task(void *context, int pending)
4791 {
4792 struct rt2870_softc *sc;
4793 struct ifnet *ifp;
4794 struct ieee80211com *ic;
4795 struct ieee80211vap *vap;
4796
4797 sc = context;
4798 ifp = sc->ifp;
4799 ic = ifp->if_l2com;
4800 vap = TAILQ_FIRST(&ic->ic_vaps);
4801
4802 RT2870_DPRINTF(sc, RT2870_DEBUG_PERIODIC,
4803 "%s: periodic task: round=%lu\n",
4804 device_get_nameunit(sc->dev), sc->periodic_round);
4805
4806 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4807 return;
4808
4809 RT2870_SOFTC_LOCK(sc);
4810
4811 sc->periodic_round++;
4812
4813 rt2870_update_stats(sc);
4814
4815 if ((sc->periodic_round % 10) == 0)
4816 {
4817 rt2870_bbp_tuning(sc);
4818
4819 rt2870_update_raw_counters(sc);
4820
4821 rt2870_watchdog(sc);
4822
4823 if (vap != NULL && vap->iv_opmode != IEEE80211_M_MONITOR && vap->iv_state == IEEE80211_S_RUN)
4824 {
4825 if (vap->iv_opmode == IEEE80211_M_STA)
4826 rt2870_amrr_update_iter_func(vap, vap->iv_bss);
4827 else
4828 ieee80211_iterate_nodes(&ic->ic_sta, rt2870_amrr_update_iter_func, vap);
4829 }
4830 }
4831
4832 RT2870_SOFTC_UNLOCK(sc);
4833
4834 callout_reset(&sc->periodic_ch, hz / 10, rt2870_periodic, sc);
4835 }
4836
4837 /*
4838 * rt2870_cmd_task
4839 */
4840 static void rt2870_cmd_task(void *context, int pending)
4841 {
4842 struct rt2870_softc *sc;
4843 struct rt2870_softc_cmd_ring *ring;
4844 struct rt2870_softc_cmd *cmd;
4845
4846 sc = context;
4847 ring = &sc->cmd_ring;
4848
4849 while (1)
4850 {
4851 RT2870_SOFTC_LOCK(sc);
4852
4853 cmd = STAILQ_FIRST(&ring->active);
4854 if (cmd == NULL)
4855 {
4856 RT2870_SOFTC_UNLOCK(sc);
4857 break;
4858 }
4859
4860 STAILQ_REMOVE_HEAD(&ring->active, next);
4861
4862 RT2870_SOFTC_UNLOCK(sc);
4863
4864 cmd->cb(sc, cmd->data);
4865
4866 RT2870_SOFTC_LOCK(sc);
4867
4868 STAILQ_INSERT_TAIL(&ring->inactive, cmd, next);
4869 ring->queued--;
4870
4871 RT2870_SOFTC_UNLOCK(sc);
4872 }
4873 }
4874
4875 /*
4876 * rt2870_rx_eof
4877 */
4878 static int rt2870_rx_eof(struct rt2870_softc *sc, int limit)
4879 {
4880 struct ifnet *ifp;
4881 struct rt2870_softc_rx_ring *ring;
4882 struct rt2870_softc_rx_data *data;
4883 uint32_t dmalen;
4884 uint8_t *buf;
4885 int nframes, len;
4886
4887 ifp = sc->ifp;
4888 ring = &sc->rx_ring;
4889
4890 nframes = 0;
4891
4892 while (limit != 0)
4893 {
4894 RT2870_SOFTC_LOCK(sc);
4895
4896 data = STAILQ_FIRST(&ring->done);
4897 if (data == NULL)
4898 {
4899 RT2870_SOFTC_UNLOCK(sc);
4900 break;
4901 }
4902
4903 STAILQ_REMOVE_HEAD(&ring->done, next);
4904
4905 RT2870_SOFTC_UNLOCK(sc);
4906
4907 buf = data->buf;
4908 len = data->len;
4909
4910 if (len < RT2870_RX_DESC_SIZE)
4911 {
4912 ifp->if_ierrors++;
4913 goto skip;
4914 }
4915
4916 while (len > (sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)))
4917 {
4918 dmalen = (le32toh(*(uint32_t *) buf) & 0xffff);
4919
4920 if (dmalen == 0 || (dmalen & 3) != 0)
4921 {
4922 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4923 "%s: bad DMA len=%u\n",
4924 device_get_nameunit(sc->dev), dmalen);
4925 goto skip;
4926 }
4927
4928 if ((dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)) > len)
4929 {
4930 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4931 "%s: bad DMA len: DMA len=%u, USB len=%d\n",
4932 device_get_nameunit(sc->dev),
4933 (unsigned int) (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)), len);
4934 goto skip;
4935 }
4936
4937 nframes++;
4938
4939 rt2870_rx_frame(sc, buf + sizeof(uint32_t), dmalen);
4940
4941 buf += (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo));
4942 len -= (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo));
4943 }
4944
4945 skip:
4946
4947 RT2870_SOFTC_LOCK(sc);
4948
4949 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4950
4951 usbd_transfer_start(sc->usb_xfer[0]);
4952
4953 RT2870_SOFTC_UNLOCK(sc);
4954
4955 limit--;
4956 }
4957
4958 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4959 "%s: Rx eof: nframes=%d\n",
4960 device_get_nameunit(sc->dev), nframes);
4961
4962 sc->rx_packets += nframes;
4963
4964 return (limit == 0);
4965 }
4966
4967 /*
4968 * rt2870_tx_eof
4969 */
4970 static void rt2870_tx_eof(struct rt2870_softc *sc,
4971 struct rt2870_softc_tx_ring *ring)
4972 {
4973 struct ifnet *ifp;
4974 struct rt2870_softc_tx_data *data;
4975 int nframes;
4976
4977 ifp = sc->ifp;
4978
4979 nframes = 0;
4980
4981 while (1)
4982 {
4983 RT2870_SOFTC_LOCK(sc);
4984
4985 data = STAILQ_FIRST(&ring->done);
4986 if (data == NULL)
4987 {
4988 RT2870_SOFTC_UNLOCK(sc);
4989 break;
4990 }
4991
4992 STAILQ_REMOVE_HEAD(&ring->done, next);
4993
4994 rt2870_drain_fifo_stats(sc);
4995
4996 RT2870_SOFTC_UNLOCK(sc);
4997
4998 nframes++;
4999
5000 if (data->m->m_flags & M_TXCB)
5001 ieee80211_process_callback(data->ni, data->m, 0);
5002
5003 m_freem(data->m);
5004
5005 ieee80211_free_node(data->ni);
5006
5007 data->m = NULL;
5008 data->ni = NULL;
5009
5010 RT2870_SOFTC_LOCK(sc);
5011
5012 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5013
5014 ring->queued--;
5015 ifp->if_opackets++;
5016
5017 RT2870_SOFTC_UNLOCK(sc);
5018 }
5019
5020 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
5021 "%s: Tx eof: qid=%d, nframes=%d\n",
5022 device_get_nameunit(sc->dev), ring->qid, nframes);
5023 }
5024
5025 /*
5026 * rt2870_update_stats
5027 */
5028 static void rt2870_update_stats(struct rt2870_softc *sc)
5029 {
5030 struct ifnet *ifp;
5031 struct ieee80211com *ic;
5032 struct ieee80211vap *vap;
5033 struct ieee80211_node *ni;
5034 uint32_t stacnt[3];
5035 int beacons, noretryok, retryok, failed, underflows, zerolen;
5036 uint16_t associd;
5037 uint8_t wcid;
5038
5039 ifp = sc->ifp;
5040 ic = ifp->if_l2com;
5041 vap = TAILQ_FIRST(&ic->ic_vaps);
5042
5043 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
5044 "%s: update statistic\n",
5045 device_get_nameunit(sc->dev));
5046
5047 rt2870_drain_fifo_stats(sc);
5048
5049 /* read and clear Tx statistic registers */
5050
5051 rt2870_io_mac_read_multi(sc, RT2870_REG_TX_STA_CNT0,
5052 stacnt, sizeof(stacnt));
5053
5054 stacnt[0] = le32toh(stacnt[0]);
5055 stacnt[1] = le32toh(stacnt[1]);
5056 stacnt[2] = le32toh(stacnt[2]);
5057
5058 beacons = stacnt[0] >> 16;
5059 noretryok = stacnt[1] & 0xffff;
5060 retryok = stacnt[1] >> 16;
5061 failed = stacnt[0] & 0xffff;
5062 underflows = stacnt[2] >> 16;
5063 zerolen = stacnt[2] & 0xffff;
5064
5065 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
5066 "%s: update statistic: beacons=%d, noretryok=%d, retryok=%d, failed=%d, underflows=%d, zerolen=%d\n",
5067 device_get_nameunit(sc->dev),
5068 beacons, noretryok, retryok, failed, underflows, zerolen);
5069
5070 ifp->if_oerrors += failed;
5071
5072 sc->tx_beacons += beacons;
5073 sc->tx_noretryok += noretryok;
5074 sc->tx_retryok += retryok;
5075 sc->tx_failed += failed;
5076 sc->tx_underflows += underflows;
5077 sc->tx_zerolen += zerolen;
5078
5079 if (vap != NULL && vap->iv_opmode == IEEE80211_M_STA && vap->iv_state == IEEE80211_S_RUN)
5080 {
5081 ni = vap->iv_bss;
5082
5083 associd = (ni != NULL) ? ni->ni_associd : 0;
5084 wcid = RT2870_AID2WCID(associd);
5085
5086 rt2870_amrr_tx_update(&sc->amrr_node[wcid],
5087 noretryok + retryok + failed, noretryok + retryok, retryok + failed);
5088 }
5089 }
5090
5091 /*
5092 * rt2870_bbp_tuning
5093 */
5094 static void rt2870_bbp_tuning(struct rt2870_softc *sc)
5095 {
5096 struct ifnet *ifp;
5097 struct ieee80211com *ic;
5098 struct ieee80211vap *vap;
5099 struct ieee80211_node *ni;
5100 int chan, group;
5101 int8_t rssi, old, new;
5102
5103 /* RT2860C does not support BBP tuning */
5104
5105 if (sc->mac_rev == 0x28600100)
5106 return;
5107
5108 ifp = sc->ifp;
5109 ic = ifp->if_l2com;
5110 vap = TAILQ_FIRST(&ic->ic_vaps);
5111
5112 if ((ic->ic_flags & IEEE80211_F_SCAN) || vap == NULL ||
5113 vap->iv_opmode != IEEE80211_M_STA || vap->iv_state != IEEE80211_S_RUN)
5114 return;
5115
5116 ni = vap->iv_bss;
5117
5118 chan = ieee80211_chan2ieee(ic, ni->ni_chan);
5119
5120 if (chan <= 14)
5121 group = 0;
5122 else if (chan <= 64)
5123 group = 1;
5124 else if (chan <= 128)
5125 group = 2;
5126 else
5127 group = 3;
5128
5129 rssi = ieee80211_getrssi(vap);
5130
5131 if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan))
5132 {
5133 new = 0x2e + sc->lna_gain[group];
5134 }
5135 else
5136 {
5137 if (!IEEE80211_IS_CHAN_HT40(ni->ni_chan))
5138 new = 0x32 + sc->lna_gain[group] * 5 / 3;
5139 else
5140 new = 0x3a + sc->lna_gain[group] * 5 / 3;
5141 }
5142
5143 /* Tune if absolute average RSSI is greater than -80 */
5144
5145 if (rssi > 30)
5146 new += 0x10;
5147
5148 old = rt2870_io_bbp_read(sc, 66);
5149
5150 if (old != new)
5151 rt2870_io_bbp_write(sc, 66, new);
5152 }
5153
5154 /*
5155 * rt2870_watchdog
5156 */
5157 static void rt2870_watchdog(struct rt2870_softc *sc)
5158 {
5159 uint32_t tmp;
5160 int ntries;
5161
5162 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
5163
5164 RT2870_DPRINTF(sc, RT2870_DEBUG_WATCHDOG,
5165 "%s: watchdog: TXRXQ_PCNT=0x%08x\n",
5166 device_get_nameunit(sc->dev), tmp);
5167
5168 if (((tmp >> RT2870_REG_TX0Q_PCNT_SHIFT) & RT2870_REG_TX0Q_PCNT_MASK) != 0)
5169 {
5170 sc->tx_queue_not_empty[0]++;
5171
5172 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40012);
5173
5174 for (ntries = 0; ntries < 10; ntries++)
5175 {
5176 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
5177 if (((tmp >> RT2870_REG_TX0Q_PCNT_SHIFT) & RT2870_REG_TX0Q_PCNT_MASK) == 0)
5178 break;
5179
5180 DELAY(1);
5181 }
5182
5183 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40006);
5184 }
5185
5186 if (((tmp >> RT2870_REG_TX1Q_PCNT_SHIFT) & RT2870_REG_TX1Q_PCNT_MASK) != 0)
5187 {
5188 sc->tx_queue_not_empty[1]++;
5189
5190 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf4000a);
5191
5192 for (ntries = 0; ntries < 10; ntries++)
5193 {
5194 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
5195 if (((tmp >> RT2870_REG_TX1Q_PCNT_SHIFT) & RT2870_REG_TX1Q_PCNT_MASK) == 0)
5196 break;
5197
5198 DELAY(1);
5199 }
5200
5201 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40006);
5202 }
5203 }
5204
5205 /*
5206 * rt2870_drain_fifo_stats
5207 */
5208 static void rt2870_drain_fifo_stats(struct rt2870_softc *sc)
5209 {
5210 struct ifnet *ifp;
5211 uint32_t stats;
5212 uint8_t wcid, mcs, pid;
5213 int ok, agg, retrycnt;
5214
5215 ifp = sc->ifp;
5216
5217 /* drain Tx status FIFO (maxsize = 16) */
5218
5219 while ((stats = rt2870_io_mac_read(sc, RT2870_REG_TX_STA_FIFO)) &
5220 RT2870_REG_TX_STA_FIFO_VALID)
5221 {
5222 wcid = (stats >> RT2870_REG_TX_STA_FIFO_WCID_SHIFT) &
5223 RT2870_REG_TX_STA_FIFO_WCID_MASK;
5224
5225 /* if no ACK was requested, no feedback is available */
5226
5227 if (!(stats & RT2870_REG_TX_STA_FIFO_ACK_REQ) || wcid == 0xff)
5228 continue;
5229
5230 /* update AMRR statistic */
5231
5232 ok = (stats & RT2870_REG_TX_STA_FIFO_TX_OK) ? 1 : 0;
5233 agg = (stats & RT2870_REG_TX_STA_FIFO_AGG) ? 1 : 0;
5234 mcs = (stats >> RT2870_REG_TX_STA_FIFO_MCS_SHIFT) &
5235 RT2870_REG_TX_STA_FIFO_MCS_MASK;
5236 pid = (stats >> RT2870_REG_TX_STA_FIFO_PID_SHIFT) &
5237 RT2870_REG_TX_STA_FIFO_PID_MASK;
5238 retrycnt = pid - mcs;
5239
5240 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
5241 "%s: FIFO statistic: wcid=0x%02x, ok=%d, agg=%d, mcs=0x%02x, pid=0x%02x, retrycnt=%d\n",
5242 device_get_nameunit(sc->dev),
5243 wcid, ok, agg, mcs, pid, retrycnt);
5244
5245 rt2870_amrr_tx_complete(&sc->amrr_node[wcid], ok, retrycnt);
5246
5247 if (!ok)
5248 ifp->if_oerrors++;
5249 }
5250 }
5251
5252 /*
5253 * rt2870_update_raw_counters
5254 */
5255 static void rt2870_update_raw_counters(struct rt2870_softc *sc)
5256 {
5257 uint32_t tmp;
5258
5259 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT);
5260
5261 sc->tx_nonagg += tmp & 0xffff;
5262 sc->tx_agg += tmp >> 16;
5263
5264 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT0);
5265
5266 sc->tx_ampdu += (tmp & 0xffff) / 1 + (tmp >> 16) / 2;
5267
5268 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT1);
5269
5270 sc->tx_ampdu += (tmp & 0xffff) / 3 + (tmp >> 16) / 4;
5271
5272 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT2);
5273
5274 sc->tx_ampdu += (tmp & 0xffff) / 5 + (tmp >> 16) / 6;
5275
5276 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT3);
5277
5278 sc->tx_ampdu += (tmp & 0xffff) / 7 + (tmp >> 16) / 8;
5279
5280 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT4);
5281
5282 sc->tx_ampdu += (tmp & 0xffff) / 9 + (tmp >> 16) / 10;
5283
5284 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT5);
5285
5286 sc->tx_ampdu += (tmp & 0xffff) / 11 + (tmp >> 16) / 12;
5287
5288 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT6);
5289
5290 sc->tx_ampdu += (tmp & 0xffff) / 13 + (tmp >> 16) / 14;
5291
5292 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT7);
5293
5294 sc->tx_ampdu += (tmp & 0xffff) / 15 + (tmp >> 16) / 16;
5295
5296 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT0);
5297
5298 sc->rx_crc_errors += tmp & 0xffff;
5299 sc->rx_phy_errors += tmp >> 16;
5300
5301 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT1);
5302
5303 sc->rx_false_ccas += tmp & 0xffff;
5304 sc->rx_plcp_errors += tmp >> 16;
5305
5306 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT2);
5307
5308 sc->rx_dup_packets += tmp & 0xffff;
5309 sc->rx_fifo_overflows += tmp >> 16;
5310
5311 tmp = rt2870_io_mac_read(sc, RT2870_REG_TXRX_MPDU_DEN_CNT);
5312
5313 sc->tx_mpdu_zero_density += tmp & 0xffff;
5314 sc->rx_mpdu_zero_density += tmp >> 16;
5315 }
5316
5317 /*
5318 * rt2870_txrx_enable
5319 */
5320 static int rt2870_txrx_enable(struct rt2870_softc *sc)
5321 {
5322 struct ieee80211com *ic;
5323 struct ifnet *ifp;
5324 uint32_t tmp;
5325 int ntries;
5326
5327 ifp = sc->ifp;
5328 ic = ifp->if_l2com;
5329
5330 /* enable Tx/Rx DMA engine */
5331
5332 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_USB_CYC_CFG);
5333
5334 tmp &= 0xffffff00;
5335 tmp |= 0x1e;
5336
5337 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_CYC_CFG, tmp);
5338
5339 if ((sc->mac_rev & 0xffff) != 0x0101)
5340 rt2870_io_mac_write(sc, RT2870_REG_TX_TXOP_CTRL_CFG, 0x583f);
5341
5342 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, RT2870_REG_TX_ENABLE);
5343
5344 for (ntries = 0; ntries < 200; ntries++)
5345 {
5346 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG);
5347 if (!(tmp & (RT2870_REG_TX_DMA_BUSY | RT2870_REG_RX_DMA_BUSY)))
5348 break;
5349
5350 DELAY(1000);
5351 }
5352
5353 if (ntries == 200)
5354 {
5355 printf("%s: timeout waiting for DMA engine\n",
5356 device_get_nameunit(sc->dev));
5357 return -1;
5358 }
5359
5360 DELAY(50);
5361
5362 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP0_CFG, 0);
5363 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP1_CFG,
5364 (48 << 16) | 96);
5365
5366 tmp |= RT2870_REG_TX_WB_DDONE |
5367 RT2870_REG_RX_DMA_ENABLE |
5368 RT2870_REG_TX_DMA_ENABLE;
5369
5370 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
5371
5372 tmp = RT2870_REG_USB_DMA_TX_ENABLE |
5373 RT2870_REG_USB_DMA_RX_ENABLE |
5374 RT2870_REG_USB_DMA_RX_AGG_ENABLE |
5375 /* Rx agg limit in unit of 1024 byte */
5376 ((RT2870_USB_RX_BULK_BUFLEN / 1024 - 3) << RT2870_REG_USB_DMA_RX_AGG_LIMIT_SHIFT) |
5377 /* Rx agg timeout in unit of 33ns */
5378 0x80;
5379
5380 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, tmp);
5381
5382 /* set Rx filter */
5383
5384 tmp = RT2870_REG_RX_FILTER_DROP_CRC_ERR |
5385 RT2870_REG_RX_FILTER_DROP_PHY_ERR;
5386
5387 if (ic->ic_opmode != IEEE80211_M_MONITOR)
5388 {
5389 tmp |= RT2870_REG_RX_FILTER_DROP_DUPL |
5390 RT2870_REG_RX_FILTER_DROP_CTS |
5391 RT2870_REG_RX_FILTER_DROP_BA |
5392 RT2870_REG_RX_FILTER_DROP_ACK |
5393 RT2870_REG_RX_FILTER_DROP_VER_ERR |
5394 RT2870_REG_RX_FILTER_DROP_CTRL_RSV |
5395 RT2870_REG_RX_FILTER_DROP_CFACK |
5396 RT2870_REG_RX_FILTER_DROP_CFEND;
5397
5398 if (ic->ic_opmode == IEEE80211_M_STA)
5399 tmp |= RT2870_REG_RX_FILTER_DROP_RTS |
5400 RT2870_REG_RX_FILTER_DROP_PSPOLL;
5401
5402 if (!(ifp->if_flags & IFF_PROMISC))
5403 tmp |= RT2870_REG_RX_FILTER_DROP_UC_NOME;
5404 }
5405
5406 rt2870_io_mac_write(sc, RT2870_REG_RX_FILTER_CFG, tmp);
5407
5408 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
5409 RT2870_REG_RX_ENABLE | RT2870_REG_TX_ENABLE);
5410
5411 return 0;
5412 }
5413
5414 /*
5415 * rt2870_alloc_rx_ring
5416 */
5417 static int rt2870_alloc_rx_ring(struct rt2870_softc *sc,
5418 struct rt2870_softc_rx_ring *ring)
5419 {
5420 struct rt2870_softc_rx_data *data;
5421 int i, error;
5422
5423 STAILQ_INIT(&ring->inactive);
5424 STAILQ_INIT(&ring->active);
5425 STAILQ_INIT(&ring->done);
5426
5427 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5428 {
5429 data = &ring->data[i];
5430
5431 data->buf = malloc(RT2870_USB_RX_BULK_BUFLEN, M_USBDEV, M_NOWAIT);
5432 if (data->buf == NULL)
5433 {
5434 printf("%s: could not allocate Rx buffer\n",
5435 device_get_nameunit(sc->dev));
5436 error = ENOMEM;
5437 goto fail;
5438 }
5439
5440 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5441 }
5442
5443 return 0;
5444
5445 fail:
5446
5447 rt2870_free_rx_ring(sc, ring);
5448
5449 return error;
5450 }
5451
5452 /*
5453 * rt2870_reset_rx_ring
5454 */
5455 static void rt2870_reset_rx_ring(struct rt2870_softc *sc,
5456 struct rt2870_softc_rx_ring *ring)
5457 {
5458 struct rt2870_softc_rx_data *data;
5459 int i;
5460
5461 STAILQ_INIT(&ring->inactive);
5462 STAILQ_INIT(&ring->active);
5463 STAILQ_INIT(&ring->done);
5464
5465 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5466 {
5467 data = &ring->data[i];
5468
5469 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5470 }
5471 }
5472
5473 /*
5474 * rt2870_free_rx_ring
5475 */
5476 static void rt2870_free_rx_ring(struct rt2870_softc *sc,
5477 struct rt2870_softc_rx_ring *ring)
5478 {
5479 struct rt2870_softc_rx_data *data;
5480 int i;
5481
5482 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5483 {
5484 data = &ring->data[i];
5485
5486 if (data->buf != NULL)
5487 {
5488 free(data->buf, M_USBDEV);
5489 data->buf = NULL;
5490 }
5491 }
5492 }
5493
5494 /*
5495 * rt2870_alloc_tx_ring
5496 */
5497 static int rt2870_alloc_tx_ring(struct rt2870_softc *sc,
5498 struct rt2870_softc_tx_ring *ring, int qid)
5499 {
5500 struct rt2870_softc_tx_data *data;
5501 int i, error;
5502
5503 STAILQ_INIT(&ring->inactive);
5504 STAILQ_INIT(&ring->pending);
5505 STAILQ_INIT(&ring->active);
5506 STAILQ_INIT(&ring->done);
5507
5508 ring->queued = 0;
5509 ring->qid = qid;
5510
5511 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
5512 {
5513 data = &ring->data[i];
5514
5515 data->buf = malloc(RT2870_TX_DESC_SIZE + MJUMPAGESIZE, M_USBDEV, M_NOWAIT);
5516 if (data->buf == NULL)
5517 {
5518 printf("%s: could not allocate Tx buffer\n",
5519 device_get_nameunit(sc->dev));
5520 error = ENOMEM;
5521 goto fail;
5522 }
5523
5524 memset(data->buf, 0, RT2870_TX_DESC_SIZE);
5525
5526 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5527 }
5528
5529 return 0;
5530
5531 fail:
5532
5533 rt2870_free_tx_ring(sc, ring);
5534
5535 return error;
5536 }
5537
5538 /*
5539 * rt2870_reset_tx_ring
5540 */
5541 static void rt2870_reset_tx_ring(struct rt2870_softc *sc,
5542 struct rt2870_softc_tx_ring *ring)
5543 {
5544 struct rt2870_softc_tx_data *data;
5545 int i;
5546
5547 STAILQ_INIT(&ring->inactive);
5548 STAILQ_INIT(&ring->pending);
5549 STAILQ_INIT(&ring->active);
5550 STAILQ_INIT(&ring->done);
5551
5552 ring->queued = 0;
5553
5554 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
5555 {
5556 data = &ring->data[i];
5557
5558 if (data->m != NULL)
5559 {
5560 m_free(data->m);
5561 data->m = NULL;
5562 }
5563
5564 if (data->ni != NULL)
5565 {
5566 ieee80211_free_node(data->ni);
5567 data->ni = NULL;
5568 }
5569
5570 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5571 }
5572 }
5573
5574 /*
5575 * rt2870_free_tx_ring
5576 */
5577 static void rt2870_free_tx_ring(struct rt2870_softc *sc,
5578 struct rt2870_softc_tx_ring *ring)
5579 {
5580 struct rt2870_softc_tx_data *data;
5581 int i;
5582
5583 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
5584 {
5585 data = &ring->data[i];
5586
5587 if (data->buf != NULL)
5588 {
5589 free(data->buf, M_USBDEV);
5590 data->buf = NULL;
5591 }
5592
5593 if (data->m != NULL)
5594 {
5595 m_free(data->m);
5596 data->m = NULL;
5597 }
5598
5599 if (data->ni != NULL)
5600 {
5601 ieee80211_free_node(data->ni);
5602 data->ni = NULL;
5603 }
5604 }
5605 }
5606
5607 /*
5608 * rt2870_reset_cmd_ring
5609 */
5610 static void rt2870_reset_cmd_ring(struct rt2870_softc *sc,
5611 struct rt2870_softc_cmd_ring *ring)
5612 {
5613 struct rt2870_softc_cmd *cmd;
5614 int i;
5615
5616 STAILQ_INIT(&ring->inactive);
5617 STAILQ_INIT(&ring->active);
5618
5619 ring->queued = 0;
5620
5621 for (i = 0; i < RT2870_SOFTC_CMD_RING_CMD_COUNT; i++)
5622 {
5623 cmd = &ring->cmd[i];
5624
5625 STAILQ_INSERT_TAIL(&ring->inactive, cmd, next);
5626 }
5627 }
5628
5629 /*
5630 * rt2870_sysctl_attach
5631 */
5632 static void rt2870_sysctl_attach(struct rt2870_softc *sc)
5633 {
5634 struct sysctl_ctx_list *ctx;
5635 struct sysctl_oid *tree;
5636 struct sysctl_oid *stats;
5637
5638 ctx = device_get_sysctl_ctx(sc->dev);
5639 tree = device_get_sysctl_tree(sc->dev);
5640
5641 stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
5642 "stats", CTLFLAG_RD, 0, "statistic");
5643
5644 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5645 "interrupts", CTLFLAG_RD, &sc->interrupts, 0,
5646 "all interrupts");
5647
5648 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5649 "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0,
5650 "Rx interrupts");
5651
5652 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
5653 {
5654 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5655 "tx_mgmt_interrupts", CTLFLAG_RD, &sc->tx_interrupts[5], 0,
5656 "Tx MGMT interrupts");
5657
5658 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5659 "tx_hcca_interrupts", CTLFLAG_RD, &sc->tx_interrupts[4], 0,
5660 "Tx HCCA interrupts");
5661 }
5662
5663 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5664 "tx_ac3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0,
5665 "Tx AC3 interrupts");
5666
5667 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5668 "tx_ac2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0,
5669 "Tx AC2 interrupts");
5670
5671 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5672 "tx_ac1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0,
5673 "Tx AC1 interrupts");
5674
5675 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5676 "tx_ac0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0,
5677 "Tx AC0 interrupts");
5678
5679 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
5680 {
5681 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5682 "tx_mgmt_data_queued", CTLFLAG_RD, &sc->tx_ring[5].queued, 0,
5683 "Tx MGMT data queued");
5684
5685 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5686 "tx_hcca_data_queued", CTLFLAG_RD, &sc->tx_ring[4].queued, 0,
5687 "Tx HCCA data queued");
5688 }
5689
5690 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5691 "tx_ac3_data_queued", CTLFLAG_RD, &sc->tx_ring[3].queued, 0,
5692 "Tx AC3 data queued");
5693
5694 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5695 "tx_ac2_data_queued", CTLFLAG_RD, &sc->tx_ring[2].queued, 0,
5696 "Tx AC2 data queued");
5697
5698 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5699 "tx_ac1_data_queued", CTLFLAG_RD, &sc->tx_ring[1].queued, 0,
5700 "Tx AC1 data queued");
5701
5702 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5703 "tx_ac0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].queued, 0,
5704 "Tx AC0 data queued");
5705
5706 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
5707 {
5708 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5709 "tx_mgmt_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[5], 0,
5710 "Tx MGMT data queue full");
5711
5712 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5713 "tx_hcca_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[4], 0,
5714 "Tx HCCA data queue full");
5715 }
5716
5717 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5718 "tx_ac3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3], 0,
5719 "Tx AC3 data queue full");
5720
5721 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5722 "tx_ac2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2], 0,
5723 "Tx AC2 data queue full");
5724
5725 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5726 "tx_ac1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1], 0,
5727 "Tx AC1 data queue full");
5728
5729 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5730 "tx_ac0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0], 0,
5731 "Tx AC0 data queue full");
5732
5733 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5734 "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts, 0,
5735 "Tx watchdog timeouts");
5736
5737 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5738 "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors, 0,
5739 "Rx mbuf allocation errors");
5740
5741 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5742 "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0], 0,
5743 "Tx queue 0 not empty");
5744
5745 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5746 "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1], 0,
5747 "Tx queue 1 not empty");
5748
5749 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5750 "tx_beacons", CTLFLAG_RD, &sc->tx_beacons, 0,
5751 "Tx beacons");
5752
5753 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5754 "tx_noretryok", CTLFLAG_RD, &sc->tx_noretryok, 0,
5755 "Tx successfull without retries");
5756
5757 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5758 "tx_retryok", CTLFLAG_RD, &sc->tx_retryok, 0,
5759 "Tx successfull with retries");
5760
5761 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5762 "tx_failed", CTLFLAG_RD, &sc->tx_failed, 0,
5763 "Tx failed");
5764
5765 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5766 "tx_underflows", CTLFLAG_RD, &sc->tx_underflows, 0,
5767 "Tx underflows");
5768
5769 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5770 "tx_zerolen", CTLFLAG_RD, &sc->tx_zerolen, 0,
5771 "Tx zero length");
5772
5773 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5774 "tx_nonagg", CTLFLAG_RD, &sc->tx_nonagg, 0,
5775 "Tx non-aggregated");
5776
5777 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5778 "tx_agg", CTLFLAG_RD, &sc->tx_agg, 0,
5779 "Tx aggregated");
5780
5781 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5782 "tx_ampdu", CTLFLAG_RD, &sc->tx_ampdu, 0,
5783 "Tx A-MPDU");
5784
5785 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5786 "tx_mpdu_zero_density", CTLFLAG_RD, &sc->tx_mpdu_zero_density, 0,
5787 "Tx MPDU with zero density");
5788
5789 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5790 "rx_packets", CTLFLAG_RD, &sc->rx_packets, 0,
5791 "Rx packets");
5792
5793 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5794 "rx_ampdu", CTLFLAG_RD, &sc->rx_ampdu, 0,
5795 "Rx A-MPDU");
5796
5797 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5798 "rx_mpdu_zero_density", CTLFLAG_RD, &sc->rx_mpdu_zero_density, 0,
5799 "Rx MPDU with zero density");
5800
5801 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5802 "rx_amsdu", CTLFLAG_RD, &sc->rx_amsdu, 0,
5803 "Rx A-MSDU");
5804
5805 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5806 "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_errors, 0,
5807 "Rx CRC errors");
5808
5809 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5810 "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_errors, 0,
5811 "Rx PHY errors");
5812
5813 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5814 "rx_false_ccas", CTLFLAG_RD, &sc->rx_false_ccas, 0,
5815 "Rx false CCAs");
5816
5817 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5818 "rx_plcp_errors", CTLFLAG_RD, &sc->rx_plcp_errors, 0,
5819 "Rx PLCP errors");
5820
5821 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5822 "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0,
5823 "Rx duplicate packets");
5824
5825 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5826 "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0,
5827 "Rx FIFO overflows");
5828 }
5829
5830 static device_method_t rt2870_dev_methods[] =
5831 {
5832 DEVMETHOD(device_probe, rt2870_probe),
5833 DEVMETHOD(device_attach, rt2870_attach),
5834 DEVMETHOD(device_detach, rt2870_detach),
5835 { 0, 0 }
5836 };
5837
5838 static driver_t rt2870_driver =
5839 {
5840 "rt2870",
5841 rt2870_dev_methods,
5842 sizeof(struct rt2870_softc),
5843 };
5844
5845 static devclass_t rt2870_dev_class;
5846
5847 DRIVER_MODULE(rt2870, uhub, rt2870_driver, rt2870_dev_class,
5848 NULL, 0);
5849
5850 MODULE_DEPEND(rt2870, usb, 1, 1, 1);
5851 MODULE_DEPEND(rt2870, wlan, 1, 1, 1);
FreeBSD 8 device driver for Ralink rt2870