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

/*
 * Copyright (c) 2008 by  Ben Taylor <bentaylor.solx86@gmail.com>
 * 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
 * Device hardware control
 *
 * Control the ZD1211 chip and the RF chip.
 */

#include <sys/byteorder.h>
#include <sys/strsun.h>

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

static zyd_res zyd_hw_configure(struct zyd_softc *sc);
static zyd_res  zyd_al2230_rf_init(struct zyd_softc *);
static zyd_res  zyd_al2230_rf_init_b(struct zyd_softc *);
static zyd_res  zyd_al2230_switch_radio(struct zyd_softc *, boolean_t);
static zyd_res  zyd_al2230_set_channel(struct zyd_softc *, uint8_t);
static zyd_res  zyd_rfmd_rf_init(struct zyd_softc *);
static zyd_res  zyd_rfmd_switch_radio(struct zyd_softc *, boolean_t);
static zyd_res  zyd_rfmd_set_channel(struct zyd_softc *, uint8_t);

/* io write sequences to initialize RF-independent PHY registers */
static const struct zyd_iowrite16 zyd_def_phy[] = ZYD_DEF_PHY;
static const struct zyd_iowrite16 zyd_def_phyB[] = ZYD_DEF_PHYB;
static const char *zyd_rf_name(uint8_t type)
{
        static const char *const zyd_rfs[] = {
                "unknown", "unknown", "UW2451", "UCHIP", "AL2230",
                "AL7230B", "THETA", "AL2210", "MAXIM_NEW", "GCT",
                "PV2000", "RALINK", "INTERSIL", "RFMD", "MAXIM_NEW2",
                "PHILIPS"
        };
        return (zyd_rfs[(type > 15) ? 0 : type]);
}

/*
 * Read a 32-bit I/O register.
 *
 *      sc      soft state
 *      reg     register number
 *      *val    place to store the value
 */
zyd_res
zyd_read32(struct zyd_softc *sc, uint16_t reg, uint32_t *val)
{
        zyd_res result;
        uint16_t tmp[4];
        uint16_t regs[2];

        regs[0] = LE_16(ZYD_REG32_HI(reg));
        regs[1] = LE_16(ZYD_REG32_LO(reg));

        result = zyd_usb_ioread_req(&sc->usb, regs, sizeof (regs),
            tmp, sizeof (tmp));

        if (result != USB_SUCCESS)
                return (ZYD_FAILURE);

        if (tmp[0] != regs[0] || tmp[2] != regs[1]) {
                ZYD_WARN("ioread response doesn't match request\n");
                ZYD_WARN("requested regs %04x, %04x; got %04x, %04x\n",
                    LE_16(regs[0]), LE_16(regs[1]),
                    LE_16(tmp[0]), LE_16(tmp[2]));
                return (ZYD_FAILURE);
        }

        *val = ((uint32_t)LE_16(tmp[1]) << 16) | (uint32_t)LE_16(tmp[3]);

        return (ZYD_SUCCESS);
}

/*
 * Write a 32-bit I/O register.
 *
 *      sc      soft state
 *      reg     register number
 *      val     value to write
 */
zyd_res
zyd_write32(struct zyd_softc *sc, uint16_t reg, uint32_t val)
{
        zyd_res result;
        uint16_t tmp[4];

        tmp[0] = LE_16(ZYD_REG32_HI(reg));
        tmp[1] = LE_16(val >> 16);
        tmp[2] = LE_16(ZYD_REG32_LO(reg));
        tmp[3] = LE_16(val & 0xffff);

        result = zyd_usb_cmd_send(&sc->usb, ZYD_CMD_IOWR, tmp, sizeof (tmp));

        return (result);
}

/*
 * Read a 16-bit I/O register.
 *
 *      sc      soft state
 *      reg     register number
 *      *val    place to store the value
 */
zyd_res
zyd_read16(struct zyd_softc *sc, uint16_t reg, uint16_t *val)
{
        zyd_res result;
        uint16_t tmp[2];
        uint16_t regbuf;

        regbuf = LE_16(reg);

        result = zyd_usb_ioread_req(&sc->usb, &regbuf, sizeof (regbuf),
            tmp, sizeof (tmp));

        if (result != USB_SUCCESS)
                return (ZYD_FAILURE);

        if (tmp[0] != regbuf) {
                ZYD_WARN("ioread response doesn't match request\n");
                ZYD_WARN("requested reg %04x; got %04x\n",
                    LE_16(regbuf), LE_16(tmp[0]));
                return (ZYD_FAILURE);
        }

        if (result != USB_SUCCESS)
                return (ZYD_FAILURE);

        *val = LE_16(tmp[1]);

        return (ZYD_SUCCESS);
}

/*
 * Write a 16-bit I/O register.
 *
 *      sc      soft state
 *      reg     register number
 *      val     value to write
 */
zyd_res
zyd_write16(struct zyd_softc *sc, uint16_t reg, uint16_t val)
{
        zyd_res result;
        uint16_t tmp[2];

        tmp[0] = LE_16(ZYD_REG32_LO(reg));
        tmp[1] = LE_16(val & 0xffff);

        result = zyd_usb_cmd_send(&sc->usb, ZYD_CMD_IOWR, tmp, sizeof (tmp));

        return (result);
}

/*
 * Write an array of 16-bit registers.
 *
 *      sc      soft state
 *      *reqa   array of register-value pairs
 *      n       number of registers
 */
zyd_res
zyd_write16a(struct zyd_softc *sc, const struct zyd_iowrite16 *reqa, int n)
{
        zyd_res res;
        int i;

        for (i = 0; i < n; i++) {
                res = zyd_write16(sc, reqa[i].reg, reqa[i].value);
                if (res != ZYD_SUCCESS)
                        return (ZYD_FAILURE);
        }

        return (ZYD_SUCCESS);
}

/*
 * Lock PHY registers.
 */
static void
zyd_lock_phy(struct zyd_softc *sc)
{
        uint32_t tmp;

        (void) zyd_read32(sc, ZYD_MAC_MISC, &tmp);
        tmp &= ~ZYD_UNLOCK_PHY_REGS;
        (void) zyd_write32(sc, ZYD_MAC_MISC, tmp);
}

/*
 * Unlock PHY registers.
 */
static void
zyd_unlock_phy(struct zyd_softc *sc)
{
        uint32_t tmp;

        (void) zyd_read32(sc, ZYD_MAC_MISC, &tmp);
        tmp |= ZYD_UNLOCK_PHY_REGS;
        (void) zyd_write32(sc, ZYD_MAC_MISC, tmp);
}

/*
 * Read MAC address from EEPROM.
 */
static zyd_res
zyd_read_mac(struct zyd_softc *sc)
{
        uint32_t tmp;

        if (zyd_read32(sc, ZYD_EEPROM_MAC_ADDR_P1, &tmp) != ZYD_SUCCESS)
                return (ZYD_FAILURE);

        sc->macaddr[0] = tmp & 0xff;
        sc->macaddr[1] = tmp >> 8;
        sc->macaddr[2] = tmp >> 16;
        sc->macaddr[3] = tmp >> 24;

        if (zyd_read32(sc, ZYD_EEPROM_MAC_ADDR_P2, &tmp) != ZYD_SUCCESS)
                return (ZYD_FAILURE);

        sc->macaddr[4] = tmp & 0xff;
        sc->macaddr[5] = tmp >> 8;

        return (ZYD_SUCCESS);
}

/*
 * Write bits to RF configuration register.
 */
static zyd_res
zyd_rfwrite(struct zyd_softc *sc, uint32_t val, int bits)
{
        uint16_t cr203;
        struct zyd_rfwrite req;
        uint16_t tmp;
        int bit;
        zyd_res res;
        int i;

        if (zyd_read16(sc, ZYD_CR203, &cr203) != ZYD_SUCCESS)
                return (ZYD_FAILURE);

        cr203 &= ~(ZYD_RF_IF_LE | ZYD_RF_CLK | ZYD_RF_DATA);

        req.code = LE_16(ZYD_RFCFG_VALUE);
        req.width = LE_16((uint16_t)bits);

        for (i = 0; i < bits; i++) {
                bit = (val & (1 << (bits - i - 1))) != 0;
                tmp = LE_16(cr203) | (bit ? LE_16(ZYD_RF_DATA) : 0);
                req.bit[i] = tmp;
        }
        res = zyd_usb_cmd_send(&sc->usb, ZYD_CMD_RFCFG, &req,
            sizeof (uint16_t) * (2 + bits));

        if (res != ZYD_SUCCESS) {
                ZYD_WARN("failed configuring rf register\n");
                return (ZYD_FAILURE);
        }

        return (ZYD_SUCCESS);
}

/*
 * Control the LEDs.
 */
static void
zyd_set_led(struct zyd_softc *sc, int which, boolean_t on)
{
        uint32_t tmp;

        (void) zyd_read32(sc, ZYD_MAC_TX_PE_CONTROL, &tmp);
        tmp &= ~which;
        if (on == B_TRUE)
                tmp |= which;
        (void) zyd_write32(sc, ZYD_MAC_TX_PE_CONTROL, tmp);
}

/*
 * Set MAC address.
 */
static void
zyd_set_macaddr(struct zyd_softc *sc, const uint8_t *addr)
{
        uint32_t tmp;

        tmp = addr[3] << 24 | addr[2] << 16 | addr[1] << 8 | addr[0];
        (void) zyd_write32(sc, ZYD_MAC_MACADRL, tmp);

        tmp = addr[5] << 8 | addr[4];
        (void) zyd_write32(sc, ZYD_MAC_MACADRH, tmp);
}

/*
 * Read data from EEPROM.
 */
static void
zyd_read_eeprom(struct zyd_softc *sc)
{
        uint32_t tmp;
        uint16_t val;
        int i;

        /* read RF chip type */
        (void) zyd_read32(sc, ZYD_EEPROM_POD, &tmp);
        sc->rf_rev = tmp & 0x0f;
        sc->pa_rev = (tmp >> 16) & 0x0f;
        sc->fix_cr47 = (tmp >> 8) & 0x01;
        sc->fix_cr157 = (tmp >> 13) & 0x01;

        ZYD_DEBUG((ZYD_DBG_HW, "fix cr47: 0x%x\n", sc->fix_cr47));
        ZYD_DEBUG((ZYD_DBG_HW, "fix cr157: 0x%x\n", sc->fix_cr157));
        ZYD_DEBUG((ZYD_DBG_HW, "found RF chip %s, rev 0x%x\n",
            zyd_rf_name(sc->rf_rev), sc->rf_rev));

        /* read regulatory domain (currently unused) */
        (void) zyd_read32(sc, ZYD_EEPROM_SUBID, &tmp);
        sc->regdomain = tmp >> 16;

        ZYD_DEBUG((ZYD_DBG_HW, "regulatory domain: %x\n", sc->regdomain));

        /* read Tx power calibration tables */
        for (i = 0; i < 7; i++) {
                (void) zyd_read16(sc, ZYD_EEPROM_PWR_CAL + i, &val);
                sc->pwr_cal[i * 2] = val >> 8;
                sc->pwr_cal[i * 2 + 1] = val & 0xff;

                (void) zyd_read16(sc, ZYD_EEPROM_PWR_INT + i, &val);
                sc->pwr_int[i * 2] = val >> 8;
                sc->pwr_int[i * 2 + 1] = val & 0xff;

                (void) zyd_read16(sc, ZYD_EEPROM_36M_CAL + i, &val);
                sc->ofdm36_cal[i * 2] = val >> 8;
                sc->ofdm36_cal[i * 2 + 1] = val & 0xff;

                (void) zyd_read16(sc, ZYD_EEPROM_48M_CAL + i, &val);
                sc->ofdm48_cal[i * 2] = val >> 8;
                sc->ofdm48_cal[i * 2 + 1] = val & 0xff;

                (void) zyd_read16(sc, ZYD_EEPROM_54M_CAL + i, &val);
                sc->ofdm54_cal[i * 2] = val >> 8;
                sc->ofdm54_cal[i * 2 + 1] = val & 0xff;
        }
}

zyd_res
zyd_hw_init(struct zyd_softc *sc)
{
        struct zyd_usb *uc = &sc->usb;
        int ures;
        zyd_res res;

        sc->mac_rev = zyd_usb_mac_rev(uc->cdata->dev_descr->idVendor,
            uc->cdata->dev_descr->idProduct);
        if (sc->mac_rev == ZYD_ZD1211) {
                res = zyd_usb_loadfirmware(uc, zd1211_firmware,
                    zd1211_firmware_size);
        } else {
                res = zyd_usb_loadfirmware(uc, zd1211b_firmware,
                    zd1211b_firmware_size);
        }
        if (res != ZYD_SUCCESS) {
                ZYD_WARN("failed to load firmware\n");
                goto fail1;
        }

        /* set configuration 1 - required for later communication */
        ures = usb_set_cfg(uc->dip, 0, USB_FLAGS_SLEEP, NULL, NULL);
        if (ures != USB_SUCCESS) {
                ZYD_WARN("failed to set configuration 1 (%d)\n", ures);
                goto fail1;
        }

        if (zyd_usb_open_pipes(uc) != ZYD_SUCCESS) {
                ZYD_WARN("failed to open pipes\n");
                goto fail1;
        }

        if (zyd_usb_cmd_in_start_polling(uc) != ZYD_SUCCESS) {
                ZYD_WARN("failed to start command IN polling\n");
                goto fail2;
        }

        if (zyd_read_mac(sc) != ZYD_SUCCESS) {
                ZYD_WARN("failed to read MAC address\n");
                goto fail3;
        }

        zyd_read_eeprom(sc);
        switch (sc->rf_rev) {
        case ZYD_RF_AL2230:
        case ZYD_RF_RFMD:
                break;
        default:
                ZYD_WARN("unsupported RF %s, chip type 0x%x\n",
                    zyd_rf_name(sc->rf_rev), sc->rf_rev);
                goto fail3;
        }

        if (zyd_hw_configure(sc) != ZYD_SUCCESS) {
                ZYD_WARN("failed to configure hardware\n");
                goto fail3;
        }

        /* RF chip init */
        zyd_lock_phy(sc);
        switch (sc->rf_rev) {
        case ZYD_RF_AL2230:
                if (sc->mac_rev == ZYD_ZD1211) {
                        res = zyd_al2230_rf_init(sc);
                } else {
                        res = zyd_al2230_rf_init_b(sc);
                }
                break;
        case ZYD_RF_RFMD:
                res = zyd_rfmd_rf_init(sc);
                break;
        default:
                ZYD_WARN("unsupported Radio %s, code = 0x%x\n",
                    zyd_rf_name(sc->rf_rev), sc->rf_rev);
                res = ZYD_FAILURE;
                break;
        }
        zyd_unlock_phy(sc);

        if (res != ZYD_SUCCESS) {
                ZYD_WARN("failed to configure RF chip\n");
                goto fail3;
        }

        ZYD_DEBUG((ZYD_DBG_HW, "MAC: %02X:%02X:%02X:%02X:%02X:%02X\n",
            sc->macaddr[0], sc->macaddr[1], sc->macaddr[2],
            sc->macaddr[3], sc->macaddr[4], sc->macaddr[5]));

        return (ZYD_SUCCESS);

fail3:
        zyd_usb_cmd_in_stop_polling(uc);
fail2:
        zyd_usb_close_pipes(uc);
fail1:
        return (ZYD_FAILURE);
}

void
zyd_hw_deinit(struct zyd_softc *sc)
{
        struct zyd_usb *uc = &sc->usb;

        zyd_usb_cmd_in_stop_polling(uc);
        zyd_usb_close_pipes(uc);
}

/*
 * Finish ZD chip initialization.
 */
static zyd_res
zyd_hw_configure(struct zyd_softc *sc)
{
        zyd_res res;
        uint32_t tmp;

        /* specify that the plug and play is finished */
        (void) zyd_write32(sc, ZYD_MAC_AFTER_PNP, 1);
        (void) zyd_read16(sc, ZYD_FIRMWARE_BASE_ADDR, &sc->fwbase);
        ZYD_DEBUG((ZYD_DBG_FW, "firmware base address: 0x%04x\n", sc->fwbase));

        /* retrieve firmware revision number */
        (void) zyd_read16(sc, sc->fwbase + ZYD_FW_FIRMWARE_REV, &sc->fw_rev);
        ZYD_DEBUG((ZYD_DBG_FW, "firmware revision: x0x%4x\n", sc->fw_rev));

        (void) zyd_write32(sc, ZYD_CR_GPI_EN, 0);
        (void) zyd_write32(sc, ZYD_MAC_CONT_WIN_LIMIT, 0x7f043f);

        /* disable interrupts */
        (void) zyd_write32(sc, ZYD_CR_INTERRUPT, 0);

        /* Init RF chip-independent PHY registers */
        zyd_lock_phy(sc);
        if (sc->mac_rev == ZYD_ZD1211) {
                res = zyd_write16a(sc, zyd_def_phy,
                    ZYD_ARRAY_LENGTH(zyd_def_phy));
        } else {
                res = zyd_write16a(sc, zyd_def_phyB,
                    ZYD_ARRAY_LENGTH(zyd_def_phyB));
        }
        if (sc->fix_cr157) {
                if (zyd_read32(sc, ZYD_EEPROM_PHY_REG, &tmp) == 0)
                        (void) zyd_write32(sc, ZYD_CR157, tmp >> 8);
        }
        zyd_unlock_phy(sc);

        if (res != ZYD_SUCCESS)
                return (ZYD_FAILURE);

        /* HMAC initialization magic */
        if (sc->mac_rev == ZYD_ZD1211) {
                (void) zyd_write32(sc, ZYD_MAC_RETRY, 0x00000002);
        } else {
                (void) zyd_write32(sc, ZYD_MACB_MAX_RETRY, 0x02020202);
                (void) zyd_write32(sc, ZYD_MACB_TXPWR_CTL4, 0x007f003f);
                (void) zyd_write32(sc, ZYD_MACB_TXPWR_CTL3, 0x007f003f);
                (void) zyd_write32(sc, ZYD_MACB_TXPWR_CTL2, 0x003f001f);
                (void) zyd_write32(sc, ZYD_MACB_TXPWR_CTL1, 0x001f000f);
                (void) zyd_write32(sc, ZYD_MACB_AIFS_CTL1, 0x00280028);
                (void) zyd_write32(sc, ZYD_MACB_AIFS_CTL2, 0x008C003c);
                (void) zyd_write32(sc, ZYD_MACB_TXOP, 0x01800824);
        }
        (void) zyd_write32(sc, ZYD_MAC_ACK_EXT, 0x00000020);
        (void) zyd_write32(sc, ZYD_CR_ADDA_MBIAS_WT, 0x30000808);
        (void) zyd_write32(sc, ZYD_MAC_SNIFFER, 0x00000000);
        (void) zyd_write32(sc, ZYD_MAC_RXFILTER, 0x00000000);
        (void) zyd_write32(sc, ZYD_MAC_GHTBL, 0x00000000);
        (void) zyd_write32(sc, ZYD_MAC_GHTBH, 0x80000000);
        (void) zyd_write32(sc, ZYD_MAC_MISC, 0x000000a4);
        (void) zyd_write32(sc, ZYD_CR_ADDA_PWR_DWN, 0x0000007f);
        (void) zyd_write32(sc, ZYD_MAC_BCNCFG, 0x00f00401);
        (void) zyd_write32(sc, ZYD_MAC_PHY_DELAY2, 0x00000000);
        (void) zyd_write32(sc, ZYD_MAC_ACK_EXT, 0x00000080);
        (void) zyd_write32(sc, ZYD_CR_ADDA_PWR_DWN, 0x00000000);
        (void) zyd_write32(sc, ZYD_MAC_SIFS_ACK_TIME, 0x00000100);
        (void) zyd_write32(sc, ZYD_MAC_DIFS_EIFS_SIFS, 0x0547c032);
        (void) zyd_write32(sc, ZYD_CR_RX_PE_DELAY, 0x00000070);
        (void) zyd_write32(sc, ZYD_CR_PS_CTRL, 0x10000000);
        (void) zyd_write32(sc, ZYD_MAC_RTSCTSRATE, 0x02030203);
        (void) zyd_write32(sc, ZYD_MAC_RX_THRESHOLD, 0x000c0640);
        (void) zyd_write32(sc, ZYD_MAC_BACKOFF_PROTECT, 0x00000114);

        return (ZYD_SUCCESS);
}

/*
 * Set active channel number.
 */
void
zyd_hw_set_channel(struct zyd_softc *sc, uint8_t chan)
{
        uint32_t tmp;

        zyd_lock_phy(sc);

        ZYD_DEBUG((ZYD_DBG_HW, "setting channel %d\n", chan));

        switch (sc->rf_rev) {
        case ZYD_RF_AL2230:
                (void) zyd_al2230_set_channel(sc, chan);
                break;
        case ZYD_RF_RFMD:
                (void) zyd_rfmd_set_channel(sc, chan);
                break;
        }

        /* update Tx power */
        ZYD_DEBUG((ZYD_DBG_HW, "updating tx power table\n"));

        (void) zyd_write16(sc, ZYD_CR31, sc->pwr_int[chan - 1]);
        if (sc->mac_rev == ZYD_ZD1211B) {
                (void) zyd_write16(sc, ZYD_CR67, sc->ofdm36_cal[chan - 1]);
                (void) zyd_write16(sc, ZYD_CR66, sc->ofdm48_cal[chan - 1]);
                (void) zyd_write16(sc, ZYD_CR65, sc->ofdm54_cal[chan - 1]);
                (void) zyd_write16(sc, ZYD_CR68, sc->pwr_cal[chan - 1]);
                (void) zyd_write16(sc, ZYD_CR69, 0x28);
                (void) zyd_write16(sc, ZYD_CR69, 0x2a);
        }

        if (sc->fix_cr47) {
                /* set CCK baseband gain from EEPROM */
                if (zyd_read32(sc, ZYD_EEPROM_PHY_REG, &tmp) == 0)
                        (void) zyd_write16(sc, ZYD_CR47, tmp & 0xff);
        }

        (void) zyd_write32(sc, ZYD_CR_CONFIG_PHILIPS, 0);

        zyd_unlock_phy(sc);
}

/*
 * Activate the device.
 */
zyd_res
zyd_hw_start(struct zyd_softc *sc)
{
        struct zyd_usb *uc = &sc->usb;
        struct ieee80211com *ic = &sc->ic;
        zyd_res res;

        if (zyd_usb_data_in_enable(&sc->usb) != ZYD_SUCCESS) {
                ZYD_WARN("error starting rx transfer\n");
                goto fail1;
        }

        ZYD_DEBUG((ZYD_DBG_HW, "setting MAC address\n"));
        zyd_set_macaddr(sc, sc->macaddr);

        /* we'll do software WEP decryption for now */
        ZYD_DEBUG((ZYD_DBG_HW, "setting encryption mode\n"));
        res = zyd_write32(sc, ZYD_MAC_ENCRYPTION_TYPE, ZYD_ENC_SNIFFER);
        if (res != ZYD_SUCCESS)
                goto fail2;

        /* promiscuous mode */
        (void) zyd_write32(sc, ZYD_MAC_SNIFFER, 0);

        /* try to catch all packets */
        (void) zyd_write32(sc, ZYD_MAC_RXFILTER, ZYD_FILTER_BSS);

        /* switch radio transmitter ON */
        switch (sc->rf_rev) {
        case ZYD_RF_AL2230:
                (void) zyd_al2230_switch_radio(sc, B_TRUE);
                break;
        case ZYD_RF_RFMD:
                (void) zyd_rfmd_switch_radio(sc, B_TRUE);
                break;
        }

        /* set basic rates */
        ZYD_DEBUG((ZYD_DBG_HW, "setting basic rates\n"));
        if (ic->ic_curmode == IEEE80211_MODE_11B)
                (void) zyd_write32(sc, ZYD_MAC_BAS_RATE, 0x0003);
        else if (ic->ic_curmode == IEEE80211_MODE_11A)
                (void) zyd_write32(sc, ZYD_MAC_BAS_RATE, 0x1500);
        else                    /* assumes 802.11b/g */
                (void) zyd_write32(sc, ZYD_MAC_BAS_RATE, 0x000f);

        /* set mandatory rates */
        ZYD_DEBUG((ZYD_DBG_HW, "setting mandatory rates\n"));
        if (ic->ic_curmode == IEEE80211_MODE_11B)
                (void) zyd_write32(sc, ZYD_MAC_MAN_RATE, 0x000f);
        else if (ic->ic_curmode == IEEE80211_MODE_11A)
                (void) zyd_write32(sc, ZYD_MAC_MAN_RATE, 0x1500);
        else                    /* assumes 802.11b/g */
                (void) zyd_write32(sc, ZYD_MAC_MAN_RATE, 0x150f);

        /* enable interrupts */
        (void) zyd_write32(sc, ZYD_CR_INTERRUPT, ZYD_HWINT_MASK);

        zyd_set_led(sc, ZYD_LED2, B_TRUE);

        return (ZYD_SUCCESS);

fail2:
        zyd_usb_data_in_disable(uc);
fail1:
        return (ZYD_FAILURE);
}

/*
 * Deactivate the device.
 */
void
zyd_hw_stop(struct zyd_softc *sc)
{
        struct zyd_usb *uc = &sc->usb;

        if (uc->connected) {
                /* switch radio transmitter OFF */
                switch (sc->rf_rev) {
                case ZYD_RF_AL2230:
                        (void) zyd_al2230_switch_radio(sc, B_FALSE);
                        break;
                case ZYD_RF_RFMD:
                        (void) zyd_rfmd_switch_radio(sc, B_FALSE);
                        break;
                }

                /* disable reception */
                (void) zyd_write32(sc, ZYD_MAC_RXFILTER, 0);

                /* disable interrupts */
                (void) zyd_write32(sc, ZYD_CR_INTERRUPT, 0);

                zyd_set_led(sc, ZYD_LED2, B_FALSE);
        } else {
                ZYD_DEBUG((ZYD_DBG_HW, "stop: device absent\n"));

        }

        zyd_usb_data_in_disable(uc);
        sc->tx_queued = 0;
}

/*
 * ZD1211 AL2230 Radio control
 * Init the AL2230 RF chip.
 */
static zyd_res
zyd_al2230_rf_init(struct zyd_softc *sc)
{
        const struct zyd_iowrite16 phyini[] = ZYD_AL2230_PHY;
        const uint32_t rfini[] = ZYD_AL2230_RF;

        zyd_res res;
        int i;

        zyd_lock_phy(sc);

        /* init RF-dependent PHY registers */
        res = zyd_write16a(sc, phyini, ZYD_ARRAY_LENGTH(phyini));
        if (res != ZYD_SUCCESS) {
                zyd_unlock_phy(sc);
                return (ZYD_FAILURE);
        }

        /* init AL2230 radio */
        for (i = 0; i < ZYD_ARRAY_LENGTH(rfini); i++) {
                res = zyd_rfwrite(sc, rfini[i], ZYD_AL2230_RF_BITS);
                if (res != ZYD_SUCCESS) {
                        zyd_unlock_phy(sc);
                        return (ZYD_FAILURE);
                }
        }

        zyd_unlock_phy(sc);

        ZYD_DEBUG((ZYD_DBG_HW, "RF chip AL2230 initialized\n"));

        return (ZYD_SUCCESS);
}

/*
 * Init the AL2230B RF chip (11b).
 */
static zyd_res
zyd_al2230_rf_init_b(struct zyd_softc *sc)
{
        const struct zyd_iowrite16 phyini[] = ZYD_AL2230_PHY_B;
        const uint32_t rfini[] = ZYD_AL2230_RF_B;
        zyd_res res;
        int i;

        zyd_lock_phy(sc);
        /* init RF-dependent PHY registers */
        res = zyd_write16a(sc, phyini, ZYD_ARRAY_LENGTH(phyini));
        if (res != ZYD_SUCCESS) {
                zyd_unlock_phy(sc);
                return (ZYD_FAILURE);
        }

        /* init AL2230 radio */
        for (i = 0; i < ZYD_ARRAY_LENGTH(rfini); i++) {
                res = zyd_rfwrite(sc, rfini[i], ZYD_AL2230_RF_BITS);
                if (res != ZYD_SUCCESS) {
                        zyd_unlock_phy(sc);
                        return (ZYD_FAILURE);
                }
        }
        zyd_unlock_phy(sc);
        ZYD_DEBUG((ZYD_DBG_HW, "RF chip AL2230 (11b) initialized\n"));

        return (ZYD_SUCCESS);
}

/*
 * Tune RF chip to a specified channel.
 */
static zyd_res
zyd_al2230_set_channel(struct zyd_softc *sc, uint8_t chan)
{
        static const struct {
                uint32_t r1, r2, r3;
        } rfprog[] = ZYD_AL2230_CHANTABLE;

        (void) zyd_rfwrite(sc, rfprog[chan - 1].r1, ZYD_AL2230_RF_BITS);
        (void) zyd_rfwrite(sc, rfprog[chan - 1].r2, ZYD_AL2230_RF_BITS);
        (void) zyd_rfwrite(sc, rfprog[chan - 1].r3, ZYD_AL2230_RF_BITS);

        (void) zyd_write16(sc, ZYD_CR138, 0x28);
        (void) zyd_write16(sc, ZYD_CR203, 0x06);

        return (ZYD_SUCCESS);
}

/*
 * Turn the radio transciever on/off.
 */
static zyd_res
zyd_al2230_switch_radio(struct zyd_softc *sc, boolean_t on)
{
        int on251 = (sc->mac_rev == ZYD_ZD1211) ? 0x3f : 0x7f;

        zyd_lock_phy(sc);

        (void) zyd_write16(sc, ZYD_CR11, (on == B_TRUE) ? 0x00 : 0x04);
        (void) zyd_write16(sc, ZYD_CR251, (on == B_TRUE) ? on251 : 0x2f);

        zyd_unlock_phy(sc);

        return (ZYD_SUCCESS);
}


/*
 * RFMD RF methods.
 */
static zyd_res
zyd_rfmd_rf_init(struct zyd_softc *sc)
{
        static const struct zyd_iowrite16 phyini[] = ZYD_RFMD_PHY;
        static const uint32_t rfini[] = ZYD_RFMD_RF;
        zyd_res res;
        int i;

        /* init RF-dependent PHY registers */
        zyd_lock_phy(sc);
        res = zyd_write16a(sc, phyini, ZYD_ARRAY_LENGTH(phyini));
        if (res != ZYD_SUCCESS) {
                zyd_unlock_phy(sc);
                return (ZYD_FAILURE);
        }
        /* init RFMD radio */
        for (i = 0; i < ZYD_ARRAY_LENGTH(rfini); i++) {
                res = zyd_rfwrite(sc, rfini[i], ZYD_RFMD_RF_BITS);
                if (res != ZYD_SUCCESS) {
                        zyd_unlock_phy(sc);
                        return (ZYD_FAILURE);
                }
        }
        zyd_unlock_phy(sc);
        ZYD_DEBUG((ZYD_DBG_HW, "RF chip RFMD initialized\n"));

        return (ZYD_SUCCESS);
}

static zyd_res
zyd_rfmd_switch_radio(struct zyd_softc *sc, boolean_t on)
{

        (void) zyd_write16(sc, ZYD_CR10, on ? 0x89 : 0x15);
        (void) zyd_write16(sc, ZYD_CR11, on ? 0x00 : 0x81);

        return (ZYD_SUCCESS);
}

static zyd_res
zyd_rfmd_set_channel(struct zyd_softc *sc, uint8_t chan)
{
        static const struct {
                uint32_t r1, r2;
        } rfprog[] = ZYD_RFMD_CHANTABLE;

        (void) zyd_rfwrite(sc, rfprog[chan - 1].r1, ZYD_RFMD_RF_BITS);
        (void) zyd_rfwrite(sc, rfprog[chan - 1].r2, ZYD_RFMD_RF_BITS);

        return (ZYD_SUCCESS);
}