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