/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2007 by  Lukas Turek <turek@ksvi.mff.cuni.cz>
 * Copyright (c) 2007 by  Jiri Svoboda <jirik.svoboda@seznam.cz>
 * Copyright (c) 2007 by  Martin Krulis <martin.krulis@matfyz.cz>
 * Copyright (c) 2006 by Damien Bergamini <damien.bergamini@free.fr>
 * Copyright (c) 2006 by Florian Stoehr <ich@florian-stoehr.de>
 *
 * 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.
 *
 */

/*
 * ZD1211 wLAN driver
 * Driver major routines
 */

#include <sys/byteorder.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/mac_provider.h>
#include <sys/mac_wifi.h>
#include <sys/strsun.h>
#include <sys/ksynch.h>

#include "zyd.h"
#include "zyd_reg.h"

static int zyd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int zyd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

static int zyd_m_stat(void *arg, uint_t stat, uint64_t *val);
static int zyd_m_start(void *arg);
static void zyd_m_stop(void *arg);
static int zyd_m_unicst(void *arg, const uint8_t *macaddr);
static int zyd_m_multicst(void *arg, boolean_t add, const uint8_t *m);
static int zyd_m_promisc(void *arg, boolean_t on);
static void zyd_m_ioctl(void *arg, queue_t *wq, mblk_t *mp);
static mblk_t *zyd_m_tx(void *arg, mblk_t *mp);
static int zyd_m_getprop(void *arg, const char *pr_name,
    mac_prop_id_t wldp_pr_num, uint_t wldp_length, void *wldp_buf);
static void zyd_m_propinfo(void *arg, const char *pr_name,
    mac_prop_id_t wldp_pr_num, mac_prop_info_handle_t mph);
static int zyd_m_setprop(void *arg, const char *pr_name,
    mac_prop_id_t wldp_pr_num, uint_t wldp_length, const void *wldp_buf);

static int zyd_newstate(struct ieee80211com *ic,
    enum ieee80211_state state, int arg);

/* Driver identification */
static char zyd_ident[] = ZYD_DRV_DESC " " ZYD_DRV_REV;

/* Global state pointer for managing per-device soft states */
void *zyd_ssp;

/*
 * Mac Call Back entries
 */
static mac_callbacks_t zyd_m_callbacks = {
        MC_IOCTL | MC_SETPROP | MC_GETPROP | MC_PROPINFO,
        zyd_m_stat,             /* Get the value of a statistic */
        zyd_m_start,            /* Start the device */
        zyd_m_stop,             /* Stop the device */
        zyd_m_promisc,          /* Enable or disable promiscuous mode */
        zyd_m_multicst,         /* Enable or disable a multicast addr */
        zyd_m_unicst,           /* Set the unicast MAC address */
        zyd_m_tx,               /* Transmit a packet */
        NULL,
        zyd_m_ioctl,            /* Process an unknown ioctl */
        NULL,                   /* mc_getcapab */
        NULL,
        NULL,
        zyd_m_setprop,
        zyd_m_getprop,
        zyd_m_propinfo
};

/*
 *  Module Loading Data & Entry Points
 */
DDI_DEFINE_STREAM_OPS(zyd_devops,       /* name */
    nulldev,                    /* identify */
    nulldev,                    /* probe */
    zyd_attach,                 /* attach */
    zyd_detach,                 /* detach */
    nodev,                      /* reset */
    NULL,                       /* getinfo */
    D_MP,                       /* flag */
    NULL,                       /* stream_tab */
    ddi_quiesce_not_needed      /* quiesce */
);

static struct modldrv zyd_modldrv = {
        &mod_driverops,         /* drv_modops */
        zyd_ident,              /* drv_linkinfo */
        &zyd_devops             /* drv_dev_ops */
};

static struct modlinkage zyd_ml = {
        MODREV_1,               /* ml_rev */
        {&zyd_modldrv, NULL}    /* ml_linkage */
};

/*
 * Wireless-specific structures
 */
static const struct ieee80211_rateset zyd_rateset_11b = {
        4, {2, 4, 11, 22}       /* units are 0.5Mbit! */
};

static const struct ieee80211_rateset zyd_rateset_11g = {
        12, {2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108}
};


#ifdef DEBUG
uint32_t zyd_dbg_flags;

void
zyd_dbg(uint32_t dbg_mask, const int8_t *fmt, ...)
{
        va_list args;

        if (dbg_mask & zyd_dbg_flags) {
                va_start(args, fmt);
                vcmn_err(CE_CONT, fmt, args);
                va_end(args);
        }
}
#endif

void
zyd_warn(const int8_t *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vcmn_err(CE_WARN, fmt, args);
        va_end(args);
}

/*
 * Internal functions
 */
static uint8_t
zyd_plcp_signal(uint16_t rate)
{
        switch (rate) {
                /* CCK rates (returned values are device-dependent) */
        case 2:
                return (0x0);
        case 4:
                return (0x1);
        case 11:
                return (0x2);
        case 22:
                return (0x3);

                /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
        case 12:
                return (0xb);
        case 18:
                return (0xf);
        case 24:
                return (0xa);
        case 36:
                return (0xe);
        case 48:
                return (0x9);
        case 72:
                return (0xd);
        case 96:
                return (0x8);
        case 108:
                return (0xc);

                /* unsupported rates (should not get there) */
        default:
                return (0xff);
        }
}

/*
 * Timeout function for scanning.
 *
 * Called at the end of each scanning round.
 */
static void
zyd_next_scan(void *arg)
{
        struct zyd_softc *sc = arg;
        struct ieee80211com *ic = &sc->ic;

        ZYD_DEBUG((ZYD_DBG_SCAN, "scan timer: fired\n"));

        if (ic->ic_state == IEEE80211_S_SCAN) {
                ieee80211_next_scan(ic);
        } else {
                ZYD_DEBUG((ZYD_DBG_SCAN, "scan timer: no work\n"));
        }
}

/*
 * Extract a 802.11 frame from the received packet and forward it to net80211.
 */
void
zyd_receive(struct zyd_softc *sc, const uint8_t *buf, uint16_t len)
{
        const struct zyd_rx_stat *stat;
        struct ieee80211com *ic = &sc->ic;
        struct ieee80211_frame *wh;
        struct ieee80211_node *in;
        int rlen;               /* Actual frame length */
        uint8_t rssi;
        mblk_t *m;

        if (len < ZYD_MIN_FRAGSZ) {
                /* Packet is too short, silently drop it */
                sc->rx_err++;
                return;
        }

        stat = (const struct zyd_rx_stat *)
            (buf + len - sizeof (struct zyd_rx_stat));
        if (stat->flags & ZYD_RX_ERROR) {
                /* Frame is corrupted, silently drop it */
                sc->rx_err++;
                return;
        }

        /* compute actual frame length */
        rlen = len - sizeof (struct zyd_plcphdr) -
            sizeof (struct zyd_rx_stat) - IEEE80211_CRC_LEN;

        m = allocb(rlen, BPRI_MED);
        if (m == NULL) {
                sc->rx_nobuf++;
                return;
        }

        /* Copy frame to new buffer */
        bcopy(buf + sizeof (struct zyd_plcphdr), m->b_wptr, rlen);
        m->b_wptr += rlen;

        /* Send frame to net80211 stack */
        wh = (struct ieee80211_frame *)m->b_rptr;
        in = ieee80211_find_rxnode(ic, wh);
        rssi = (stat->rssi < 25) ? 230 : (255 - stat->rssi) / 2;

        (void) ieee80211_input(ic, m, in, (int32_t)rssi, 0);

        ieee80211_free_node(in);
}

/*
 * xxx_send callback for net80211.
 *
 * Transmit a 802.11 frame.
 *
 * Constructs a packet from zyd_tx_header and 802.11 frame data
 * and sends it to the chip.
 */
/*ARGSUSED*/
static int
zyd_send(ieee80211com_t *ic, mblk_t *mp, uint8_t type)
{
        struct zyd_softc *sc = ZYD_IC_TO_SOFTC(ic);
        struct zyd_tx_header *buf_hdr;
        struct ieee80211_frame *wh;
        struct ieee80211_node *in;
        struct ieee80211_key *k;
        mblk_t *m, *m0;
        int len, off, mblen;
        uint16_t frame_size, additional_size, rate;
        uint8_t service;
        int res;

        ASSERT(mp->b_next == NULL);

        /* device not ready, drop all frames */
        if (!sc->usb.connected || sc->suspended || !sc->running) {
                freemsg(mp);
                if (type == IEEE80211_FC0_TYPE_DATA)
                        return (DDI_SUCCESS);
                else
                        return (DDI_FAILURE);
        }

        /* device queue overrun */
        if (sc->tx_queued >= ZYD_TX_LIST_COUNT) {
                /* drop management frames */
                if (type != IEEE80211_FC0_TYPE_DATA) {
                        freemsg(mp);
                } else {
                        (void) zyd_serial_enter(sc, ZYD_NO_SIG);
                        sc->resched = B_TRUE;
                        zyd_serial_exit(sc);
                }
                return (DDI_FAILURE);
        }

        m = allocb(msgdsize(mp) + sizeof (struct zyd_tx_header) + 32,
            BPRI_MED);
        if (m == NULL) {
                sc->tx_nobuf++;
                (void) zyd_serial_enter(sc, ZYD_NO_SIG);
                sc->resched = B_TRUE;
                zyd_serial_exit(sc);
                return (DDI_FAILURE);
        }
        m->b_rptr += sizeof (struct zyd_tx_header);
        m->b_wptr = m->b_rptr;

        for (off = 0, m0 = mp; m0 != NULL; m0 = m0->b_cont) {
                mblen = MBLKL(m0);
                (void) memcpy(m->b_rptr + off, m0->b_rptr, mblen);
                off += mblen;
        }
        m->b_wptr += off;

        wh = (struct ieee80211_frame *)m->b_rptr;
        in = ieee80211_find_txnode(ic, wh->i_addr1);

        if (in == NULL) {
                freemsg(m);
                sc->tx_err++;
                freemsg(mp);
                return (DDI_SUCCESS);
        }
        in->in_inact = 0;

        if (type == IEEE80211_FC0_TYPE_DATA)
                (void) ieee80211_encap(ic, m, in);

        if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
                k = ieee80211_crypto_encap(ic, m);
                if (k == NULL) {
                        sc->tx_err++;
                        ieee80211_free_node(in);
                        freemsg(m);
                        freemsg(mp);
                        return (DDI_SUCCESS);
                }
                /* packet header may have moved, reset our local pointer */
                wh = (struct ieee80211_frame *)m->b_rptr;
        }

        /*
         * pickup a rate. May need work to make adaptive - at present,
         * picks best rate for mode.
         */
        if (type == IEEE80211_FC0_TYPE_MGT) {
                /* mgmt frames are sent at 1M */
                rate = (uint16_t)in->in_rates.ir_rates[0];
        } else if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) {
                rate = (uint16_t)ic->ic_sup_rates[ic->ic_curmode].
                    ir_rates[ic->ic_fixed_rate];
        } else {
                rate = (uint16_t)ic->ic_sup_rates[ic->ic_curmode].
                    ir_rates[in->in_txrate];
        }
        rate &= IEEE80211_RATE_VAL;
        if (rate == 0)          /* should not happen */
                rate = 2;

        /* Get total length of frame */
        len = msgsize(m);

        m->b_rptr -= sizeof (struct zyd_tx_header);
        buf_hdr = (struct zyd_tx_header *)m->b_rptr;

        frame_size = (uint16_t)len + 4; /* include CRC32 */
        buf_hdr->frame_size = LE_16(frame_size);

        /*
         * Compute "packet size". What the 10 stands for,
         * nobody knows.
         */
        additional_size = sizeof (struct zyd_tx_header) + 10;
        if (sc->mac_rev == ZYD_ZD1211)
                buf_hdr->packet_size = LE_16(frame_size + additional_size);
        else
                buf_hdr->packet_size = LE_16(additional_size);

        buf_hdr->rate_mod_flags = LE_8(zyd_plcp_signal(rate));
        buf_hdr->type_flags = LE_8(ZYD_TX_FLAG_BACKOFF);
        if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
                /* multicast frames are not sent at OFDM rates in 802.11b/g */
                if (frame_size > ic->ic_rtsthreshold) {
                        buf_hdr->type_flags |= ZYD_TX_FLAG_RTS;
                } else if (ZYD_RATE_IS_OFDM(rate) &&
                    (ic->ic_flags & IEEE80211_F_USEPROT)) {
                        if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
                                buf_hdr->type_flags |=
                                    ZYD_TX_FLAG_CTS_TO_SELF;
                        else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
                                buf_hdr->type_flags |= ZYD_TX_FLAG_RTS;
                }
        } else
                buf_hdr->type_flags |= ZYD_TX_FLAG_MULTICAST;

        if ((type == IEEE80211_FC0_TYPE_CTL) &&
            (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK)
            == IEEE80211_FC0_SUBTYPE_PS_POLL)
                buf_hdr->type_flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL);

        if (ZYD_RATE_IS_OFDM(rate)) {
                buf_hdr->rate_mod_flags |= ZYD_TX_RMF_OFDM;
                if (ic->ic_curmode == IEEE80211_MODE_11A)
                        buf_hdr->rate_mod_flags |= ZYD_TX_RMF_5GHZ;
        } else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
                buf_hdr->rate_mod_flags |= ZYD_TX_RMF_SH_PREAMBLE;

        /*
         * Compute frame duration and length-extension service flag.
         */
        service = 0x00;

        buf_hdr->frame_duration = LE_16((16 * frame_size + rate - 1) / rate);
        buf_hdr->service = service;
        buf_hdr->next_frame_duration = LE_16(0);

        if (rate == 22) {
                const int remainder = (16 * frame_size) % 22;
                if (remainder != 0 && remainder < 7)
                        buf_hdr->service |= ZYD_TX_SERVICE_LENGTH_EXTENSION;
        }

        res = zyd_usb_send_packet(&sc->usb, m);
        if (res != ZYD_SUCCESS) {
                sc->tx_err++;
        } else {
                (void) zyd_serial_enter(sc, ZYD_NO_SIG);
                sc->tx_queued++;
                zyd_serial_exit(sc);
                freemsg(mp);
                ic->ic_stats.is_tx_frags++;
                ic->ic_stats.is_tx_bytes += len;
        }

        ieee80211_free_node(in);

        return (DDI_SUCCESS);
}

/*
 * Register with the MAC layer.
 */
static zyd_res
zyd_mac_init(struct zyd_softc *sc)
{
        struct ieee80211com *ic = &sc->ic;
        mac_register_t *macp;
        wifi_data_t wd = { 0 };
        int err;

        /*
         * Initialize mac structure
         */
        macp = mac_alloc(MAC_VERSION);
        if (macp == NULL) {
                ZYD_WARN("failed to allocate MAC structure\n");
                return (ZYD_FAILURE);
        }

        /*
         * Initialize pointer to device specific functions
         */
        wd.wd_secalloc = WIFI_SEC_NONE;
        wd.wd_opmode = sc->ic.ic_opmode;
        IEEE80211_ADDR_COPY(wd.wd_bssid, ic->ic_macaddr);

        macp->m_type_ident = MAC_PLUGIN_IDENT_WIFI;
        macp->m_driver = sc;
        macp->m_dip = sc->dip;
        macp->m_src_addr = ic->ic_macaddr;
        macp->m_callbacks = &zyd_m_callbacks;
        macp->m_min_sdu = 0;
        macp->m_max_sdu = IEEE80211_MTU;
        macp->m_pdata = &wd;
        macp->m_pdata_size = sizeof (wd);

        /*
         * Register the macp to mac
         */
        err = mac_register(macp, &sc->ic.ic_mach);
        mac_free(macp);

        if (err != DDI_SUCCESS) {
                ZYD_WARN("failed to register MAC structure\n");
                return (ZYD_FAILURE);
        }

        return (ZYD_SUCCESS);
}

/*
 * Register with net80211.
 */
static void
zyd_wifi_init(struct zyd_softc *sc)
{
        struct ieee80211com *ic = &sc->ic;
        int i;

        /*
         * Initialize the WiFi part, which will be used by generic layer
         */
        ic->ic_phytype = IEEE80211_T_OFDM;
        ic->ic_opmode = IEEE80211_M_STA;
        ic->ic_state = IEEE80211_S_INIT;
        ic->ic_maxrssi = 255;
        ic->ic_xmit = zyd_send;

        /* set device capabilities */
        ic->ic_caps = IEEE80211_C_TXPMGT |      /* tx power management */
            IEEE80211_C_SHPREAMBLE |            /* short preamble supported */
            IEEE80211_C_SHSLOT | IEEE80211_C_WPA;       /* Support WPA/WPA2 */

        /* Copy MAC address */
        IEEE80211_ADDR_COPY(ic->ic_macaddr, sc->macaddr);

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

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

        /*
         * Init generic layer (it cannot fail)
         */
        ieee80211_attach(ic);

        /* register WPA door */
        ieee80211_register_door(ic, ddi_driver_name(sc->dip),
            ddi_get_instance(sc->dip));

        /* Must be after attach! */
        sc->newstate = ic->ic_newstate;
        ic->ic_newstate = zyd_newstate;

        ieee80211_media_init(ic);
        ic->ic_def_txkey = 0;
}

/*
 * Device operations
 */
/*
 * Binding the driver to a device.
 *
 * Concurrency: Until zyd_attach() returns with success,
 * the only other entry point that can be executed is getinfo().
 * Thus no locking here yet.
 */
static int
zyd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        struct zyd_softc *sc;
        char strbuf[32];
        int instance;
        int err;

        switch (cmd) {
        case DDI_ATTACH:
                break;

        case DDI_RESUME:
                sc = ddi_get_soft_state(zyd_ssp, ddi_get_instance(dip));
                ASSERT(sc != NULL);

                (void) zyd_resume(sc);
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }

        instance = ddi_get_instance(dip);
        err = ddi_soft_state_zalloc(zyd_ssp, instance);

        if (err != DDI_SUCCESS) {
                ZYD_WARN("failed to allocate soft state\n");
                return (DDI_FAILURE);
        }

        sc = ddi_get_soft_state(zyd_ssp, instance);
        sc->dip = dip;
        sc->timeout_id = 0;

        if (zyd_usb_init(sc) != ZYD_SUCCESS) {
                ddi_soft_state_free(zyd_ssp, instance);
                return (DDI_FAILURE);
        }

        if (zyd_hw_init(sc) != ZYD_SUCCESS) {
                zyd_usb_deinit(sc);
                ddi_soft_state_free(zyd_ssp, instance);
                return (DDI_FAILURE);
        }

        zyd_wifi_init(sc);

        if (zyd_mac_init(sc) != DDI_SUCCESS) {
                ieee80211_detach(&sc->ic);
                zyd_usb_deinit(sc);
                ddi_soft_state_free(zyd_ssp, instance);
                return (DDI_FAILURE);
        }

        /*
         * Create minor node of type DDI_NT_NET_WIFI
         */
        (void) snprintf(strbuf, sizeof (strbuf), ZYD_DRV_NAME"%d", instance);
        err = ddi_create_minor_node(dip, strbuf, S_IFCHR,
            instance + 1, DDI_NT_NET_WIFI, 0);
        if (err != DDI_SUCCESS)
                ZYD_WARN("failed to create minor node\n");

        /* initialize locking */
        zyd_serial_init(sc);

        return (DDI_SUCCESS);
}

/*
 * Detach the driver from a device.
 *
 * Concurrency: Will be called only after a successful attach
 * (and not concurrently).
 */
static int
zyd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        struct zyd_softc *sc = NULL;

        switch (cmd) {
        case DDI_DETACH:
                break;

        case DDI_SUSPEND:
                sc = ddi_get_soft_state(zyd_ssp, ddi_get_instance(dip));
                ASSERT(sc != NULL);

                return (zyd_suspend(sc));

        default:
                return (DDI_FAILURE);
        }

        sc = ddi_get_soft_state(zyd_ssp, ddi_get_instance(dip));
        ASSERT(sc != NULL);

        if (mac_disable(sc->ic.ic_mach) != 0)
                return (DDI_FAILURE);
        /*
         * Unregister from the MAC layer subsystem
         */
        (void) mac_unregister(sc->ic.ic_mach);

        /*
         * Detach ieee80211
         */
        ieee80211_detach(&sc->ic);

        zyd_hw_deinit(sc);
        zyd_usb_deinit(sc);

        /* At this point it should be safe to release & destroy the locks */
        zyd_serial_deinit(sc);

        ddi_remove_minor_node(dip, NULL);
        ddi_soft_state_free(zyd_ssp, ddi_get_instance(dip));
        return (DDI_SUCCESS);
}

/*
 * Mac Call Back functions
 */

/*
 * Read device statistic information.
 */
static int
zyd_m_stat(void *arg, uint_t stat, uint64_t *val)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;
        ieee80211com_t *ic = &sc->ic;
        ieee80211_node_t *in;

        switch (stat) {
        case MAC_STAT_IFSPEED:
                if (!sc->usb.connected || sc->suspended || !sc->running)
                        return (ENOTSUP);
                in = ieee80211_ref_node(ic->ic_bss);
                *val = ((ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) ?
                    IEEE80211_RATE(in->in_txrate) :
                    ic->ic_fixed_rate) / 2 * 1000000;
                ieee80211_free_node(in);
                break;
        case MAC_STAT_NOXMTBUF:
                *val = sc->tx_nobuf;
                break;
        case MAC_STAT_NORCVBUF:
                *val = sc->rx_nobuf;
                break;
        case MAC_STAT_IERRORS:
                *val = sc->rx_err;
                break;
        case MAC_STAT_RBYTES:
                *val = ic->ic_stats.is_rx_bytes;
                break;
        case MAC_STAT_IPACKETS:
                *val = ic->ic_stats.is_rx_frags;
                break;
        case MAC_STAT_OBYTES:
                *val = ic->ic_stats.is_tx_bytes;
                break;
        case MAC_STAT_OPACKETS:
                *val = ic->ic_stats.is_tx_frags;
                break;
        case MAC_STAT_OERRORS:
        case WIFI_STAT_TX_FAILED:
                *val = sc->tx_err;
                break;
        case WIFI_STAT_TX_RETRANS:
        case WIFI_STAT_FCS_ERRORS:
        case WIFI_STAT_WEP_ERRORS:
        case WIFI_STAT_TX_FRAGS:
        case WIFI_STAT_MCAST_TX:
        case WIFI_STAT_RTS_SUCCESS:
        case WIFI_STAT_RTS_FAILURE:
        case WIFI_STAT_ACK_FAILURE:
        case WIFI_STAT_RX_FRAGS:
        case WIFI_STAT_MCAST_RX:
        case WIFI_STAT_RX_DUPS:
                return (ieee80211_stat(ic, stat, val));
        default:
                return (ENOTSUP);
        }
        return (0);
}

/*
 * Start the device.
 *
 * Concurrency: Presumably fully concurrent, must lock.
 */
static int
zyd_m_start(void *arg)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;

        (void) zyd_serial_enter(sc, ZYD_NO_SIG);
        if ((!sc->usb.connected) || (zyd_hw_start(sc) != ZYD_SUCCESS)) {
                zyd_serial_exit(sc);
                return (DDI_FAILURE);
        }
        zyd_serial_exit(sc);

        ieee80211_new_state(&sc->ic, IEEE80211_S_INIT, -1);
        sc->running = B_TRUE;

        return (DDI_SUCCESS);
}

/*
 * Stop the device.
 */
static void
zyd_m_stop(void *arg)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;

        sc->running = B_FALSE;
        ieee80211_new_state(&sc->ic, IEEE80211_S_INIT, -1);

        (void) zyd_serial_enter(sc, ZYD_NO_SIG);
        sc->resched = B_FALSE;
        zyd_hw_stop(sc);
        zyd_serial_exit(sc);
}

/*
 * Change the MAC address of the device.
 */
/*ARGSUSED*/
static int
zyd_m_unicst(void *arg, const uint8_t *macaddr)
{
        return (DDI_FAILURE);
}

/*
 * Enable/disable multicast.
 */
/*ARGSUSED*/
static int
zyd_m_multicst(void *arg, boolean_t add, const uint8_t *m)
{
        ZYD_DEBUG((ZYD_DBG_GLD, "multicast not implemented\n"));
        return (DDI_SUCCESS);
}

/*
 * Enable/disable promiscuous mode.
 */
/*ARGSUSED*/
static int
zyd_m_promisc(void *arg, boolean_t on)
{
        ZYD_DEBUG((ZYD_DBG_GLD, "promiscuous not implemented\n"));
        return (DDI_SUCCESS);
}

/*
 * IOCTL request.
 */
static void
zyd_m_ioctl(void *arg, queue_t *wq, mblk_t *mp)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;
        struct ieee80211com *ic = &sc->ic;

        if (!sc->usb.connected || sc->suspended || !sc->running) {
                miocnak(wq, mp, 0, ENXIO);
                return;
        }

        if (ieee80211_ioctl(ic, wq, mp) == ENETRESET) {
                if (sc->running && ic->ic_des_esslen) {
                        zyd_m_stop(sc);
                        if (zyd_m_start(sc) != DDI_SUCCESS)
                                return;
                        ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
                }
        }
}

/*
 * callback functions for /get/set properties
 */
static int
zyd_m_setprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
    uint_t wldp_length, const void *wldp_buf)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;
        struct ieee80211com *ic = &sc->ic;
        int err;

        if (!sc->usb.connected || sc->suspended || !sc->running) {
                return (ENXIO);
        }

        err = ieee80211_setprop(ic, pr_name, wldp_pr_num, wldp_length,
            wldp_buf);
        if (err == ENETRESET) {
                if (sc->running && ic->ic_des_esslen) {
                        zyd_m_stop(sc);
                        if (zyd_m_start(sc) != DDI_SUCCESS)
                                return (DDI_FAILURE);
                        ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
                }
                err = 0;
        }

        return (err);
}

static int
zyd_m_getprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
    uint_t wldp_length, void *wldp_buf)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;
        int err;

        if (!sc->usb.connected || sc->suspended || !sc->running) {
                return (DDI_FAILURE);
        }

        err = ieee80211_getprop(&sc->ic, pr_name, wldp_pr_num,
            wldp_length, wldp_buf);

        return (err);
}

static void
zyd_m_propinfo(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
    mac_prop_info_handle_t mph)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;

        ieee80211_propinfo(&sc->ic, pr_name, wldp_pr_num, mph);
}

/*
 * Transmit a data frame.
 */
static mblk_t *
zyd_m_tx(void *arg, mblk_t *mp)
{
        struct zyd_softc *sc = (struct zyd_softc *)arg;
        struct ieee80211com *ic = &sc->ic;
        mblk_t *next;

        ASSERT(mp != NULL);

        /* not associated, drop data frames */
        if (ic->ic_state != IEEE80211_S_RUN) {
                freemsg(mp);
                return (DDI_SUCCESS);
        }

        while (mp != NULL) {
                next = mp->b_next;
                mp->b_next = NULL;

                if (zyd_send(ic, mp, IEEE80211_FC0_TYPE_DATA) != DDI_SUCCESS) {
                        mp->b_next = next;
                        break;
                }
                mp = next;
        }

        return (mp);
}

/*
 * xxx_newstate callback for net80211.
 *
 * Called by net80211 whenever the ieee80211 state changes.
 */
static int
zyd_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
{
        struct zyd_softc *sc = ZYD_IC_TO_SOFTC(ic);
        struct ieee80211_node *in;
        uint_t chan;

        if (sc->timeout_id != 0) {
                (void) untimeout(sc->timeout_id);
                sc->timeout_id = 0;
        }

        if (!sc->usb.connected || sc->suspended || !sc->running) {
                return (sc->newstate(ic, nstate, arg));
        }

        switch (nstate) {
        case IEEE80211_S_SCAN:
                ZYD_DEBUG((ZYD_DBG_SCAN, "scan timer: starting next\n"));
                sc->timeout_id = timeout(zyd_next_scan, sc,
                    drv_usectohz(ZYD_DWELL_TIME));
                /*FALLTHRU*/
        case IEEE80211_S_AUTH:
        case IEEE80211_S_ASSOC:
        case IEEE80211_S_RUN:
                chan = ieee80211_chan2ieee(ic, ic->ic_curchan);
                if (chan == 0 || chan == IEEE80211_CHAN_ANY) {
                        ZYD_WARN("invalid channel number\n");
                        return (0);
                }
                (void) zyd_serial_enter(sc, ZYD_SER_SIG);
                zyd_hw_set_channel(sc, chan);
                zyd_serial_exit(sc);

                in = ic->ic_bss;
                in->in_txrate = in->in_rates.ir_nrates - 1;
        default:
                break;
        }

        return (sc->newstate(ic, nstate, arg));
}

/*
 * USB-safe synchronization.
 * Debugging routines.
 *
 * Kmutexes should never be held when making calls to USBA
 * or when sleeping. Thus, we implement our own "mutex" on top
 * of kmutexes and kcondvars.
 *
 * Usage: Any (possibly concurrent) access to the soft state or device must
 * be serialized with a pair of zyd_serial_enter()/zyd_serial_exit().
 */
/*
 * Initialize the serialization object.
 */
void
zyd_serial_init(struct zyd_softc *sc)
{
        mutex_init(&sc->serial.lock, NULL, MUTEX_DRIVER,
            sc->usb.cdata->dev_iblock_cookie);
        cv_init(&sc->serial.wait, NULL, CV_DRIVER, NULL);

        sc->serial.held = B_FALSE;
        sc->serial.initialized = B_TRUE;
}

/*
 * Wait for the serialization object.
 *
 * If wait_sig is ZYD_SER_SIG, the function may return
 * a signal is received. In this case, the serialization object
 * is not acquired (but the mutex is) and the return value is ZYD_FAILURE.
 *
 * In any other case the function returns ZYD_SUCCESS and the
 * serialization object is acquired.
 */
zyd_res
zyd_serial_enter(struct zyd_softc *sc, boolean_t wait_sig)
{
        zyd_res res;

        mutex_enter(&sc->serial.lock);

        res = ZYD_SUCCESS;

        while (sc->serial.held != B_FALSE) {
                if (wait_sig == ZYD_SER_SIG) {
                        res = cv_wait_sig(&sc->serial.wait, &sc->serial.lock);
                } else {
                        cv_wait(&sc->serial.wait, &sc->serial.lock);
                }
        }
        sc->serial.held = B_TRUE;

        mutex_exit(&sc->serial.lock);

        return (res);
}

/*
 * Release the serialization object.
 */
void
zyd_serial_exit(struct zyd_softc *sc)
{
        mutex_enter(&sc->serial.lock);
        sc->serial.held = B_FALSE;
        cv_broadcast(&sc->serial.wait);
        mutex_exit(&sc->serial.lock);
}

/*
 * Destroy the serialization object.
 */
void
zyd_serial_deinit(struct zyd_softc *sc)
{
        cv_destroy(&sc->serial.wait);
        mutex_destroy(&sc->serial.lock);

        sc->serial.initialized = B_FALSE;
}


/*
 * zyd_cb_lock: a special signal structure that is used for notification
 * that a callback function has been called.
 */

/* Initializes the zyd_cb_lock structure. */
void
zyd_cb_lock_init(struct zyd_cb_lock *lock)
{
        ASSERT(lock != NULL);
        mutex_init(&lock->mutex, NULL, MUTEX_DRIVER, NULL);
        cv_init(&lock->cv, NULL, CV_DRIVER, NULL);
        lock->done = B_FALSE;
}

/* Deinitalizes the zyd_cb_lock structure. */
void
zyd_cb_lock_destroy(struct zyd_cb_lock *lock)
{
        ASSERT(lock != NULL);
        mutex_destroy(&lock->mutex);
        cv_destroy(&lock->cv);
}

/*
 * Wait on lock until someone calls the "signal" function or the timeout
 * expires. Note: timeout is in microseconds.
 */
zyd_res
zyd_cb_lock_wait(struct zyd_cb_lock *lock, clock_t timeout)
{
        zyd_res res;
        clock_t etime;
        int cv_res;

        ASSERT(lock != NULL);

        mutex_enter(&lock->mutex);

        if (timeout < 0) {
                /* no timeout - wait as long as needed */
                while (lock->done == B_FALSE)
                        (void) cv_wait(&lock->cv, &lock->mutex);
        } else {
                /* wait with timeout (given in usec) */
                etime = ddi_get_lbolt() + drv_usectohz(timeout);
                while (lock->done == B_FALSE) {
                        cv_res =
                            cv_timedwait_sig(&lock->cv, &lock->mutex, etime);
                        if (cv_res <= 0)
                                break;
                }
        }

        res = (lock->done == B_TRUE) ? ZYD_SUCCESS : ZYD_FAILURE;

        mutex_exit(&lock->mutex);

        return (res);
}

/* Signal that the job (eg. callback) is done and unblock anyone who waits. */
void
zyd_cb_lock_signal(struct zyd_cb_lock *lock)
{
        ASSERT(lock != NULL);

        mutex_enter(&lock->mutex);

        lock->done = B_TRUE;
        cv_broadcast(&lock->cv);

        mutex_exit(&lock->mutex);
}

/*
 * Loadable module configuration entry points
 */

/*
 * _init module entry point.
 *
 * Called when the module is being loaded into memory.
 */
int
_init(void)
{
        int err;

        err = ddi_soft_state_init(&zyd_ssp, sizeof (struct zyd_softc), 1);

        if (err != DDI_SUCCESS)
                return (err);

        mac_init_ops(&zyd_devops, ZYD_DRV_NAME);
        err = mod_install(&zyd_ml);

        if (err != DDI_SUCCESS) {
                mac_fini_ops(&zyd_devops);
                ddi_soft_state_fini(&zyd_ssp);
        }

        return (err);
}

/*
 * _info module entry point.
 *
 * Called to obtain information about the module.
 */
int
_info(struct modinfo *modinfop)
{
        return (mod_info(&zyd_ml, modinfop));
}

/*
 * _fini module entry point.
 *
 * Called when the module is being unloaded.
 */
int
_fini(void)
{
        int err;

        err = mod_remove(&zyd_ml);
        if (err == DDI_SUCCESS) {
                mac_fini_ops(&zyd_devops);
                ddi_soft_state_fini(&zyd_ssp);
        }

        return (err);
}