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