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