#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_athn_usb.c,v 1.39 2024/01/11 00:31:02 gutteridge Exp $");
#ifdef _KERNEL_OPT
#include "opt_inet.h"
#endif
#include <sys/param.h>
#include <sys/callout.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/mbuf.h>
#include <sys/module.h>
#include <sys/proc.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/bus.h>
#include <sys/endian.h>
#include <sys/intr.h>
#include <net/bpf.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <net/if_dl.h>
#include <net/if_ether.h>
#include <net/if_media.h>
#include <net/if_types.h>
#include <netinet/if_inarp.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <net80211/ieee80211_var.h>
#include <net80211/ieee80211_amrr.h>
#include <net80211/ieee80211_radiotap.h>
#include <dev/firmload.h>
#include <dev/usb/usb.h>
#include <dev/usb/usbdevs.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/ic/athnreg.h>
#include <dev/ic/athnvar.h>
#include <dev/ic/arn9285.h>
#include <dev/usb/if_athn_usb.h>
#define ATHN_USB_SOFTC(sc) ((struct athn_usb_softc *)(sc))
#define ATHN_USB_NODE(ni) ((struct athn_usb_node *)(ni))
#define IS_UP_AND_RUNNING(ifp) \
(((ifp)->if_flags & IFF_UP) && ((ifp)->if_flags & IFF_RUNNING))
#define athn_usb_wmi_cmd(sc, cmd_id) \
athn_usb_wmi_xcmd(sc, cmd_id, NULL, 0, NULL)
Static int athn_usb_activate(device_t, enum devact);
Static int athn_usb_detach(device_t, int);
Static int athn_usb_match(device_t, cfdata_t, void *);
Static void athn_usb_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(athn_usb, sizeof(struct athn_usb_softc), athn_usb_match,
athn_usb_attach, athn_usb_detach, athn_usb_activate);
Static int athn_usb_alloc_rx_list(struct athn_usb_softc *);
Static int athn_usb_alloc_tx_cmd(struct athn_usb_softc *);
Static int athn_usb_alloc_tx_msg(struct athn_usb_softc *);
Static int athn_usb_alloc_tx_list(struct athn_usb_softc *);
Static void athn_usb_attachhook(device_t);
Static void athn_usb_bcneof(struct usbd_xfer *, void *,
usbd_status);
Static void athn_usb_abort_pipes(struct athn_usb_softc *);
Static void athn_usb_close_pipes(struct athn_usb_softc *);
Static int athn_usb_create_hw_node(struct athn_usb_softc *,
struct ar_htc_target_sta *);
Static int athn_usb_create_node(struct athn_usb_softc *,
struct ieee80211_node *);
Static void athn_usb_do_async(struct athn_usb_softc *,
void (*)(struct athn_usb_softc *, void *), void *, int);
Static void athn_usb_free_rx_list(struct athn_usb_softc *);
Static void athn_usb_free_tx_cmd(struct athn_usb_softc *);
Static void athn_usb_free_tx_msg(struct athn_usb_softc *);
Static void athn_usb_free_tx_list(struct athn_usb_softc *);
Static int athn_usb_htc_connect_svc(struct athn_usb_softc *, uint16_t,
uint8_t, uint8_t, uint8_t *);
Static int athn_usb_htc_msg(struct athn_usb_softc *, uint16_t, void *,
int);
Static int athn_usb_htc_setup(struct athn_usb_softc *);
Static int athn_usb_init(struct ifnet *);
Static int athn_usb_init_locked(struct ifnet *);
Static void athn_usb_intr(struct usbd_xfer *, void *,
usbd_status);
Static int athn_usb_ioctl(struct ifnet *, u_long, void *);
Static int athn_usb_load_firmware(struct athn_usb_softc *);
Static const struct athn_usb_type *
athn_usb_lookup(int, int);
Static int athn_usb_media_change(struct ifnet *);
Static void athn_usb_newassoc(struct ieee80211_node *, int);
Static void athn_usb_newassoc_cb(struct athn_usb_softc *, void *);
Static int athn_usb_newstate(struct ieee80211com *, enum ieee80211_state,
int);
Static void athn_usb_newstate_cb(struct athn_usb_softc *, void *);
Static void athn_usb_node_cleanup(struct ieee80211_node *);
Static void athn_usb_node_cleanup_cb(struct athn_usb_softc *, void *);
Static int athn_usb_open_pipes(struct athn_usb_softc *);
Static uint32_t athn_usb_read(struct athn_softc *, uint32_t);
Static int athn_usb_remove_hw_node(struct athn_usb_softc *, uint8_t *);
Static void athn_usb_rx_enable(struct athn_softc *);
Static void athn_usb_rx_frame(struct athn_usb_softc *, struct mbuf *);
Static void athn_usb_rx_radiotap(struct athn_softc *, struct mbuf *,
struct ar_rx_status *);
Static void athn_usb_rx_wmi_ctrl(struct athn_usb_softc *, uint8_t *, size_t);
Static void athn_usb_rxeof(struct usbd_xfer *, void *,
usbd_status);
Static void athn_usb_start(struct ifnet *);
Static void athn_usb_stop(struct ifnet *, int disable);
Static void athn_usb_stop_locked(struct ifnet *);
Static void athn_usb_swba(struct athn_usb_softc *);
Static int athn_usb_switch_chan(struct athn_softc *,
struct ieee80211_channel *, struct ieee80211_channel *);
Static void athn_usb_task(void *);
Static int athn_usb_tx(struct athn_softc *, struct mbuf *,
struct ieee80211_node *, struct athn_usb_tx_data *);
Static void athn_usb_txeof(struct usbd_xfer *, void *,
usbd_status);
Static void athn_usb_updateslot(struct ifnet *);
Static void athn_usb_updateslot_cb(struct athn_usb_softc *, void *);
Static void athn_usb_wait_async(struct athn_usb_softc *);
Static int athn_usb_wait_msg(struct athn_usb_softc *);
Static void athn_usb_watchdog(struct ifnet *);
Static int athn_usb_wmi_xcmd(struct athn_usb_softc *, uint16_t, void *,
int, void *);
Static void athn_usb_wmieof(struct usbd_xfer *, void *,
usbd_status);
Static void athn_usb_write(struct athn_softc *, uint32_t, uint32_t);
Static void athn_usb_write_barrier(struct athn_softc *);
#ifdef unused
Static int athn_usb_read_rom(struct athn_softc *);
#endif
#ifdef notyet_edca
Static void athn_usb_updateedca(struct ieee80211com *);
Static void athn_usb_updateedca_cb(struct athn_usb_softc *, void *);
#endif
#ifdef notyet
Static int athn_usb_ampdu_tx_start(struct ieee80211com *,
struct ieee80211_node *, uint8_t);
Static void athn_usb_ampdu_tx_start_cb(struct athn_usb_softc *, void *);
Static void athn_usb_ampdu_tx_stop(struct ieee80211com *,
struct ieee80211_node *, uint8_t);
Static void athn_usb_ampdu_tx_stop_cb(struct athn_usb_softc *, void *);
Static void athn_usb_delete_key(struct ieee80211com *,
struct ieee80211_node *, struct ieee80211_key *);
Static void athn_usb_delete_key_cb(struct athn_usb_softc *, void *);
Static int athn_usb_set_key(struct ieee80211com *,
struct ieee80211_node *, struct ieee80211_key *);
Static void athn_usb_set_key_cb(struct athn_usb_softc *, void *);
#endif
struct athn_usb_type {
struct usb_devno devno;
u_int flags;
};
Static const struct athn_usb_type *
athn_usb_lookup(int vendor, int product)
{
static const struct athn_usb_type athn_usb_devs[] = {
#define _D(v,p,f) \
{{ USB_VENDOR_##v, USB_PRODUCT_##p }, ATHN_USB_FLAG_##f }
_D( ACCTON, ACCTON_AR9280, AR7010 ),
_D( ACTIONTEC, ACTIONTEC_AR9287, AR7010 ),
_D( ATHEROS2, ATHEROS2_AR9271_1, NONE ),
_D( ATHEROS2, ATHEROS2_AR9271_2, NONE ),
_D( ATHEROS2, ATHEROS2_AR9271_3, NONE ),
_D( ATHEROS2, ATHEROS2_AR9280, AR7010 ),
_D( ATHEROS2, ATHEROS2_AR9287, AR7010 ),
_D( AZUREWAVE, AZUREWAVE_AR9271_1, NONE ),
_D( AZUREWAVE, AZUREWAVE_AR9271_2, NONE ),
_D( AZUREWAVE, AZUREWAVE_AR9271_3, NONE ),
_D( AZUREWAVE, AZUREWAVE_AR9271_4, NONE ),
_D( AZUREWAVE, AZUREWAVE_AR9271_5, NONE ),
_D( AZUREWAVE, AZUREWAVE_AR9271_6, NONE ),
_D( DLINK2, DLINK2_AR9271, NONE ),
_D( LITEON, LITEON_AR9271, NONE ),
_D( NETGEAR, NETGEAR_WNA1100, NONE ),
_D( NETGEAR, NETGEAR_WNDA3200, AR7010 ),
_D( VIA, VIA_AR9271, NONE ),
_D( MELCO, MELCO_CEWL_1, AR7010 ),
_D( PANASONIC, PANASONIC_N5HBZ0000055, AR7010 ),
#undef _D
};
return (const void *)usb_lookup(athn_usb_devs, vendor, product);
}
Static int
athn_usb_match(device_t parent, cfdata_t match, void *aux)
{
struct usb_attach_arg *uaa = aux;
return athn_usb_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
}
Static void
athn_usb_attach(device_t parent, device_t self, void *aux)
{
struct athn_usb_softc *usc;
struct athn_softc *sc;
struct usb_attach_arg *uaa;
char *devinfop;
int error;
usc = device_private(self);
sc = &usc->usc_sc;
uaa = aux;
sc->sc_dev = self;
usc->usc_udev = uaa->uaa_device;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(usc->usc_udev, 0);
aprint_normal_dev(sc->sc_dev, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
DPRINTFN(DBG_FN, sc, "\n");
usc->usc_init_state = ATHN_INIT_NONE;
usc->usc_athn_attached = 0;
usc->usc_flags = athn_usb_lookup(uaa->uaa_vendor, uaa->uaa_product)->flags;
sc->sc_flags |= ATHN_FLAG_USB;
#ifdef notyet
if (strncmp(product, "wb193", 5) == 0)
sc->sc_flags |= ATHN_FLAG_BTCOEX3WIRE;
#endif
sc->sc_ops.read = athn_usb_read;
sc->sc_ops.write = athn_usb_write;
sc->sc_ops.write_barrier = athn_usb_write_barrier;
mutex_init(&usc->usc_lock, MUTEX_DEFAULT, IPL_NONE);
cv_init(&usc->usc_wmi_cv, "athnwmi");
cv_init(&usc->usc_htc_cv, "athnhtc");
cv_init(&usc->usc_cmd_cv, "athncmd");
mutex_init(&usc->usc_cmd_mtx, MUTEX_DEFAULT, IPL_SOFTUSB);
cv_init(&usc->usc_msg_cv, "athnmsg");
mutex_init(&usc->usc_msg_mtx, MUTEX_DEFAULT, IPL_SOFTUSB);
cv_init(&usc->usc_task_cv, "athntsk");
mutex_init(&usc->usc_task_mtx, MUTEX_DEFAULT, IPL_NET);
mutex_init(&usc->usc_tx_mtx, MUTEX_DEFAULT, IPL_NONE);
usb_init_task(&usc->usc_task, athn_usb_task, usc, 0);
if (usbd_set_config_no(usc->usc_udev, 1, 0) != 0) {
aprint_error_dev(sc->sc_dev,
"could not set configuration no\n");
goto fail;
}
error = usbd_device2interface_handle(usc->usc_udev, 0, &usc->usc_iface);
if (error != 0) {
aprint_error_dev(sc->sc_dev,
"could not get interface handle\n");
goto fail;
}
if (athn_usb_open_pipes(usc) != 0)
goto fail;
if (athn_usb_alloc_tx_cmd(usc) != 0)
goto fail;
if (athn_usb_alloc_tx_msg(usc) != 0)
goto fail;
error = athn_usb_alloc_rx_list(usc);
if (error != 0)
goto fail;
error = athn_usb_alloc_tx_list(usc);
if (error != 0)
goto fail;
config_mountroot(self, athn_usb_attachhook);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, usc->usc_udev, sc->sc_dev);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
usc->usc_init_state = ATHN_INIT_INITED;
return;
fail:
athn_usb_abort_pipes(usc);
athn_usb_free_tx_list(usc);
athn_usb_free_rx_list(usc);
athn_usb_free_tx_cmd(usc);
athn_usb_free_tx_msg(usc);
athn_usb_close_pipes(usc);
usb_rem_task_wait(usc->usc_udev, &usc->usc_task, USB_TASKQ_DRIVER,
NULL);
cv_destroy(&usc->usc_cmd_cv);
cv_destroy(&usc->usc_msg_cv);
cv_destroy(&usc->usc_wmi_cv);
cv_destroy(&usc->usc_htc_cv);
mutex_destroy(&usc->usc_lock);
mutex_destroy(&usc->usc_cmd_mtx);
mutex_destroy(&usc->usc_msg_mtx);
mutex_destroy(&usc->usc_tx_mtx);
mutex_destroy(&usc->usc_task_mtx);
}
Static void
athn_usb_node_cleanup_cb(struct athn_usb_softc *usc, void *arg)
{
uint8_t sta_index = *(uint8_t *)arg;
DPRINTFN(DBG_FN, usc, "\n");
DPRINTFN(DBG_NODES, usc, "removing node %u\n", sta_index);
athn_usb_remove_hw_node(usc, &sta_index);
}
Static void
athn_usb_node_cleanup(struct ieee80211_node *ni)
{
struct athn_usb_softc *usc;
struct ieee80211com *ic;
uint8_t sta_index;
usc = ATHN_USB_SOFTC(ni->ni_ic->ic_ifp->if_softc);
ic = &ATHN_SOFTC(usc)->sc_ic;
DPRINTFN(DBG_FN, usc, "\n");
if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
sta_index = ATHN_NODE(ni)->sta_index;
if (sta_index != 0)
athn_usb_do_async(usc, athn_usb_node_cleanup_cb,
&sta_index, sizeof(sta_index));
}
usc->usc_node_cleanup(ni);
}
Static void
athn_usb_attachhook(device_t arg)
{
struct athn_usb_softc *usc = device_private(arg);
struct athn_softc *sc = &usc->usc_sc;
struct athn_ops *ops = &sc->sc_ops;
struct ieee80211com *ic = &sc->sc_ic;
struct ifnet *ifp = &sc->sc_if;
size_t i;
int error;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, usc, "\n");
error = athn_usb_load_firmware(usc);
if (error != 0) {
aprint_error_dev(sc->sc_dev,
"could not load firmware (%d)\n", error);
return;
}
error = athn_usb_htc_setup(usc);
if (error != 0)
return;
ic->ic_ifp = ifp;
ic->ic_updateslot = athn_usb_updateslot;
sc->sc_max_aid = AR_USB_MAX_STA;
sc->sc_media_change = athn_usb_media_change;
ifp->if_init = athn_usb_init;
ifp->if_stop = athn_usb_stop;
ifp->if_ioctl = athn_usb_ioctl;
ifp->if_start = athn_usb_start;
ifp->if_watchdog = athn_usb_watchdog;
error = athn_attach(sc);
if (error != 0) {
return;
}
usc->usc_athn_attached = 1;
ic->ic_newassoc = athn_usb_newassoc;
usc->usc_node_cleanup = ic->ic_node_cleanup;
ic->ic_node_cleanup = athn_usb_node_cleanup;
#ifdef notyet_edca
ic->ic_updateedca = athn_usb_updateedca;
#endif
#ifdef notyet
ic->ic_set_key = athn_usb_set_key;
ic->ic_delete_key = athn_usb_delete_key;
ic->ic_ampdu_tx_start = athn_usb_ampdu_tx_start;
ic->ic_ampdu_tx_stop = athn_usb_ampdu_tx_stop;
#endif
ic->ic_newstate = athn_usb_newstate;
ops->rx_enable = athn_usb_rx_enable;
for (i = 0; i < sc->sc_kc_entries; i++)
athn_reset_key(sc, i);
ops->enable_antenna_diversity(sc);
#ifdef ATHN_BT_COEXISTENCE
if (sc->sc_flags & ATHN_FLAG_BTCOEX)
athn_btcoex_init(sc);
#endif
athn_led_init(sc);
ieee80211_announce(ic);
}
Static int
athn_usb_detach(device_t self, int flags)
{
struct athn_usb_softc *usc = device_private(self);
struct athn_softc *sc = &usc->usc_sc;
int error;
DPRINTFN(DBG_FN, usc, "\n");
if (usc->usc_init_state < ATHN_INIT_INITED)
return 0;
pmf_device_deregister(self);
mutex_enter(&usc->usc_lock);
usc->usc_dying = 1;
mutex_exit(&usc->usc_lock);
mutex_enter(&usc->usc_cmd_mtx);
while (usc->usc_wmiactive) {
error = cv_timedwait(&usc->usc_wmi_cv, &usc->usc_cmd_mtx, hz);
if (error) {
mutex_exit(&usc->usc_cmd_mtx);
return error;
}
}
mutex_exit(&usc->usc_cmd_mtx);
mutex_enter(&usc->usc_msg_mtx);
while (usc->usc_htcactive) {
error = cv_timedwait(&usc->usc_htc_cv, &usc->usc_msg_mtx, hz);
if (error) {
mutex_exit(&usc->usc_msg_mtx);
return error;
}
}
mutex_exit(&usc->usc_msg_mtx);
athn_usb_wait_async(usc);
athn_usb_stop(&sc->sc_if, 0);
usb_rem_task_wait(usc->usc_udev, &usc->usc_task, USB_TASKQ_DRIVER,
NULL);
athn_usb_abort_pipes(usc);
if (usc->usc_athn_attached) {
usc->usc_athn_attached = 0;
athn_detach(sc);
}
athn_usb_free_rx_list(usc);
athn_usb_free_tx_list(usc);
athn_usb_free_tx_cmd(usc);
athn_usb_free_tx_msg(usc);
athn_usb_close_pipes(usc);
mutex_destroy(&usc->usc_tx_mtx);
cv_destroy(&usc->usc_task_cv);
mutex_destroy(&usc->usc_task_mtx);
mutex_destroy(&usc->usc_cmd_mtx);
cv_destroy(&usc->usc_cmd_cv);
mutex_destroy(&usc->usc_msg_mtx);
cv_destroy(&usc->usc_msg_cv);
cv_destroy(&usc->usc_wmi_cv);
mutex_destroy(&usc->usc_lock);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, usc->usc_udev, sc->sc_dev);
return 0;
}
Static int
athn_usb_activate(device_t self, enum devact act)
{
struct athn_usb_softc *usc = device_private(self);
struct athn_softc *sc = &usc->usc_sc;
DPRINTFN(DBG_FN, usc, "\n");
switch (act) {
case DVACT_DEACTIVATE:
if_deactivate(sc->sc_ic.ic_ifp);
usc->usc_dying = 1;
return 0;
default:
return EOPNOTSUPP;
}
}
Static int
athn_usb_open_pipes(struct athn_usb_softc *usc)
{
usb_endpoint_descriptor_t *ed;
int error;
DPRINTFN(DBG_FN, usc, "\n");
error = usbd_open_pipe(usc->usc_iface, AR_PIPE_TX_DATA, 0,
&usc->usc_tx_data_pipe);
if (error != 0) {
aprint_error_dev(usc->usc_dev,
"could not open Tx bulk pipe\n");
goto fail;
}
error = usbd_open_pipe(usc->usc_iface, AR_PIPE_RX_DATA, 0,
&usc->usc_rx_data_pipe);
if (error != 0) {
aprint_error_dev(usc->usc_dev,
"could not open Rx bulk pipe\n");
goto fail;
}
ed = usbd_get_endpoint_descriptor(usc->usc_iface, AR_PIPE_RX_INTR);
if (ed == NULL) {
aprint_error_dev(usc->usc_dev,
"could not retrieve Rx intr pipe descriptor\n");
goto fail;
}
usc->usc_ibufsize = UGETW(ed->wMaxPacketSize);
if (usc->usc_ibufsize == 0) {
aprint_error_dev(usc->usc_dev,
"invalid Rx intr pipe descriptor\n");
goto fail;
}
usc->usc_ibuf = kmem_alloc(usc->usc_ibufsize, KM_SLEEP);
error = usbd_open_pipe_intr(usc->usc_iface, AR_PIPE_RX_INTR,
USBD_SHORT_XFER_OK, &usc->usc_rx_intr_pipe, usc, usc->usc_ibuf,
usc->usc_ibufsize, athn_usb_intr, USBD_DEFAULT_INTERVAL);
if (error != 0) {
aprint_error_dev(usc->usc_dev,
"could not open Rx intr pipe\n");
goto fail;
}
error = usbd_open_pipe(usc->usc_iface, AR_PIPE_TX_INTR, 0,
&usc->usc_tx_intr_pipe);
if (error != 0) {
aprint_error_dev(usc->usc_dev,
"could not open Tx intr pipe\n");
goto fail;
}
return 0;
fail:
athn_usb_abort_pipes(usc);
athn_usb_close_pipes(usc);
return error;
}
static inline void
athn_usb_kill_pipe(struct usbd_pipe **pipeptr)
{
struct usbd_pipe *pipe;
CTASSERT(sizeof(pipe) == sizeof(void *));
pipe = atomic_swap_ptr(pipeptr, NULL);
if (pipe != NULL) {
usbd_close_pipe(pipe);
}
}
Static void
athn_usb_abort_pipes(struct athn_usb_softc *usc)
{
DPRINTFN(DBG_FN, usc, "\n");
if (usc->usc_tx_data_pipe != NULL)
usbd_abort_pipe(usc->usc_tx_data_pipe);
if (usc->usc_rx_data_pipe != NULL)
usbd_abort_pipe(usc->usc_rx_data_pipe);
if (usc->usc_tx_intr_pipe != NULL)
usbd_abort_pipe(usc->usc_tx_intr_pipe);
if (usc->usc_rx_intr_pipe != NULL)
usbd_abort_pipe(usc->usc_rx_intr_pipe);
}
Static void
athn_usb_close_pipes(struct athn_usb_softc *usc)
{
uint8_t *ibuf;
DPRINTFN(DBG_FN, usc, "\n");
athn_usb_kill_pipe(&usc->usc_tx_data_pipe);
athn_usb_kill_pipe(&usc->usc_rx_data_pipe);
athn_usb_kill_pipe(&usc->usc_tx_intr_pipe);
athn_usb_kill_pipe(&usc->usc_rx_intr_pipe);
ibuf = atomic_swap_ptr(&usc->usc_ibuf, NULL);
if (ibuf != NULL)
kmem_free(ibuf, usc->usc_ibufsize);
}
Static int
athn_usb_alloc_rx_list(struct athn_usb_softc *usc)
{
struct athn_usb_rx_data *data;
size_t i;
int error = 0;
DPRINTFN(DBG_FN, usc, "\n");
for (i = 0; i < ATHN_USB_RX_LIST_COUNT; i++) {
data = &usc->usc_rx_data[i];
data->sc = usc;
error = usbd_create_xfer(usc->usc_rx_data_pipe,
ATHN_USB_RXBUFSZ, 0, 0, &data->xfer);
if (error) {
aprint_error_dev(usc->usc_dev,
"could not allocate xfer\n");
break;
}
data->buf = usbd_get_buffer(data->xfer);
}
if (error != 0)
athn_usb_free_rx_list(usc);
return error;
}
Static void
athn_usb_free_rx_list(struct athn_usb_softc *usc)
{
struct usbd_xfer *xfer;
size_t i;
DPRINTFN(DBG_FN, usc, "\n");
for (i = 0; i < ATHN_USB_RX_LIST_COUNT; i++) {
CTASSERT(sizeof(xfer) == sizeof(void *));
xfer = atomic_swap_ptr(&usc->usc_rx_data[i].xfer, NULL);
if (xfer != NULL)
usbd_destroy_xfer(xfer);
}
}
Static int
athn_usb_alloc_tx_list(struct athn_usb_softc *usc)
{
struct athn_usb_tx_data *data;
size_t i;
int error = 0;
DPRINTFN(DBG_FN, usc, "\n");
mutex_enter(&usc->usc_tx_mtx);
TAILQ_INIT(&usc->usc_tx_free_list);
for (i = 0; i < ATHN_USB_TX_LIST_COUNT; i++) {
data = &usc->usc_tx_data[i];
data->sc = usc;
error = usbd_create_xfer(usc->usc_tx_data_pipe,
ATHN_USB_TXBUFSZ, USBD_FORCE_SHORT_XFER, 0, &data->xfer);
if (error) {
aprint_error_dev(usc->usc_dev,
"could not create xfer on TX pipe\n");
break;
}
data->buf = usbd_get_buffer(data->xfer);
TAILQ_INSERT_TAIL(&usc->usc_tx_free_list, data, next);
}
if (error == 0) {
usc->usc_tx_bcn = TAILQ_FIRST(&usc->usc_tx_free_list);
TAILQ_REMOVE(&usc->usc_tx_free_list, usc->usc_tx_bcn, next);
} else {
athn_usb_free_tx_list(usc);
}
mutex_exit(&usc->usc_tx_mtx);
return error;
}
Static void
athn_usb_free_tx_list(struct athn_usb_softc *usc)
{
struct usbd_xfer *xfer;
size_t i;
DPRINTFN(DBG_FN, usc, "\n");
for (i = 0; i < ATHN_USB_TX_LIST_COUNT; i++) {
CTASSERT(sizeof(xfer) == sizeof(void *));
xfer = atomic_swap_ptr(&usc->usc_tx_data[i].xfer, NULL);
if (xfer != NULL)
usbd_destroy_xfer(xfer);
}
}
Static int
athn_usb_alloc_tx_cmd(struct athn_usb_softc *usc)
{
struct athn_usb_tx_data *data = &usc->usc_tx_cmd;
DPRINTFN(DBG_FN, usc, "\n");
data->sc = usc;
int err = usbd_create_xfer(usc->usc_tx_intr_pipe, ATHN_USB_TXCMDSZ,
0, 0, &data->xfer);
if (err) {
aprint_error_dev(usc->usc_dev,
"could not allocate command xfer\n");
return err;
}
data->buf = usbd_get_buffer(data->xfer);
return 0;
}
Static void
athn_usb_free_tx_cmd(struct athn_usb_softc *usc)
{
struct usbd_xfer *xfer;
DPRINTFN(DBG_FN, usc, "\n");
CTASSERT(sizeof(xfer) == sizeof(void *));
xfer = atomic_swap_ptr(&usc->usc_tx_cmd.xfer, NULL);
if (xfer != NULL)
usbd_destroy_xfer(xfer);
}
Static int
athn_usb_alloc_tx_msg(struct athn_usb_softc *usc)
{
struct athn_usb_tx_data *data = &usc->usc_tx_msg;
DPRINTFN(DBG_FN, usc, "\n");
data->sc = usc;
int err = usbd_create_xfer(usc->usc_tx_intr_pipe, ATHN_USB_TXCMDSZ,
0, 0, &data->xfer);
if (err) {
aprint_error_dev(usc->usc_dev,
"could not allocate command xfer\n");
return err;
}
data->buf = usbd_get_buffer(data->xfer);
return 0;
}
Static void
athn_usb_free_tx_msg(struct athn_usb_softc *usc)
{
struct usbd_xfer *xfer;
DPRINTFN(DBG_FN, usc, "\n");
CTASSERT(sizeof(xfer) == sizeof(void *));
xfer = atomic_swap_ptr(&usc->usc_tx_msg.xfer, NULL);
if (xfer != NULL)
usbd_destroy_xfer(xfer);
}
Static void
athn_usb_task(void *arg)
{
struct athn_usb_softc *usc = arg;
struct athn_usb_host_cmd_ring *ring = &usc->usc_cmdq;
struct athn_usb_host_cmd *cmd;
DPRINTFN(DBG_FN, usc, "\n");
mutex_spin_enter(&usc->usc_task_mtx);
while (ring->next != ring->cur) {
cmd = &ring->cmd[ring->next];
mutex_spin_exit(&usc->usc_task_mtx);
if (!usc->usc_dying)
cmd->cb(usc, cmd->data);
mutex_spin_enter(&usc->usc_task_mtx);
ring->queued--;
ring->next = (ring->next + 1) % ATHN_USB_HOST_CMD_RING_COUNT;
}
cv_broadcast(&usc->usc_task_cv);
mutex_spin_exit(&usc->usc_task_mtx);
}
Static void
athn_usb_do_async(struct athn_usb_softc *usc,
void (*cb)(struct athn_usb_softc *, void *), void *arg, int len)
{
struct athn_usb_host_cmd_ring *ring = &usc->usc_cmdq;
struct athn_usb_host_cmd *cmd;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, usc, "\n");
mutex_spin_enter(&usc->usc_task_mtx);
cmd = &ring->cmd[ring->cur];
cmd->cb = cb;
KASSERT(len <= sizeof(cmd->data));
memcpy(cmd->data, arg, len);
ring->cur = (ring->cur + 1) % ATHN_USB_HOST_CMD_RING_COUNT;
if (++ring->queued == 1) {
usb_add_task(usc->usc_udev, &usc->usc_task, USB_TASKQ_DRIVER);
}
mutex_spin_exit(&usc->usc_task_mtx);
}
Static void
athn_usb_wait_async(struct athn_usb_softc *usc)
{
DPRINTFN(DBG_FN, usc, "\n");
mutex_spin_enter(&usc->usc_task_mtx);
while (usc->usc_cmdq.queued > 0)
cv_wait(&usc->usc_task_cv, &usc->usc_task_mtx);
mutex_spin_exit(&usc->usc_task_mtx);
}
Static int
athn_usb_load_firmware(struct athn_usb_softc *usc)
{
struct athn_softc *sc = &usc->usc_sc;
firmware_handle_t fwh;
usb_device_descriptor_t *dd;
usb_device_request_t req;
const char *name;
u_char *fw, *ptr;
size_t size, remain;
uint32_t addr;
int mlen, error;
DPRINTFN(DBG_FN, sc, "\n");
if (usc->usc_flags & ATHN_USB_FLAG_AR7010) {
dd = usbd_get_device_descriptor(usc->usc_udev);
if (UGETW(dd->bcdDevice) == 0x0202)
name = "athn-ar7010-11";
else
name = "athn-ar7010";
} else
name = "athn-ar9271";
if ((error = firmware_open("if_athn", name, &fwh)) != 0) {
aprint_error_dev(sc->sc_dev,
"failed to open firmware file %s (%d)\n", name, error);
return error;
}
size = firmware_get_size(fwh);
fw = firmware_malloc(size);
if (fw == NULL) {
aprint_error_dev(usc->usc_dev,
"failed to allocate firmware memory\n");
firmware_close(fwh);
return ENOMEM;
}
error = firmware_read(fwh, 0, fw, size);
firmware_close(fwh);
if (error != 0) {
aprint_error_dev(usc->usc_dev,
"failed to read firmware (error %d)\n", error);
firmware_free(fw, size);
return error;
}
ptr = fw;
addr = AR9271_FIRMWARE >> 8;
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = AR_FW_DOWNLOAD;
USETW(req.wIndex, 0);
remain = size;
while (remain > 0) {
mlen = MIN(remain, 4096);
USETW(req.wValue, addr);
USETW(req.wLength, mlen);
error = usbd_do_request(usc->usc_udev, &req, ptr);
if (error != 0) {
firmware_free(fw, size);
return error;
}
addr += mlen >> 8;
ptr += mlen;
remain -= mlen;
}
firmware_free(fw, size);
if (usc->usc_flags & ATHN_USB_FLAG_AR7010)
addr = AR7010_FIRMWARE_TEXT >> 8;
else
addr = AR9271_FIRMWARE_TEXT >> 8;
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = AR_FW_DOWNLOAD_COMP;
USETW(req.wIndex, 0);
USETW(req.wValue, addr);
USETW(req.wLength, 0);
mutex_enter(&usc->usc_msg_mtx);
while (usc->usc_htcactive) {
error = cv_timedwait(&usc->usc_htc_cv, &usc->usc_msg_mtx, hz);
if (error) {
mutex_exit(&usc->usc_msg_mtx);
return error;
}
}
usc->usc_htcactive = true;
KASSERT(usc->usc_wait_msg_id == 0);
usc->usc_wait_msg_id = AR_HTC_MSG_READY;
mutex_exit(&usc->usc_msg_mtx);
error = usbd_do_request(usc->usc_udev, &req, NULL);
mutex_enter(&usc->usc_msg_mtx);
if (error == 0)
error = athn_usb_wait_msg(usc);
usc->usc_htcactive = false;
cv_broadcast(&usc->usc_htc_cv);
mutex_exit(&usc->usc_msg_mtx);
DPRINTFN(DBG_FN, sc, "return %d\n", error);
return error;
}
Static int
athn_usb_htc_msg(struct athn_usb_softc *usc, uint16_t msg_id, void *buf,
int len)
{
struct athn_usb_tx_data *data = &usc->usc_tx_msg;
struct ar_htc_frame_hdr *htc;
struct ar_htc_msg_hdr *msg;
if (usc->usc_dying)
return USBD_CANCELLED;
DPRINTFN(DBG_FN, usc, "\n");
htc = (struct ar_htc_frame_hdr *)data->buf;
memset(htc, 0, sizeof(*htc));
htc->endpoint_id = 0;
htc->payload_len = htobe16(sizeof(*msg) + len);
msg = (struct ar_htc_msg_hdr *)&htc[1];
msg->msg_id = htobe16(msg_id);
memcpy(&msg[1], buf, len);
usbd_setup_xfer(data->xfer, NULL, data->buf,
sizeof(*htc) + sizeof(*msg) + len,
USBD_SHORT_XFER_OK, ATHN_USB_CMD_TIMEOUT, NULL);
return usbd_sync_transfer(data->xfer);
}
Static int
athn_usb_htc_setup(struct athn_usb_softc *usc)
{
struct ar_htc_msg_config_pipe cfg;
int error;
mutex_enter(&usc->usc_msg_mtx);
while (usc->usc_htcactive) {
error = cv_timedwait(&usc->usc_htc_cv, &usc->usc_msg_mtx, hz);
if (error) {
mutex_exit(&usc->usc_msg_mtx);
return error;
}
}
usc->usc_htcactive = true;
mutex_exit(&usc->usc_msg_mtx);
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_CONTROL,
AR_PIPE_TX_INTR, AR_PIPE_RX_INTR, &usc->usc_ep_ctrl);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_BEACON,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_bcn);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_CAB,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_cab);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_UAPSD,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_uapsd);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_MGMT,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_mgmt);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_BE,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_BE]);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_BK,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_BK]);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_VI,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_VI]);
if (error != 0)
return error;
error = athn_usb_htc_connect_svc(usc, AR_SVC_WMI_DATA_VO,
AR_PIPE_TX_DATA, AR_PIPE_RX_DATA, &usc->usc_ep_data[WME_AC_VO]);
if (error != 0)
return error;
memset(&cfg, 0, sizeof(cfg));
cfg.pipe_id = UE_GET_ADDR(AR_PIPE_TX_DATA);
cfg.credits = (usc->usc_flags & ATHN_USB_FLAG_AR7010) ? 45 : 33;
mutex_enter(&usc->usc_msg_mtx);
KASSERT(usc->usc_wait_msg_id == 0);
usc->usc_wait_msg_id = AR_HTC_MSG_CONF_PIPE_RSP;
mutex_exit(&usc->usc_msg_mtx);
error = athn_usb_htc_msg(usc, AR_HTC_MSG_CONF_PIPE, &cfg, sizeof(cfg));
if (error != 0) {
aprint_error_dev(usc->usc_dev, "could not request pipe configurations\n");
return error;
}
mutex_enter(&usc->usc_msg_mtx);
error = athn_usb_wait_msg(usc);
if (error) {
mutex_exit(&usc->usc_msg_mtx);
return error;
}
mutex_exit(&usc->usc_msg_mtx);
error = athn_usb_htc_msg(usc, AR_HTC_MSG_SETUP_COMPLETE, NULL, 0);
if (error != 0) {
aprint_error_dev(usc->usc_dev, "could not request complete setup\n");
return error;
}
mutex_enter(&usc->usc_msg_mtx);
error = athn_usb_wait_msg(usc);
if (error) {
mutex_exit(&usc->usc_msg_mtx);
return error;
}
usc->usc_htcactive = false;
cv_broadcast(&usc->usc_htc_cv);
mutex_exit(&usc->usc_msg_mtx);
return 0;
}
Static int
athn_usb_htc_connect_svc(struct athn_usb_softc *usc, uint16_t svc_id,
uint8_t ul_pipe, uint8_t dl_pipe, uint8_t *endpoint_id)
{
struct ar_htc_msg_conn_svc msg;
struct ar_htc_msg_conn_svc_rsp rsp;
int error;
DPRINTFN(DBG_FN, usc, "\n");
memset(&msg, 0, sizeof(msg));
msg.svc_id = htobe16(svc_id);
msg.dl_pipeid = UE_GET_ADDR(dl_pipe);
msg.ul_pipeid = UE_GET_ADDR(ul_pipe);
mutex_enter(&usc->usc_msg_mtx);
KASSERT(usc->usc_wait_msg_id == 0);
usc->usc_msg_conn_svc_rsp = &rsp;
usc->usc_wait_msg_id = AR_HTC_MSG_CONN_SVC_RSP;
mutex_exit(&usc->usc_msg_mtx);
error = athn_usb_htc_msg(usc, AR_HTC_MSG_CONN_SVC, &msg, sizeof(msg));
mutex_enter(&usc->usc_msg_mtx);
if (error == 0)
error = athn_usb_wait_msg(usc);
mutex_exit(&usc->usc_msg_mtx);
if (error != 0) {
aprint_error_dev(usc->usc_dev,
"error waiting for service %d connection\n", svc_id);
return error;
}
if (rsp.status != AR_HTC_SVC_SUCCESS) {
aprint_error_dev(usc->usc_dev,
"service %d connection failed, error %d\n",
svc_id, rsp.status);
return EIO;
}
DPRINTFN(DBG_INIT, usc,
"service %d successfully connected to endpoint %d\n",
svc_id, rsp.endpoint_id);
*endpoint_id = rsp.endpoint_id;
return 0;
}
Static int
athn_usb_wait_msg(struct athn_usb_softc *usc)
{
DPRINTFN(DBG_FN, usc, "\n");
KASSERT(mutex_owned(&usc->usc_msg_mtx));
int error = 0;
while (usc->usc_wait_msg_id)
error = cv_timedwait(&usc->usc_msg_cv, &usc->usc_msg_mtx, hz);
return error;
}
Static void
athn_usb_wmieof(struct usbd_xfer *xfer, void * priv,
usbd_status status)
{
struct athn_usb_softc *usc = priv;
DPRINTFN(DBG_FN, usc, "\n");
if (__predict_false(status == USBD_STALLED))
usbd_clear_endpoint_stall_async(usc->usc_tx_intr_pipe);
}
Static int
athn_usb_wmi_xcmd(struct athn_usb_softc *usc, uint16_t cmd_id, void *ibuf,
int ilen, void *obuf)
{
struct athn_usb_tx_data *data = &usc->usc_tx_cmd;
struct ar_htc_frame_hdr *htc;
struct ar_wmi_cmd_hdr *wmi;
int error = 0;
if (usc->usc_dying)
return EIO;
DPRINTFN(DBG_FN, usc, "cmd_id %#x\n", cmd_id);
htc = (struct ar_htc_frame_hdr *)data->buf;
memset(htc, 0, sizeof(*htc));
htc->endpoint_id = usc->usc_ep_ctrl;
htc->payload_len = htobe16(sizeof(*wmi) + ilen);
wmi = (struct ar_wmi_cmd_hdr *)&htc[1];
wmi->cmd_id = htobe16(cmd_id);
usc->usc_wmi_seq_no++;
wmi->seq_no = htobe16(usc->usc_wmi_seq_no);
memcpy(&wmi[1], ibuf, ilen);
usbd_setup_xfer(data->xfer, usc, data->buf,
sizeof(*htc) + sizeof(*wmi) + ilen,
USBD_SHORT_XFER_OK, ATHN_USB_CMD_TIMEOUT,
athn_usb_wmieof);
mutex_enter(&usc->usc_cmd_mtx);
while (usc->usc_wmiactive) {
error = cv_timedwait(&usc->usc_wmi_cv, &usc->usc_cmd_mtx, hz);
if (error) {
mutex_exit(&usc->usc_cmd_mtx);
return error;
}
}
usc->usc_wmiactive = true;
KASSERT(usc->usc_wait_cmd_id == 0);
usc->usc_wait_cmd_id = cmd_id;
usc->usc_obuf = obuf;
mutex_exit(&usc->usc_cmd_mtx);
error = usbd_sync_transfer(data->xfer);
if (error) {
DPRINTFN(DBG_FN, usc, "transfer error %d\n", error);
return error;
}
mutex_enter(&usc->usc_cmd_mtx);
while (usc->usc_wait_cmd_id)
error = cv_timedwait(&usc->usc_cmd_cv, &usc->usc_cmd_mtx, hz);
usc->usc_wmiactive = false;
cv_broadcast(&usc->usc_wmi_cv);
mutex_exit(&usc->usc_cmd_mtx);
return 0;
}
#ifdef unused
Static int
athn_usb_read_rom(struct athn_softc *sc)
{
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
uint32_t addrs[8], vals[8], addr;
uint16_t *eep;
size_t i, j;
int error = 0;
DPRINTFN(DBG_FN, sc, "\n");
eep = sc->sc_eep;
addr = AR_EEPROM_OFFSET(sc->sc_eep_base);
for (i = 0; i < sc->sc_eep_size / 16; i++) {
for (j = 0; j < 8; j++, addr += 4)
addrs[j] = htobe32(addr);
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_REG_READ,
addrs, sizeof(addrs), vals);
if (error != 0)
break;
for (j = 0; j < 8; j++)
*eep++ = be32toh(vals[j]);
}
return error;
}
#endif
Static uint32_t
athn_usb_read(struct athn_softc *sc, uint32_t addr)
{
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
uint32_t val;
int error;
if (usc->usc_dying)
return 0;
DPRINTFN(DBG_FN, sc, "addr %#x\n", htobe32(addr));
athn_usb_write_barrier(sc);
addr = htobe32(addr);
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_REG_READ,
&addr, sizeof(addr), &val);
if (error != 0) {
DPRINTFN(DBG_FN, sc, "error %d\n", addr);
return 0xdeadbeef;
}
DPRINTFN(DBG_FN, sc, "addr %#x return %#x\n", addr, be32toh(val));
return be32toh(val);
}
Static void
athn_usb_write(struct athn_softc *sc, uint32_t addr, uint32_t val)
{
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, sc, "addr %#x val %#x\n", addr, val);
usc->usc_wbuf[usc->usc_wcount].addr = htobe32(addr);
usc->usc_wbuf[usc->usc_wcount].val = htobe32(val);
if (++usc->usc_wcount == AR_MAX_WRITE_COUNT)
athn_usb_write_barrier(sc);
}
Static void
athn_usb_write_barrier(struct athn_softc *sc)
{
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
if (usc->usc_dying)
goto done;
DPRINTFN(DBG_FN, sc, "usc_wcount %d\n", usc->usc_wcount);
if (usc->usc_wcount == 0)
return;
(void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_REG_WRITE,
usc->usc_wbuf, usc->usc_wcount * sizeof(usc->usc_wbuf[0]), NULL);
done:
usc->usc_wcount = 0;
}
Static int
athn_usb_media_change(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
int error;
if (usc->usc_dying)
return EIO;
DPRINTFN(DBG_FN, sc, "\n");
error = ieee80211_media_change(ifp);
if (error == ENETRESET && IS_UP_AND_RUNNING(ifp)) {
athn_usb_stop(ifp, 0);
error = athn_usb_init(ifp);
}
return error;
}
Static int
athn_usb_newstate(struct ieee80211com *ic, enum ieee80211_state nstate,
int arg)
{
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct athn_usb_cmd_newstate cmd;
DPRINTFN(DBG_FN, sc, "\n");
cmd.state = nstate;
cmd.arg = arg;
athn_usb_do_async(usc, athn_usb_newstate_cb, &cmd, sizeof(cmd));
return 0;
}
Static void
athn_usb_newstate_cb(struct athn_usb_softc *usc, void *arg)
{
struct athn_usb_cmd_newstate *cmd = arg;
struct athn_softc *sc = &usc->usc_sc;
struct ieee80211com *ic = &sc->sc_ic;
enum ieee80211_state ostate, nstate;
uint32_t reg, intr_mask;
int s;
DPRINTFN(DBG_FN, sc, "\n");
callout_stop(&sc->sc_calib_to);
s = splnet();
ostate = ic->ic_state;
nstate = cmd->state;
DPRINTFN(DBG_STM, usc, "newstate %s(%d) -> %s(%d)\n",
ieee80211_state_name[ostate], ostate,
ieee80211_state_name[nstate], nstate);
if (ostate == IEEE80211_S_RUN) {
uint8_t sta_index;
sta_index = ATHN_NODE(ic->ic_bss)->sta_index;
DPRINTFN(DBG_NODES, usc, "removing node %u\n", sta_index);
athn_usb_remove_hw_node(usc, &sta_index);
}
switch (nstate) {
case IEEE80211_S_INIT:
athn_set_led(sc, 0);
break;
case IEEE80211_S_SCAN:
athn_set_led(sc, !sc->sc_led_state);
(void)athn_usb_switch_chan(sc, ic->ic_curchan, NULL);
if (!usc->usc_dying)
callout_schedule(&sc->sc_scan_to, hz / 5);
break;
case IEEE80211_S_AUTH:
athn_set_led(sc, 0);
athn_usb_switch_chan(sc, ic->ic_curchan, NULL);
break;
case IEEE80211_S_ASSOC:
break;
case IEEE80211_S_RUN:
athn_set_led(sc, 1);
if (ic->ic_opmode == IEEE80211_M_MONITOR)
break;
DPRINTFN(DBG_NODES, sc, "create node for AID=%#x\n",
ic->ic_bss->ni_associd);
athn_usb_create_node(usc, ic->ic_bss);
athn_set_bss(sc, ic->ic_bss);
athn_usb_wmi_cmd(usc, AR_WMI_CMD_DISABLE_INTR);
#ifndef IEEE80211_STA_ONLY
if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
athn_set_hostap_timers(sc);
intr_mask = htobe32(AR_IMR_SWBA);
} else
#endif
{
athn_set_sta_timers(sc);
intr_mask = htobe32(AR_IMR_BMISS);
reg = AR_READ(sc, AR_RX_FILTER);
reg = (reg & ~AR_RX_FILTER_BEACON) |
AR_RX_FILTER_MYBEACON;
AR_WRITE(sc, AR_RX_FILTER, reg);
AR_WRITE_BARRIER(sc);
}
athn_usb_wmi_xcmd(usc, AR_WMI_CMD_ENABLE_INTR,
&intr_mask, sizeof(intr_mask), NULL);
break;
}
if (!usc->usc_dying)
(void)sc->sc_newstate(ic, nstate, cmd->arg);
splx(s);
}
Static void
athn_usb_newassoc(struct ieee80211_node *ni, int isnew)
{
struct ieee80211com *ic = ni->ni_ic;
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
DPRINTFN(DBG_FN, sc, "\n");
if (ic->ic_opmode != IEEE80211_M_HOSTAP || !isnew)
return;
ieee80211_ref_node(ni);
athn_usb_do_async(usc, athn_usb_newassoc_cb, &ni, sizeof(ni));
}
Static void
athn_usb_newassoc_cb(struct athn_usb_softc *usc, void *arg)
{
struct ieee80211_node *ni = *(void **)arg;
int s;
DPRINTFN(DBG_FN, usc, "\n");
s = splnet();
if (ni->ni_associd != 0) {
DPRINTFN(DBG_NODES, usc, "creating node for AID=%#x\n",
ni->ni_associd);
(void)athn_usb_create_node(usc, ni);
}
ieee80211_free_node(ni);
splx(s);
}
#ifdef notyet
Static int
athn_usb_ampdu_tx_start(struct ieee80211com *ic, struct ieee80211_node *ni,
uint8_t tid)
{
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct athn_node *an = ATHN_NODE(ni);
struct athn_usb_aggr_cmd cmd;
DPRINTFN(DBG_FN, sc, "\n");
cmd.sta_index = an->sta_index;
cmd.tid = tid;
athn_usb_do_async(usc, athn_usb_ampdu_tx_start_cb, &cmd, sizeof(cmd));
return 0;
}
Static void
athn_usb_ampdu_tx_start_cb(struct athn_usb_softc *usc, void *arg)
{
struct athn_usb_aggr_cmd *cmd = arg;
struct ar_htc_target_aggr aggr;
DPRINTFN(DBG_FN, usc, "\n");
memset(&aggr, 0, sizeof(aggr));
aggr.sta_index = cmd->sta_index;
aggr.tidno = cmd->tid;
aggr.aggr_enable = 1;
(void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_TX_AGGR_ENABLE,
&aggr, sizeof(aggr), NULL);
}
Static void
athn_usb_ampdu_tx_stop(struct ieee80211com *ic, struct ieee80211_node *ni,
uint8_t tid)
{
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct athn_node *an = ATHN_NODE(ni);
struct athn_usb_aggr_cmd cmd;
DPRINTFN(DBG_FN, sc, "\n");
cmd.sta_index = an->sta_index;
cmd.tid = tid;
athn_usb_do_async(usc, athn_usb_ampdu_tx_stop_cb, &cmd, sizeof(cmd));
}
Static void
athn_usb_ampdu_tx_stop_cb(struct athn_usb_softc *usc, void *arg)
{
struct athn_usb_aggr_cmd *cmd = arg;
struct ar_htc_target_aggr aggr;
DPRINTFN(DBG_FN, usc, "\n");
memset(&aggr, 0, sizeof(aggr));
aggr.sta_index = cmd->sta_index;
aggr.tidno = cmd->tid;
aggr.aggr_enable = 0;
(void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_TX_AGGR_ENABLE,
&aggr, sizeof(aggr), NULL);
}
#endif
Static int
athn_usb_remove_hw_node(struct athn_usb_softc *usc, uint8_t *sta_idx)
{
int error;
DPRINTFN(DBG_FN, usc, "\n");
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_NODE_REMOVE,
sta_idx, sizeof(*sta_idx), NULL);
DPRINTFN(DBG_NODES, usc, "node=%u error=%d\n",
*sta_idx, error);
return error;
}
Static int
athn_usb_create_hw_node(struct athn_usb_softc *usc,
struct ar_htc_target_sta *sta)
{
int error;
DPRINTFN(DBG_FN, usc, "\n");
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_NODE_CREATE,
sta, sizeof(*sta), NULL);
DPRINTFN(DBG_NODES, usc, "node=%u error=%d\n",
sta->sta_index, error);
return error;
}
Static int
athn_usb_create_node(struct athn_usb_softc *usc, struct ieee80211_node *ni)
{
struct athn_node *an = ATHN_NODE(ni);
struct ar_htc_target_sta sta;
struct ar_htc_target_rate rate;
int error;
DPRINTFN(DBG_FN | DBG_NODES, usc, "AID=%#x\n", ni->ni_associd);
if (ATHN_SOFTC(usc)->sc_ic.ic_opmode == IEEE80211_M_HOSTAP)
an->sta_index = IEEE80211_NODE_AID(ni);
else
an->sta_index = 1;
memset(&sta, 0, sizeof(sta));
IEEE80211_ADDR_COPY(sta.macaddr, ni->ni_macaddr);
IEEE80211_ADDR_COPY(sta.bssid, ni->ni_bssid);
sta.associd = htobe16(ni->ni_associd);
sta.valid = 1;
sta.sta_index = an->sta_index;
sta.maxampdu = 0xffff;
#ifndef IEEE80211_NO_HT
if (ni->ni_flags & IEEE80211_NODE_HT)
sta.flags |= htobe16(AR_HTC_STA_HT);
#endif
error = athn_usb_create_hw_node(usc, &sta);
if (error)
return error;
memset(&rate, 0, sizeof(rate));
rate.sta_index = sta.sta_index;
rate.isnew = 1;
rate.lg_rates.rs_nrates = ni->ni_rates.rs_nrates;
memcpy(rate.lg_rates.rs_rates, ni->ni_rates.rs_rates,
ni->ni_rates.rs_nrates);
#ifndef IEEE80211_NO_HT
if (ni->ni_flags & IEEE80211_NODE_HT) {
rate.capflags |= htobe32(AR_RC_HT_FLAG);
#ifdef notyet
if (ni->ni_htcaps & IEEE80211_HTCAP_CBW20_40)
rate.capflags |= htobe32(AR_RC_40_FLAG);
if (ni->ni_htcaps & IEEE80211_HTCAP_SGI40)
rate.capflags |= htobe32(AR_RC_SGI_FLAG);
if (ni->ni_htcaps & IEEE80211_HTCAP_SGI20)
rate.capflags |= htobe32(AR_RC_SGI_FLAG);
#endif
}
#endif
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_RC_RATE_UPDATE,
&rate, sizeof(rate), NULL);
return error;
}
Static void
athn_usb_rx_enable(struct athn_softc *sc)
{
DPRINTFN(DBG_FN, sc, "\n");
AR_WRITE(sc, AR_CR, AR_CR_RXE);
AR_WRITE_BARRIER(sc);
}
Static int
athn_usb_switch_chan(struct athn_softc *sc, struct ieee80211_channel *curchan,
struct ieee80211_channel *extchan)
{
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
uint16_t mode;
int error;
DPRINTFN(DBG_FN, sc, "\n");
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_DISABLE_INTR);
if (error != 0)
goto reset;
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_DRAIN_TXQ_ALL);
if (error != 0)
goto reset;
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_STOP_RECV);
if (error != 0)
goto reset;
if (curchan->ic_flags != sc->sc_curchan->ic_flags ||
((extchan != NULL) ^ (sc->sc_curchanext != NULL))) {
DPRINTFN(DBG_RF, sc, "channel band switch\n");
goto reset;
}
error = athn_set_chan(sc, curchan, extchan);
if (AR_SREV_9271(sc) && error == 0)
ar9271_load_ani(sc);
if (error != 0) {
reset:
DPRINTFN(DBG_RF, sc, "needs a full reset\n");
error = athn_hw_reset(sc, curchan, extchan, 0);
if (error != 0)
return error;
}
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_START_RECV);
if (error != 0)
return error;
athn_rx_start(sc);
mode = htobe16(IEEE80211_IS_CHAN_2GHZ(curchan) ?
AR_HTC_MODE_11NG : AR_HTC_MODE_11NA);
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_SET_MODE,
&mode, sizeof(mode), NULL);
if (error != 0)
return error;
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_ENABLE_INTR);
return error;
}
#ifdef notyet_edca
Static void
athn_usb_updateedca(struct ieee80211com *ic)
{
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
DPRINTFN(DBG_FN, sc, "\n");
athn_usb_do_async(usc, athn_usb_updateedca_cb, NULL, 0);
}
Static void
athn_usb_updateedca_cb(struct athn_usb_softc *usc, void *arg)
{
int s;
DPRINTFN(DBG_FN, usc, "\n");
s = splnet();
athn_updateedca(&usc->usc_sc.sc_ic);
splx(s);
}
#endif
Static void
athn_usb_updateslot(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
DPRINTFN(DBG_FN, sc, "\n");
if (usc->usc_athn_attached)
athn_usb_do_async(usc, athn_usb_updateslot_cb, NULL, 0);
}
Static void
athn_usb_updateslot_cb(struct athn_usb_softc *usc, void *arg)
{
int s;
DPRINTFN(DBG_FN, usc, "\n");
s = splnet();
athn_updateslot(&usc->usc_sc.sc_if);
splx(s);
}
#ifdef notyet
Static int
athn_usb_set_key(struct ieee80211com *ic, struct ieee80211_node *ni,
struct ieee80211_key *k)
{
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct ifnet *ifp = &usc->usc_sc.sc_if;
struct athn_usb_cmd_key cmd;
DPRINTFN(DBG_FN, sc, "\n");
if (!IS_UP_AND_RUNNING(ifp))
return 0;
cmd.ni = (ni != NULL) ? ieee80211_ref_node(ni) : NULL;
cmd.key = k;
athn_usb_do_async(usc, athn_usb_set_key_cb, &cmd, sizeof(cmd));
return 0;
}
Static void
athn_usb_set_key_cb(struct athn_usb_softc *usc, void *arg)
{
struct ieee80211com *ic = &usc->usc_sc.sc_ic;
struct athn_usb_cmd_key *cmd = arg;
int s;
DPRINTFN(DBG_FN, usc, "\n");
s = splnet();
athn_set_key(ic, cmd->ni, cmd->key);
if (cmd->ni != NULL)
ieee80211_free_node(cmd->ni);
splx(s);
}
Static void
athn_usb_delete_key(struct ieee80211com *ic, struct ieee80211_node *ni,
struct ieee80211_key *k)
{
struct athn_softc *sc = ic->ic_ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct ifnet *ifp = &usc->usc_sc.sc_if;
struct athn_usb_cmd_key cmd;
DPRINTFN(DBG_FN, sc, "\n");
if (!(ifp->if_flags & IFF_RUNNING) ||
ic->ic_state != IEEE80211_S_RUN)
return;
cmd.ni = (ni != NULL) ? ieee80211_ref_node(ni) : NULL;
cmd.key = k;
athn_usb_do_async(usc, athn_usb_delete_key_cb, &cmd, sizeof(cmd));
}
Static void
athn_usb_delete_key_cb(struct athn_usb_softc *usc, void *arg)
{
struct ieee80211com *ic = &usc->usc_sc.sc_ic;
struct athn_usb_cmd_key *cmd = arg;
int s;
DPRINTFN(DBG_FN, usc, "\n");
s = splnet();
athn_delete_key(ic, cmd->ni, cmd->key);
if (cmd->ni != NULL)
ieee80211_free_node(cmd->ni);
splx(s);
}
#endif
#ifndef IEEE80211_STA_ONLY
Static void
athn_usb_bcneof(struct usbd_xfer *xfer, void * priv,
usbd_status status)
{
struct athn_usb_tx_data *data = priv;
struct athn_usb_softc *usc = data->sc;
DPRINTFN(DBG_FN, usc, "\n");
if (__predict_false(status == USBD_STALLED))
usbd_clear_endpoint_stall_async(usc->usc_tx_data_pipe);
usc->usc_tx_bcn = data;
}
Static void
athn_usb_swba(struct athn_usb_softc *usc)
{
struct athn_softc *sc = &usc->usc_sc;
struct ieee80211com *ic = &sc->sc_ic;
struct athn_usb_tx_data *data;
struct ieee80211_frame *wh;
struct ieee80211_beacon_offsets bo;
struct ar_stream_hdr *hdr;
struct ar_htc_frame_hdr *htc;
struct ar_tx_bcn *bcn;
struct mbuf *m;
int error;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, sc, "\n");
if (ic->ic_dtim_count == 0)
ic->ic_dtim_count = ic->ic_dtim_period - 1;
else
ic->ic_dtim_count--;
if (usc->usc_tx_bcn == NULL)
return;
data = usc->usc_tx_bcn;
#ifdef ATHN_DEBUG
memset(&bo, 0, sizeof(bo));
#endif
m = ieee80211_beacon_alloc(ic, ic->ic_bss, &bo);
if (__predict_false(m == NULL))
return;
wh = mtod(m, struct ieee80211_frame *);
*(uint16_t *)&wh->i_seq[0] =
htole16(ic->ic_bss->ni_txseqs[0] << IEEE80211_SEQ_SEQ_SHIFT);
ic->ic_bss->ni_txseqs[0]++;
hdr = (struct ar_stream_hdr *)data->buf;
hdr->tag = htole16(AR_USB_TX_STREAM_TAG);
hdr->len = htole16(sizeof(*htc) + sizeof(*bcn) + m->m_pkthdr.len);
htc = (struct ar_htc_frame_hdr *)&hdr[1];
memset(htc, 0, sizeof(*htc));
htc->endpoint_id = usc->usc_ep_bcn;
htc->payload_len = htobe16(sizeof(*bcn) + m->m_pkthdr.len);
bcn = (struct ar_tx_bcn *)&htc[1];
memset(bcn, 0, sizeof(*bcn));
bcn->vif_idx = 0;
m_copydata(m, 0, m->m_pkthdr.len, (void *)&bcn[1]);
usbd_setup_xfer(data->xfer, data, data->buf,
sizeof(*hdr) + sizeof(*htc) + sizeof(*bcn) + m->m_pkthdr.len,
USBD_SHORT_XFER_OK, ATHN_USB_TX_TIMEOUT,
athn_usb_bcneof);
m_freem(m);
usc->usc_tx_bcn = NULL;
error = usbd_transfer(data->xfer);
if (__predict_false(error != USBD_IN_PROGRESS && error != 0))
usc->usc_tx_bcn = data;
}
#endif
Static void
athn_usb_rx_wmi_ctrl(struct athn_usb_softc *usc, uint8_t *buf, size_t len)
{
#ifdef ATHN_DEBUG
struct ar_wmi_evt_txrate *txrate;
#endif
struct ar_wmi_cmd_hdr *wmi;
uint16_t cmd_id;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, usc, "\n");
if (__predict_false(len < sizeof(*wmi)))
return;
wmi = (struct ar_wmi_cmd_hdr *)buf;
cmd_id = be16toh(wmi->cmd_id);
if (!(cmd_id & AR_WMI_EVT_FLAG)) {
mutex_enter(&usc->usc_cmd_mtx);
if (usc->usc_wait_cmd_id == cmd_id) {
if (usc->usc_obuf != NULL) {
memcpy(usc->usc_obuf, &wmi[1], len - sizeof(*wmi));
}
usc->usc_wait_cmd_id = 0;
cv_broadcast(&usc->usc_cmd_cv);
}
mutex_exit(&usc->usc_cmd_mtx);
return;
}
switch (cmd_id & 0xfff) {
#ifndef IEEE80211_STA_ONLY
case AR_WMI_EVT_SWBA:
athn_usb_swba(usc);
break;
#endif
case AR_WMI_EVT_FATAL:
aprint_error_dev(usc->usc_dev, "fatal firmware error\n");
break;
case AR_WMI_EVT_TXRATE:
#ifdef ATHN_DEBUG
txrate = (struct ar_wmi_evt_txrate *)&wmi[1];
DPRINTFN(DBG_TX, usc, "txrate=%d\n", be32toh(txrate->txrate));
#endif
break;
default:
DPRINTFN(DBG_TX, usc, "WMI event %#x (%d) ignored\n", cmd_id, cmd_id);
break;
}
}
Static void
athn_usb_intr(struct usbd_xfer *xfer, void * priv,
usbd_status status)
{
struct athn_usb_softc *usc = priv;
struct ar_htc_frame_hdr *htc;
struct ar_htc_msg_hdr *msg;
uint8_t *buf = usc->usc_ibuf;
uint16_t msg_id;
int len;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, usc, "\n");
if (__predict_false(status != USBD_NORMAL_COMPLETION)) {
DPRINTFN(DBG_INTR, usc, "intr status=%d\n", status);
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(usc->usc_rx_intr_pipe);
return;
}
usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
if (len >= 4 && *(uint32_t *)buf == htobe32(0x00c60000)) {
buf += 4;
len -= 4;
}
if (__predict_false(len < (int)sizeof(*htc)))
return;
htc = (struct ar_htc_frame_hdr *)buf;
buf += sizeof(*htc);
len -= sizeof(*htc);
if (htc->endpoint_id != 0) {
if (__predict_false(htc->endpoint_id != usc->usc_ep_ctrl)) {
DPRINTFN(DBG_RX, usc, "Rx %d != %d\n",
htc->endpoint_id, usc->usc_ep_ctrl);
return;
}
if (htc->flags & AR_HTC_FLAG_TRAILER) {
if (__predict_false(len < htc->control[0])) {
DPRINTFN(DBG_RX, usc, "Rx trailer %d < %d\n",
len, htc->control[0]);
return;
}
len -= htc->control[0];
}
athn_usb_rx_wmi_ctrl(usc, buf, len);
return;
}
if (__predict_false(len < (int)sizeof(*msg)))
return;
msg = (struct ar_htc_msg_hdr *)buf;
msg_id = be16toh(msg->msg_id);
DPRINTFN(DBG_RX, usc, "Rx HTC message %d\n", msg_id);
switch (msg_id) {
case AR_HTC_MSG_READY:
case AR_HTC_MSG_CONF_PIPE_RSP:
mutex_enter(&usc->usc_msg_mtx);
DPRINTFN(DBG_RX, usc, "AR_HTC_MSG_READY: %d vs %d\n",
usc->usc_wait_msg_id, msg_id);
if (usc->usc_wait_msg_id == msg_id) {
usc->usc_wait_msg_id = 0;
cv_broadcast(&usc->usc_msg_cv);
}
mutex_exit(&usc->usc_msg_mtx);
break;
case AR_HTC_MSG_CONN_SVC_RSP:
mutex_enter(&usc->usc_msg_mtx);
DPRINTFN(DBG_RX, usc, "AR_HTC_MSG_CONN_SVC_RSP: %d vs %d\n",
usc->usc_wait_msg_id, msg_id);
if (usc->usc_wait_msg_id == msg_id) {
if (usc->usc_msg_conn_svc_rsp != NULL) {
memcpy(usc->usc_msg_conn_svc_rsp, &msg[1],
sizeof(*usc->usc_msg_conn_svc_rsp));
}
usc->usc_wait_msg_id = 0;
cv_broadcast(&usc->usc_msg_cv);
}
mutex_exit(&usc->usc_msg_mtx);
break;
default:
DPRINTFN(DBG_RX, usc, "HTC message %d ignored\n", msg_id);
break;
}
}
Static void
athn_usb_rx_radiotap(struct athn_softc *sc, struct mbuf *m,
struct ar_rx_status *rs)
{
struct athn_rx_radiotap_header *tap = &sc->sc_rxtap;
struct ieee80211com *ic = &sc->sc_ic;
uint8_t rate;
DPRINTFN(DBG_FN, sc, "\n");
tap->wr_flags = IEEE80211_RADIOTAP_F_FCS;
tap->wr_tsft = htole64(be64toh(rs->rs_tstamp));
tap->wr_chan_freq = htole16(ic->ic_curchan->ic_freq);
tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags);
tap->wr_dbm_antsignal = rs->rs_rssi;
tap->wr_antenna = rs->rs_antenna;
rate = rs->rs_rate;
if (rate & 0x80) {
tap->wr_rate = rate;
if (!(rs->rs_flags & AR_RXS_FLAG_GI))
tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTGI;
} else if (rate & 0x10) {
if (rate & 0x04)
tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
switch (rate & ~0x14) {
case 0xb: tap->wr_rate = 2; break;
case 0xa: tap->wr_rate = 4; break;
case 0x9: tap->wr_rate = 11; break;
case 0x8: tap->wr_rate = 22; break;
default: tap->wr_rate = 0; break;
}
} else {
switch (rate) {
case 0xb: tap->wr_rate = 12; break;
case 0xf: tap->wr_rate = 18; break;
case 0xa: tap->wr_rate = 24; break;
case 0xe: tap->wr_rate = 36; break;
case 0x9: tap->wr_rate = 48; break;
case 0xd: tap->wr_rate = 72; break;
case 0x8: tap->wr_rate = 96; break;
case 0xc: tap->wr_rate = 108; break;
default: tap->wr_rate = 0; break;
}
}
bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_rxtap_len, m, BPF_D_IN);
}
Static void
athn_usb_rx_frame(struct athn_usb_softc *usc, struct mbuf *m)
{
struct athn_softc *sc = &usc->usc_sc;
struct ieee80211com *ic = &sc->sc_ic;
struct ifnet *ifp = &sc->sc_if;
struct ieee80211_frame *wh;
struct ieee80211_node *ni;
struct ar_htc_frame_hdr *htc;
struct ar_rx_status *rs;
uint16_t datalen;
int s;
DPRINTFN(DBG_FN, sc, "\n");
if (__predict_false(m->m_len < (int)sizeof(*htc)))
goto skip;
htc = mtod(m, struct ar_htc_frame_hdr *);
if (__predict_false(htc->endpoint_id == 0)) {
DPRINTFN(DBG_RX, sc, "bad endpoint %d\n", htc->endpoint_id);
goto skip;
}
if (htc->flags & AR_HTC_FLAG_TRAILER) {
if (m->m_len < htc->control[0])
goto skip;
m_adj(m, -(int)htc->control[0]);
}
m_adj(m, sizeof(*htc));
if (__predict_false(m->m_len < (int)sizeof(*rs)))
goto skip;
rs = mtod(m, struct ar_rx_status *);
datalen = be16toh(rs->rs_datalen);
if (__predict_false(m->m_len < (int)sizeof(*rs) + datalen))
goto skip;
if (__predict_false(datalen <
sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN))
goto skip;
m_adj(m, sizeof(*rs));
m_set_rcvif(m, ifp);
s = splnet();
wh = mtod(m, struct ieee80211_frame *);
ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);
if (!(wh->i_fc[0] & IEEE80211_FC0_TYPE_CTL)) {
u_int hdrlen = ieee80211_anyhdrsize(wh);
if (hdrlen & 3) {
memmove((uint8_t *)wh + 2, wh, hdrlen);
m_adj(m, 2);
}
}
if (__predict_false(sc->sc_drvbpf != NULL))
athn_usb_rx_radiotap(sc, m, rs);
m_adj(m, -IEEE80211_CRC_LEN);
ieee80211_input(ic, m, ni, rs->rs_rssi + AR_USB_DEFAULT_NF, 0);
ieee80211_free_node(ni);
splx(s);
return;
skip:
m_freem(m);
}
Static void
athn_usb_rxeof(struct usbd_xfer *xfer, void * priv,
usbd_status status)
{
struct athn_usb_rx_data *data = priv;
struct athn_usb_softc *usc = data->sc;
struct athn_usb_rx_stream *stream = &usc->usc_rx_stream;
uint8_t *buf = data->buf;
struct ar_stream_hdr *hdr;
struct mbuf *m;
uint16_t pktlen;
int off, len;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, usc, "\n");
if (__predict_false(status != USBD_NORMAL_COMPLETION)) {
DPRINTFN(DBG_RX, usc, "RX status=%d\n", status);
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(usc->usc_rx_data_pipe);
if (status != USBD_CANCELLED)
goto resubmit;
return;
}
usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
if (stream->left > 0) {
if (len >= stream->left) {
if (__predict_true(stream->m != NULL)) {
memcpy(mtod(stream->m, uint8_t *) +
stream->moff, buf, stream->left);
athn_usb_rx_frame(usc, stream->m);
stream->m = NULL;
}
off = (stream->left + 3) & ~3;
buf += off;
len -= off;
stream->left = 0;
} else {
if (__predict_true(stream->m != NULL)) {
memcpy(mtod(stream->m, uint8_t *) +
stream->moff, buf, len);
stream->moff += len;
}
stream->left -= len;
goto resubmit;
}
}
KASSERT(stream->left == 0);
while (len >= (int)sizeof(*hdr)) {
hdr = (struct ar_stream_hdr *)buf;
if (hdr->tag != htole16(AR_USB_RX_STREAM_TAG)) {
DPRINTFN(DBG_RX, usc, "invalid tag %#x\n", hdr->tag);
break;
}
pktlen = le16toh(hdr->len);
buf += sizeof(*hdr);
len -= sizeof(*hdr);
if (__predict_true(pktlen <= MCLBYTES)) {
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (__predict_true(m != NULL)) {
m->m_pkthdr.len = m->m_len = pktlen;
if (pktlen > MHLEN) {
MCLGET(m, M_DONTWAIT);
if (!(m->m_flags & M_EXT)) {
m_free(m);
m = NULL;
}
}
}
} else
m = NULL;
if (pktlen > len) {
stream->m = m;
if (__predict_true(stream->m != NULL)) {
memcpy(mtod(stream->m, uint8_t *), buf, len);
stream->moff = len;
}
stream->left = pktlen - len;
goto resubmit;
}
if (__predict_true(m != NULL)) {
memcpy(mtod(m, uint8_t *), buf, pktlen);
athn_usb_rx_frame(usc, m);
}
off = (pktlen + 3) & ~3;
buf += off;
len -= off;
}
resubmit:
usbd_setup_xfer(xfer, data, data->buf, ATHN_USB_RXBUFSZ,
USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, athn_usb_rxeof);
(void)usbd_transfer(xfer);
}
Static void
athn_usb_txeof(struct usbd_xfer *xfer, void * priv,
usbd_status status)
{
struct athn_usb_tx_data *data = priv;
struct athn_usb_softc *usc = data->sc;
struct athn_softc *sc = &usc->usc_sc;
struct ifnet *ifp = &sc->sc_if;
int s;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, usc, "\n");
s = splnet();
mutex_enter(&usc->usc_tx_mtx);
TAILQ_INSERT_TAIL(&usc->usc_tx_free_list, data, next);
mutex_exit(&usc->usc_tx_mtx);
if (__predict_false(status != USBD_NORMAL_COMPLETION)) {
DPRINTFN(DBG_TX, sc, "TX status=%d\n", status);
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(usc->usc_tx_data_pipe);
if_statinc(ifp, if_oerrors);
splx(s);
return;
}
sc->sc_tx_timer = 0;
if_statinc(ifp, if_opackets);
if (ifp->if_flags & IFF_OACTIVE) {
ifp->if_flags &= ~IFF_OACTIVE;
ifp->if_start(ifp);
}
splx(s);
}
Static int
athn_usb_tx(struct athn_softc *sc, struct mbuf *m, struct ieee80211_node *ni,
struct athn_usb_tx_data *data)
{
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct athn_node *an = ATHN_NODE(ni);
struct ieee80211com *ic = &sc->sc_ic;
struct ieee80211_frame *wh;
struct ieee80211_key *k = NULL;
struct ar_stream_hdr *hdr;
struct ar_htc_frame_hdr *htc;
struct ar_tx_frame *txf;
struct ar_tx_mgmt *txm;
uint8_t *frm;
uint8_t sta_index, qid, tid;
int error, s, xferlen;
DPRINTFN(DBG_FN, sc, "\n");
wh = mtod(m, struct ieee80211_frame *);
if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
k = ieee80211_crypto_encap(ic, ni, m);
if (k == NULL)
return ENOBUFS;
wh = mtod(m, struct ieee80211_frame *);
}
#ifdef notyet_edca
if (ieee80211_has_qos(wh)) {
uint16_t qos;
qos = ieee80211_get_qos(wh);
tid = qos & IEEE80211_QOS_TID;
qid = ieee80211_up_to_ac(ic, tid);
} else
#endif
{
tid = 0;
qid = WME_AC_BE;
}
if (__predict_false(sc->sc_drvbpf != NULL)) {
struct athn_tx_radiotap_header *tap = &sc->sc_txtap;
tap->wt_flags = 0;
tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED)
tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m, BPF_D_OUT);
}
sta_index = an->sta_index;
hdr = (struct ar_stream_hdr *)data->buf;
hdr->tag = htole16(AR_USB_TX_STREAM_TAG);
htc = (struct ar_htc_frame_hdr *)&hdr[1];
memset(htc, 0, sizeof(*htc));
if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
IEEE80211_FC0_TYPE_DATA) {
htc->endpoint_id = usc->usc_ep_data[qid];
txf = (struct ar_tx_frame *)&htc[1];
memset(txf, 0, sizeof(*txf));
txf->data_type = AR_HTC_NORMAL;
txf->node_idx = sta_index;
txf->vif_idx = 0;
txf->tid = tid;
if (m->m_pkthdr.len + IEEE80211_CRC_LEN > ic->ic_rtsthreshold)
txf->flags |= htobe32(AR_HTC_TX_RTSCTS);
else if (ic->ic_flags & IEEE80211_F_USEPROT) {
if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
txf->flags |= htobe32(AR_HTC_TX_CTSONLY);
else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
txf->flags |= htobe32(AR_HTC_TX_RTSCTS);
}
txf->key_idx = 0xff;
frm = (uint8_t *)&txf[1];
} else {
htc->endpoint_id = usc->usc_ep_mgmt;
txm = (struct ar_tx_mgmt *)&htc[1];
memset(txm, 0, sizeof(*txm));
txm->node_idx = sta_index;
txm->vif_idx = 0;
txm->key_idx = 0xff;
frm = (uint8_t *)&txm[1];
}
m_copydata(m, 0, m->m_pkthdr.len, (void *)frm);
frm += m->m_pkthdr.len;
htc->payload_len = htobe16(frm - (uint8_t *)&htc[1]);
hdr->len = htole16(frm - (uint8_t *)&hdr[1]);
xferlen = frm - data->buf;
s = splnet();
usbd_setup_xfer(data->xfer, data, data->buf, xferlen,
USBD_FORCE_SHORT_XFER, ATHN_USB_TX_TIMEOUT, athn_usb_txeof);
error = usbd_transfer(data->xfer);
if (__predict_false(error != USBD_IN_PROGRESS && error != 0)) {
splx(s);
return error;
}
splx(s);
return 0;
}
Static void
athn_usb_start(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct ieee80211com *ic = &sc->sc_ic;
struct athn_usb_tx_data *data;
struct ether_header *eh;
struct ieee80211_node *ni;
struct mbuf *m;
if (usc->usc_dying)
return;
DPRINTFN(DBG_FN, sc, "\n");
if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
return;
data = NULL;
for (;;) {
mutex_enter(&usc->usc_tx_mtx);
if (data == NULL && !TAILQ_EMPTY(&usc->usc_tx_free_list)) {
data = TAILQ_FIRST(&usc->usc_tx_free_list);
TAILQ_REMOVE(&usc->usc_tx_free_list, data, next);
}
mutex_exit(&usc->usc_tx_mtx);
if (data == NULL) {
ifp->if_flags |= IFF_OACTIVE;
return;
}
IF_DEQUEUE(&ic->ic_mgtq, m);
if (m != NULL) {
ni = M_GETCTX(m, struct ieee80211_node *);
M_CLEARCTX(m);
goto sendit;
}
if (ic->ic_state != IEEE80211_S_RUN)
break;
IFQ_DEQUEUE(&ifp->if_snd, m);
if (m == NULL)
break;
if (m->m_len < (int)sizeof(*eh) &&
(m = m_pullup(m, sizeof(*eh))) == NULL) {
if_statinc(ifp, if_oerrors);
continue;
}
eh = mtod(m, struct ether_header *);
ni = ieee80211_find_txnode(ic, eh->ether_dhost);
if (ni == NULL) {
m_freem(m);
if_statinc(ifp, if_oerrors);
continue;
}
bpf_mtap(ifp, m, BPF_D_OUT);
if ((m = ieee80211_encap(ic, m, ni)) == NULL) {
ieee80211_free_node(ni);
if_statinc(ifp, if_oerrors);
continue;
}
sendit:
bpf_mtap3(ic->ic_rawbpf, m, BPF_D_OUT);
if (athn_usb_tx(sc, m, ni, data) != 0) {
m_freem(m);
ieee80211_free_node(ni);
if_statinc(ifp, if_oerrors);
continue;
}
data = NULL;
m_freem(m);
ieee80211_free_node(ni);
sc->sc_tx_timer = 5;
ifp->if_timer = 1;
}
mutex_enter(&usc->usc_tx_mtx);
TAILQ_INSERT_TAIL(&usc->usc_tx_free_list, data, next);
mutex_exit(&usc->usc_tx_mtx);
}
Static void
athn_usb_watchdog(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
DPRINTFN(DBG_FN, sc, "\n");
ifp->if_timer = 0;
if (sc->sc_tx_timer > 0) {
if (--sc->sc_tx_timer == 0) {
aprint_error_dev(sc->sc_dev, "device timeout\n");
if_statinc(ifp, if_oerrors);
return;
}
ifp->if_timer = 1;
}
ieee80211_watchdog(&sc->sc_ic);
}
Static int
athn_usb_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct ieee80211com *ic = &sc->sc_ic;
int s, error = 0;
if (usc->usc_dying)
return EIO;
DPRINTFN(DBG_FN, sc, "cmd=0x%08lx\n", cmd);
s = splnet();
switch (cmd) {
case SIOCSIFFLAGS:
if ((error = ifioctl_common(ifp, cmd, data)) != 0)
break;
switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
case IFF_UP | IFF_RUNNING:
break;
case IFF_UP:
error = athn_usb_init(ifp);
break;
case IFF_RUNNING:
athn_usb_stop(ifp, 0);
break;
case 0:
default:
break;
}
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) {
error = 0;
}
break;
case SIOCS80211CHANNEL:
error = ieee80211_ioctl(ic, cmd, data);
if (error == ENETRESET &&
ic->ic_opmode == IEEE80211_M_MONITOR) {
if (IS_UP_AND_RUNNING(ifp))
athn_usb_switch_chan(sc, ic->ic_curchan, NULL);
error = 0;
}
break;
default:
error = ieee80211_ioctl(ic, cmd, data);
break;
}
if (error == ENETRESET) {
error = 0;
if (IS_UP_AND_RUNNING(ifp) &&
ic->ic_roaming != IEEE80211_ROAMING_MANUAL) {
mutex_enter(&usc->usc_lock);
athn_usb_stop_locked(ifp);
error = athn_usb_init_locked(ifp);
mutex_exit(&usc->usc_lock);
}
}
splx(s);
return error;
}
Static int
athn_usb_init(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
mutex_enter(&usc->usc_lock);
int ret = athn_usb_init_locked(ifp);
mutex_exit(&usc->usc_lock);
return ret;
}
Static int
athn_usb_init_locked(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct athn_ops *ops = &sc->sc_ops;
struct ieee80211com *ic = &sc->sc_ic;
struct ieee80211_channel *curchan, *extchan;
struct athn_usb_rx_data *data;
struct ar_htc_target_vif hvif;
struct ar_htc_target_sta sta;
struct ar_htc_cap_target hic;
uint16_t mode;
size_t i;
int error;
if (usc->usc_dying)
return USBD_CANCELLED;
DPRINTFN(DBG_FN, sc, "\n");
mutex_spin_enter(&usc->usc_task_mtx);
usc->usc_cmdq.cur = usc->usc_cmdq.next = usc->usc_cmdq.queued = 0;
mutex_spin_exit(&usc->usc_task_mtx);
curchan = ic->ic_curchan;
extchan = NULL;
IEEE80211_ADDR_COPY(ic->ic_myaddr, CLLADDR(ifp->if_sadl));
error = athn_set_power_awake(sc);
if (error != 0)
goto fail;
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_FLUSH_RECV);
if (error != 0)
goto fail;
error = athn_hw_reset(sc, curchan, extchan, 1);
if (error != 0)
goto fail;
ops->set_txpower(sc, curchan, extchan);
mode = htobe16(IEEE80211_IS_CHAN_2GHZ(curchan) ?
AR_HTC_MODE_11NG : AR_HTC_MODE_11NA);
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_SET_MODE,
&mode, sizeof(mode), NULL);
if (error != 0)
goto fail;
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_ATH_INIT);
if (error != 0)
goto fail;
error = athn_usb_wmi_cmd(usc, AR_WMI_CMD_START_RECV);
if (error != 0)
goto fail;
athn_rx_start(sc);
memset(&hvif, 0, sizeof(hvif));
hvif.index = 0;
IEEE80211_ADDR_COPY(hvif.myaddr, ic->ic_myaddr);
switch (ic->ic_opmode) {
case IEEE80211_M_STA:
hvif.opmode = htobe32(AR_HTC_M_STA);
break;
case IEEE80211_M_MONITOR:
hvif.opmode = htobe32(AR_HTC_M_MONITOR);
break;
#ifndef IEEE80211_STA_ONLY
case IEEE80211_M_IBSS:
hvif.opmode = htobe32(AR_HTC_M_IBSS);
break;
case IEEE80211_M_AHDEMO:
hvif.opmode = htobe32(AR_HTC_M_AHDEMO);
break;
case IEEE80211_M_HOSTAP:
hvif.opmode = htobe32(AR_HTC_M_HOSTAP);
break;
#endif
}
hvif.rtsthreshold = htobe16(ic->ic_rtsthreshold);
DPRINTFN(DBG_INIT, sc, "creating VAP\n");
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_VAP_CREATE,
&hvif, sizeof(hvif), NULL);
if (error != 0)
goto fail;
memset(&sta, 0, sizeof(sta));
IEEE80211_ADDR_COPY(sta.macaddr, ic->ic_myaddr);
sta.sta_index = 0;
sta.is_vif_sta = 1;
sta.vif_index = hvif.index;
sta.maxampdu = 0xffff;
DPRINTFN(DBG_INIT | DBG_NODES, sc, "creating default node %u\n",
sta.sta_index);
error = athn_usb_create_hw_node(usc, &sta);
if (error != 0)
goto fail;
memset(&hic, 0, sizeof(hic));
hic.flags = htobe32(0x400c2400);
hic.flags_ext = htobe32(0x00106080);
hic.ampdu_limit = htobe32(0x0000ffff);
hic.ampdu_subframes = 20;
hic.protmode = 1;
hic.lg_txchainmask = sc->sc_txchainmask;
hic.ht_txchainmask = sc->sc_txchainmask;
DPRINTFN(DBG_INIT, sc, "updating target configuration\n");
error = athn_usb_wmi_xcmd(usc, AR_WMI_CMD_TARGET_IC_UPDATE,
&hic, sizeof(hic), NULL);
if (error != 0)
goto fail;
for (i = 0; i < ATHN_USB_RX_LIST_COUNT; i++) {
data = &usc->usc_rx_data[i];
usbd_setup_xfer(data->xfer, data, data->buf,
ATHN_USB_RXBUFSZ, USBD_SHORT_XFER_OK,
USBD_NO_TIMEOUT, athn_usb_rxeof);
error = usbd_transfer(data->xfer);
if (error != 0 && error != USBD_IN_PROGRESS)
goto fail;
}
ifp->if_flags &= ~IFF_OACTIVE;
ifp->if_flags |= IFF_RUNNING;
#ifdef notyet
if (ic->ic_flags & IEEE80211_F_WEPON) {
for (i = 0; i < IEEE80211_WEP_NKID; i++)
athn_usb_set_key(ic, NULL, &ic->ic_nw_keys[i]);
}
#endif
if (ic->ic_opmode == IEEE80211_M_HOSTAP)
ic->ic_max_aid = AR_USB_MAX_STA;
else
ic->ic_max_aid = sc->sc_max_aid;
if (ic->ic_opmode == IEEE80211_M_MONITOR)
ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
else
ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
athn_usb_wait_async(usc);
return 0;
fail:
athn_usb_stop(ifp, 0);
return error;
}
Static void
athn_usb_stop(struct ifnet *ifp, int disable)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
mutex_enter(&usc->usc_lock);
athn_usb_stop_locked(ifp);
mutex_exit(&usc->usc_lock);
}
Static void
athn_usb_stop_locked(struct ifnet *ifp)
{
struct athn_softc *sc = ifp->if_softc;
struct athn_usb_softc *usc = ATHN_USB_SOFTC(sc);
struct ieee80211com *ic = &sc->sc_ic;
struct ar_htc_target_vif hvif;
struct mbuf *m;
uint8_t sta_index;
int s;
DPRINTFN(DBG_FN, sc, "\n");
s = splusb();
ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
athn_usb_wait_async(usc);
splx(s);
sc->sc_tx_timer = 0;
ifp->if_timer = 0;
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
callout_stop(&sc->sc_scan_to);
callout_stop(&sc->sc_calib_to);
usbd_abort_pipe(usc->usc_tx_data_pipe);
usbd_abort_pipe(usc->usc_rx_data_pipe);
CTASSERT(sizeof(m) == sizeof(void *));
m = atomic_swap_ptr(&usc->usc_rx_stream.m, NULL);
m_freem(m);
usc->usc_rx_stream.left = 0;
memset(&hvif, 0, sizeof(hvif));
hvif.index = 0;
IEEE80211_ADDR_COPY(hvif.myaddr, ic->ic_myaddr);
(void)athn_usb_wmi_xcmd(usc, AR_WMI_CMD_VAP_REMOVE,
&hvif, sizeof(hvif), NULL);
sta_index = 0;
DPRINTFN(DBG_NODES, usc, "removing node %u\n", sta_index);
(void)athn_usb_remove_hw_node(usc, &sta_index);
(void)athn_usb_wmi_cmd(usc, AR_WMI_CMD_DISABLE_INTR);
(void)athn_usb_wmi_cmd(usc, AR_WMI_CMD_DRAIN_TXQ_ALL);
(void)athn_usb_wmi_cmd(usc, AR_WMI_CMD_STOP_RECV);
athn_reset(sc, 0);
athn_init_pll(sc, NULL);
athn_set_power_awake(sc);
athn_reset(sc, 1);
athn_init_pll(sc, NULL);
athn_set_power_sleep(sc);
}
MODULE(MODULE_CLASS_DRIVER, if_athn_usb, NULL);
#ifdef _MODULE
#include "ioconf.c"
#endif
static int
if_athn_usb_modcmd(modcmd_t cmd, void *aux)
{
int error = 0;
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
error = config_init_component(cfdriver_ioconf_if_athn_usb,
cfattach_ioconf_if_athn_usb, cfdata_ioconf_if_athn_usb);
#endif
return error;
case MODULE_CMD_FINI:
#ifdef _MODULE
error = config_fini_component(cfdriver_ioconf_if_athn_usb,
cfattach_ioconf_if_athn_usb, cfdata_ioconf_if_athn_usb);
#endif
return error;
default:
return ENOTTY;
}
}
