1/* $NetBSD: if_athn_usb.c,v 1.13 2016/09/05 20:58:51 skrll Exp $ */
2/* $OpenBSD: if_athn_usb.c,v 1.12 2013/01/14 09:50:31 jsing Exp $ */
3
4/*-
5 * Copyright (c) 2011 Damien Bergamini <damien.bergamini@free.fr>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20/*
21 * USB front-end for Atheros AR9271 and AR7010 chipsets.
22 */
23
24#include <sys/cdefs.h>
25__KERNEL_RCSID(0, "$NetBSD: if_athn_usb.c,v 1.13 2016/09/05 20:58:51 skrll Exp $");
26
27#ifdef _KERNEL_OPT
28#include "opt_inet.h"
29#endif
30
31#include <sys/param.h>
32#include <sys/callout.h>
33#include <sys/conf.h>
34#include <sys/device.h>
35#include <sys/kernel.h>
36#include <sys/mbuf.h>
37#include <sys/module.h>
38#include <sys/proc.h>
39#include <sys/socket.h>
40#include <sys/sockio.h>
41#include <sys/systm.h>
42#include <sys/kmem.h>
43
44#include <sys/bus.h>
45#include <sys/endian.h>
46#include <sys/intr.h>
47
48#include <net/bpf.h>
49#include <net/if.h>
50#include <net/if_arp.h>
51#include <net/if_dl.h>
52#include <net/if_ether.h>
53#include <net/if_media.h>
54#include <net/if_types.h>
55
56#include <netinet/if_inarp.h>
57#include <netinet/in.h>
58#include <netinet/in_systm.h>
59#include <netinet/in_var.h>
60#include <netinet/ip.h>
61
62#include <net80211/ieee80211_var.h>
63#include <net80211/ieee80211_amrr.h>
64#include <net80211/ieee80211_radiotap.h>
65
66#include <dev/firmload.h>
67
68#include <dev/usb/usb.h>
69#include <dev/usb/usbdevs.h>
70#include <dev/usb/usbdi.h>
71#include <dev/usb/usbdi_util.h>
72
73#include <dev/ic/athnreg.h>
74#include <dev/ic/athnvar.h>
75#include <dev/ic/arn9285.h>
76#include <dev/usb/if_athn_usb.h>
77
78#define ATHN_USB_SOFTC(sc) ((struct athn_usb_softc *)(sc))
79#define ATHN_USB_NODE(ni) ((struct athn_usb_node *)(ni))
80
81#define IS_UP_AND_RUNNING(ifp) \
82 (((ifp)->if_flags & IFF_UP) && ((ifp)->if_flags & IFF_RUNNING))
83
84#define athn_usb_wmi_cmd(sc, cmd_id) \
85 athn_usb_wmi_xcmd(sc, cmd_id, NULL, 0, NULL)
86
87Static int athn_usb_activate(device_t, enum devact);
88Static int athn_usb_detach(device_t, int);
89Static int athn_usb_match(device_t, cfdata_t, void *);
90Static void athn_usb_attach(device_t, device_t, void *);
91
92CFATTACH_DECL_NEW(athn_usb, sizeof(struct athn_usb_softc), athn_usb_match,
93 athn_usb_attach, athn_usb_detach, athn_usb_activate);
94
95Static int athn_usb_alloc_rx_list(struct athn_usb_softc *);
96Static int athn_usb_alloc_tx_cmd(struct athn_usb_softc *);
97Static int athn_usb_alloc_tx_list(struct athn_usb_softc *);
98Static void athn_usb_attachhook(device_t);
99Static void athn_usb_bcneof(struct usbd_xfer *, void *,
100 usbd_status);
101Static void athn_usb_abort_pipes(struct athn_usb_softc *);
102Static void athn_usb_close_pipes(struct athn_usb_softc *);
103Static int athn_usb_create_hw_node(struct athn_usb_softc *,
104 struct ar_htc_target_sta *);
105Static int athn_usb_create_node(struct athn_usb_softc *,
106 struct ieee80211_node *);
107Static void athn_usb_do_async(struct athn_usb_softc *,
108 void (*)(struct athn_usb_softc *, void *), void *, int);
109Static void athn_usb_free_rx_list(struct athn_usb_softc *);
110Static void athn_usb_free_tx_cmd(struct athn_usb_softc *);
111Static void athn_usb_free_tx_list(struct athn_usb_softc *);
112Static int athn_usb_htc_connect_svc(struct athn_usb_softc *, uint16_t,
113 uint8_t, uint8_t, uint8_t *);
114Static int athn_usb_htc_msg(struct athn_usb_softc *, uint16_t, void *,
115 int);
116Static int athn_usb_htc_setup(struct athn_usb_softc *);
117Static int athn_usb_init(struct ifnet *);
118Static void athn_usb_intr(struct usbd_xfer *, void *,
119 usbd_status);
120Static int athn_usb_ioctl(struct ifnet *, u_long, void *);
121Static int athn_usb_load_firmware(struct athn_usb_softc *);
122Static const struct athn_usb_type *
123 athn_usb_lookup(int, int);
124Static int athn_usb_media_change(struct ifnet *);
125Static void athn_usb_newassoc(struct ieee80211_node *, int);
126Static void athn_usb_newassoc_cb(struct athn_usb_softc *, void *);
127Static int athn_usb_newstate(struct ieee80211com *, enum ieee80211_state,
128 int);
129Static void athn_usb_newstate_cb(struct athn_usb_softc *, void *);
130Static void athn_usb_node_cleanup(struct ieee80211_node *);
131Static void athn_usb_node_cleanup_cb(struct athn_usb_softc *, void *);
132Static int athn_usb_open_pipes(struct athn_usb_softc *);
133Static uint32_t athn_usb_read(struct athn_softc *, uint32_t);
134Static int athn_usb_remove_hw_node(struct athn_usb_softc *, uint8_t *);
135Static void athn_usb_rx_enable(struct athn_softc *);
136Static void athn_usb_rx_frame(struct athn_usb_softc *, struct mbuf *);
137Static void athn_usb_rx_radiotap(struct athn_softc *, struct mbuf *,
138 struct ar_rx_status *);
139Static void athn_usb_rx_wmi_ctrl(struct athn_usb_softc *, uint8_t *, size_t);
140Static void athn_usb_rxeof(struct usbd_xfer *, void *,
141 usbd_status);
142Static void athn_usb_start(struct ifnet *);
143Static void athn_usb_stop(struct ifnet *);
144Static void athn_usb_swba(struct athn_usb_softc *);
145Static int athn_usb_switch_chan(struct athn_softc *,
146 struct ieee80211_channel *, struct ieee80211_channel *);
147Static void athn_usb_task(void *);
148Static int athn_usb_tx(struct athn_softc *, struct mbuf *,
149 struct ieee80211_node *, struct athn_usb_tx_data *);
150Static void athn_usb_txeof(struct usbd_xfer *, void *,
151 usbd_status);
152Static void athn_usb_updateslot(struct ifnet *);
153Static void athn_usb_updateslot_cb(struct athn_usb_softc *, void *);
154Static void athn_usb_wait_async(struct athn_usb_softc *);
155Static void athn_usb_wait_cmd(struct athn_usb_softc *);
156Static void athn_usb_wait_msg(struct athn_usb_softc *);
157Static void athn_usb_wait_wmi(struct athn_usb_softc *);
158Static void athn_usb_watchdog(struct ifnet *);
159Static int athn_usb_wmi_xcmd(struct athn_usb_softc *, uint16_t, void *,
160 int, void *);
161Static void athn_usb_wmieof(struct usbd_xfer *, void *,
162 usbd_status);
163Static void athn_usb_write(struct athn_softc *, uint32_t, uint32_t);
164Static void athn_usb_write_barrier(struct athn_softc *);
165
166/************************************************************************
167 * unused/notyet declarations
168 */
169#ifdef unused
170Static int athn_usb_read_rom(struct athn_softc *);
171#endif /* unused */
172
173#ifdef notyet_edca
174Static void athn_usb_updateedca(struct ieee80211com *);
175Static void athn_usb_updateedca_cb(struct athn_usb_softc *, void *);
176#endif /* notyet_edca */
177
178#ifdef notyet
179Static int athn_usb_ampdu_tx_start(struct ieee80211com *,
180 struct ieee80211_node *, uint8_t);
181Static void athn_usb_ampdu_tx_start_cb(struct athn_usb_softc *, void *);
182Static void athn_usb_ampdu_tx_stop(struct ieee80211com *,
183 struct ieee80211_node *, uint8_t);
184Static void athn_usb_ampdu_tx_stop_cb(struct athn_usb_softc *, void *);
185Static void athn_usb_delete_key(struct ieee80211com *,
186 struct ieee80211_node *, struct ieee80211_key *);
187Static void athn_usb_delete_key_cb(struct athn_usb_softc *, void *);
188Static int athn_usb_set_key(struct ieee80211com *,
189 struct ieee80211_node *, struct ieee80211_key *);
190Static void athn_usb_set_key_cb(struct athn_usb_softc *, void *);
191#endif /* notyet */
192/************************************************************************/
193
194struct athn_usb_type {
195 struct usb_devno devno;
196 u_int flags;
197};
198
199Static const struct athn_usb_type *
200athn_usb_lookup(int vendor, int product)
201{
202 static const struct athn_usb_type athn_usb_devs[] = {
203#define _D(v,p,f) \
204 {{ USB_VENDOR_##v, USB_PRODUCT_##p }, ATHN_USB_FLAG_##f }
205
206 _D( ACCTON, ACCTON_AR9280, AR7010 ),
207 _D( ACTIONTEC, ACTIONTEC_AR9287, AR7010 ),
208 _D( ATHEROS2, ATHEROS2_AR9271_1, NONE ),
209 _D( ATHEROS2, ATHEROS2_AR9271_2, NONE ),
210 _D( ATHEROS2, ATHEROS2_AR9271_3, NONE ),
211 _D( ATHEROS2, ATHEROS2_AR9280, AR7010 ),
212 _D( ATHEROS2, ATHEROS2_AR9287, AR7010 ),
213 _D( AZUREWAVE, AZUREWAVE_AR9271_1, NONE ),
214 _D( AZUREWAVE, AZUREWAVE_AR9271_2, NONE ),
215 _D( AZUREWAVE, AZUREWAVE_AR9271_3, NONE ),
216 _D( AZUREWAVE, AZUREWAVE_AR9271_4, NONE ),
217 _D( AZUREWAVE, AZUREWAVE_AR9271_5, NONE ),
218 _D( AZUREWAVE, AZUREWAVE_AR9271_6, NONE ),
219 _D( DLINK2, DLINK2_AR9271, NONE ),
220 _D( LITEON, LITEON_AR9271, NONE ),
221 _D( NETGEAR, NETGEAR_WNA1100, NONE ),
222 _D( NETGEAR, NETGEAR_WNDA3200, AR7010 ),
223 _D( VIA, VIA_AR9271, NONE )
224#undef _D
225 };
226
227 return (const void *)usb_lookup(athn_usb_devs, vendor, product);
228}
229
230Static int
231athn_usb_match(device_t parent, cfdata_t match, void *aux)
232{
233 struct usb_attach_arg *uaa = aux;
234
235 return athn_usb_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
236 UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
237}
238
239Static void
240athn_usb_attach(device_t parent, device_t self, void *aux)
241{
242 struct athn_usb_softc *usc;
243 struct athn_softc *sc;
244 struct usb_attach_arg *uaa;
245 int error;
246
247 usc = device_private(self);
248 sc = &usc->usc_sc;
249 uaa = aux;
250 sc->sc_dev = self;
251 usc->usc_udev = uaa->uaa_device;
252
253 aprint_naive("\n");
254 aprint_normal("\n");
255
256 DPRINTFN(DBG_FN, sc, "\n");
257
258 usc->usc_athn_attached = 0;
259 usc->usc_flags = athn_usb_lookup(uaa->uaa_vendor, uaa->uaa_product)->flags;
260 sc->sc_flags |= ATHN_FLAG_USB;
261#ifdef notyet
262 /* Check if it is a combo WiFi+Bluetooth (WB193) device. */
263 if (strncmp(product, "wb193", 5) == 0)
264 sc->sc_flags |= ATHN_FLAG_BTCOEX3WIRE;
265#endif
266
267 sc->sc_ops.read = athn_usb_read;
268 sc->sc_ops.write = athn_usb_write;
269 sc->sc_ops.write_barrier = athn_usb_write_barrier;
270
271 cv_init(&usc->usc_task_cv, "athntsk");
272 mutex_init(&usc->usc_task_mtx, MUTEX_DEFAULT, IPL_NET);
273 mutex_init(&usc->usc_tx_mtx, MUTEX_DEFAULT, IPL_NONE);
274
275 usb_init_task(&usc->usc_task, athn_usb_task, usc, 0);
276
277 if (usbd_set_config_no(usc->usc_udev, 1, 0) != 0) {
278 aprint_error_dev(sc->sc_dev,
279 "could not set configuration no\n");
280 goto fail;
281 }
282
283 /* Get the first interface handle. */
284 error = usbd_device2interface_handle(usc->usc_udev, 0, &usc->usc_iface);
285 if (error != 0) {
286 aprint_error_dev(sc->sc_dev,
287 "could not get interface handle\n");
288 goto fail;
289 }
290
291 if (athn_usb_open_pipes(usc) != 0)
292 goto fail;
293
294 /* Allocate xfer for firmware commands. */
295 if (athn_usb_alloc_tx_cmd(usc) != 0)
296 goto fail;
297
298 /* Allocate Tx/Rx buffers. */
299 error = athn_usb_alloc_rx_list(usc);
300 if (error != 0)
301 goto fail;
302 error = athn_usb_alloc_tx_list(usc);
303 if (error != 0)
304 goto fail;
305
306 config_mountroot(self, athn_usb_attachhook);
307
308 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, usc->usc_udev, sc->sc_dev);
309 return;
310
311 fail:
312 /* Free Tx/Rx buffers. */
313 athn_usb_abort_pipes(usc);
314 athn_usb_free_tx_list(usc);
315 athn_usb_free_rx_list(usc);
316 athn_usb_free_tx_cmd(usc);
317 athn_usb_close_pipes(usc);
318 usb_rem_task(usc->usc_udev, &usc->usc_task);
319 mutex_destroy(&usc->usc_tx_mtx);
320 mutex_destroy(&usc->usc_task_mtx);
321}
322
323Static void
324athn_usb_node_cleanup_cb(struct athn_usb_softc *usc, void *arg)
325{
326 uint8_t sta_index = *(uint8_t *)arg;
327
328 DPRINTFN(DBG_FN, usc, "\n");
329 DPRINTFN(DBG_NODES, usc, "removing node %u\n", sta_index);
330 athn_usb_remove_hw_node(usc, &sta_index);
331}
332
333Static void
334athn_usb_node_cleanup(struct ieee80211_node *ni)
335{
336 struct athn_usb_softc *usc;
337 struct ieee80211com *ic;
338 uint8_t sta_index;
339
340 usc = ATHN_USB_SOFTC(ni->ni_ic->ic_ifp->if_softc);
341 ic = &ATHN_SOFTC(usc)->sc_ic;
342
343 DPRINTFN(DBG_FN, usc, "\n");
344
345 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
346 sta_index = ATHN_NODE(ni)->sta_index;
347 if (sta_index != 0)
348 athn_usb_do_async(usc, athn_usb_node_cleanup_cb,
349 &sta_index, sizeof(sta_index));
350 }
351 usc->usc_node_cleanup(ni);
352}
353
354Static void
355athn_usb_attachhook(device_t arg)
356{
357 struct athn_usb_softc *usc = device_private(arg);
358 struct athn_softc *sc = &usc->usc_sc;
359 struct athn_ops *ops = &sc->sc_ops;
360 struct ieee80211com *ic = &sc->sc_ic;
361 struct ifnet *ifp = &sc->sc_if;
362 size_t i;
363 int s, error;
364
365 if (usc->usc_dying)
366 return;
367
368 DPRINTFN(DBG_FN, usc, "\n");
369
370 /* Load firmware. */
371 error = athn_usb_load_firmware(usc);
372 if (error != 0) {
373 aprint_error_dev(sc->sc_dev,
374 "could not load firmware (%d)\n", error);
375 return;
376 }
377
378 /* Setup the host transport communication interface. */
379 error = athn_usb_htc_setup(usc);
380 if (error != 0)
381 return;
382
383 /* We're now ready to attach the bus agnostic driver. */
384 s = splnet();
385 ic->ic_ifp = ifp;
386 ic->ic_updateslot = athn_usb_updateslot;
387 sc->sc_max_aid = AR_USB_MAX_STA; /* Firmware is limited to 8 STA */
388 sc->sc_media_change = athn_usb_media_change;
389 error = athn_attach(sc);
390 if (error != 0) {
391 splx(s);
392 return;
393 }
394 usc->usc_athn_attached = 1;
395
396 /* Override some operations for USB. */
397 ifp->if_init = athn_usb_init;
398 ifp->if_ioctl = athn_usb_ioctl;
399 ifp->if_start = athn_usb_start;
400 ifp->if_watchdog = athn_usb_watchdog;
401
402 /* hooks for HostAP association and disassociation */
403 ic->ic_newassoc = athn_usb_newassoc;
404 usc->usc_node_cleanup = ic->ic_node_cleanup;
405 ic->ic_node_cleanup = athn_usb_node_cleanup;
406
407#ifdef notyet_edca
408 ic->ic_updateedca = athn_usb_updateedca;
409#endif
410#ifdef notyet
411 ic->ic_set_key = athn_usb_set_key;
412 ic->ic_delete_key = athn_usb_delete_key;
413 ic->ic_ampdu_tx_start = athn_usb_ampdu_tx_start;
414 ic->ic_ampdu_tx_stop = athn_usb_ampdu_tx_stop;
415#endif
416 ic->ic_newstate = athn_usb_newstate;
417
418 ops->rx_enable = athn_usb_rx_enable;
419 splx(s);
420
421 /* Reset HW key cache entries. */
422 for (i = 0; i < sc->sc_kc_entries; i++)
423 athn_reset_key(sc, i);
424
425 ops->enable_antenna_diversity(sc);
426
427#ifdef ATHN_BT_COEXISTENCE
428 /* Configure bluetooth coexistence for combo chips. */
429 if (sc->sc_flags & ATHN_FLAG_BTCOEX)
430 athn_btcoex_init(sc);
431#endif
432 /* Configure LED. */
433 athn_led_init(sc);
434
435 ieee80211_announce(ic);
436}
437
438Static int
439athn_usb_detach(device_t self, int flags)
440{
441 struct athn_usb_softc *usc = device_private(self);
442 struct athn_softc *sc = &usc->usc_sc;
443 int s;
444
445 DPRINTFN(DBG_FN, usc, "\n");
446
447 s = splusb();
448 usc->usc_dying = 1;
449
450 athn_usb_wait_wmi(usc);
451 athn_usb_wait_cmd(usc);
452 athn_usb_wait_msg(usc);
453 athn_usb_wait_async(usc);
454
455 usb_rem_task(usc->usc_udev, &usc->usc_task);
456
457 if (usc->usc_athn_attached) {
458 usc->usc_athn_attached = 0;
459 athn_detach(sc);
460 }
461 /* Abort Tx/Rx pipes. */
462 athn_usb_abort_pipes(usc);
463 splx(s);
464
465 /* Free Tx/Rx buffers. */
466 athn_usb_free_rx_list(usc);
467 athn_usb_free_tx_list(usc);
468 athn_usb_free_tx_cmd(usc);
469
470 /* Close Tx/Rx pipes. */
471 athn_usb_close_pipes(usc);
472
473 mutex_destroy(&usc->usc_tx_mtx);
474 mutex_destroy(&usc->usc_task_mtx);
475 cv_destroy(&usc->usc_task_cv);
476
477 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, usc->usc_udev, sc->sc_dev);
478 return 0;
479}
480
481Static int
482athn_usb_activate(device_t self, enum devact act)
483{
484 struct athn_usb_softc *usc = device_private(self);
485 struct athn_softc *sc = &usc->usc_sc;
486
487 DPRINTFN(DBG_FN, usc, "\n");
488
489 switch (act) {
490 case DVACT_DEACTIVATE:
491 if_deactivate(sc->sc_ic.ic_ifp);
492 usc->usc_dying = 1;
493 return 0;
494 default:
495 return EOPNOTSUPP;
496 }
497}
498
499Static int
500athn_usb_open_pipes(struct athn_usb_softc *usc)
501{
502 usb_endpoint_descriptor_t *ed;
503 int error;
504
505 DPRINTFN(DBG_FN, usc, "\n");
506
507 error = usbd_open_pipe(usc->usc_iface, AR_PIPE_TX_DATA, 0,
508 &usc->usc_tx_data_pipe);
509 if (error != 0) {
510 aprint_error_dev(usc->usc_dev,
511 "could not open Tx bulk pipe\n");
512 goto fail;
513 }
514
515 error = usbd_open_pipe(usc->usc_iface, AR_PIPE_RX_DATA, 0,
516 &usc->usc_rx_data_pipe);
517 if (error != 0) {
518 aprint_error_dev(usc->usc_dev,
519 "could not open Rx bulk pipe\n");
520 goto fail;
521 }
522
523 ed = usbd_get_endpoint_descriptor(usc->usc_iface, AR_PIPE_RX_INTR);
524 if (ed == NULL) {
525 aprint_error_dev(usc->usc_dev,
526 "could not retrieve Rx intr pipe descriptor\n");
527 goto fail;
528 }
529 usc->usc_ibufsize = UGETW(ed->wMaxPacketSize);
530 if (usc->usc_ibufsize == 0) {
531 aprint_error_dev(usc->usc_dev,
532 "invalid Rx intr pipe descriptor\n");
533 goto fail;
534 }
535 usc->usc_ibuf = kmem_alloc(usc->usc_ibufsize, KM_SLEEP);
536 if (usc->usc_ibuf == NULL) {
537 aprint_error_dev(usc->usc_dev,
538 "could not allocate Rx intr buffer\n");
539 goto fail;
540 }
541
542 error = usbd_open_pipe_intr(usc->usc_iface, AR_PIPE_RX_INTR,
543 USBD_SHORT_XFER_OK, &usc->usc_rx_intr_pipe, usc, usc->usc_ibuf,
544 usc->usc_ibufsize, athn_usb_intr, USBD_DEFAULT_INTERVAL);
545 if (error != 0) {
546 aprint_error_dev(usc->usc_dev,
547 "could not open Rx intr pipe\n");
548 goto fail;
549 }
550 error = usbd_open_pipe(usc->usc_iface, AR_PIPE_TX_INTR, 0,
551 &usc->usc_tx_intr_pipe);
552 if (error != 0) {
553 aprint_error_dev(usc->usc_dev,
554 "could not open Tx intr pipe\n");
555 goto fail;
556 }
557 return 0;
558 fail:
559 athn_usb_abort_pipes(usc);
560 athn_usb_close_pipes(usc);
561 return error;
562}
563
564static inline void
565athn_usb_kill_pipe(struct usbd_pipe **pipeptr)
566{
567 struct usbd_pipe *pipe;
568
569 CTASSERT(sizeof(pipe) == sizeof(void *));
570 pipe = atomic_swap_ptr(pipeptr, NULL);
571 if (pipe != NULL) {
572 usbd_close_pipe(pipe);
573 }
574}
575
576Static void
577athn_usb_abort_pipes(struct athn_usb_softc *usc)
578{
579 DPRINTFN(DBG_FN, usc, "\n");
580
581 if (usc->usc_tx_data_pipe != NULL)
582 usbd_abort_pipe(usc->usc_tx_data_pipe);
583 if (usc->usc_rx_data_pipe != NULL)
584 usbd_abort_pipe(usc->usc_rx_data_pipe);
585 if (usc->usc_tx_intr_pipe != NULL)
586 usbd_abort_pipe(usc->usc_tx_intr_pipe);
587 if (usc->usc_rx_intr_pipe != NULL)
588 usbd_abort_pipe(usc->usc_rx_intr_pipe);
589}
590
591Static void
592athn_usb_close_pipes(struct athn_usb_softc *usc)
593{
594 uint8_t *ibuf;
595
596 DPRINTFN(DBG_FN, usc, "\n");
597
598 athn_usb_kill_pipe(&usc->usc_tx_data_pipe);
599 athn_usb_kill_pipe(&usc->usc_rx_data_pipe);
600 athn_usb_kill_pipe(&usc->usc_tx_intr_pipe);
601 athn_usb_kill_pipe(&usc->usc_rx_intr_pipe);
602 ibuf = atomic_swap_ptr(&usc->usc_ibuf, NULL);
603 if (ibuf != NULL)
604 kmem_free(ibuf, usc->usc_ibufsize);
605}
606
607Static int
608athn_usb_alloc_rx_list(struct athn_usb_softc *usc)
609{
610 struct athn_usb_rx_data *data;
611 size_t i;
612 int error = 0;
613
614 DPRINTFN(DBG_FN, usc, "\n");
615
616 for (i = 0; i < ATHN_USB_RX_LIST_COUNT; i++) {
617 data = &usc->usc_rx_data[i];
618
619 data->sc = usc; /* Backpointer for callbacks. */
620
621 error = usbd_create_xfer(usc->usc_rx_data_pipe,
622 ATHN_USB_RXBUFSZ, USBD_SHORT_XFER_OK, 0, &data->xfer);
623 if (error) {
624 aprint_error_dev(usc->usc_dev,
625 "could not allocate xfer\n");
626 break;
627 }
628 data->buf = usbd_get_buffer(data->xfer);
629 }
630 if (error != 0)
631 athn_usb_free_rx_list(usc);
632 return error;
633}
634
635Static void
636athn_usb_free_rx_list(struct athn_usb_softc *usc)
637{
638 struct usbd_xfer *xfer;
639 size_t i;
640
641 DPRINTFN(DBG_FN, usc, "\n");
642
643 /* NB: Caller must abort pipe first. */
644 for (i = 0; i < ATHN_USB_RX_LIST_COUNT; i++) {
645 CTASSERT(sizeof(xfer) == sizeof(void *));
646 xfer = atomic_swap_ptr(&usc->usc_rx_data[i].xfer, NULL);
647 if (xfer != NULL)
648 usbd_destroy_xfer(xfer);
649 }
650}
651
652Static int
653athn_usb_alloc_tx_list(struct athn_usb_softc *usc)
654{
655 struct athn_usb_tx_data *data;
656 size_t i;
657 int error = 0;
658
659 DPRINTFN(DBG_FN, usc, "\n");
660
661 mutex_enter(&usc->usc_tx_mtx);
662 TAILQ_INIT(&usc->usc_tx_free_list);
663 for (i = 0; i < ATHN_USB_TX_LIST_COUNT; i++) {
664 data = &usc->usc_tx_data[i];
665
666 data->sc = usc; /* Backpointer for callbacks. */
667
668 error = usbd_create_xfer(usc->usc_tx_data_pipe,
669 ATHN_USB_TXBUFSZ, USBD_SHORT_XFER_OK, 0, &data->xfer);
670 if (error) {
671 aprint_error_dev(usc->usc_dev,
672 "could not create xfer on TX pipe\n");
673 break;
674 }
675 data->buf = usbd_get_buffer(data->xfer);
676
677 /* Append this Tx buffer to our free list. */
678 TAILQ_INSERT_TAIL(&usc->usc_tx_free_list, data, next);
679 }
680 if (error != 0)
681 athn_usb_free_tx_list(usc);
682 mutex_exit(&usc->usc_tx_mtx);
683 return error;
684}
685
686Static void
687athn_usb_free_tx_list(struct athn_usb_softc *usc)
688{
689 struct usbd_xfer *xfer;
690 size_t i;
691
692 DPRINTFN(DBG_FN, usc, "\n");
693
694 /* NB: Caller must abort pipe first. */
695 for (i = 0; i < ATHN_USB_TX_LIST_COUNT; i++) {
696 CTASSERT(sizeof(xfer) == sizeof(void *));
697 xfer = atomic_swap_ptr(&usc->usc_tx_data[i].xfer, NULL);
698 if (xfer != NULL)
699 usbd_destroy_xfer(xfer);
700 }
701}
702
703Static int
704athn_usb_alloc_tx_cmd(struct athn_usb_softc *usc)
705{
706 struct athn_usb_tx_data *data = &usc->usc_tx_cmd;
707
708 DPRINTFN(DBG_FN, usc, "\n");
709
710 data->sc = usc; /* Backpointer for callbacks. */
711
712 int err = usbd_create_xfer(usc->usc_tx_intr_pipe, ATHN_USB_TXCMDSZ,
713 0, 0, &data->xfer);
714 if (err) {
715 aprint_error_dev(usc->usc_dev,
716 "could not allocate command xfer\n");
717 return err;
718 }
719 data->buf = usbd_get_buffer(data->xfer);
720
721 return 0;
722}
723
724Static void
725athn_usb_free_tx_cmd(struct athn_usb_softc *usc)
726{
727 struct usbd_xfer *xfer;
728
729 DPRINTFN(DBG_FN, usc, "\n");
730
731 CTASSERT(sizeof(xfer) == sizeof(void *));
732 xfer = atomic_swap_ptr(&usc->usc_tx_cmd.xfer, NULL);
733 if (xfer != NULL)
734 usbd_destroy_xfer(xfer);
735}
736
737Static void
738athn_usb_task(void *arg)
739{
740 struct athn_usb_softc *usc = arg;
741 struct athn_usb_host_cmd_ring *ring = &usc->usc_cmdq;
742 struct athn_usb_host_cmd *cmd;
743 int s;
744
745 DPRINTFN(DBG_FN, usc, "\n");
746
747 /* Process host commands. */
748 s = splusb();
749 mutex_spin_enter(&usc->usc_task_mtx);
750 while (ring->next != ring->cur) {
751 cmd = &ring->cmd[ring->next];
752 mutex_spin_exit(&usc->usc_task_mtx);
753 splx(s);
754
755 /* Invoke callback. */
756 if (!usc->usc_dying)
757 cmd->cb(usc, cmd->data);
758
759 s = splusb();
760 mutex_spin_enter(&usc->usc_task_mtx);
761 ring->queued--;
762 ring->next = (ring->next + 1) % ATHN_USB_HOST_CMD_RING_COUNT;
763 }
764 mutex_spin_exit(&usc->usc_task_mtx);
765 wakeup(ring);
766 splx(s);
767}
768
769Static void
770athn_usb_do_async(struct athn_usb_softc *usc,
771 void (*cb)(struct athn_usb_softc *, void *), void *arg, int len)
772{
773 struct athn_usb_host_cmd_ring *ring = &usc->usc_cmdq;
774 struct athn_usb_host_cmd *cmd;
775 int s;
776
777 if (usc->usc_dying)
778 return;
779
780 DPRINTFN(DBG_FN, usc, "\n");
781
782 s = splusb();
783 mutex_spin_enter(&usc->usc_task_mtx);
784 cmd = &ring->cmd[ring->cur];
785 cmd->cb = cb;
786 KASSERT(len <= sizeof(cmd->data));
787 memcpy(cmd->data, arg, len);
788 ring->cur = (ring->cur + 1) % ATHN_USB_HOST_CMD_RING_COUNT;
789
790 /* If there is no pending command already, schedule a task. */
791 if (++ring->queued == 1) {
792 mutex_spin_exit(&usc->usc_task_mtx);
793 usb_add_task(usc->usc_udev, &usc->usc_task, USB_TASKQ_DRIVER);
794 }
795 else
796 mutex_spin_exit(&usc->usc_task_mtx);
797 splx(s);
798}
799
800Static void
801athn_usb_wait_async(struct athn_usb_softc *usc)
802{
803
804 DPRINTFN(DBG_FN, usc, "\n");
805
806 /* Wait for all queued asynchronous commands to complete. */
807 mutex_spin_enter(&usc->usc_task_mtx);
808 while (usc->usc_cmdq.queued > 0)
809 cv_wait(&usc->usc_task_cv, &usc->usc_task_mtx);
810 mutex_spin_exit(&usc->usc_task_mtx);
811}
812
813Static int
814athn_usb_load_firmware(struct athn_usb_softc *usc)
815{
816 struct athn_softc *sc = &usc->usc_sc;
817 firmware_handle_t fwh;
818 usb_device_descriptor_t *dd;
819 usb_device_request_t req;
820 const char *name;
821 u_char *fw, *ptr;
822 size_t size, remain;
823 uint32_t addr;
824 int s, mlen, error;
825
826 DPRINTFN(DBG_FN, sc, "\n");
827
828 /* Determine which firmware image to load. */
829 if (usc->usc_flags & ATHN_USB_FLAG_AR7010) {
830 dd = usbd_get_device_descriptor(usc->usc_udev);
831 if (UGETW(dd->bcdDevice) == 0x0202)
832 name = "athn-ar7010-11";
833 else
834 name = "athn-ar7010";
835 }
836 else
837 name = "athn-ar9271";
838
839 /* Read firmware image from the filesystem. */
840 if ((error = firmware_open("if_athn", name, &fwh)) != 0) {
841 aprint_error_dev(sc->sc_dev,
842 "failed to open firmware file %s (%d)\n", name, error);
843 return error;
844 }
845 size = firmware_get_size(fwh);
846 fw = firmware_malloc(size);
847 if (fw == NULL) {
848 aprint_error_dev(usc->usc_dev,
849 "failed to allocate firmware memory\n");
850 firmware_close(fwh);
851 return ENOMEM;
852 }
853 error = firmware_read(fwh, 0, fw, size);
854 firmware_close(fwh);
855 if (error != 0) {
856 aprint_error_dev(usc->usc_dev,
857 "failed to read firmware (error %d)\n", error);
858 firmware_free(fw, size);
859 return error;
860 }
861
862 /* Load firmware image. */
863 ptr = fw;
864 addr = AR9271_FIRMWARE >> 8;
865 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
866 req.bRequest = AR_FW_DOWNLOAD;
867 USETW(req.wIndex, 0);
868 remain = size;
869 while (remain > 0) {
870 mlen = MIN(remain, 4096);
871
872 USETW(req.wValue, addr);
873 USETW(req.wLength, mlen);
874 error = usbd_do_request(usc->usc_udev, &req, ptr);
875 if (error != 0) {
876 firmware_free(fw, size);
877 return error;
878 }
879 addr += mlen >> 8;
880 ptr += mlen;
881 remain -= mlen;
882 }
883 firmware_free(fw, size);
884
885 /* Start firmware. */
886 if (usc->usc_flags & ATHN_USB_FLAG_AR7010)
887 addr = AR7010_FIRMWARE_TEXT >> 8;
888 else
889 addr = AR9271_FIRMWARE_TEXT >> 8;
890 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
891 req.bRequest = AR_FW_DOWNLOAD_COMP;
892 USETW(req.wIndex, 0);
893 USETW(req.wValue, addr);
894 USETW(req.wLength, 0);
895
896 s = splusb();
897 usc->usc_wait_msg_id = AR_HTC_MSG_READY;
898 error = usbd_do_request(usc->usc_udev, &req, NULL);
899 /* Wait at most 1 second for firmware to boot. */
900 if (error == 0 && usc->usc_wait_msg_id != 0)
901 error = tsleep(&usc->usc_wait_msg_id, 0, "athnfw", hz);
902 usc->usc_wait_msg_id = 0;
903 splx(s);
904 return error;
905}
906
907Static int
908athn_usb_htc_msg(struct athn_usb_softc *usc, uint16_t msg_id, void *buf,
909 int len)
910{
911 struct athn_usb_tx_data *data = &usc->usc_tx_cmd;
912 struct ar_htc_frame_hdr *htc;
913 struct ar_htc_msg_hdr *msg;
914
915 if (usc->usc_dying)
916 return USBD_CANCELLED;
917
918 DPRINTFN(DBG_FN, usc, "\n");
919
920 htc = (struct ar_htc_frame_hdr *)data->buf;
921 memset(htc, 0, sizeof(*htc));
922 htc->endpoint_id = 0;
923 htc->payload_len = htobe16(sizeof(*msg) + len);
924
925 msg = (struct ar_htc_msg_hdr *)&htc[1];
926 msg->msg_id = htobe16(msg_id);
927
928 memcpy(&msg[1], buf, len);
929
930 usbd_setup_xfer(data->xfer, NULL, data->buf,
931 sizeof(*htc) + sizeof(*msg) + len,
932 USBD_SHORT_XFER_OK, ATHN_USB_CMD_TIMEOUT, NULL);
933 return usbd_sync_transfer(data->xfer);
934}
935
936Static int
937athn_usb_htc_setup(struct athn_usb_softc *usc)
938{
939 struct ar_htc_msg_config_pipe cfg;
940 int s, error;
941
942 /*
943 * Connect WMI services to USB pipes.
944 */
945 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_CONTROL,
946 AR_PIPE_TX_INTR, AR_PIPE_RX_INTR, &usc->usc_ep_ctrl);
947 if (error != 0)
948 return error;
949 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_BEACON,
950 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_bcn);
951 if (error != 0)
952 return error;
953 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_CAB,
954 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_cab);
955 if (error != 0)
956 return error;
957 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_UAPSD,
958 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_uapsd);
959 if (error != 0)
960 return error;
961 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_MGMT,
962 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_mgmt);
963 if (error != 0)
964 return error;
965 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_BE,
966 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_BE]);
967 if (error != 0)
968 return error;
969 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_BK,
970 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_BK]);
971 if (error != 0)
972 return error;
973 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_VI,
974 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_VI]);
975 if (error != 0)
976 return error;
977 error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_VO,
978 AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_VO]);
979 if (error != 0)
980 return error;
981
982 /* Set credits for WLAN Tx pipe. */
983 memset(&cfg, 0, sizeof(cfg));
984 cfg.pipe_id = UE_GET_ADDR(AR_PIPE_TX_DATA);
985 cfg.credits = (usc->usc_flags & ATHN_USB_FLAG_AR7010) ? 45 : 33;
986
987 s = splusb();
988
989 usc->usc_wait_msg_id = AR_HTC_MSG_CONF_PIPE_RSP;
990 error = athn_usb_htc_msg(usc, AR_HTC_MSG_CONF_PIPE, &cfg, sizeof(cfg));
991 if (error == 0 && usc->usc_wait_msg_id != 0)
992 error = tsleep(&usc->usc_wait_msg_id, 0, "athnhtc", hz);
993 usc->usc_wait_msg_id = 0;
994
995 splx(s);
996
997 if (error != 0) {
998 aprint_error_dev(usc->usc_dev, "could not configure pipe\n");
999 return error;
1000 }
1001
1002 error = athn_usb_htc_msg(usc, AR_HTC_MSG_SETUP_COMPLETE, NULL, 0);
1003 if (error != 0) {
1004 aprint_error_dev(usc->usc_dev, "could not complete setup\n");
1005 return error;
1006 }
1007 return 0;
1008}
1009
1010Static int
1011athn_usb_htc_connect_svc(struct athn_usb_softc *usc, uint16_t svc_id,
1012 uint8_t ul_pipe, uint8_t dl_pipe, uint8_t *endpoint_id)
1013{
1014 struct ar_htc_msg_conn_svc msg;
1015 struct ar_htc_msg_conn_svc_rsp rsp;
1016 int s, error;
1017
1018 DPRINTFN(DBG_FN, usc, "\n");
1019
1020 memset(&msg, 0, sizeof(msg));
1021 msg.svc_id = htobe16(svc_id);
1022 msg.dl_pipeid = UE_GET_ADDR(dl_pipe);
1023 msg.ul_pipeid = UE_GET_ADDR(ul_pipe);
1024 s = splusb();
1025
1026 usc->usc_msg_conn_svc_rsp = &rsp;
1027
1028 usc->usc_wait_msg_id = AR_HTC_MSG_CONN_SVC_RSP;
1029 error = athn_usb_htc_msg(usc, AR_HTC_MSG_CONN_SVC, &msg, sizeof(msg));
1030 if (error == 0 && usc->usc_wait_msg_id != 0)
1031 error = tsleep(&usc->usc_wait_msg_id, 0, "athnhtc", hz);
1032 usc->usc_wait_msg_id = 0;
1033
1034 splx(s);
1035 if (error != 0) {
1036 aprint_error_dev(usc->usc_dev,
1037 "error waiting for service %d connection\n", svc_id);
1038 return error;
1039 }
1040 if (rsp.status != AR_HTC_SVC_SUCCESS) {
1041 aprint_error_dev(usc->usc_dev,
1042 "service %d connection failed, error %d\n",
1043 svc_id, rsp.status);
1044 return EIO;
1045 }
1046 DPRINTFN(DBG_INIT, usc,
1047 "service %d successfully connected to endpoint %d\n",
1048 svc_id, rsp.endpoint_id);
1049
1050 /* Return endpoint id. */
1051 *endpoint_id = rsp.endpoint_id;
1052 return 0;
1053}
1054
1055Static void
1056athn_usb_wait_msg(struct athn_usb_softc *usc)
1057{
1058
1059 DPRINTFN(DBG_FN, usc, "\n");
1060
1061 while (__predict_false(usc->usc_wait_msg_id))
1062 tsleep(&usc->usc_wait_msg_id, 0, "athnmsg", hz);
1063}
1064
1065Static void
1066athn_usb_wait_cmd(struct athn_usb_softc *usc)
1067{
1068
1069 DPRINTFN(DBG_FN, usc, "\n");
1070
1071 while (__predict_false(usc->usc_wait_cmd_id))
1072 tsleep(&usc->usc_wait_cmd_id, 0, "athncmd", hz);
1073}
1074
1075Static void
1076athn_usb_wmieof(struct usbd_xfer *xfer, void * priv,
1077 usbd_status status)
1078{
1079 struct athn_usb_softc *usc = priv;
1080
1081 DPRINTFN(DBG_FN, usc, "\n");
1082
1083 if (__predict_false(status == USBD_STALLED))
1084 usbd_clear_endpoint_stall_async(usc->usc_tx_intr_pipe);
1085
1086 usc->usc_wmi_done = 1;
1087 wakeup(&usc->usc_wmi_done);
1088}
1089
1090Static int
1091athn_usb_wmi_xcmd(struct athn_usb_softc *usc, uint16_t cmd_id, void *ibuf,
1092 int ilen, void *obuf)
1093{
1094 struct athn_usb_tx_data *data = &usc->usc_tx_cmd;
1095 struct ar_htc_frame_hdr *htc;
1096 struct ar_wmi_cmd_hdr *wmi;
1097 int s, error;
1098
1099 if (usc->usc_dying)
1100 return EIO;
1101
1102 DPRINTFN(DBG_FN, usc, "\n");
1103
1104 htc = (struct ar_htc_frame_hdr *)data->buf;
1105 memset(htc, 0, sizeof(*htc));
1106 htc->endpoint_id = usc->usc_ep_ctrl;
1107 htc->payload_len = htobe16(sizeof(*wmi) + ilen);
1108
1109 wmi = (struct ar_wmi_cmd_hdr *)&htc[1];
1110 wmi->cmd_id = htobe16(cmd_id);
1111 usc->usc_wmi_seq_no++;
1112 wmi->seq_no = htobe16(usc->usc_wmi_seq_no);
1113
1114 memcpy(&wmi[1], ibuf, ilen);
1115
1116 usbd_setup_xfer(data->xfer, usc, data->buf,
1117 sizeof(*htc) + sizeof(*wmi) + ilen,
1118 USBD_SHORT_XFER_OK, ATHN_USB_CMD_TIMEOUT,
1119 athn_usb_wmieof);
1120
1121 s = splusb();
1122 usc->usc_wmi_done = 0;
1123 usc->usc_wait_cmd_id = cmd_id;
1124 error = usbd_transfer(data->xfer);
1125 if (__predict_true(error == 0 || error == USBD_IN_PROGRESS)) {
1126 usc->usc_obuf = obuf;
1127
1128 /* Wait for WMI command to complete. */
1129 error = tsleep(&usc->usc_wait_cmd_id, 0, "athnwmi", hz);
1130 usc->usc_wait_cmd_id = 0;
1131 athn_usb_wait_wmi(usc);
1132 }
1133 splx(s);
1134 return error;
1135}
1136
1137Static void
1138athn_usb_wait_wmi(struct athn_usb_softc *usc)
1139{
1140
1141 DPRINTFN(DBG_FN, usc, "\n");
1142
1143 while (__predict_false(!usc->usc_wmi_done))
1144 tsleep(&usc->usc_wmi_done, 0, "athnwmi", 0);
1145}
1146
1147#ifdef unused
1148Static int
1149athn_usb_read_rom(struct athn_softc *sc)
1150{
1151 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1152 uint32_t addrs[8], vals[8], addr;
1153 uint16_t *eep;
1154 size_t i, j;
1155 int error = 0;
1156
1157 DPRINTFN(DBG_FN, sc, "\n");
1158
1159 /* Read EEPROM by blocks of 16 bytes. */
1160 eep = sc->sc_eep;
1161 addr = AR_EEPROM_OFFSET(sc->sc_eep_base);
1162 for (i = 0; i < sc->sc_eep_size / 16; i++) {
1163 for (j = 0; j < 8; j++, addr += 4)
1164 addrs[j] = htobe32(addr);
1165 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_REG_READ,
1166 addrs, sizeof(addrs), vals);
1167 if (error != 0)
1168 break;
1169 for (j = 0; j < 8; j++)
1170 *eep++ = be32toh(vals[j]);
1171 }
1172 return error;
1173}
1174#endif /* unused */
1175
1176Static uint32_t
1177athn_usb_read(struct athn_softc *sc, uint32_t addr)
1178{
1179 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1180 uint32_t val;
1181 int error;
1182
1183 if (usc->usc_dying)
1184 return 0;
1185
1186 DPRINTFN(DBG_FN, sc, "\n");
1187
1188 /* Flush pending writes for strict consistency. */
1189 athn_usb_write_barrier(sc);
1190
1191 addr = htobe32(addr);
1192 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_REG_READ,
1193 &addr, sizeof(addr), &val);
1194 if (error != 0)
1195 return 0xdeadbeef;
1196 return be32toh(val);
1197}
1198
1199Static void
1200athn_usb_write(struct athn_softc *sc, uint32_t addr, uint32_t val)
1201{
1202 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1203
1204 if (usc->usc_dying)
1205 return;
1206
1207 DPRINTFN(DBG_FN, sc, "\n");
1208
1209 usc->usc_wbuf[usc->usc_wcount].addr = htobe32(addr);
1210 usc->usc_wbuf[usc->usc_wcount].val = htobe32(val);
1211 if (++usc->usc_wcount == AR_MAX_WRITE_COUNT)
1212 athn_usb_write_barrier(sc);
1213}
1214
1215Static void
1216athn_usb_write_barrier(struct athn_softc *sc)
1217{
1218 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1219
1220 if (usc->usc_dying)
1221 goto done;
1222
1223 DPRINTFN(DBG_FN, sc, "\n");
1224
1225 if (usc->usc_wcount == 0)
1226 return;
1227
1228 (void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_REG_WRITE,
1229 usc->usc_wbuf, usc->usc_wcount * sizeof(usc->usc_wbuf[0]), NULL);
1230 done:
1231 usc->usc_wcount = 0; /* Always flush buffer. */
1232}
1233
1234Static int
1235athn_usb_media_change(struct ifnet *ifp)
1236{
1237 struct athn_softc *sc = ifp->if_softc;
1238 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1239 int error;
1240
1241 if (usc->usc_dying)
1242 return EIO;
1243
1244 DPRINTFN(DBG_FN, sc, "\n");
1245
1246 error = ieee80211_media_change(ifp);
1247 if (error == ENETRESET && IS_UP_AND_RUNNING(ifp)) {
1248 athn_usb_stop(ifp);
1249 error = athn_usb_init(ifp);
1250 }
1251 return error;
1252}
1253
1254Static int
1255athn_usb_newstate(struct ieee80211com *ic, enum ieee80211_state nstate,
1256 int arg)
1257{
1258 struct athn_softc *sc = ic->ic_ifp->if_softc;
1259 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1260 struct athn_usb_cmd_newstate cmd;
1261
1262 DPRINTFN(DBG_FN, sc, "\n");
1263
1264 /* Do it in a process context. */
1265 cmd.state = nstate;
1266 cmd.arg = arg;
1267 athn_usb_do_async(usc, athn_usb_newstate_cb, &cmd, sizeof(cmd));
1268 return 0;
1269}
1270
1271Static void
1272athn_usb_newstate_cb(struct athn_usb_softc *usc, void *arg)
1273{
1274 struct athn_usb_cmd_newstate *cmd = arg;
1275 struct athn_softc *sc = &usc->usc_sc;
1276 struct ieee80211com *ic = &sc->sc_ic;
1277 enum ieee80211_state ostate, nstate;
1278 uint32_t reg, imask;
1279 int s;
1280
1281 DPRINTFN(DBG_FN, sc, "\n");
1282
1283 callout_stop(&sc->sc_calib_to);
1284
1285 s = splnet();
1286
1287 ostate = ic->ic_state;
1288 nstate = cmd->state;
1289 DPRINTFN(DBG_STM, usc, "newstate %s(%d) -> %s(%d)\n",
1290 ieee80211_state_name[ostate], ostate,
1291 ieee80211_state_name[nstate], nstate);
1292
1293 if (ostate == IEEE80211_S_RUN) {
1294 uint8_t sta_index;
1295
1296 sta_index = ATHN_NODE(ic->ic_bss)->sta_index;
1297 DPRINTFN(DBG_NODES, usc, "removing node %u\n", sta_index);
1298 athn_usb_remove_hw_node(usc, &sta_index);
1299 }
1300
1301 switch (nstate) {
1302 case IEEE80211_S_INIT:
1303 athn_set_led(sc, 0);
1304 break;
1305 case IEEE80211_S_SCAN:
1306 /* Make the LED blink while scanning. */
1307 athn_set_led(sc, !sc->sc_led_state);
1308 (void)athn_usb_switch_chan(sc, ic->ic_curchan, NULL);
1309 if (!usc->usc_dying)
1310 callout_schedule(&sc->sc_scan_to, hz / 5);
1311 break;
1312 case IEEE80211_S_AUTH:
1313 athn_set_led(sc, 0);
1314 athn_usb_switch_chan(sc, ic->ic_curchan, NULL);
1315 break;
1316 case IEEE80211_S_ASSOC:
1317 break;
1318 case IEEE80211_S_RUN:
1319 athn_set_led(sc, 1);
1320
1321 if (ic->ic_opmode == IEEE80211_M_MONITOR)
1322 break;
1323
1324 /* Create node entry for our BSS. */
1325 DPRINTFN(DBG_NODES, sc, "create node for AID=0x%x\n",
1326 ic->ic_bss->ni_associd);
1327 athn_usb_create_node(usc, ic->ic_bss); /* XXX: handle error? */
1328
1329 athn_set_bss(sc, ic->ic_bss);
1330 athn_usb_wmi_cmd(usc, AR_WMI_CMD_DISABLE_INTR);
1331#ifndef IEEE80211_STA_ONLY
1332 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
1333 athn_set_hostap_timers(sc);
1334 /* Enable software beacon alert interrupts. */
1335 imask = htobe32(AR_IMR_SWBA);
1336 }
1337 else
1338#endif
1339 {
1340 athn_set_sta_timers(sc);
1341 /* Enable beacon miss interrupts. */
1342 imask = htobe32(AR_IMR_BMISS);
1343
1344 /* Stop receiving beacons from other BSS. */
1345 reg = AR_READ(sc, AR_RX_FILTER);
1346 reg = (reg & ~AR_RX_FILTER_BEACON) |
1347 AR_RX_FILTER_MYBEACON;
1348 AR_WRITE(sc, AR_RX_FILTER, reg);
1349 AR_WRITE_BARRIER(sc);
1350 }
1351 athn_usb_wmi_xcmd(usc, AR_WMI_CMD_ENABLE_INTR,
1352 &imask, sizeof(imask), NULL);
1353 break;
1354 }
1355 if (!usc->usc_dying)
1356 (void)sc->sc_newstate(ic, nstate, cmd->arg);
1357 splx(s);
1358}
1359
1360Static void
1361athn_usb_newassoc(struct ieee80211_node *ni, int isnew)
1362{
1363 struct ieee80211com *ic = ni->ni_ic;
1364 struct athn_softc *sc = ic->ic_ifp->if_softc;
1365 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1366
1367 DPRINTFN(DBG_FN, sc, "\n");
1368
1369 if (ic->ic_opmode != IEEE80211_M_HOSTAP || !isnew)
1370 return;
1371
1372 /* Do it in a process context. */
1373 ieee80211_ref_node(ni);
1374 athn_usb_do_async(usc, athn_usb_newassoc_cb, &ni, sizeof(ni));
1375}
1376
1377Static void
1378athn_usb_newassoc_cb(struct athn_usb_softc *usc, void *arg)
1379{
1380 struct ieee80211_node *ni = *(void **)arg;
1381 int s;
1382
1383 DPRINTFN(DBG_FN, usc, "\n");
1384
1385 s = splnet();
1386 /* NB: Node may have left before we got scheduled. */
1387 if (ni->ni_associd != 0) {
1388 DPRINTFN(DBG_NODES, usc, "creating node for AID=0x%x\n",
1389 ni->ni_associd);
1390 (void)athn_usb_create_node(usc, ni); /* XXX: handle error? */
1391 }
1392 ieee80211_free_node(ni);
1393 splx(s);
1394}
1395
1396#ifdef notyet
1397Static int
1398athn_usb_ampdu_tx_start(struct ieee80211com *ic, struct ieee80211_node *ni,
1399 uint8_t tid)
1400{
1401 struct athn_softc *sc = ic->ic_ifp->if_softc;
1402 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1403 struct athn_node *an = ATHN_NODE(ni);
1404 struct athn_usb_aggr_cmd cmd;
1405
1406 DPRINTFN(DBG_FN, sc, "\n");
1407
1408 /* Do it in a process context. */
1409 cmd.sta_index = an->sta_index;
1410 cmd.tid = tid;
1411 athn_usb_do_async(usc, athn_usb_ampdu_tx_start_cb, &cmd, sizeof(cmd));
1412 return 0;
1413}
1414
1415Static void
1416athn_usb_ampdu_tx_start_cb(struct athn_usb_softc *usc, void *arg)
1417{
1418 struct athn_usb_aggr_cmd *cmd = arg;
1419 struct ar_htc_target_aggr aggr;
1420
1421 DPRINTFN(DBG_FN, usc, "\n");
1422
1423 memset(&aggr, 0, sizeof(aggr));
1424 aggr.sta_index = cmd->sta_index;
1425 aggr.tidno = cmd->tid;
1426 aggr.aggr_enable = 1;
1427 (void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_TX_AGGR_ENABLE,
1428 &aggr, sizeof(aggr), NULL);
1429}
1430
1431Static void
1432athn_usb_ampdu_tx_stop(struct ieee80211com *ic, struct ieee80211_node *ni,
1433 uint8_t tid)
1434{
1435 struct athn_softc *sc = ic->ic_ifp->if_softc;
1436 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1437 struct athn_node *an = ATHN_NODE(ni);
1438 struct athn_usb_aggr_cmd cmd;
1439
1440 DPRINTFN(DBG_FN, sc, "\n");
1441
1442 /* Do it in a process context. */
1443 cmd.sta_index = an->sta_index;
1444 cmd.tid = tid;
1445 athn_usb_do_async(usc, athn_usb_ampdu_tx_stop_cb, &cmd, sizeof(cmd));
1446}
1447
1448Static void
1449athn_usb_ampdu_tx_stop_cb(struct athn_usb_softc *usc, void *arg)
1450{
1451 struct athn_usb_aggr_cmd *cmd = arg;
1452 struct ar_htc_target_aggr aggr;
1453
1454 DPRINTFN(DBG_FN, usc, "\n");
1455
1456 memset(&aggr, 0, sizeof(aggr));
1457 aggr.sta_index = cmd->sta_index;
1458 aggr.tidno = cmd->tid;
1459 aggr.aggr_enable = 0;
1460 (void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_TX_AGGR_ENABLE,
1461 &aggr, sizeof(aggr), NULL);
1462}
1463#endif /* notyet */
1464
1465Static int
1466athn_usb_remove_hw_node(struct athn_usb_softc *usc, uint8_t *sta_idx)
1467{
1468 int error;
1469
1470 DPRINTFN(DBG_FN, usc, "\n");
1471
1472 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_NODE_REMOVE,
1473 sta_idx, sizeof(*sta_idx), NULL);
1474
1475 DPRINTFN(DBG_NODES, usc, "node=%u error=%d\n",
1476 *sta_idx, error);
1477 return error;
1478}
1479
1480Static int
1481athn_usb_create_hw_node(struct athn_usb_softc *usc,
1482 struct ar_htc_target_sta *sta)
1483{
1484 int error;
1485
1486 DPRINTFN(DBG_FN, usc, "\n");
1487
1488 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_NODE_CREATE,
1489 sta, sizeof(*sta), NULL);
1490
1491 DPRINTFN(DBG_NODES, usc, "node=%u error=%d\n",
1492 sta->sta_index, error);
1493
1494 return error;
1495}
1496
1497Static int
1498athn_usb_create_node(struct athn_usb_softc *usc, struct ieee80211_node *ni)
1499{
1500 struct athn_node *an = ATHN_NODE(ni);
1501 struct ar_htc_target_sta sta;
1502 struct ar_htc_target_rate rate;
1503 int error;
1504
1505 DPRINTFN(DBG_FN | DBG_NODES, usc, "AID=0x%x\n", ni->ni_associd);
1506
1507 /*
1508 * NB: this is called by ic_newstate and (in HOSTAP mode by)
1509 * ic_newassoc.
1510 *
1511 * The firmware has a limit of 8 nodes. In HOSTAP mode, we
1512 * limit the AID to < 8 and use that value to index the
1513 * firmware node table. Node zero is used for the BSS.
1514 *
1515 * In STA mode, we simply use node 1 for the BSS.
1516 */
1517 if (ATHN_SOFTC(usc)->sc_ic.ic_opmode == IEEE80211_M_HOSTAP)
1518 an->sta_index = IEEE80211_NODE_AID(ni);
1519 else
1520 an->sta_index = 1;
1521
1522 /* Create node entry on target. */
1523 memset(&sta, 0, sizeof(sta));
1524 IEEE80211_ADDR_COPY(sta.macaddr, ni->ni_macaddr);
1525 IEEE80211_ADDR_COPY(sta.bssid, ni->ni_bssid);
1526
1527 sta.associd = htobe16(ni->ni_associd);
1528 sta.valid = 1;
1529 sta.sta_index = an->sta_index;
1530
1531 sta.maxampdu = 0xffff;
1532#ifndef IEEE80211_NO_HT
1533 if (ni->ni_flags & IEEE80211_NODE_HT)
1534 sta.flags |= htobe16(AR_HTC_STA_HT);
1535#endif
1536 error = athn_usb_create_hw_node(usc, &sta);
1537 if (error)
1538 return error;
1539
1540 /* Setup supported rates. */
1541 memset(&rate, 0, sizeof(rate));
1542 rate.sta_index = sta.sta_index;
1543 rate.isnew = 1;
1544 rate.lg_rates.rs_nrates = ni->ni_rates.rs_nrates;
1545 memcpy(rate.lg_rates.rs_rates, ni->ni_rates.rs_rates,
1546 ni->ni_rates.rs_nrates);
1547
1548#ifndef IEEE80211_NO_HT
1549 if (ni->ni_flags & IEEE80211_NODE_HT) {
1550 rate.capflags |= htobe32(AR_RC_HT_FLAG);
1551#ifdef notyet
1552 /* XXX setup HT rates */
1553 if (ni->ni_htcaps & IEEE80211_HTCAP_CBW20_40)
1554 rate.capflags |= htobe32(AR_RC_40_FLAG);
1555 if (ni->ni_htcaps & IEEE80211_HTCAP_SGI40)
1556 rate.capflags |= htobe32(AR_RC_SGI_FLAG);
1557 if (ni->ni_htcaps & IEEE80211_HTCAP_SGI20)
1558 rate.capflags |= htobe32(AR_RC_SGI_FLAG);
1559#endif
1560 }
1561#endif
1562 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_RC_RATE_UPDATE,
1563 &rate, sizeof(rate), NULL);
1564 return error;
1565}
1566
1567Static void
1568athn_usb_rx_enable(struct athn_softc *sc)
1569{
1570
1571 DPRINTFN(DBG_FN, sc, "\n");
1572
1573 AR_WRITE(sc, AR_CR, AR_CR_RXE);
1574 AR_WRITE_BARRIER(sc);
1575}
1576
1577Static int
1578athn_usb_switch_chan(struct athn_softc *sc, struct ieee80211_channel *curchan,
1579 struct ieee80211_channel *extchan)
1580{
1581 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1582 uint16_t mode;
1583 int error;
1584
1585 DPRINTFN(DBG_FN, sc, "\n");
1586
1587 /* Disable interrupts. */
1588 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_DISABLE_INTR);
1589 if (error != 0)
1590 goto reset;
1591 /* Stop all Tx queues. */
1592 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_DRAIN_TXQ_ALL);
1593 if (error != 0)
1594 goto reset;
1595 /* Stop Rx. */
1596 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_STOP_RECV);
1597 if (error != 0)
1598 goto reset;
1599
1600 /* If band or bandwidth changes, we need to do a full reset. */
1601 if (curchan->ic_flags != sc->sc_curchan->ic_flags ||
1602 ((extchan != NULL) ^ (sc->sc_curchanext != NULL))) {
1603 DPRINTFN(DBG_RF, sc, "channel band switch\n");
1604 goto reset;
1605 }
1606
1607 error = athn_set_chan(sc, curchan, extchan);
1608 if (AR_SREV_9271(sc) && error == 0)
1609 ar9271_load_ani(sc);
1610 if (error != 0) {
1611 reset: /* Error found, try a full reset. */
1612 DPRINTFN(DBG_RF, sc, "needs a full reset\n");
1613 error = athn_hw_reset(sc, curchan, extchan, 0);
1614 if (error != 0) /* Hopeless case. */
1615 return error;
1616 }
1617
1618 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_START_RECV);
1619 if (error != 0)
1620 return error;
1621 athn_rx_start(sc);
1622
1623 mode = htobe16(IEEE80211_IS_CHAN_2GHZ(curchan) ?
1624 AR_HTC_MODE_11NG : AR_HTC_MODE_11NA);
1625 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_SET_MODE,
1626 &mode, sizeof(mode), NULL);
1627 if (error != 0)
1628 return error;
1629
1630 /* Re-enable interrupts. */
1631 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_ENABLE_INTR);
1632 return error;
1633}
1634
1635#ifdef notyet_edca
1636Static void
1637athn_usb_updateedca(struct ieee80211com *ic)
1638{
1639 struct athn_softc *sc = ic->ic_ifp->if_softc;
1640 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1641
1642 DPRINTFN(DBG_FN, sc, "\n");
1643
1644 /* Do it in a process context. */
1645 athn_usb_do_async(usc, athn_usb_updateedca_cb, NULL, 0);
1646}
1647
1648Static void
1649athn_usb_updateedca_cb(struct athn_usb_softc *usc, void *arg)
1650{
1651 int s;
1652
1653 DPRINTFN(DBG_FN, usc, "\n");
1654
1655 s = splnet();
1656 athn_updateedca(&usc->usc_sc.sc_ic);
1657 splx(s);
1658}
1659#endif /* notyet_edca */
1660
1661Static void
1662athn_usb_updateslot(struct ifnet *ifp)
1663{
1664 struct athn_softc *sc = ifp->if_softc;
1665 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1666
1667 DPRINTFN(DBG_FN, sc, "\n");
1668
1669 /*
1670 * NB: athn_updateslog() needs to be done in a process context
1671 * to avoid being called by ieee80211_reset_erp() inside a
1672 * spinlock held by ieee80211_free_allnodes().
1673 *
1674 * XXX: calling this during the athn_attach() causes
1675 * usb_insert_transfer() to produce a bunch of "not busy"
1676 * messages. Why?
1677 */
1678 if (usc->usc_athn_attached)
1679 athn_usb_do_async(usc, athn_usb_updateslot_cb, NULL, 0);
1680}
1681
1682Static void
1683athn_usb_updateslot_cb(struct athn_usb_softc *usc, void *arg)
1684{
1685 int s;
1686
1687 DPRINTFN(DBG_FN, usc, "\n");
1688
1689 s = splnet();
1690 athn_updateslot(&usc->usc_sc.sc_if);
1691 splx(s);
1692}
1693
1694#ifdef notyet
1695Static int
1696athn_usb_set_key(struct ieee80211com *ic, struct ieee80211_node *ni,
1697 struct ieee80211_key *k)
1698{
1699 struct athn_softc *sc = ic->ic_ifp->if_softc;
1700 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1701 struct ifnet *ifp = &usc->usc_sc.sc_if;
1702 struct athn_usb_cmd_key cmd;
1703
1704 DPRINTFN(DBG_FN, sc, "\n");
1705
1706 /* Defer setting of WEP keys until interface is brought up. */
1707 if (!IS_UP_AND_RUNNING(ifp))
1708 return 0;
1709
1710 /* Do it in a process context. */
1711 cmd.ni = (ni != NULL) ? ieee80211_ref_node(ni) : NULL;
1712 cmd.key = k;
1713 athn_usb_do_async(usc, athn_usb_set_key_cb, &cmd, sizeof(cmd));
1714 return 0;
1715}
1716
1717Static void
1718athn_usb_set_key_cb(struct athn_usb_softc *usc, void *arg)
1719{
1720 struct ieee80211com *ic = &usc->usc_sc.sc_ic;
1721 struct athn_usb_cmd_key *cmd = arg;
1722 int s;
1723
1724 DPRINTFN(DBG_FN, usc, "\n");
1725
1726 s = splnet();
1727 athn_set_key(ic, cmd->ni, cmd->key);
1728 if (cmd->ni != NULL)
1729 ieee80211_free_node(cmd->ni);
1730 splx(s);
1731}
1732
1733Static void
1734athn_usb_delete_key(struct ieee80211com *ic, struct ieee80211_node *ni,
1735 struct ieee80211_key *k)
1736{
1737 struct athn_softc *sc = ic->ic_ifp->if_softc;
1738 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
1739 struct ifnet *ifp = &usc->usc_sc.sc_if;
1740 struct athn_usb_cmd_key cmd;
1741
1742 DPRINTFN(DBG_FN, sc, "\n");
1743
1744 if (!(ifp->if_flags & IFF_RUNNING) ||
1745 ic->ic_state != IEEE80211_S_RUN)
1746 return; /* Nothing to do. */
1747
1748 /* Do it in a process context. */
1749 cmd.ni = (ni != NULL) ? ieee80211_ref_node(ni) : NULL;
1750 cmd.key = k;
1751 athn_usb_do_async(usc, athn_usb_delete_key_cb, &cmd, sizeof(cmd));
1752}
1753
1754Static void
1755athn_usb_delete_key_cb(struct athn_usb_softc *usc, void *arg)
1756{
1757 struct ieee80211com *ic = &usc->usc_sc.sc_ic;
1758 struct athn_usb_cmd_key *cmd = arg;
1759 int s;
1760
1761 DPRINTFN(DBG_FN, usc, "\n");
1762
1763 s = splnet();
1764 athn_delete_key(ic, cmd->ni, cmd->key);
1765 if (cmd->ni != NULL)
1766 ieee80211_free_node(cmd->ni);
1767 splx(s);
1768}
1769#endif /* notyet */
1770
1771#ifndef IEEE80211_STA_ONLY
1772Static void
1773athn_usb_bcneof(struct usbd_xfer *xfer, void * priv,
1774 usbd_status status)
1775{
1776 struct athn_usb_tx_data *data = priv;
1777 struct athn_usb_softc *usc = data->sc;
1778
1779 DPRINTFN(DBG_FN, usc, "\n");
1780
1781 if (__predict_false(status == USBD_STALLED))
1782 usbd_clear_endpoint_stall_async(usc->usc_tx_data_pipe);
1783 usc->usc_tx_bcn = data;
1784}
1785
1786/*
1787 * Process Software Beacon Alert interrupts.
1788 */
1789Static void
1790athn_usb_swba(struct athn_usb_softc *usc)
1791{
1792 struct athn_softc *sc = &usc->usc_sc;
1793 struct ieee80211com *ic = &sc->sc_ic;
1794 struct athn_usb_tx_data *data;
1795 struct ieee80211_frame *wh;
1796 struct ieee80211_beacon_offsets bo;
1797 struct ar_stream_hdr *hdr;
1798 struct ar_htc_frame_hdr *htc;
1799 struct ar_tx_bcn *bcn;
1800 struct mbuf *m;
1801 int error;
1802
1803 if (usc->usc_dying)
1804 return;
1805
1806 DPRINTFN(DBG_FN, sc, "\n");
1807
1808 if (ic->ic_dtim_count == 0)
1809 ic->ic_dtim_count = ic->ic_dtim_period - 1;
1810 else
1811 ic->ic_dtim_count--;
1812
1813 /* Make sure previous beacon has been sent. */
1814 if (usc->usc_tx_bcn == NULL)
1815 return;
1816 data = usc->usc_tx_bcn;
1817
1818 /* Get new beacon. */
1819#ifdef ATHN_DEBUG
1820 memset(&bo, 0, sizeof(bo));
1821#endif
1822 m = ieee80211_beacon_alloc(ic, ic->ic_bss, &bo);
1823 if (__predict_false(m == NULL))
1824 return;
1825 /* Assign sequence number. */
1826 /* XXX: use non-QoS tid? */
1827 wh = mtod(m, struct ieee80211_frame *);
1828 *(uint16_t *)&wh->i_seq[0] =
1829 htole16(ic->ic_bss->ni_txseqs[0] << IEEE80211_SEQ_SEQ_SHIFT);
1830 ic->ic_bss->ni_txseqs[0]++;
1831
1832 hdr = (struct ar_stream_hdr *)data->buf;
1833 hdr->tag = htole16(AR_USB_TX_STREAM_TAG);
1834 hdr->len = htole16(sizeof(*htc) + sizeof(*bcn) + m->m_pkthdr.len);
1835
1836 htc = (struct ar_htc_frame_hdr *)&hdr[1];
1837 memset(htc, 0, sizeof(*htc));
1838 htc->endpoint_id = usc->usc_ep_bcn;
1839 htc->payload_len = htobe16(sizeof(*bcn) + m->m_pkthdr.len);
1840
1841 bcn = (struct ar_tx_bcn *)&htc[1];
1842 memset(bcn, 0, sizeof(*bcn));
1843 bcn->vif_idx = 0;
1844
1845 m_copydata(m, 0, m->m_pkthdr.len, (void *)&bcn[1]);
1846
1847 usbd_setup_xfer(data->xfer, data, data->buf,
1848 sizeof(*hdr) + sizeof(*htc) + sizeof(*bcn) + m->m_pkthdr.len,
1849 USBD_SHORT_XFER_OK, ATHN_USB_TX_TIMEOUT,
1850 athn_usb_bcneof);
1851
1852 m_freem(m);
1853 usc->usc_tx_bcn = NULL;
1854 error = usbd_transfer(data->xfer);
1855 if (__predict_false(error != USBD_IN_PROGRESS && error != 0))
1856 usc->usc_tx_bcn = data;
1857}
1858#endif
1859
1860Static void
1861athn_usb_rx_wmi_ctrl(struct athn_usb_softc *usc, uint8_t *buf, size_t len)
1862{
1863#ifdef ATHN_DEBUG
1864 struct ar_wmi_evt_txrate *txrate;
1865#endif
1866 struct ar_wmi_cmd_hdr *wmi;
1867 uint16_t cmd_id;
1868
1869 if (usc->usc_dying)
1870 return;
1871
1872 DPRINTFN(DBG_FN, usc, "\n");
1873
1874 if (__predict_false(len < sizeof(*wmi)))
1875 return;
1876 wmi = (struct ar_wmi_cmd_hdr *)buf;
1877 cmd_id = be16toh(wmi->cmd_id);
1878
1879 if (!(cmd_id & AR_WMI_EVT_FLAG)) {
1880 if (usc->usc_wait_cmd_id != cmd_id)
1881 return; /* Unexpected reply. */
1882 if (usc->usc_obuf != NULL) {
1883 /* Copy answer into caller supplied buffer. */
1884 memcpy(usc->usc_obuf, &wmi[1], len - sizeof(*wmi));
1885 }
1886 /* Notify caller of completion. */
1887 usc->usc_wait_cmd_id = 0;
1888 wakeup(&usc->usc_wait_cmd_id);
1889 return;
1890 }
1891 /*
1892 * XXX: the Linux 2.6 and 3.7.4 kernels differ on the event numbers!
1893 * See the alternate defines in if_athn_usb.h.
1894 */
1895 switch (cmd_id & 0xfff) {
1896#ifndef IEEE80211_STA_ONLY
1897 case AR_WMI_EVT_SWBA:
1898 athn_usb_swba(usc);
1899 break;
1900#endif
1901 case AR_WMI_EVT_FATAL:
1902 aprint_error_dev(usc->usc_dev, "fatal firmware error\n");
1903 break;
1904 case AR_WMI_EVT_TXRATE:
1905#ifdef ATHN_DEBUG
1906 txrate = (struct ar_wmi_evt_txrate *)&wmi[1];
1907 DPRINTFN(DBG_TX, usc, "txrate=%d\n", be32toh(txrate->txrate));
1908#endif
1909 break;
1910 default:
1911 DPRINTFN(DBG_TX, usc, "WMI event 0x%x (%d) ignored\n", cmd_id, cmd_id);
1912 break;
1913 }
1914}
1915
1916Static void
1917athn_usb_intr(struct usbd_xfer *xfer, void * priv,
1918 usbd_status status)
1919{
1920 struct athn_usb_softc *usc = priv;
1921 struct ar_htc_frame_hdr *htc;
1922 struct ar_htc_msg_hdr *msg;
1923 uint8_t *buf = usc->usc_ibuf;
1924 uint16_t msg_id;
1925 int len;
1926
1927 if (usc->usc_dying)
1928 return;
1929
1930 DPRINTFN(DBG_FN, usc, "\n");
1931
1932 if (__predict_false(status != USBD_NORMAL_COMPLETION)) {
1933 DPRINTFN(DBG_INTR, usc, "intr status=%d\n", status);
1934 if (status == USBD_STALLED)
1935 usbd_clear_endpoint_stall_async(usc->usc_rx_intr_pipe);
1936 return;
1937 }
1938 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
1939
1940 /* Skip watchdog pattern if present. */
1941 if (len >= 4 && *(uint32_t *)buf == htobe32(0x00c60000)) {
1942 buf += 4;
1943 len -= 4;
1944 }
1945 if (__predict_false(len < (int)sizeof(*htc)))
1946 return;
1947 htc = (struct ar_htc_frame_hdr *)buf;
1948 /* Skip HTC header. */
1949 buf += sizeof(*htc);
1950 len -= sizeof(*htc);
1951
1952 if (htc->endpoint_id != 0) {
1953 if (__predict_false(htc->endpoint_id != usc->usc_ep_ctrl))
1954 return;
1955 /* Remove trailer if present. */
1956 if (htc->flags & AR_HTC_FLAG_TRAILER) {
1957 if (__predict_false(len < htc->control[0]))
1958 return;
1959 len -= htc->control[0];
1960 }
1961 athn_usb_rx_wmi_ctrl(usc, buf, len);
1962 return;
1963 }
1964
1965 /*
1966 * Endpoint 0 carries HTC messages.
1967 */
1968 if (__predict_false(len < (int)sizeof(*msg)))
1969 return;
1970 msg = (struct ar_htc_msg_hdr *)buf;
1971 msg_id = be16toh(msg->msg_id);
1972 DPRINTFN(DBG_RX, usc, "Rx HTC message %d\n", msg_id);
1973 switch (msg_id) {
1974 case AR_HTC_MSG_READY:
1975 case AR_HTC_MSG_CONF_PIPE_RSP:
1976 if (usc->usc_wait_msg_id != msg_id)
1977 break;
1978 usc->usc_wait_msg_id = 0;
1979 wakeup(&usc->usc_wait_msg_id);
1980 break;
1981 case AR_HTC_MSG_CONN_SVC_RSP:
1982 if (usc->usc_wait_msg_id != msg_id)
1983 break;
1984 if (usc->usc_msg_conn_svc_rsp != NULL) {
1985 memcpy(usc->usc_msg_conn_svc_rsp, &msg[1],
1986 sizeof(*usc->usc_msg_conn_svc_rsp));
1987 }
1988 usc->usc_wait_msg_id = 0;
1989 wakeup(&usc->usc_wait_msg_id);
1990 break;
1991 default:
1992 DPRINTFN(DBG_RX, usc, "HTC message %d ignored\n", msg_id);
1993 break;
1994 }
1995}
1996
1997Static void
1998athn_usb_rx_radiotap(struct athn_softc *sc, struct mbuf *m,
1999 struct ar_rx_status *rs)
2000{
2001 struct athn_rx_radiotap_header *tap = &sc->sc_rxtap;
2002 struct ieee80211com *ic = &sc->sc_ic;
2003 uint8_t rate;
2004
2005 DPRINTFN(DBG_FN, sc, "\n");
2006
2007 tap->wr_flags = IEEE80211_RADIOTAP_F_FCS;
2008 tap->wr_tsft = htole64(be64toh(rs->rs_tstamp));
2009 tap->wr_chan_freq = htole16(ic->ic_curchan->ic_freq);
2010 tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags);
2011 tap->wr_dbm_antsignal = rs->rs_rssi;
2012 /* XXX noise. */
2013 tap->wr_antenna = rs->rs_antenna;
2014 rate = rs->rs_rate;
2015 if (rate & 0x80) { /* HT. */
2016 /* Bit 7 set means HT MCS instead of rate. */
2017 tap->wr_rate = rate;
2018 if (!(rs->rs_flags & AR_RXS_FLAG_GI))
2019 tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTGI;
2020 }
2021 else if (rate & 0x10) { /* CCK. */
2022 if (rate & 0x04)
2023 tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
2024 switch (rate & ~0x14) {
2025 case 0xb: tap->wr_rate = 2; break;
2026 case 0xa: tap->wr_rate = 4; break;
2027 case 0x9: tap->wr_rate = 11; break;
2028 case 0x8: tap->wr_rate = 22; break;
2029 default: tap->wr_rate = 0; break;
2030 }
2031 }
2032 else { /* OFDM. */
2033 switch (rate) {
2034 case 0xb: tap->wr_rate = 12; break;
2035 case 0xf: tap->wr_rate = 18; break;
2036 case 0xa: tap->wr_rate = 24; break;
2037 case 0xe: tap->wr_rate = 36; break;
2038 case 0x9: tap->wr_rate = 48; break;
2039 case 0xd: tap->wr_rate = 72; break;
2040 case 0x8: tap->wr_rate = 96; break;
2041 case 0xc: tap->wr_rate = 108; break;
2042 default: tap->wr_rate = 0; break;
2043 }
2044 }
2045 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_rxtap_len, m);
2046}
2047
2048Static void
2049athn_usb_rx_frame(struct athn_usb_softc *usc, struct mbuf *m)
2050{
2051 struct athn_softc *sc = &usc->usc_sc;
2052 struct ieee80211com *ic = &sc->sc_ic;
2053 struct ifnet *ifp = &sc->sc_if;
2054 struct ieee80211_frame *wh;
2055 struct ieee80211_node *ni;
2056 struct ar_htc_frame_hdr *htc;
2057 struct ar_rx_status *rs;
2058 uint16_t datalen;
2059 int s;
2060
2061 DPRINTFN(DBG_FN, sc, "\n");
2062
2063 if (__predict_false(m->m_len < (int)sizeof(*htc)))
2064 goto skip;
2065 htc = mtod(m, struct ar_htc_frame_hdr *);
2066 if (__predict_false(htc->endpoint_id == 0)) {
2067 DPRINTFN(DBG_RX, sc, "bad endpoint %d\n", htc->endpoint_id);
2068 goto skip;
2069 }
2070 if (htc->flags & AR_HTC_FLAG_TRAILER) {
2071 if (m->m_len < htc->control[0])
2072 goto skip;
2073 m_adj(m, -(int)htc->control[0]);
2074 }
2075 m_adj(m, sizeof(*htc)); /* Strip HTC header. */
2076
2077 if (__predict_false(m->m_len < (int)sizeof(*rs)))
2078 goto skip;
2079 rs = mtod(m, struct ar_rx_status *);
2080
2081 /* Make sure that payload fits. */
2082 datalen = be16toh(rs->rs_datalen);
2083 if (__predict_false(m->m_len < (int)sizeof(*rs) + datalen))
2084 goto skip;
2085
2086 /* Ignore runt frames. Let ACKs be seen by bpf */
2087 if (__predict_false(datalen <
2088 sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN))
2089 goto skip;
2090
2091 m_adj(m, sizeof(*rs)); /* Strip Rx status. */
2092 m_set_rcvif(m, ifp);
2093
2094 s = splnet();
2095
2096 /* Grab a reference to the source node. */
2097 wh = mtod(m, struct ieee80211_frame *);
2098 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);
2099
2100 /* Remove any HW padding after the 802.11 header. */
2101 if (!(wh->i_fc[0] & IEEE80211_FC0_TYPE_CTL)) {
2102 u_int hdrlen = ieee80211_anyhdrsize(wh);
2103 if (hdrlen & 3) {
2104 ovbcopy(wh, (uint8_t *)wh + 2, hdrlen);
2105 m_adj(m, 2);
2106 }
2107 }
2108 if (__predict_false(sc->sc_drvbpf != NULL))
2109 athn_usb_rx_radiotap(sc, m, rs);
2110
2111 /* Trim 802.11 FCS after radiotap. */
2112 m_adj(m, -IEEE80211_CRC_LEN);
2113
2114 /* Send the frame to the 802.11 layer. */
2115 ieee80211_input(ic, m, ni, rs->rs_rssi + AR_USB_DEFAULT_NF, 0);
2116
2117 /* Node is no longer needed. */
2118 ieee80211_free_node(ni);
2119 splx(s);
2120 return;
2121 skip:
2122 m_freem(m);
2123}
2124
2125Static void
2126athn_usb_rxeof(struct usbd_xfer *xfer, void * priv,
2127 usbd_status status)
2128{
2129 struct athn_usb_rx_data *data = priv;
2130 struct athn_usb_softc *usc = data->sc;
2131 struct athn_usb_rx_stream *stream = &usc->usc_rx_stream;
2132 uint8_t *buf = data->buf;
2133 struct ar_stream_hdr *hdr;
2134 struct mbuf *m;
2135 uint16_t pktlen;
2136 int off, len;
2137
2138 if (usc->usc_dying)
2139 return;
2140
2141 DPRINTFN(DBG_FN, usc, "\n");
2142
2143 if (__predict_false(status != USBD_NORMAL_COMPLETION)) {
2144 DPRINTFN(DBG_RX, usc, "RX status=%d\n", status);
2145 if (status == USBD_STALLED)
2146 usbd_clear_endpoint_stall_async(usc->usc_rx_data_pipe);
2147 if (status != USBD_CANCELLED)
2148 goto resubmit;
2149 return;
2150 }
2151 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
2152
2153 if (stream->left > 0) {
2154 if (len >= stream->left) {
2155 /* We have all our pktlen bytes now. */
2156 if (__predict_true(stream->m != NULL)) {
2157 memcpy(mtod(stream->m, uint8_t *) +
2158 stream->moff, buf, stream->left);
2159 athn_usb_rx_frame(usc, stream->m);
2160 stream->m = NULL;
2161 }
2162 /* Next header is 32-bit aligned. */
2163 off = (stream->left + 3) & ~3;
2164 buf += off;
2165 len -= off;
2166 stream->left = 0;
2167 }
2168 else {
2169 /* Still need more bytes, save what we have. */
2170 if (__predict_true(stream->m != NULL)) {
2171 memcpy(mtod(stream->m, uint8_t *) +
2172 stream->moff, buf, len);
2173 stream->moff += len;
2174 }
2175 stream->left -= len;
2176 goto resubmit;
2177 }
2178 }
2179 KASSERT(stream->left == 0);
2180 while (len >= (int)sizeof(*hdr)) {
2181 hdr = (struct ar_stream_hdr *)buf;
2182 if (hdr->tag != htole16(AR_USB_RX_STREAM_TAG)) {
2183 DPRINTFN(DBG_RX, usc, "invalid tag 0x%x\n", hdr->tag);
2184 break;
2185 }
2186 pktlen = le16toh(hdr->len);
2187 buf += sizeof(*hdr);
2188 len -= sizeof(*hdr);
2189
2190 if (__predict_true(pktlen <= MCLBYTES)) {
2191 /* Allocate an mbuf to store the next pktlen bytes. */
2192 MGETHDR(m, M_DONTWAIT, MT_DATA);
2193 if (__predict_true(m != NULL)) {
2194 m->m_pkthdr.len = m->m_len = pktlen;
2195 if (pktlen > MHLEN) {
2196 MCLGET(m, M_DONTWAIT);
2197 if (!(m->m_flags & M_EXT)) {
2198 m_free(m);
2199 m = NULL;
2200 }
2201 }
2202 }
2203 }
2204 else /* Drop frames larger than MCLBYTES. */
2205 m = NULL;
2206 /*
2207 * NB: m can be NULL, in which case the next pktlen bytes
2208 * will be discarded from the Rx stream.
2209 */
2210 if (pktlen > len) {
2211 /* Need more bytes, save what we have. */
2212 stream->m = m; /* NB: m can be NULL. */
2213 if (__predict_true(stream->m != NULL)) {
2214 memcpy(mtod(stream->m, uint8_t *), buf, len);
2215 stream->moff = len;
2216 }
2217 stream->left = pktlen - len;
2218 goto resubmit;
2219 }
2220 if (__predict_true(m != NULL)) {
2221 /* We have all the pktlen bytes in this xfer. */
2222 memcpy(mtod(m, uint8_t *), buf, pktlen);
2223 athn_usb_rx_frame(usc, m);
2224 }
2225
2226 /* Next header is 32-bit aligned. */
2227 off = (pktlen + 3) & ~3;
2228 buf += off;
2229 len -= off;
2230 }
2231
2232 resubmit:
2233 /* Setup a new transfer. */
2234 usbd_setup_xfer(xfer, data, data->buf, ATHN_USB_RXBUFSZ,
2235 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, athn_usb_rxeof);
2236 (void)usbd_transfer(xfer);
2237}
2238
2239Static void
2240athn_usb_txeof(struct usbd_xfer *xfer, void * priv,
2241 usbd_status status)
2242{
2243 struct athn_usb_tx_data *data = priv;
2244 struct athn_usb_softc *usc = data->sc;
2245 struct athn_softc *sc = &usc->usc_sc;
2246 struct ifnet *ifp = &sc->sc_if;
2247 int s;
2248
2249 if (usc->usc_dying)
2250 return;
2251
2252 DPRINTFN(DBG_FN, usc, "\n");
2253
2254 s = splnet();
2255 /* Put this Tx buffer back to our free list. */
2256 mutex_enter(&usc->usc_tx_mtx);
2257 TAILQ_INSERT_TAIL(&usc->usc_tx_free_list, data, next);
2258 mutex_exit(&usc->usc_tx_mtx);
2259
2260 if (__predict_false(status != USBD_NORMAL_COMPLETION)) {
2261 DPRINTFN(DBG_TX, sc, "TX status=%d\n", status);
2262 if (status == USBD_STALLED)
2263 usbd_clear_endpoint_stall_async(usc->usc_tx_data_pipe);
2264 ifp->if_oerrors++;
2265 splx(s);
2266 /* XXX Why return? */
2267 return;
2268 }
2269 sc->sc_tx_timer = 0;
2270 ifp->if_opackets++;
2271
2272 /* We just released a Tx buffer, notify Tx. */
2273 if (ifp->if_flags & IFF_OACTIVE) {
2274 ifp->if_flags &= ~IFF_OACTIVE;
2275 ifp->if_start(ifp);
2276 }
2277 splx(s);
2278}
2279
2280Static int
2281athn_usb_tx(struct athn_softc *sc, struct mbuf *m, struct ieee80211_node *ni,
2282 struct athn_usb_tx_data *data)
2283{
2284 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
2285 struct athn_node *an = ATHN_NODE(ni);
2286 struct ieee80211com *ic = &sc->sc_ic;
2287 struct ieee80211_frame *wh;
2288 struct ieee80211_key *k = NULL;
2289 struct ar_stream_hdr *hdr;
2290 struct ar_htc_frame_hdr *htc;
2291 struct ar_tx_frame *txf;
2292 struct ar_tx_mgmt *txm;
2293 uint8_t *frm;
2294 uint8_t sta_index, qid, tid;
2295 int error, s, xferlen;
2296
2297 DPRINTFN(DBG_FN, sc, "\n");
2298
2299 wh = mtod(m, struct ieee80211_frame *);
2300 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
2301 k = ieee80211_crypto_encap(ic, ni, m);
2302 if (k == NULL)
2303 return ENOBUFS;
2304
2305 /* packet header may have moved, reset our local pointer */
2306 wh = mtod(m, struct ieee80211_frame *);
2307 }
2308#ifdef notyet_edca
2309 if (ieee80211_has_qos(wh)) {
2310 uint16_t qos;
2311
2312 qos = ieee80211_get_qos(wh);
2313 tid = qos & IEEE80211_QOS_TID;
2314 qid = ieee80211_up_to_ac(ic, tid);
2315 }
2316 else
2317#endif /* notyet_edca */
2318 {
2319 tid = 0;
2320 qid = WME_AC_BE;
2321 }
2322
2323 /* XXX Change radiotap Tx header for USB (no txrate). */
2324 if (__predict_false(sc->sc_drvbpf != NULL)) {
2325 struct athn_tx_radiotap_header *tap = &sc->sc_txtap;
2326
2327 tap->wt_flags = 0;
2328 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
2329 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
2330 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED)
2331 tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
2332
2333 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m);
2334 }
2335 sta_index = an->sta_index;
2336
2337 /* NB: We don't take advantage of USB Tx stream mode for now. */
2338 hdr = (struct ar_stream_hdr *)data->buf;
2339 hdr->tag = htole16(AR_USB_TX_STREAM_TAG);
2340
2341 htc = (struct ar_htc_frame_hdr *)&hdr[1];
2342 memset(htc, 0, sizeof(*htc));
2343 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
2344 IEEE80211_FC0_TYPE_DATA) {
2345 htc->endpoint_id = usc->usc_ep_data[qid];
2346
2347 txf = (struct ar_tx_frame *)&htc[1];
2348 memset(txf, 0, sizeof(*txf));
2349 txf->data_type = AR_HTC_NORMAL;
2350 txf->node_idx = sta_index;
2351 txf->vif_idx = 0;
2352 txf->tid = tid;
2353 if (m->m_pkthdr.len + IEEE80211_CRC_LEN > ic->ic_rtsthreshold)
2354 txf->flags |= htobe32(AR_HTC_TX_RTSCTS);
2355 else if (ic->ic_flags & IEEE80211_F_USEPROT) {
2356 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
2357 txf->flags |= htobe32(AR_HTC_TX_CTSONLY);
2358 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
2359 txf->flags |= htobe32(AR_HTC_TX_RTSCTS);
2360 }
2361 txf->key_idx = 0xff;
2362 frm = (uint8_t *)&txf[1];
2363 }
2364 else {
2365 htc->endpoint_id = usc->usc_ep_mgmt;
2366
2367 txm = (struct ar_tx_mgmt *)&htc[1];
2368 memset(txm, 0, sizeof(*txm));
2369 txm->node_idx = sta_index;
2370 txm->vif_idx = 0;
2371 txm->key_idx = 0xff;
2372 frm = (uint8_t *)&txm[1];
2373 }
2374 /* Copy payload. */
2375 m_copydata(m, 0, m->m_pkthdr.len, (void *)frm);
2376 frm += m->m_pkthdr.len;
2377
2378 /* Finalize headers. */
2379 htc->payload_len = htobe16(frm - (uint8_t *)&htc[1]);
2380 hdr->len = htole16(frm - (uint8_t *)&hdr[1]);
2381 xferlen = frm - data->buf;
2382
2383 s = splnet();
2384 usbd_setup_xfer(data->xfer, data, data->buf, xferlen,
2385 USBD_FORCE_SHORT_XFER, ATHN_USB_TX_TIMEOUT, athn_usb_txeof);
2386 error = usbd_transfer(data->xfer);
2387 if (__predict_false(error != USBD_IN_PROGRESS && error != 0)) {
2388 splx(s);
2389 return error;
2390 }
2391 splx(s);
2392 return 0;
2393}
2394
2395Static void
2396athn_usb_start(struct ifnet *ifp)
2397{
2398 struct athn_softc *sc = ifp->if_softc;
2399 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
2400 struct ieee80211com *ic = &sc->sc_ic;
2401 struct athn_usb_tx_data *data;
2402 struct ether_header *eh;
2403 struct ieee80211_node *ni;
2404 struct mbuf *m;
2405
2406 if (usc->usc_dying)
2407 return;
2408
2409 DPRINTFN(DBG_FN, sc, "\n");
2410
2411 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
2412 return;
2413
2414 data = NULL;
2415 for (;;) {
2416 mutex_enter(&usc->usc_tx_mtx);
2417 if (data == NULL && !TAILQ_EMPTY(&usc->usc_tx_free_list)) {
2418 data = TAILQ_FIRST(&usc->usc_tx_free_list);
2419 TAILQ_REMOVE(&usc->usc_tx_free_list, data, next);
2420 }
2421 mutex_exit(&usc->usc_tx_mtx);
2422
2423 if (data == NULL) {
2424 ifp->if_flags |= IFF_OACTIVE;
2425 return;
2426 }
2427
2428 /* Send pending management frames first. */
2429 IF_DEQUEUE(&ic->ic_mgtq, m);
2430 if (m != NULL) {
2431 ni = M_GETCTX(m, struct ieee80211_node *);
2432 M_CLEARCTX(m);
2433 goto sendit;
2434 }
2435 if (ic->ic_state != IEEE80211_S_RUN)
2436 break;
2437
2438 /* Encapsulate and send data frames. */
2439 IFQ_DEQUEUE(&ifp->if_snd, m);
2440 if (m == NULL)
2441 break;
2442
2443 if (m->m_len < (int)sizeof(*eh) &&
2444 (m = m_pullup(m, sizeof(*eh))) == NULL) {
2445 ifp->if_oerrors++;
2446 continue;
2447 }
2448 eh = mtod(m, struct ether_header *);
2449 ni = ieee80211_find_txnode(ic, eh->ether_dhost);
2450 if (ni == NULL) {
2451 m_freem(m);
2452 ifp->if_oerrors++;
2453 continue;
2454 }
2455
2456 bpf_mtap(ifp, m);
2457
2458 if ((m = ieee80211_encap(ic, m, ni)) == NULL) {
2459 ieee80211_free_node(ni);
2460 ifp->if_oerrors++;
2461 continue;
2462 }
2463 sendit:
2464 bpf_mtap3(ic->ic_rawbpf, m);
2465
2466 if (athn_usb_tx(sc, m, ni, data) != 0) {
2467 m_freem(m);
2468 ieee80211_free_node(ni);
2469 ifp->if_oerrors++;
2470 continue;
2471 }
2472 data = NULL;
2473 m_freem(m);
2474 ieee80211_free_node(ni);
2475 sc->sc_tx_timer = 5;
2476 ifp->if_timer = 1;
2477 }
2478
2479 /* Return the Tx buffer to the free list */
2480 mutex_enter(&usc->usc_tx_mtx);
2481 TAILQ_INSERT_TAIL(&usc->usc_tx_free_list, data, next);
2482 mutex_exit(&usc->usc_tx_mtx);
2483}
2484
2485Static void
2486athn_usb_watchdog(struct ifnet *ifp)
2487{
2488 struct athn_softc *sc = ifp->if_softc;
2489
2490 DPRINTFN(DBG_FN, sc, "\n");
2491
2492 ifp->if_timer = 0;
2493
2494 if (sc->sc_tx_timer > 0) {
2495 if (--sc->sc_tx_timer == 0) {
2496 aprint_error_dev(sc->sc_dev, "device timeout\n");
2497 /* athn_usb_init(ifp); XXX needs a process context! */
2498 ifp->if_oerrors++;
2499 return;
2500 }
2501 ifp->if_timer = 1;
2502 }
2503 ieee80211_watchdog(&sc->sc_ic);
2504}
2505
2506Static int
2507athn_usb_ioctl(struct ifnet *ifp, u_long cmd, void *data)
2508{
2509 struct athn_softc *sc = ifp->if_softc;
2510 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
2511 struct ieee80211com *ic = &sc->sc_ic;
2512 int s, error = 0;
2513
2514 if (usc->usc_dying)
2515 return EIO;
2516
2517 DPRINTFN(DBG_FN, sc, "cmd=0x%08lx\n", cmd);
2518
2519 s = splnet();
2520
2521 switch (cmd) {
2522 case SIOCSIFFLAGS:
2523 if ((error = ifioctl_common(ifp, cmd, data)) != 0)
2524 break;
2525
2526 switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
2527 case IFF_UP | IFF_RUNNING:
2528 break;
2529 case IFF_UP:
2530 error = athn_usb_init(ifp);
2531 break;
2532 case IFF_RUNNING:
2533 athn_usb_stop(ifp);
2534 break;
2535 case 0:
2536 default:
2537 break;
2538 }
2539 break;
2540
2541 case SIOCADDMULTI:
2542 case SIOCDELMULTI:
2543 if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) {
2544 /* setup multicast filter, etc */
2545 error = 0;
2546 }
2547 break;
2548
2549 case SIOCS80211CHANNEL:
2550 error = ieee80211_ioctl(ic, cmd, data);
2551 if (error == ENETRESET &&
2552 ic->ic_opmode == IEEE80211_M_MONITOR) {
2553 if (IS_UP_AND_RUNNING(ifp))
2554 athn_usb_switch_chan(sc, ic->ic_curchan, NULL);
2555 error = 0;
2556 }
2557 break;
2558
2559 default:
2560 error = ieee80211_ioctl(ic, cmd, data);
2561 break;
2562 }
2563 if (error == ENETRESET) {
2564 error = 0;
2565 if (IS_UP_AND_RUNNING(ifp) &&
2566 ic->ic_roaming != IEEE80211_ROAMING_MANUAL) {
2567 athn_usb_stop(ifp);
2568 error = athn_usb_init(ifp);
2569 }
2570 }
2571 splx(s);
2572 return error;
2573}
2574
2575Static int
2576athn_usb_init(struct ifnet *ifp)
2577{
2578 struct athn_softc *sc = ifp->if_softc;
2579 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
2580 struct athn_ops *ops = &sc->sc_ops;
2581 struct ieee80211com *ic = &sc->sc_ic;
2582 struct ieee80211_channel *curchan, *extchan;
2583 struct athn_usb_rx_data *data;
2584 struct ar_htc_target_vif hvif;
2585 struct ar_htc_target_sta sta;
2586 struct ar_htc_cap_target hic;
2587 uint16_t mode;
2588 size_t i;
2589 int error;
2590
2591 if (usc->usc_dying)
2592 return USBD_CANCELLED;
2593
2594 DPRINTFN(DBG_FN, sc, "\n");
2595
2596 /* Init host async commands ring. */
2597 mutex_spin_enter(&usc->usc_task_mtx);
2598 usc->usc_cmdq.cur = usc->usc_cmdq.next = usc->usc_cmdq.queued = 0;
2599 mutex_spin_exit(&usc->usc_task_mtx);
2600
2601 /* Steal one buffer for beacons. */
2602 mutex_enter(&usc->usc_tx_mtx);
2603 usc->usc_tx_bcn = TAILQ_FIRST(&usc->usc_tx_free_list);
2604 TAILQ_REMOVE(&usc->usc_tx_free_list, usc->usc_tx_bcn, next);
2605 mutex_exit(&usc->usc_tx_mtx);
2606
2607 curchan = ic->ic_curchan;
2608 extchan = NULL;
2609
2610 /* In case a new MAC address has been configured. */
2611 IEEE80211_ADDR_COPY(ic->ic_myaddr, CLLADDR(ifp->if_sadl));
2612
2613 error = athn_set_power_awake(sc);
2614 if (error != 0)
2615 goto fail;
2616
2617 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_FLUSH_RECV);
2618 if (error != 0)
2619 goto fail;
2620
2621 error = athn_hw_reset(sc, curchan, extchan, 1);
2622 if (error != 0)
2623 goto fail;
2624
2625 ops->set_txpower(sc, curchan, extchan);
2626
2627 mode = htobe16(IEEE80211_IS_CHAN_2GHZ(curchan) ?
2628 AR_HTC_MODE_11NG : AR_HTC_MODE_11NA);
2629 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_SET_MODE,
2630 &mode, sizeof(mode), NULL);
2631 if (error != 0)
2632 goto fail;
2633
2634 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_ATH_INIT);
2635 if (error != 0)
2636 goto fail;
2637
2638 error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_START_RECV);
2639 if (error != 0)
2640 goto fail;
2641
2642 athn_rx_start(sc);
2643
2644 /* Create main interface on target. */
2645 memset(&hvif, 0, sizeof(hvif));
2646 hvif.index = 0;
2647 IEEE80211_ADDR_COPY(hvif.myaddr, ic->ic_myaddr);
2648 switch (ic->ic_opmode) {
2649 case IEEE80211_M_STA:
2650 hvif.opmode = htobe32(AR_HTC_M_STA);
2651 break;
2652 case IEEE80211_M_MONITOR:
2653 hvif.opmode = htobe32(AR_HTC_M_MONITOR);
2654 break;
2655#ifndef IEEE80211_STA_ONLY
2656 case IEEE80211_M_IBSS:
2657 hvif.opmode = htobe32(AR_HTC_M_IBSS);
2658 break;
2659 case IEEE80211_M_AHDEMO:
2660 hvif.opmode = htobe32(AR_HTC_M_AHDEMO);
2661 break;
2662 case IEEE80211_M_HOSTAP:
2663 hvif.opmode = htobe32(AR_HTC_M_HOSTAP);
2664 break;
2665#endif
2666 }
2667 hvif.rtsthreshold = htobe16(ic->ic_rtsthreshold);
2668 DPRINTFN(DBG_INIT, sc, "creating VAP\n");
2669 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_VAP_CREATE,
2670 &hvif, sizeof(hvif), NULL);
2671 if (error != 0)
2672 goto fail;
2673
2674 /* Create a fake node to send management frames before assoc. */
2675 memset(&sta, 0, sizeof(sta));
2676 IEEE80211_ADDR_COPY(sta.macaddr, ic->ic_myaddr);
2677 sta.sta_index = 0;
2678 sta.is_vif_sta = 1;
2679 sta.vif_index = hvif.index;
2680 sta.maxampdu = 0xffff;
2681
2682 DPRINTFN(DBG_INIT | DBG_NODES, sc, "creating default node %u\n",
2683 sta.sta_index);
2684 error = athn_usb_create_hw_node(usc, &sta);
2685 if (error != 0)
2686 goto fail;
2687
2688 /* Update target capabilities. */
2689 memset(&hic, 0, sizeof(hic));
2690 hic.flags = htobe32(0x400c2400);
2691 hic.flags_ext = htobe32(0x00106080);
2692 hic.ampdu_limit = htobe32(0x0000ffff);
2693 hic.ampdu_subframes = 20;
2694 hic.protmode = 1; /* XXX */
2695 hic.lg_txchainmask = sc->sc_txchainmask;
2696 hic.ht_txchainmask = sc->sc_txchainmask;
2697 DPRINTFN(DBG_INIT, sc, "updating target configuration\n");
2698 error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_TARGET_IC_UPDATE,
2699 &hic, sizeof(hic), NULL);
2700 if (error != 0)
2701 goto fail;
2702
2703 /* Queue Rx xfers. */
2704 for (i = 0; i < ATHN_USB_RX_LIST_COUNT; i++) {
2705 data = &usc->usc_rx_data[i];
2706
2707 usbd_setup_xfer(data->xfer, data, data->buf,
2708 ATHN_USB_RXBUFSZ, USBD_SHORT_XFER_OK,
2709 USBD_NO_TIMEOUT, athn_usb_rxeof);
2710 error = usbd_transfer(data->xfer);
2711 if (error != 0 && error != USBD_IN_PROGRESS)
2712 goto fail;
2713 }
2714 /* We're ready to go. */
2715 ifp->if_flags &= ~IFF_OACTIVE;
2716 ifp->if_flags |= IFF_RUNNING;
2717
2718#ifdef notyet
2719 if (ic->ic_flags & IEEE80211_F_WEPON) {
2720 /* Install WEP keys. */
2721 for (i = 0; i < IEEE80211_WEP_NKID; i++)
2722 athn_usb_set_key(ic, NULL, &ic->ic_nw_keys[i]);
2723 }
2724#endif
2725 if (ic->ic_opmode == IEEE80211_M_HOSTAP)
2726 ic->ic_max_aid = AR_USB_MAX_STA; /* Firmware is limited to 8 STA */
2727 else
2728 ic->ic_max_aid = sc->sc_max_aid;
2729
2730 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2731 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
2732 else
2733 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
2734 athn_usb_wait_async(usc);
2735 return 0;
2736 fail:
2737 athn_usb_stop(ifp);
2738 return error;
2739}
2740
2741Static void
2742athn_usb_stop(struct ifnet *ifp)
2743{
2744 struct athn_softc *sc = ifp->if_softc;
2745 struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
2746 struct ieee80211com *ic = &sc->sc_ic;
2747 struct ar_htc_target_vif hvif;
2748 struct mbuf *m;
2749 uint8_t sta_index;
2750 int s;
2751
2752 DPRINTFN(DBG_FN, sc, "\n");
2753
2754 s = splusb();
2755 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
2756 athn_usb_wait_async(usc);
2757 splx(s);
2758
2759 sc->sc_tx_timer = 0;
2760 ifp->if_timer = 0;
2761 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2762
2763 callout_stop(&sc->sc_scan_to);
2764 callout_stop(&sc->sc_calib_to);
2765
2766 /* Abort Tx/Rx. */
2767 usbd_abort_pipe(usc->usc_tx_data_pipe);
2768 usbd_abort_pipe(usc->usc_rx_data_pipe);
2769
2770 /* Free Tx/Rx buffers. */
2771 athn_usb_free_tx_list(usc);
2772 athn_usb_free_rx_list(usc);
2773
2774 /* Flush Rx stream. */
2775 CTASSERT(sizeof(m) == sizeof(void *));
2776 m = atomic_swap_ptr(&usc->usc_rx_stream.m, NULL);
2777 m_freem(m);
2778 usc->usc_rx_stream.left = 0;
2779
2780 /* Remove main interface. */
2781 memset(&hvif, 0, sizeof(hvif));
2782 hvif.index = 0;
2783 IEEE80211_ADDR_COPY(hvif.myaddr, ic->ic_myaddr);
2784 (void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_VAP_REMOVE,
2785 &hvif, sizeof(hvif), NULL);
2786
2787 /* Remove default node. */
2788 sta_index = 0;
2789 DPRINTFN(DBG_NODES, usc, "removing node %u\n", sta_index);
2790 (void)athn_usb_remove_hw_node(usc, &sta_index);
2791
2792 (void)athn_usb_wmi_cmd(usc, AR_WMI_CMD_DISABLE_INTR);
2793 (void)athn_usb_wmi_cmd(usc, AR_WMI_CMD_DRAIN_TXQ_ALL);
2794 (void)athn_usb_wmi_cmd(usc, AR_WMI_CMD_STOP_RECV);
2795
2796 athn_reset(sc, 0);
2797 athn_init_pll(sc, NULL);
2798 athn_set_power_awake(sc);
2799 athn_reset(sc, 1);
2800 athn_init_pll(sc, NULL);
2801 athn_set_power_sleep(sc);
2802}
2803
2804MODULE(MODULE_CLASS_DRIVER, if_athn_usb, "bpf");
2805
2806#ifdef _MODULE
2807#include "ioconf.c"
2808#endif
2809
2810static int
2811if_athn_usb_modcmd(modcmd_t cmd, void *aux)
2812{
2813 int error = 0;
2814
2815 switch (cmd) {
2816 case MODULE_CMD_INIT:
2817#ifdef _MODULE
2818 error = config_init_component(cfdriver_ioconf_if_athn_usb,
2819 cfattach_ioconf_if_athn_usb, cfdata_ioconf_if_athn_usb);
2820#endif
2821 return error;
2822 case MODULE_CMD_FINI:
2823#ifdef _MODULE
2824 error = config_fini_component(cfdriver_ioconf_if_athn_usb,
2825 cfattach_ioconf_if_athn_usb, cfdata_ioconf_if_athn_usb);
2826#endif
2827 return error;
2828 default:
2829 return ENOTTY;
2830 }
2831}
2832