usr/src/uts/common/io/zyd/zyd_hw.c

/*
 * 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);
}