/*      $OpenBSD: if_uath.c,v 1.89 2024/05/23 03:21:08 jsg Exp $        */

/*-
 * Copyright (c) 2006
 *      Damien Bergamini <damien.bergamini@free.fr>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*-
 * Driver for Atheros AR5005UG/AR5005UX chipsets.
 *
 * IMPORTANT NOTICE:
 * This driver was written without any documentation or support from Atheros
 * Communications. It is based on a black-box analysis of the Windows binary
 * driver. It handles both pre and post-firmware devices.
 */

#include "bpfilter.h"

#include <sys/param.h>
#include <sys/sockio.h>
#include <sys/mbuf.h>
#include <sys/systm.h>
#include <sys/timeout.h>
#include <sys/device.h>
#include <sys/endian.h>

#include <machine/bus.h>
#include <machine/intr.h>

#if NBPFILTER > 0
#include <net/bpf.h>
#endif
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_media.h>

#include <netinet/in.h>
#include <netinet/if_ether.h>

#include <net80211/ieee80211_var.h>
#include <net80211/ieee80211_radiotap.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdivar.h>   /* needs_reattach() */
#include <dev/usb/usbdevs.h>

#include <dev/usb/if_uathreg.h>
#include <dev/usb/if_uathvar.h>

#ifdef UATH_DEBUG
#define DPRINTF(x)      do { if (uath_debug) printf x; } while (0)
#define DPRINTFN(n, x)  do { if (uath_debug >= (n)) printf x; } while (0)
int uath_debug = 1;
#else
#define DPRINTF(x)
#define DPRINTFN(n, x)
#endif

/*-
 * Various supported device vendors/products.
 * UB51: AR5005UG 802.11b/g, UB52: AR5005UX 802.11a/b/g
 */
#define UATH_DEV(v, p, f)                                               \
        { { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, (f) },             \
        { { USB_VENDOR_##v, USB_PRODUCT_##v##_##p##_NF },               \
            (f) | UATH_FLAG_PRE_FIRMWARE }
#define UATH_DEV_UG(v, p)       UATH_DEV(v, p, 0)
#define UATH_DEV_UX(v, p)       UATH_DEV(v, p, UATH_FLAG_ABG)
static const struct uath_type {
        struct usb_devno        dev;
        unsigned int            flags;
#define UATH_FLAG_PRE_FIRMWARE  (1 << 0)
#define UATH_FLAG_ABG           (1 << 1)
} uath_devs[] = {
        UATH_DEV_UG(ACCTON,             SMCWUSBTG2),
        UATH_DEV_UG(ATHEROS,            AR5523),
        UATH_DEV_UG(ATHEROS2,           AR5523_1),
        UATH_DEV_UG(ATHEROS2,           AR5523_2),
        UATH_DEV_UX(ATHEROS2,           AR5523_3),
        UATH_DEV_UG(CONCEPTRONIC,       AR5523_1),
        UATH_DEV_UX(CONCEPTRONIC,       AR5523_2),
        UATH_DEV_UX(DLINK,              DWLAG122),
        UATH_DEV_UX(DLINK,              DWLAG132),      
        UATH_DEV_UG(DLINK,              DWLG132),
        UATH_DEV_UG(DLINK2,             WUA2340),
        UATH_DEV_UG(GIGASET,            AR5523),
        UATH_DEV_UG(GIGASET,            SMCWUSBTG),
        UATH_DEV_UG(GLOBALSUN,          AR5523_1),
        UATH_DEV_UX(GLOBALSUN,          AR5523_2),
        UATH_DEV_UG(IODATA,             USBWNG54US),
        UATH_DEV_UG(MELCO,              WLIU2KAMG54),
        UATH_DEV_UX(NETGEAR,            WG111U),
        UATH_DEV_UG(NETGEAR3,           WG111T),
        UATH_DEV_UG(NETGEAR3,           WPN111),
        UATH_DEV_UG(PHILIPS,            SNU6500),
        UATH_DEV_UX(UMEDIA,             AR5523_2),
        UATH_DEV_UG(UMEDIA,             TEW444UBEU),
        UATH_DEV_UG(WISTRONNEWEB,       AR5523_1),
        UATH_DEV_UX(WISTRONNEWEB,       AR5523_2),
        UATH_DEV_UG(ZCOM,               AR5523),

        /* Devices that share one of the IDs above. */
        { { USB_VENDOR_NETGEAR3, USB_PRODUCT_NETGEAR3_WG111T_1 }, 0 }           \
};
#define uath_lookup(v, p)       \
        ((const struct uath_type *)usb_lookup(uath_devs, v, p))

void    uath_attachhook(struct device *);
int     uath_open_pipes(struct uath_softc *);
void    uath_close_pipes(struct uath_softc *);
int     uath_alloc_tx_data_list(struct uath_softc *);
void    uath_free_tx_data_list(struct uath_softc *);
int     uath_alloc_rx_data_list(struct uath_softc *);
void    uath_free_rx_data_list(struct uath_softc *);
int     uath_alloc_tx_cmd_list(struct uath_softc *);
void    uath_free_tx_cmd_list(struct uath_softc *);
int     uath_alloc_rx_cmd_list(struct uath_softc *);
void    uath_free_rx_cmd_list(struct uath_softc *);
int     uath_media_change(struct ifnet *);
void    uath_stat(void *);
void    uath_next_scan(void *);
void    uath_task(void *);
int     uath_newstate(struct ieee80211com *, enum ieee80211_state, int);
#ifdef UATH_DEBUG
void    uath_dump_cmd(const uint8_t *, int, char);
#endif
int     uath_cmd(struct uath_softc *, uint32_t, const void *, int, void *,
            int);
int     uath_cmd_write(struct uath_softc *, uint32_t, const void *, int, int);
int     uath_cmd_read(struct uath_softc *, uint32_t, const void *, int, void *,
            int);
int     uath_write_reg(struct uath_softc *, uint32_t, uint32_t);
int     uath_write_multi(struct uath_softc *, uint32_t, const void *, int);
int     uath_read_reg(struct uath_softc *, uint32_t, uint32_t *);
int     uath_read_eeprom(struct uath_softc *, uint32_t, void *);
void    uath_cmd_rxeof(struct usbd_xfer *, void *, usbd_status);
void    uath_data_rxeof(struct usbd_xfer *, void *, usbd_status);
void    uath_data_txeof(struct usbd_xfer *, void *, usbd_status);
int     uath_tx_null(struct uath_softc *);
int     uath_tx_data(struct uath_softc *, struct mbuf *,
            struct ieee80211_node *);
void    uath_start(struct ifnet *);
void    uath_watchdog(struct ifnet *);
int     uath_ioctl(struct ifnet *, u_long, caddr_t);
int     uath_query_eeprom(struct uath_softc *);
int     uath_reset(struct uath_softc *);
int     uath_reset_tx_queues(struct uath_softc *);
int     uath_wme_init(struct uath_softc *);
int     uath_set_chan(struct uath_softc *, struct ieee80211_channel *);
int     uath_set_key(struct uath_softc *, const struct ieee80211_key *, int);
int     uath_set_keys(struct uath_softc *);
int     uath_set_rates(struct uath_softc *, const struct ieee80211_rateset *);
int     uath_set_rxfilter(struct uath_softc *, uint32_t, uint32_t);
int     uath_set_led(struct uath_softc *, int, int);
int     uath_switch_channel(struct uath_softc *, struct ieee80211_channel *);
int     uath_init(struct ifnet *);
void    uath_stop(struct ifnet *, int);
int     uath_loadfirmware(struct uath_softc *, const u_char *, int);

int uath_match(struct device *, void *, void *);
void uath_attach(struct device *, struct device *, void *);
int uath_detach(struct device *, int);

struct cfdriver uath_cd = {
        NULL, "uath", DV_IFNET
};

const struct cfattach uath_ca = {
        sizeof(struct uath_softc), uath_match, uath_attach, uath_detach
};

int
uath_match(struct device *parent, void *match, void *aux)
{
        struct usb_attach_arg *uaa = aux;

        if (uaa->iface == NULL || uaa->configno != UATH_CONFIG_NO)
                return UMATCH_NONE;

        return (uath_lookup(uaa->vendor, uaa->product) != NULL) ?
            UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
}

void
uath_attachhook(struct device *self)
{
        struct uath_softc *sc = (struct uath_softc *)self;
        u_char *fw;
        size_t size;
        int error;

        if ((error = loadfirmware("uath-ar5523", &fw, &size)) != 0) {
                printf("%s: error %d, could not read firmware %s\n",
                    sc->sc_dev.dv_xname, error, "uath-ar5523");
                return;
        }

        error = uath_loadfirmware(sc, fw, size);
        free(fw, M_DEVBUF, size);

        if (error == 0) {
                /*
                 * Hack alert: the device doesn't always gracefully detach
                 * from the bus after a firmware upload.  We need to force
                 * a port reset and a re-exploration on the parent hub.
                 */
                usbd_reset_port(sc->sc_uhub, sc->sc_port);
                usb_needs_reattach(sc->sc_udev);
        } else {
                printf("%s: could not load firmware (error=%s)\n",
                    sc->sc_dev.dv_xname, usbd_errstr(error));
        }
}

void
uath_attach(struct device *parent, struct device *self, void *aux)
{
        struct uath_softc *sc = (struct uath_softc *)self;
        struct usb_attach_arg *uaa = aux;
        struct ieee80211com *ic = &sc->sc_ic;
        struct ifnet *ifp = &ic->ic_if;
        usbd_status error;
        int i;

        sc->sc_udev = uaa->device;
        sc->sc_uhub = uaa->device->myhub;
        sc->sc_port = uaa->port;

        sc->sc_flags = uath_lookup(uaa->vendor, uaa->product)->flags;

        /* get the first interface handle */
        error = usbd_device2interface_handle(sc->sc_udev, UATH_IFACE_INDEX,
            &sc->sc_iface);
        if (error != 0) {
                printf("%s: could not get interface handle\n",
                    sc->sc_dev.dv_xname);
                return;
        }

        /*
         * We must open the pipes early because they're used to upload the
         * firmware (pre-firmware devices) or to send firmware commands.
         */
        if (uath_open_pipes(sc) != 0) {
                printf("%s: could not open pipes\n", sc->sc_dev.dv_xname);
                return;
        }

        if (sc->sc_flags & UATH_FLAG_PRE_FIRMWARE) {
                config_mountroot(self, uath_attachhook);
                return;
        }

        /*
         * Only post-firmware devices here.
         */
        usb_init_task(&sc->sc_task, uath_task, sc, USB_TASK_TYPE_GENERIC);
        timeout_set(&sc->scan_to, uath_next_scan, sc);
        timeout_set(&sc->stat_to, uath_stat, sc);

        /*
         * Allocate xfers for firmware commands.
         */
        if (uath_alloc_tx_cmd_list(sc) != 0) {
                printf("%s: could not allocate Tx command list\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }
        if (uath_alloc_rx_cmd_list(sc) != 0) {
                printf("%s: could not allocate Rx command list\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }

        /*
         * Queue Rx command xfers.
         */
        for (i = 0; i < UATH_RX_CMD_LIST_COUNT; i++) {
                struct uath_rx_cmd *cmd = &sc->rx_cmd[i];

                usbd_setup_xfer(cmd->xfer, sc->cmd_rx_pipe, cmd, cmd->buf,
                    UATH_MAX_RXCMDSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
                    USBD_NO_TIMEOUT, uath_cmd_rxeof);
                error = usbd_transfer(cmd->xfer);
                if (error != USBD_IN_PROGRESS && error != 0) {
                        printf("%s: could not queue Rx command xfer\n",
                            sc->sc_dev.dv_xname);
                        goto fail;
                }
        }

        /*
         * We're now ready to send/receive firmware commands.
         */
        if (uath_reset(sc) != 0) {
                printf("%s: could not initialize adapter\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }
        if (uath_query_eeprom(sc) != 0) {
                printf("%s: could not read EEPROM\n", sc->sc_dev.dv_xname);
                goto fail;
        }

        printf("%s: MAC/BBP AR5523, RF AR%c112, address %s\n",
            sc->sc_dev.dv_xname, (sc->sc_flags & UATH_FLAG_ABG) ? '5': '2',
            ether_sprintf(ic->ic_myaddr));

        /*
         * Allocate xfers for Tx/Rx data pipes.
         */
        if (uath_alloc_tx_data_list(sc) != 0) {
                printf("%s: could not allocate Tx data list\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }
        if (uath_alloc_rx_data_list(sc) != 0) {
                printf("%s: could not allocate Rx data list\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }

        ic->ic_phytype = IEEE80211_T_OFDM;      /* not only, but not used */
        ic->ic_opmode = IEEE80211_M_STA;        /* default to BSS mode */
        ic->ic_state = IEEE80211_S_INIT;

        /* set device capabilities */
        ic->ic_caps =
            IEEE80211_C_MONITOR |       /* monitor mode supported */
            IEEE80211_C_TXPMGT |        /* tx power management */
            IEEE80211_C_SHPREAMBLE |    /* short preamble supported */
            IEEE80211_C_SHSLOT |        /* short slot time supported */
            IEEE80211_C_WEP;            /* h/w WEP */

        /* set supported .11b and .11g rates */
        ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
        ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;

        /* set supported .11b and .11g channels (1 through 14) */
        for (i = 1; i <= 14; i++) {
                ic->ic_channels[i].ic_freq =
                    ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
                ic->ic_channels[i].ic_flags =
                    IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
                    IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
        }

        ifp->if_softc = sc;
        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
        ifp->if_ioctl = uath_ioctl;
        ifp->if_start = uath_start;
        ifp->if_watchdog = uath_watchdog;
        memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);

        if_attach(ifp);
        ieee80211_ifattach(ifp);

        /* override state transition machine */
        sc->sc_newstate = ic->ic_newstate;
        ic->ic_newstate = uath_newstate;
        ieee80211_media_init(ifp, uath_media_change, ieee80211_media_status);

#if NBPFILTER > 0
        bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
            sizeof (struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN);

        sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
        sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
        sc->sc_rxtap.wr_ihdr.it_present = htole32(UATH_RX_RADIOTAP_PRESENT);

        sc->sc_txtap_len = sizeof sc->sc_txtapu;
        sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
        sc->sc_txtap.wt_ihdr.it_present = htole32(UATH_TX_RADIOTAP_PRESENT);
#endif

        return;

fail:   uath_close_pipes(sc);
        uath_free_tx_data_list(sc);
        uath_free_rx_cmd_list(sc);
        uath_free_tx_cmd_list(sc);
        usbd_deactivate(sc->sc_udev);
}

int
uath_detach(struct device *self, int flags)
{
        struct uath_softc *sc = (struct uath_softc *)self;
        struct ifnet *ifp = &sc->sc_ic.ic_if;
        int s;

        s = splnet();

        if (sc->sc_flags & UATH_FLAG_PRE_FIRMWARE) {
                uath_close_pipes(sc);
                splx(s);
                return 0;
        }

        /* post-firmware device */

        usb_rem_task(sc->sc_udev, &sc->sc_task);
        if (timeout_initialized(&sc->scan_to))
                timeout_del(&sc->scan_to);
        if (timeout_initialized(&sc->stat_to))
                timeout_del(&sc->stat_to);

        /* close Tx/Rx pipes */
        uath_close_pipes(sc);

        /* free xfers */
        uath_free_tx_data_list(sc);
        uath_free_rx_data_list(sc);
        uath_free_tx_cmd_list(sc);
        uath_free_rx_cmd_list(sc);

        if (ifp->if_softc != NULL) {
                ieee80211_ifdetach(ifp);        /* free all nodes */
                if_detach(ifp);
        }

        splx(s);

        return 0;
}

int
uath_open_pipes(struct uath_softc *sc)
{
        int error;

        /*
         * XXX pipes numbers are hardcoded because we don't have any way
         * to distinguish the data pipes from the firmware command pipes
         * (both are bulk pipes) using the endpoints descriptors.
         */
        error = usbd_open_pipe(sc->sc_iface, 0x01, USBD_EXCLUSIVE_USE,
            &sc->cmd_tx_pipe);
        if (error != 0) {
                printf("%s: could not open Tx command pipe: %s\n",
                    sc->sc_dev.dv_xname, usbd_errstr(error));
                goto fail;
        }

        error = usbd_open_pipe(sc->sc_iface, 0x02, USBD_EXCLUSIVE_USE,
            &sc->data_tx_pipe);
        if (error != 0) {
                printf("%s: could not open Tx data pipe: %s\n",
                    sc->sc_dev.dv_xname, usbd_errstr(error));
                goto fail;
        }

        error = usbd_open_pipe(sc->sc_iface, 0x81, USBD_EXCLUSIVE_USE,
            &sc->cmd_rx_pipe);
        if (error != 0) {
                printf("%s: could not open Rx command pipe: %s\n",
                    sc->sc_dev.dv_xname, usbd_errstr(error));
                goto fail;
        }

        error = usbd_open_pipe(sc->sc_iface, 0x82, USBD_EXCLUSIVE_USE,
            &sc->data_rx_pipe);
        if (error != 0) {
                printf("%s: could not open Rx data pipe: %s\n",
                    sc->sc_dev.dv_xname, usbd_errstr(error));
                goto fail;
        }

        return 0;

fail:   uath_close_pipes(sc);
        return error;
}

void
uath_close_pipes(struct uath_softc *sc)
{
        if (sc->data_tx_pipe != NULL) {
                usbd_close_pipe(sc->data_tx_pipe);
                sc->data_tx_pipe = NULL;
        }

        if (sc->data_rx_pipe != NULL) {
                usbd_close_pipe(sc->data_rx_pipe);
                sc->data_rx_pipe = NULL;
        }

        if (sc->cmd_tx_pipe != NULL) {
                usbd_close_pipe(sc->cmd_tx_pipe);
                sc->cmd_tx_pipe = NULL;
        }

        if (sc->cmd_rx_pipe != NULL) {
                usbd_close_pipe(sc->cmd_rx_pipe);
                sc->cmd_rx_pipe = NULL;
        }
}

int
uath_alloc_tx_data_list(struct uath_softc *sc)
{
        int i, error;

        for (i = 0; i < UATH_TX_DATA_LIST_COUNT; i++) {
                struct uath_tx_data *data = &sc->tx_data[i];

                data->sc = sc;  /* backpointer for callbacks */

                data->xfer = usbd_alloc_xfer(sc->sc_udev);
                if (data->xfer == NULL) {
                        printf("%s: could not allocate xfer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
                data->buf = usbd_alloc_buffer(data->xfer, UATH_MAX_TXBUFSZ);
                if (data->buf == NULL) {
                        printf("%s: could not allocate xfer buffer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
        }
        return 0;

fail:   uath_free_tx_data_list(sc);
        return error;
}

void
uath_free_tx_data_list(struct uath_softc *sc)
{
        int i;

        for (i = 0; i < UATH_TX_DATA_LIST_COUNT; i++)
                if (sc->tx_data[i].xfer != NULL) {
                        usbd_free_xfer(sc->tx_data[i].xfer);
                        sc->tx_data[i].xfer = NULL;
                }
}

int
uath_alloc_rx_data_list(struct uath_softc *sc)
{
        int i, error;

        for (i = 0; i < UATH_RX_DATA_LIST_COUNT; i++) {
                struct uath_rx_data *data = &sc->rx_data[i];

                data->sc = sc;  /* backpointer for callbacks */

                data->xfer = usbd_alloc_xfer(sc->sc_udev);
                if (data->xfer == NULL) {
                        printf("%s: could not allocate xfer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
                if (usbd_alloc_buffer(data->xfer, sc->rxbufsz) == NULL) {
                        printf("%s: could not allocate xfer buffer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }

                MGETHDR(data->m, M_DONTWAIT, MT_DATA);
                if (data->m == NULL) {
                        printf("%s: could not allocate rx mbuf\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
                MCLGETL(data->m, M_DONTWAIT, sc->rxbufsz);
                if (!(data->m->m_flags & M_EXT)) {
                        printf("%s: could not allocate rx mbuf cluster\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }

                data->buf = mtod(data->m, uint8_t *);
        }
        return 0;

fail:   uath_free_rx_data_list(sc);
        return error;
}

void
uath_free_rx_data_list(struct uath_softc *sc)
{
        int i;

        for (i = 0; i < UATH_RX_DATA_LIST_COUNT; i++) {
                struct uath_rx_data *data = &sc->rx_data[i];

                if (data->xfer != NULL) {
                        usbd_free_xfer(data->xfer);
                        data->xfer = NULL;
                }

                if (data->m != NULL) {
                        m_freem(data->m);
                        data->m = NULL;
                }
        }
}

int
uath_alloc_tx_cmd_list(struct uath_softc *sc)
{
        int i, error;

        for (i = 0; i < UATH_TX_CMD_LIST_COUNT; i++) {
                struct uath_tx_cmd *cmd = &sc->tx_cmd[i];

                cmd->sc = sc;   /* backpointer for callbacks */

                cmd->xfer = usbd_alloc_xfer(sc->sc_udev);
                if (cmd->xfer == NULL) {
                        printf("%s: could not allocate xfer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
                cmd->buf = usbd_alloc_buffer(cmd->xfer, UATH_MAX_TXCMDSZ);
                if (cmd->buf == NULL) {
                        printf("%s: could not allocate xfer buffer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
        }
        return 0;

fail:   uath_free_tx_cmd_list(sc);
        return error;
}

void
uath_free_tx_cmd_list(struct uath_softc *sc)
{
        int i;

        for (i = 0; i < UATH_TX_CMD_LIST_COUNT; i++)
                if (sc->tx_cmd[i].xfer != NULL) {
                        usbd_free_xfer(sc->tx_cmd[i].xfer);
                        sc->tx_cmd[i].xfer = NULL;
                }
}

int
uath_alloc_rx_cmd_list(struct uath_softc *sc)
{
        int i, error;

        for (i = 0; i < UATH_RX_CMD_LIST_COUNT; i++) {
                struct uath_rx_cmd *cmd = &sc->rx_cmd[i];

                cmd->sc = sc;   /* backpointer for callbacks */

                cmd->xfer = usbd_alloc_xfer(sc->sc_udev);
                if (cmd->xfer == NULL) {
                        printf("%s: could not allocate xfer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
                cmd->buf = usbd_alloc_buffer(cmd->xfer, UATH_MAX_RXCMDSZ);
                if (cmd->buf == NULL) {
                        printf("%s: could not allocate xfer buffer\n",
                            sc->sc_dev.dv_xname);
                        error = ENOMEM;
                        goto fail;
                }
        }
        return 0;

fail:   uath_free_rx_cmd_list(sc);
        return error;
}

void
uath_free_rx_cmd_list(struct uath_softc *sc)
{
        int i;

        for (i = 0; i < UATH_RX_CMD_LIST_COUNT; i++)
                if (sc->rx_cmd[i].xfer != NULL) {
                        usbd_free_xfer(sc->rx_cmd[i].xfer);
                        sc->rx_cmd[i].xfer = NULL;
                }
}

int
uath_media_change(struct ifnet *ifp)
{
        int error;

        error = ieee80211_media_change(ifp);
        if (error != ENETRESET)
                return error;

        if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
                error = uath_init(ifp);

        return error;
}

/*
 * This function is called periodically (every second) when associated to
 * query device statistics.
 */
void
uath_stat(void *arg)
{
        struct uath_softc *sc = arg;
        int error;

        /*
         * Send request for statistics asynchronously. The timer will be
         * restarted when we'll get the stats notification.
         */
        error = uath_cmd_write(sc, UATH_CMD_STATS, NULL, 0,
            UATH_CMD_FLAG_ASYNC);
        if (error != 0) {
                printf("%s: could not query statistics (error=%d)\n",
                    sc->sc_dev.dv_xname, error);
        }
}

/*
 * This function is called periodically (every 250ms) during scanning to
 * switch from one channel to another.
 */
void
uath_next_scan(void *arg)
{
        struct uath_softc *sc = arg;
        struct ieee80211com *ic = &sc->sc_ic;
        struct ifnet *ifp = &ic->ic_if;

        if (ic->ic_state == IEEE80211_S_SCAN)
                ieee80211_next_scan(ifp);
}

void
uath_task(void *arg)
{
        struct uath_softc *sc = arg;
        struct ieee80211com *ic = &sc->sc_ic;
        enum ieee80211_state ostate;

        ostate = ic->ic_state;

        switch (sc->sc_state) {
        case IEEE80211_S_INIT:
                if (ostate == IEEE80211_S_RUN) {
                        /* turn link and activity LEDs off */
                        (void)uath_set_led(sc, UATH_LED_LINK, 0);
                        (void)uath_set_led(sc, UATH_LED_ACTIVITY, 0);
                }
                break;

        case IEEE80211_S_SCAN:
                if (uath_switch_channel(sc, ic->ic_bss->ni_chan) != 0) {
                        printf("%s: could not switch channel\n",
                            sc->sc_dev.dv_xname);
                        break;
                }
                timeout_add_msec(&sc->scan_to, 250);
                break;

        case IEEE80211_S_AUTH:
        {
                struct ieee80211_node *ni = ic->ic_bss;
                struct uath_cmd_bssid bssid;
                struct uath_cmd_0b cmd0b;
                struct uath_cmd_0c cmd0c;

                if (uath_switch_channel(sc, ni->ni_chan) != 0) {
                        printf("%s: could not switch channel\n",
                            sc->sc_dev.dv_xname);
                        break;
                }

                (void)uath_cmd_write(sc, UATH_CMD_24, NULL, 0, 0);

                bzero(&bssid, sizeof bssid);
                bssid.len = htobe32(IEEE80211_ADDR_LEN);
                IEEE80211_ADDR_COPY(bssid.bssid, ni->ni_bssid);
                (void)uath_cmd_write(sc, UATH_CMD_SET_BSSID, &bssid,
                    sizeof bssid, 0);

                bzero(&cmd0b, sizeof cmd0b);
                cmd0b.code = htobe32(2);
                cmd0b.size = htobe32(sizeof (cmd0b.data));
                (void)uath_cmd_write(sc, UATH_CMD_0B, &cmd0b, sizeof cmd0b, 0);

                bzero(&cmd0c, sizeof cmd0c);
                cmd0c.magic1 = htobe32(2);
                cmd0c.magic2 = htobe32(7);
                cmd0c.magic3 = htobe32(1);
                (void)uath_cmd_write(sc, UATH_CMD_0C, &cmd0c, sizeof cmd0c, 0);

                if (uath_set_rates(sc, &ni->ni_rates) != 0) {
                        printf("%s: could not set negotiated rate set\n",
                            sc->sc_dev.dv_xname);
                        break;
                }
                break;
        }

        case IEEE80211_S_ASSOC:
                break;

        case IEEE80211_S_RUN:
        {
                struct ieee80211_node *ni = ic->ic_bss;
                struct uath_cmd_bssid bssid;
                struct uath_cmd_xled xled;
                uint32_t val;

                if (ic->ic_opmode == IEEE80211_M_MONITOR) {
                        /* make both LEDs blink while monitoring */
                        bzero(&xled, sizeof xled);
                        xled.which = htobe32(0);
                        xled.rate = htobe32(1);
                        xled.mode = htobe32(2);
                        (void)uath_cmd_write(sc, UATH_CMD_SET_XLED, &xled,
                            sizeof xled, 0);
                        break;
                }

                /*
                 * Tx rate is controlled by firmware, report the maximum
                 * negotiated rate in ifconfig output.
                 */
                ni->ni_txrate = ni->ni_rates.rs_nrates - 1;

                val = htobe32(1);
                (void)uath_cmd_write(sc, UATH_CMD_2E, &val, sizeof val, 0);

                bzero(&bssid, sizeof bssid);
                bssid.flags1 = htobe32(0xc004);
                bssid.flags2 = htobe32(0x003b);
                bssid.len = htobe32(IEEE80211_ADDR_LEN);
                IEEE80211_ADDR_COPY(bssid.bssid, ni->ni_bssid);
                (void)uath_cmd_write(sc, UATH_CMD_SET_BSSID, &bssid,
                    sizeof bssid, 0);

                /* turn link LED on */
                (void)uath_set_led(sc, UATH_LED_LINK, 1);

                /* make activity LED blink */
                bzero(&xled, sizeof xled);
                xled.which = htobe32(1);
                xled.rate = htobe32(1);
                xled.mode = htobe32(2);
                (void)uath_cmd_write(sc, UATH_CMD_SET_XLED, &xled, sizeof xled,
                    0);

                /* set state to associated */
                val = htobe32(1);
                (void)uath_cmd_write(sc, UATH_CMD_SET_STATE, &val, sizeof val,
                    0);

                /* start statistics timer */
                timeout_add_sec(&sc->stat_to, 1);
                break;
        }
        }
        sc->sc_newstate(ic, sc->sc_state, sc->sc_arg);
}

int
uath_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
{
        struct uath_softc *sc = ic->ic_softc;

        usb_rem_task(sc->sc_udev, &sc->sc_task);
        timeout_del(&sc->scan_to);
        timeout_del(&sc->stat_to);

        /* do it in a process context */
        sc->sc_state = nstate;
        sc->sc_arg = arg;
        usb_add_task(sc->sc_udev, &sc->sc_task);
        return 0;
}

#ifdef UATH_DEBUG
void
uath_dump_cmd(const uint8_t *buf, int len, char prefix)
{
        int i;

        for (i = 0; i < len; i++) {
                if ((i % 16) == 0)
                        printf("\n%c ", prefix);
                else if ((i % 4) == 0)
                        printf(" ");
                printf("%02x", buf[i]);
        }
        printf("\n");
}
#endif

/*
 * Low-level function to send read or write commands to the firmware.
 */
int
uath_cmd(struct uath_softc *sc, uint32_t code, const void *idata, int ilen,
    void *odata, int flags)
{
        struct uath_cmd_hdr *hdr;
        struct uath_tx_cmd *cmd;
        uint16_t xferflags;
        int s, xferlen, error;

        /* grab a xfer */
        cmd = &sc->tx_cmd[sc->cmd_idx];

        /* always bulk-out a multiple of 4 bytes */
        xferlen = (sizeof (struct uath_cmd_hdr) + ilen + 3) & ~3;

        hdr = (struct uath_cmd_hdr *)cmd->buf;
        bzero(hdr, sizeof (struct uath_cmd_hdr));
        hdr->len   = htobe32(xferlen);
        hdr->code  = htobe32(code);
        hdr->priv  = sc->cmd_idx;       /* don't care about endianness */
        hdr->magic = htobe32((flags & UATH_CMD_FLAG_MAGIC) ? 1 << 24 : 0);
        bcopy(idata, (uint8_t *)(hdr + 1), ilen);

#ifdef UATH_DEBUG
        if (uath_debug >= 5) {
                printf("sending command code=0x%02x flags=0x%x index=%u",
                    code, flags, sc->cmd_idx);
                uath_dump_cmd(cmd->buf, xferlen, '+');
        }
#endif
        xferflags = USBD_FORCE_SHORT_XFER | USBD_NO_COPY;
        if (!(flags & UATH_CMD_FLAG_READ)) {
                if (!(flags & UATH_CMD_FLAG_ASYNC))
                        xferflags |= USBD_SYNCHRONOUS;
        } else
                s = splusb();

        cmd->odata = odata;

        usbd_setup_xfer(cmd->xfer, sc->cmd_tx_pipe, cmd, cmd->buf, xferlen,
            xferflags, UATH_CMD_TIMEOUT, NULL);
        error = usbd_transfer(cmd->xfer);
        if (error != USBD_IN_PROGRESS && error != 0) {
                if (flags & UATH_CMD_FLAG_READ)
                        splx(s);
                printf("%s: could not send command 0x%x (error=%s)\n",
                    sc->sc_dev.dv_xname, code, usbd_errstr(error));
                return error;
        }
        sc->cmd_idx = (sc->cmd_idx + 1) % UATH_TX_CMD_LIST_COUNT;

        if (!(flags & UATH_CMD_FLAG_READ))
                return 0;       /* write: don't wait for reply */

        /* wait at most two seconds for command reply */
        error = tsleep_nsec(cmd, PCATCH, "uathcmd", SEC_TO_NSEC(2));
        cmd->odata = NULL;      /* in case answer is received too late */
        splx(s);
        if (error != 0) {
                printf("%s: timeout waiting for command reply\n",
                    sc->sc_dev.dv_xname);
        }
        return error;
}

int
uath_cmd_write(struct uath_softc *sc, uint32_t code, const void *data, int len,
    int flags)
{
        flags &= ~UATH_CMD_FLAG_READ;
        return uath_cmd(sc, code, data, len, NULL, flags);
}

int
uath_cmd_read(struct uath_softc *sc, uint32_t code, const void *idata,
    int ilen, void *odata, int flags)
{
        flags |= UATH_CMD_FLAG_READ;
        return uath_cmd(sc, code, idata, ilen, odata, flags);
}

int
uath_write_reg(struct uath_softc *sc, uint32_t reg, uint32_t val)
{
        struct uath_write_mac write;
        int error;

        write.reg = htobe32(reg);
        write.len = htobe32(0); /* 0 = single write */
        *(uint32_t *)write.data = htobe32(val);

        error = uath_cmd_write(sc, UATH_CMD_WRITE_MAC, &write,
            3 * sizeof (uint32_t), 0);
        if (error != 0) {
                printf("%s: could not write register 0x%02x\n",
                    sc->sc_dev.dv_xname, reg);
        }
        return error;
}

int
uath_write_multi(struct uath_softc *sc, uint32_t reg, const void *data,
    int len)
{
        struct uath_write_mac write;
        int error;

        write.reg = htobe32(reg);
        write.len = htobe32(len);
        bcopy(data, write.data, len);

        /* properly handle the case where len is zero (reset) */
        error = uath_cmd_write(sc, UATH_CMD_WRITE_MAC, &write,
            (len == 0) ? sizeof (uint32_t) : 2 * sizeof (uint32_t) + len, 0);
        if (error != 0) {
                printf("%s: could not write %d bytes to register 0x%02x\n",
                    sc->sc_dev.dv_xname, len, reg);
        }
        return error;
}

int
uath_read_reg(struct uath_softc *sc, uint32_t reg, uint32_t *val)
{
        struct uath_read_mac read;
        int error;

        reg = htobe32(reg);
        error = uath_cmd_read(sc, UATH_CMD_READ_MAC, &reg, sizeof reg, &read,
            0);
        if (error != 0) {
                printf("%s: could not read register 0x%02x\n",
                    sc->sc_dev.dv_xname, betoh32(reg));
                return error;
        }
        *val = betoh32(*(uint32_t *)read.data);
        return error;
}

int
uath_read_eeprom(struct uath_softc *sc, uint32_t reg, void *odata)
{
        struct uath_read_mac read;
        int len, error;

        reg = htobe32(reg);
        error = uath_cmd_read(sc, UATH_CMD_READ_EEPROM, &reg, sizeof reg,
            &read, 0);
        if (error != 0) {
                printf("%s: could not read EEPROM offset 0x%02x\n",
                    sc->sc_dev.dv_xname, betoh32(reg));
                return error;
        }
        len = betoh32(read.len);
        bcopy(read.data, odata, (len == 0) ? sizeof (uint32_t) : len);
        return error;
}

void
uath_cmd_rxeof(struct usbd_xfer *xfer, void *priv,
    usbd_status status)
{
        struct uath_rx_cmd *cmd = priv;
        struct uath_softc *sc = cmd->sc;
        struct uath_cmd_hdr *hdr;

        if (status != USBD_NORMAL_COMPLETION) {
                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(sc->cmd_rx_pipe);
                return;
        }

        hdr = (struct uath_cmd_hdr *)cmd->buf;

#ifdef UATH_DEBUG
        if (uath_debug >= 5) {
                printf("received command code=0x%x index=%u len=%u",
                    betoh32(hdr->code), hdr->priv, betoh32(hdr->len));
                uath_dump_cmd(cmd->buf, betoh32(hdr->len), '-');
        }
#endif

        switch (betoh32(hdr->code) & 0xff) {
        /* reply to a read command */
        default:
        {
                struct uath_tx_cmd *txcmd = &sc->tx_cmd[hdr->priv];

                if (txcmd->odata != NULL) {
                        /* copy answer into caller's supplied buffer */
                        bcopy((uint8_t *)(hdr + 1), txcmd->odata,
                            betoh32(hdr->len) - sizeof (struct uath_cmd_hdr));
                }
                wakeup(txcmd);  /* wake up caller */
                break;
        }
        /* spontaneous firmware notifications */
        case UATH_NOTIF_READY:
                DPRINTF(("received device ready notification\n"));
                wakeup(UATH_COND_INIT(sc));
                break;

        case UATH_NOTIF_TX:
                /* this notification is sent when UATH_TX_NOTIFY is set */
                DPRINTF(("received Tx notification\n"));
                break;

        case UATH_NOTIF_STATS:
                DPRINTFN(2, ("received device statistics\n"));
                timeout_add_sec(&sc->stat_to, 1);
                break;
        }

        /* setup a new transfer */
        usbd_setup_xfer(xfer, sc->cmd_rx_pipe, cmd, cmd->buf, UATH_MAX_RXCMDSZ,
            USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
            uath_cmd_rxeof);
        (void)usbd_transfer(xfer);
}

void
uath_data_rxeof(struct usbd_xfer *xfer, void *priv,
    usbd_status status)
{
        struct uath_rx_data *data = priv;
        struct uath_softc *sc = data->sc;
        struct ieee80211com *ic = &sc->sc_ic;
        struct ifnet *ifp = &ic->ic_if;
        struct ieee80211_frame *wh;
        struct ieee80211_rxinfo rxi;
        struct ieee80211_node *ni;
        struct uath_rx_desc *desc;
        struct mbuf *mnew, *m;
        uint32_t hdr;
        int s, len;

        if (status != USBD_NORMAL_COMPLETION) {
                if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
                        return;

                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(sc->data_rx_pipe);

                ifp->if_ierrors++;
                return;
        }
        usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);

        if (len < UATH_MIN_RXBUFSZ) {
                DPRINTF(("wrong xfer size (len=%d)\n", len));
                ifp->if_ierrors++;
                goto skip;
        }

        hdr = betoh32(*(uint32_t *)data->buf);

        /* Rx descriptor is located at the end, 32-bit aligned */
        desc = (struct uath_rx_desc *)
            (data->buf + len - sizeof (struct uath_rx_desc));

        if (betoh32(desc->len) > sc->rxbufsz) {
                DPRINTF(("bad descriptor (len=%d)\n", betoh32(desc->len)));
                ifp->if_ierrors++;
                goto skip;
        }

        /* there's probably a "bad CRC" flag somewhere in the descriptor.. */

        MGETHDR(mnew, M_DONTWAIT, MT_DATA);
        if (mnew == NULL) {
                printf("%s: could not allocate rx mbuf\n",
                    sc->sc_dev.dv_xname);
                ifp->if_ierrors++;
                goto skip;
        }
        MCLGETL(mnew, M_DONTWAIT, sc->rxbufsz);
        if (!(mnew->m_flags & M_EXT)) {
                printf("%s: could not allocate rx mbuf cluster\n",
                    sc->sc_dev.dv_xname);
                m_freem(mnew);
                ifp->if_ierrors++;
                goto skip;
        }

        m = data->m;
        data->m = mnew;

        /* finalize mbuf */
        m->m_data = data->buf + sizeof (uint32_t);
        m->m_pkthdr.len = m->m_len = betoh32(desc->len) -
            sizeof (struct uath_rx_desc) - IEEE80211_CRC_LEN;

        data->buf = mtod(data->m, uint8_t *);

        wh = mtod(m, struct ieee80211_frame *);
        memset(&rxi, 0, sizeof(rxi));
        if ((wh->i_fc[1] & IEEE80211_FC1_WEP) &&
            ic->ic_opmode != IEEE80211_M_MONITOR) {
                /*
                 * Hardware decrypts the frame itself but leaves the WEP bit
                 * set in the 802.11 header and doesn't remove the IV and CRC
                 * fields.
                 */
                wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
                memmove((caddr_t)wh + IEEE80211_WEP_IVLEN +
                    IEEE80211_WEP_KIDLEN, wh, sizeof (struct ieee80211_frame));
                m_adj(m, IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN);
                m_adj(m, -IEEE80211_WEP_CRCLEN);
                wh = mtod(m, struct ieee80211_frame *);

                rxi.rxi_flags |= IEEE80211_RXI_HWDEC;
        }

#if NBPFILTER > 0
        /* there are a lot more fields in the Rx descriptor */
        if (sc->sc_drvbpf != NULL) {
                struct mbuf mb;
                struct uath_rx_radiotap_header *tap = &sc->sc_rxtap;

                tap->wr_flags = 0;
                tap->wr_chan_freq = htole16(betoh32(desc->freq));
                tap->wr_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);
                tap->wr_dbm_antsignal = (int8_t)betoh32(desc->rssi);

                mb.m_data = (caddr_t)tap;
                mb.m_len = sc->sc_rxtap_len;
                mb.m_next = m;
                mb.m_nextpkt = NULL;
                mb.m_type = 0;
                mb.m_flags = 0;
                bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
        }
#endif

        s = splnet();
        ni = ieee80211_find_rxnode(ic, wh);
        rxi.rxi_rssi = (int)betoh32(desc->rssi);
        ieee80211_input(ifp, m, ni, &rxi);

        /* node is no longer needed */
        ieee80211_release_node(ic, ni);
        splx(s);

skip:   /* setup a new transfer */
        usbd_setup_xfer(xfer, sc->data_rx_pipe, data, data->buf, sc->rxbufsz,
            USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, uath_data_rxeof);
        (void)usbd_transfer(data->xfer);
}

int
uath_tx_null(struct uath_softc *sc)
{
        struct uath_tx_data *data;
        struct uath_tx_desc *desc;

        data = &sc->tx_data[sc->data_idx];

        data->ni = NULL;

        *(uint32_t *)data->buf = UATH_MAKECTL(1, sizeof (struct uath_tx_desc));
        desc = (struct uath_tx_desc *)(data->buf + sizeof (uint32_t));

        bzero(desc, sizeof (struct uath_tx_desc));
        desc->len  = htobe32(sizeof (struct uath_tx_desc));
        desc->type = htobe32(UATH_TX_NULL);

        usbd_setup_xfer(data->xfer, sc->data_tx_pipe, data, data->buf,
            sizeof (uint32_t) + sizeof (struct uath_tx_desc), USBD_NO_COPY |
            USBD_FORCE_SHORT_XFER | USBD_SYNCHRONOUS, UATH_DATA_TIMEOUT, NULL);
        if (usbd_transfer(data->xfer) != 0)
                return EIO;

        sc->data_idx = (sc->data_idx + 1) % UATH_TX_DATA_LIST_COUNT;

        return uath_cmd_write(sc, UATH_CMD_0F, NULL, 0, UATH_CMD_FLAG_ASYNC);
}

void
uath_data_txeof(struct usbd_xfer *xfer, void *priv,
    usbd_status status)
{
        struct uath_tx_data *data = priv;
        struct uath_softc *sc = data->sc;
        struct ieee80211com *ic = &sc->sc_ic;
        struct ifnet *ifp = &ic->ic_if;
        int s;

        if (status != USBD_NORMAL_COMPLETION) {
                if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
                        return;

                printf("%s: could not transmit buffer: %s\n",
                    sc->sc_dev.dv_xname, usbd_errstr(status));

                if (status == USBD_STALLED)
                        usbd_clear_endpoint_stall_async(sc->data_tx_pipe);

                ifp->if_oerrors++;
                return;
        }

        s = splnet();

        ieee80211_release_node(ic, data->ni);
        data->ni = NULL;

        sc->tx_queued--;

        sc->sc_tx_timer = 0;
        ifq_clr_oactive(&ifp->if_snd);
        uath_start(ifp);

        splx(s);
}

int
uath_tx_data(struct uath_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
{
        struct ieee80211com *ic = &sc->sc_ic;
        struct uath_tx_data *data;
        struct uath_tx_desc *desc;
        const struct ieee80211_frame *wh;
        int paylen, totlen, xferlen, error;

        data = &sc->tx_data[sc->data_idx];
        desc = (struct uath_tx_desc *)(data->buf + sizeof (uint32_t));

        data->ni = ni;

#if NBPFILTER > 0
        if (sc->sc_drvbpf != NULL) {
                struct mbuf mb;
                struct uath_tx_radiotap_header *tap = &sc->sc_txtap;

                tap->wt_flags = 0;
                tap->wt_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq);
                tap->wt_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);

                mb.m_data = (caddr_t)tap;
                mb.m_len = sc->sc_txtap_len;
                mb.m_next = m0;
                mb.m_nextpkt = NULL;
                mb.m_type = 0;
                mb.m_flags = 0;
                bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
        }
#endif

        paylen = m0->m_pkthdr.len;
        xferlen = sizeof (uint32_t) + sizeof (struct uath_tx_desc) + paylen;

        wh = mtod(m0, struct ieee80211_frame *);
        if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
                uint8_t *frm = (uint8_t *)(desc + 1);
                uint32_t iv;

                /* h/w WEP: it's up to the host to fill the IV field */
                bcopy(wh, frm, sizeof (struct ieee80211_frame));
                frm += sizeof (struct ieee80211_frame);

                /* insert IV: code copied from net80211 */
                iv = (ic->ic_iv != 0) ? ic->ic_iv : arc4random();
                if (iv >= 0x03ff00 && (iv & 0xf8ff00) == 0x00ff00)
                        iv += 0x000100;
                ic->ic_iv = iv + 1;

                *frm++ = iv & 0xff;
                *frm++ = (iv >>  8) & 0xff;
                *frm++ = (iv >> 16) & 0xff;
                *frm++ = ic->ic_wep_txkey << 6;

                m_copydata(m0, sizeof(struct ieee80211_frame),
                    m0->m_pkthdr.len - sizeof(struct ieee80211_frame), frm);

                paylen  += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
                xferlen += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
                totlen = xferlen + IEEE80211_WEP_CRCLEN;
        } else {
                m_copydata(m0, 0, m0->m_pkthdr.len, desc + 1);
                totlen = xferlen;
        }

        /* fill Tx descriptor */
        *(uint32_t *)data->buf = UATH_MAKECTL(1, xferlen - sizeof (uint32_t));

        desc->len    = htobe32(totlen);
        desc->priv   = sc->data_idx;    /* don't care about endianness */
        desc->paylen = htobe32(paylen);
        desc->type   = htobe32(UATH_TX_DATA);
        desc->flags  = htobe32(0);
        if (IEEE80211_IS_MULTICAST(wh->i_addr1)) {
                desc->dest  = htobe32(UATH_ID_BROADCAST);
                desc->magic = htobe32(3);
        } else {
                desc->dest  = htobe32(UATH_ID_BSS);
                desc->magic = htobe32(1);
        }

        m_freem(m0);    /* mbuf is no longer needed */

#ifdef UATH_DEBUG
        if (uath_debug >= 6) {
                printf("sending frame index=%u len=%d xferlen=%d",
                    sc->data_idx, paylen, xferlen);
                uath_dump_cmd(data->buf, xferlen, '+');
        }
#endif
        usbd_setup_xfer(data->xfer, sc->data_tx_pipe, data, data->buf, xferlen,
            USBD_FORCE_SHORT_XFER | USBD_NO_COPY, UATH_DATA_TIMEOUT,
            uath_data_txeof);
        error = usbd_transfer(data->xfer);
        if (error != USBD_IN_PROGRESS && error != 0) {
                ic->ic_if.if_oerrors++;
                return error;
        }
        sc->data_idx = (sc->data_idx + 1) % UATH_TX_DATA_LIST_COUNT;
        sc->tx_queued++;

        return 0;
}

void
uath_start(struct ifnet *ifp)
{
        struct uath_softc *sc = ifp->if_softc;
        struct ieee80211com *ic = &sc->sc_ic;
        struct ieee80211_node *ni;
        struct mbuf *m0;

        /*
         * net80211 may still try to send management frames even if the
         * IFF_RUNNING flag is not set...
         */
        if (!(ifp->if_flags & IFF_RUNNING) && ifq_is_oactive(&ifp->if_snd))
                return;

        for (;;) {
                if (sc->tx_queued >= UATH_TX_DATA_LIST_COUNT) {
                        ifq_set_oactive(&ifp->if_snd);
                        break;
                }

                m0 = mq_dequeue(&ic->ic_mgtq);
                if (m0 != NULL) {
                        ni = m0->m_pkthdr.ph_cookie;
#if NBPFILTER > 0
                        if (ic->ic_rawbpf != NULL)
                                bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
#endif
                        if (uath_tx_data(sc, m0, ni) != 0)
                                break;
                } else {
                        if (ic->ic_state != IEEE80211_S_RUN)
                                break;

                        m0 = ifq_dequeue(&ifp->if_snd);
                        if (m0 == NULL)
                                break;
#if NBPFILTER > 0
                        if (ifp->if_bpf != NULL)
                                bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
#endif
                        m0 = ieee80211_encap(ifp, m0, &ni);
                        if (m0 == NULL)
                                continue;
#if NBPFILTER > 0
                        if (ic->ic_rawbpf != NULL)
                                bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
#endif
                        if (uath_tx_data(sc, m0, ni) != 0) {
                                if (ni != NULL)
                                        ieee80211_release_node(ic, ni);
                                ifp->if_oerrors++;
                                break;
                        }
                }

                sc->sc_tx_timer = 5;
                ifp->if_timer = 1;
        }
}

void
uath_watchdog(struct ifnet *ifp)
{
        struct uath_softc *sc = ifp->if_softc;

        ifp->if_timer = 0;

        if (sc->sc_tx_timer > 0) {
                if (--sc->sc_tx_timer == 0) {
                        printf("%s: device timeout\n", sc->sc_dev.dv_xname);
                        /*uath_init(ifp); XXX needs a process context! */
                        ifp->if_oerrors++;
                        return;
                }
                ifp->if_timer = 1;
        }

        ieee80211_watchdog(ifp);
}

int
uath_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
        int s, error = 0;

        s = splnet();

        switch (cmd) {
        case SIOCSIFADDR:
                ifp->if_flags |= IFF_UP;
                /* FALLTHROUGH */
        case SIOCSIFFLAGS:
                if (ifp->if_flags & IFF_UP) {
                        if (!(ifp->if_flags & IFF_RUNNING))
                                uath_init(ifp);
                } else {
                        if (ifp->if_flags & IFF_RUNNING)
                                uath_stop(ifp, 1);
                }
                break;

        default:
                error = ieee80211_ioctl(ifp, cmd, data);
        }

        if (error == ENETRESET) {
                if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
                    (IFF_UP | IFF_RUNNING))
                        uath_init(ifp);
                error = 0;
        }

        splx(s);

        return error;
}

int
uath_query_eeprom(struct uath_softc *sc)
{
        uint32_t tmp;
        int error;

        /* retrieve MAC address */
        error = uath_read_eeprom(sc, UATH_EEPROM_MACADDR, sc->sc_ic.ic_myaddr);
        if (error != 0) {
                printf("%s: could not read MAC address\n",
                    sc->sc_dev.dv_xname);
                return error;
        }

        /* retrieve the maximum frame size that the hardware can receive */
        error = uath_read_eeprom(sc, UATH_EEPROM_RXBUFSZ, &tmp);
        if (error != 0) {
                printf("%s: could not read maximum Rx buffer size\n",
                    sc->sc_dev.dv_xname);
                return error;
        }
        sc->rxbufsz = betoh32(tmp) & 0xfff;
        DPRINTF(("maximum Rx buffer size %d\n", sc->rxbufsz));
        return 0;
}

int
uath_reset(struct uath_softc *sc)
{
        struct uath_cmd_setup setup;
        uint32_t reg, val;
        int s, error;

        /* init device with some voodoo incantations.. */
        setup.magic1 = htobe32(1);
        setup.magic2 = htobe32(5);
        setup.magic3 = htobe32(200);
        setup.magic4 = htobe32(27);
        s = splusb();
        error = uath_cmd_write(sc, UATH_CMD_SETUP, &setup, sizeof setup,
            UATH_CMD_FLAG_ASYNC);
        /* ..and wait until firmware notifies us that it is ready */
        if (error == 0)
                error = tsleep_nsec(UATH_COND_INIT(sc), PCATCH, "uathinit",
                    SEC_TO_NSEC(5));
        splx(s);
        if (error != 0)
                return error;

        /* read PHY registers */
        for (reg = 0x09; reg <= 0x24; reg++) {
                if (reg == 0x0b || reg == 0x0c)
                        continue;
                DELAY(100);
                if ((error = uath_read_reg(sc, reg, &val)) != 0)
                        return error;
                DPRINTFN(2, ("reg 0x%02x=0x%08x\n", reg, val));
        }
        return error;
}

int
uath_reset_tx_queues(struct uath_softc *sc)
{
        int ac, error;

        for (ac = 0; ac < 4; ac++) {
                const uint32_t qid = htobe32(UATH_AC_TO_QID(ac));

                DPRINTF(("resetting Tx queue %d\n", UATH_AC_TO_QID(ac)));
                error = uath_cmd_write(sc, UATH_CMD_RESET_QUEUE, &qid,
                    sizeof qid, 0);
                if (error != 0)
                        break;
        }
        return error;
}

int
uath_wme_init(struct uath_softc *sc)
{
        struct uath_qinfo qinfo;
        int ac, error;
        static const struct uath_wme_settings uath_wme_11g[4] = {
                { 7, 4, 10,  0, 0 },    /* Background */
                { 3, 4, 10,  0, 0 },    /* Best-Effort */
                { 3, 3,  4, 26, 0 },    /* Video */
                { 2, 2,  3, 47, 0 }     /* Voice */
        };

        bzero(&qinfo, sizeof qinfo);
        qinfo.size   = htobe32(32);
        qinfo.magic1 = htobe32(1);      /* XXX ack policy? */
        qinfo.magic2 = htobe32(1);
        for (ac = 0; ac < 4; ac++) {
                qinfo.qid      = htobe32(UATH_AC_TO_QID(ac));
                qinfo.ac       = htobe32(ac);
                qinfo.aifsn    = htobe32(uath_wme_11g[ac].aifsn);
                qinfo.logcwmin = htobe32(uath_wme_11g[ac].logcwmin);
                qinfo.logcwmax = htobe32(uath_wme_11g[ac].logcwmax);
                qinfo.txop     = htobe32(UATH_TXOP_TO_US(
                                     uath_wme_11g[ac].txop));
                qinfo.acm      = htobe32(uath_wme_11g[ac].acm);

                DPRINTF(("setting up Tx queue %d\n", UATH_AC_TO_QID(ac)));
                error = uath_cmd_write(sc, UATH_CMD_SET_QUEUE, &qinfo,
                    sizeof qinfo, 0);
                if (error != 0)
                        break;
        }
        return error;
}

int
uath_set_chan(struct uath_softc *sc, struct ieee80211_channel *c)
{
        struct uath_set_chan chan;

        bzero(&chan, sizeof chan);
        chan.flags  = htobe32(0x1400);
        chan.freq   = htobe32(c->ic_freq);
        chan.magic1 = htobe32(20);
        chan.magic2 = htobe32(50);
        chan.magic3 = htobe32(1);

        DPRINTF(("switching to channel %d\n",
            ieee80211_chan2ieee(&sc->sc_ic, c)));
        return uath_cmd_write(sc, UATH_CMD_SET_CHAN, &chan, sizeof chan, 0);
}

int
uath_set_key(struct uath_softc *sc, const struct ieee80211_key *k, int index)
{
        struct uath_cmd_crypto crypto;
        int i;

        bzero(&crypto, sizeof crypto);
        crypto.keyidx = htobe32(index);
        crypto.magic1 = htobe32(1);
        crypto.size   = htobe32(368);
        crypto.mask   = htobe32(0xffff);
        crypto.flags  = htobe32(0x80000068);
        if (index != UATH_DEFAULT_KEY)
                crypto.flags |= htobe32(index << 16);
        memset(crypto.magic2, 0xff, sizeof crypto.magic2);

        /*
         * Each byte of the key must be XOR'ed with 10101010 before being
         * transmitted to the firmware.
         */
        for (i = 0; i < k->k_len; i++)
                crypto.key[i] = k->k_key[i] ^ 0xaa;

        DPRINTF(("setting crypto key index=%d len=%d\n", index, k->k_len));
        return uath_cmd_write(sc, UATH_CMD_CRYPTO, &crypto, sizeof crypto, 0);
}

int
uath_set_keys(struct uath_softc *sc)
{
        const struct ieee80211com *ic = &sc->sc_ic;
        int i, error;

        for (i = 0; i < IEEE80211_WEP_NKID; i++) {
                const struct ieee80211_key *k = &ic->ic_nw_keys[i];

                if (k->k_len > 0 && (error = uath_set_key(sc, k, i)) != 0)
                        return error;
        }
        return uath_set_key(sc, &ic->ic_nw_keys[ic->ic_wep_txkey],
            UATH_DEFAULT_KEY);
}

int
uath_set_rates(struct uath_softc *sc, const struct ieee80211_rateset *rs)
{
        struct uath_cmd_rates rates;

        bzero(&rates, sizeof rates);
        rates.magic1 = htobe32(0x02);
        rates.size   = htobe32(1 + sizeof rates.rates);
        rates.nrates = rs->rs_nrates;
        bcopy(rs->rs_rates, rates.rates, rs->rs_nrates);

        DPRINTF(("setting supported rates nrates=%d\n", rs->rs_nrates));
        return uath_cmd_write(sc, UATH_CMD_SET_RATES, &rates, sizeof rates, 0);
}

int
uath_set_rxfilter(struct uath_softc *sc, uint32_t filter, uint32_t flags)
{
        struct uath_cmd_filter rxfilter;

        rxfilter.filter = htobe32(filter);
        rxfilter.flags  = htobe32(flags);

        DPRINTF(("setting Rx filter=0x%x flags=0x%x\n", filter, flags));
        return uath_cmd_write(sc, UATH_CMD_SET_FILTER, &rxfilter,
            sizeof rxfilter, 0);
}

int
uath_set_led(struct uath_softc *sc, int which, int on)
{
        struct uath_cmd_led led;

        led.which = htobe32(which);
        led.state = htobe32(on ? UATH_LED_ON : UATH_LED_OFF);

        DPRINTFN(2, ("switching %s led %s\n",
            (which == UATH_LED_LINK) ? "link" : "activity",
            on ? "on" : "off"));
        return uath_cmd_write(sc, UATH_CMD_SET_LED, &led, sizeof led, 0);
}

int
uath_switch_channel(struct uath_softc *sc, struct ieee80211_channel *c)
{
        uint32_t val;
        int error;

        /* set radio frequency */
        if ((error = uath_set_chan(sc, c)) != 0) {
                printf("%s: could not set channel\n", sc->sc_dev.dv_xname);
                return error;
        }

        /* reset Tx rings */
        if ((error = uath_reset_tx_queues(sc)) != 0) {
                printf("%s: could not reset Tx queues\n",
                    sc->sc_dev.dv_xname);
                return error;
        }

        /* set Tx rings WME properties */
        if ((error = uath_wme_init(sc)) != 0) {
                printf("%s: could not init Tx queues\n",
                    sc->sc_dev.dv_xname);
                return error;
        }

        val = htobe32(0);
        error = uath_cmd_write(sc, UATH_CMD_SET_STATE, &val, sizeof val, 0);
        if (error != 0) {
                printf("%s: could not set state\n", sc->sc_dev.dv_xname);
                return error;
        }

        return uath_tx_null(sc);
}

int
uath_init(struct ifnet *ifp)
{
        struct uath_softc *sc = ifp->if_softc;
        struct ieee80211com *ic = &sc->sc_ic;
        struct uath_cmd_31 cmd31;
        uint32_t val;
        int i, error;

        /* reset data and command rings */
        sc->tx_queued = sc->data_idx = sc->cmd_idx = 0;

        val = htobe32(0);
        (void)uath_cmd_write(sc, UATH_CMD_02, &val, sizeof val, 0);

        /* set MAC address */
        IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl));
        (void)uath_write_multi(sc, 0x13, ic->ic_myaddr, IEEE80211_ADDR_LEN);

        (void)uath_write_reg(sc, 0x02, 0x00000001);
        (void)uath_write_reg(sc, 0x0e, 0x0000003f);
        (void)uath_write_reg(sc, 0x10, 0x00000001);
        (void)uath_write_reg(sc, 0x06, 0x0000001e);

        /*
         * Queue Rx data xfers.
         */
        for (i = 0; i < UATH_RX_DATA_LIST_COUNT; i++) {
                struct uath_rx_data *data = &sc->rx_data[i];

                usbd_setup_xfer(data->xfer, sc->data_rx_pipe, data, data->buf,
                    sc->rxbufsz, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT,
                    uath_data_rxeof);
                error = usbd_transfer(data->xfer);
                if (error != USBD_IN_PROGRESS && error != 0) {
                        printf("%s: could not queue Rx transfer\n",
                            sc->sc_dev.dv_xname);
                        goto fail;
                }
        }

        error = uath_cmd_read(sc, UATH_CMD_07, NULL, 0, &val,
            UATH_CMD_FLAG_MAGIC);
        if (error != 0) {
                printf("%s: could not send read command 07h\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }
        DPRINTF(("command 07h return code: %x\n", betoh32(val)));

        /* set default channel */
        ic->ic_bss->ni_chan = ic->ic_ibss_chan;
        if ((error = uath_set_chan(sc, ic->ic_bss->ni_chan)) != 0) {
                printf("%s: could not set channel\n", sc->sc_dev.dv_xname);
                goto fail;
        }

        if ((error = uath_wme_init(sc)) != 0) {
                printf("%s: could not setup WME parameters\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }

        /* init MAC registers */
        (void)uath_write_reg(sc, 0x19, 0x00000000);
        (void)uath_write_reg(sc, 0x1a, 0x0000003c);
        (void)uath_write_reg(sc, 0x1b, 0x0000003c);
        (void)uath_write_reg(sc, 0x1c, 0x00000000);
        (void)uath_write_reg(sc, 0x1e, 0x00000000);
        (void)uath_write_reg(sc, 0x1f, 0x00000003);
        (void)uath_write_reg(sc, 0x0c, 0x00000000);
        (void)uath_write_reg(sc, 0x0f, 0x00000002);
        (void)uath_write_reg(sc, 0x0a, 0x00000007);     /* XXX retry? */
        (void)uath_write_reg(sc, 0x09, ic->ic_rtsthreshold);

        val = htobe32(4);
        (void)uath_cmd_write(sc, UATH_CMD_27, &val, sizeof val, 0);
        (void)uath_cmd_write(sc, UATH_CMD_27, &val, sizeof val, 0);
        (void)uath_cmd_write(sc, UATH_CMD_1B, NULL, 0, 0);

        if ((error = uath_set_keys(sc)) != 0) {
                printf("%s: could not set crypto keys\n",
                    sc->sc_dev.dv_xname);
                goto fail;
        }

        /* enable Rx */
        (void)uath_set_rxfilter(sc, 0x0000, 4);
        (void)uath_set_rxfilter(sc, 0x0817, 1);

        cmd31.magic1 = htobe32(0xffffffff);
        cmd31.magic2 = htobe32(0xffffffff);
        (void)uath_cmd_write(sc, UATH_CMD_31, &cmd31, sizeof cmd31, 0);

        ifp->if_flags |= IFF_RUNNING;
        ifq_clr_oactive(&ifp->if_snd);

        if (ic->ic_opmode == IEEE80211_M_MONITOR)
                ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
        else
                ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);

        return 0;

fail:   uath_stop(ifp, 1);
        return error;
}

void
uath_stop(struct ifnet *ifp, int disable)
{
        struct uath_softc *sc = ifp->if_softc;
        struct ieee80211com *ic = &sc->sc_ic;
        uint32_t val;
        int s;

        s = splusb();

        sc->sc_tx_timer = 0;
        ifp->if_timer = 0;
        ifp->if_flags &= ~IFF_RUNNING;
        ifq_clr_oactive(&ifp->if_snd);

        ieee80211_new_state(ic, IEEE80211_S_INIT, -1);  /* free all nodes */

        val = htobe32(0);
        (void)uath_cmd_write(sc, UATH_CMD_SET_STATE, &val, sizeof val, 0);
        (void)uath_cmd_write(sc, UATH_CMD_RESET, NULL, 0, 0);

        val = htobe32(0);
        (void)uath_cmd_write(sc, UATH_CMD_15, &val, sizeof val, 0);

#if 0
        (void)uath_cmd_read(sc, UATH_CMD_SHUTDOWN, NULL, 0, NULL,
            UATH_CMD_FLAG_MAGIC);
#endif

        /* abort any pending transfers */
        usbd_abort_pipe(sc->data_tx_pipe);
        usbd_abort_pipe(sc->data_rx_pipe);
        usbd_abort_pipe(sc->cmd_tx_pipe);

        splx(s);
}

/*
 * Load the MIPS R4000 microcode into the device.  Once the image is loaded,
 * the device will detach itself from the bus and reattach later with a new
 * product Id (a la ezusb).  XXX this could also be implemented in userland
 * through /dev/ugen.
 */
int
uath_loadfirmware(struct uath_softc *sc, const u_char *fw, int len)
{
        struct usbd_xfer *ctlxfer, *txxfer, *rxxfer;
        struct uath_fwblock *txblock, *rxblock;
        uint8_t *txdata;
        int error = 0;

        if ((ctlxfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
                printf("%s: could not allocate Tx control xfer\n",
                    sc->sc_dev.dv_xname);
                error = USBD_NOMEM;
                goto fail1;
        }
        txblock = usbd_alloc_buffer(ctlxfer, sizeof (struct uath_fwblock));
        if (txblock == NULL) {
                printf("%s: could not allocate Tx control block\n",
                    sc->sc_dev.dv_xname);
                error = USBD_NOMEM;
                goto fail2;
        }

        if ((txxfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
                printf("%s: could not allocate Tx xfer\n",
                    sc->sc_dev.dv_xname);
                error = USBD_NOMEM;
                goto fail2;
        }
        txdata = usbd_alloc_buffer(txxfer, UATH_MAX_FWBLOCK_SIZE);
        if (txdata == NULL) {
                printf("%s: could not allocate Tx buffer\n",
                    sc->sc_dev.dv_xname);
                error = USBD_NOMEM;
                goto fail3;
        }

        if ((rxxfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
                printf("%s: could not allocate Rx control xfer\n",
                    sc->sc_dev.dv_xname);
                error = USBD_NOMEM;
                goto fail3;
        }
        rxblock = usbd_alloc_buffer(rxxfer, sizeof (struct uath_fwblock));
        if (rxblock == NULL) {
                printf("%s: could not allocate Rx control block\n",
                    sc->sc_dev.dv_xname);
                error = USBD_NOMEM;
                goto fail4;
        }

        bzero(txblock, sizeof (struct uath_fwblock));
        txblock->flags = htobe32(UATH_WRITE_BLOCK);
        txblock->total = htobe32(len);

        while (len > 0) {
                int mlen = min(len, UATH_MAX_FWBLOCK_SIZE);

                txblock->remain = htobe32(len - mlen);
                txblock->len = htobe32(mlen);

                DPRINTF(("sending firmware block: %d bytes remaining\n",
                    len - mlen));

                /* send firmware block meta-data */
                usbd_setup_xfer(ctlxfer, sc->cmd_tx_pipe, sc, txblock,
                    sizeof (struct uath_fwblock),
                    USBD_NO_COPY | USBD_SYNCHRONOUS,
                    UATH_CMD_TIMEOUT, NULL);
                if ((error = usbd_transfer(ctlxfer)) != 0) {
                        printf("%s: could not send firmware block info\n",
                            sc->sc_dev.dv_xname);
                        break;
                }

                /* send firmware block data */
                bcopy(fw, txdata, mlen);
                usbd_setup_xfer(txxfer, sc->data_tx_pipe, sc, txdata, mlen,
                    USBD_NO_COPY | USBD_SYNCHRONOUS, UATH_DATA_TIMEOUT, NULL);
                if ((error = usbd_transfer(txxfer)) != 0) {
                        printf("%s: could not send firmware block data\n",
                            sc->sc_dev.dv_xname);
                        break;
                }

                /* wait for ack from firmware */
                usbd_setup_xfer(rxxfer, sc->cmd_rx_pipe, sc, rxblock,
                    sizeof (struct uath_fwblock), USBD_SHORT_XFER_OK |
                    USBD_NO_COPY | USBD_SYNCHRONOUS, UATH_CMD_TIMEOUT, NULL);
                if ((error = usbd_transfer(rxxfer)) != 0) {
                        printf("%s: could not read firmware answer\n",
                            sc->sc_dev.dv_xname);
                        break;
                }

                DPRINTFN(2, ("rxblock flags=0x%x total=%d\n",
                    betoh32(rxblock->flags), betoh32(rxblock->rxtotal)));
                fw += mlen;
                len -= mlen;
        }

fail4:  usbd_free_xfer(rxxfer);
fail3:  usbd_free_xfer(txxfer);
fail2:  usbd_free_xfer(ctlxfer);
fail1:  return error;
}