xref: /titanic_44/usr/src/uts/common/io/pcic.c (revision 3db86aab554edbb4244c8d1a1c90f152eee768af)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * PCIC device/interrupt handler
 *	The "pcic" driver handles the Intel 82365SL, Cirrus Logic
 *	and Toshiba (and possibly other clones) PCMCIA adapter chip
 *	sets.  It implements a subset of Socket Services as defined
 *	in the Solaris PCMCIA design documents
 */

/*
 * currently defined "properties"
 *
 * clock-frequency		bus clock frequency
 * smi				system management interrupt override
 * need-mult-irq		need status IRQ for each pair of sockets
 * disable-audio		don't route audio signal to speaker
 */


#include <sys/types.h>
#include <sys/inttypes.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/autoconf.h>
#include <sys/vtoc.h>
#include <sys/dkio.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/var.h>
#include <sys/callb.h>
#include <sys/open.h>
#include <sys/ddidmareq.h>
#include <sys/dma_engine.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/pci.h>
#include <sys/pci_impl.h>

#include <sys/pctypes.h>
#include <sys/pcmcia.h>
#include <sys/sservice.h>

#include <sys/note.h>

#include <sys/pcic_reg.h>
#include <sys/pcic_var.h>

#if defined(__sparc)
#include <sys/pci/pci_nexus.h>
#endif

#include <sys/syshw.h>
#include "cardbus/cardbus.h"

#define	SOFTC_SIZE	(sizeof (anp_t))

static int pcic_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int pcic_attach(dev_info_t *, ddi_attach_cmd_t);
static int pcic_detach(dev_info_t *, ddi_detach_cmd_t);
static uint_t pcic_intr(caddr_t, caddr_t);
static int pcic_do_io_intr(pcicdev_t *, uint32_t);
static int pcic_probe(dev_info_t *);

static int pcic_open(dev_t *, int, int, cred_t *);
static int pcic_close(dev_t, int, int, cred_t *);
static int pcic_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

typedef struct pcm_regs pcm_regs_t;

static void pcic_init_assigned(dev_info_t *);
static int pcic_apply_avail_ranges(dev_info_t *, pcm_regs_t *,
	pci_regspec_t *, int);
int pci_resource_setup_avail(dev_info_t *, pci_regspec_t *, int);

/*
 * On x86 platforms the ddi_iobp_alloc(9F) and ddi_mem_alloc(9F) calls
 * are xlated into DMA ctlops. To make this nexus work on x86, we
 * need to have the default ddi_dma_mctl ctlops in the bus_ops
 * structure, just to pass the request to the parent. The correct
 * ctlops should be ddi_no_dma_mctl because so far we don't do DMA.
 */
static
struct bus_ops pcmciabus_ops = {
	BUSO_REV,
	pcmcia_bus_map,
	NULL,
	NULL,
	NULL,
	i_ddi_map_fault,
	ddi_no_dma_map,
	ddi_no_dma_allochdl,
	ddi_no_dma_freehdl,
	ddi_no_dma_bindhdl,
	ddi_no_dma_unbindhdl,
	ddi_no_dma_flush,
	ddi_no_dma_win,
	ddi_dma_mctl,
	pcmcia_ctlops,
	pcmcia_prop_op,
	NULL,				/* (*bus_get_eventcookie)();	*/
	NULL,				/* (*bus_add_eventcall)();	*/
	NULL,				/* (*bus_remove_eventcall)();	*/
	NULL,				/* (*bus_post_event)();		*/
	NULL,				/* (*bus_intr_ctl)();		*/
	NULL,				/* (*bus_config)(); 		*/
	NULL,				/* (*bus_unconfig)(); 		*/
	NULL,				/* (*bus_fm_init)(); 		*/
	NULL,				/* (*bus_fm_fini)(); 		*/
	NULL,				/* (*bus_enter)()		*/
	NULL,				/* (*bus_exit)()		*/
	NULL,				/* (*bus_power)()		*/
	pcmcia_intr_ops			/* (*bus_intr_op)(); 		*/
};

static struct cb_ops pcic_cbops = {
	pcic_open,
	pcic_close,
	nodev,
	nodev,
	nodev,
	nodev,
	nodev,
	pcic_ioctl,
	nodev,
	nodev,
	nodev,
	nochpoll,
	ddi_prop_op,
	NULL,
#ifdef CARDBUS
	D_NEW | D_MP | D_HOTPLUG
#else
	D_NEW | D_MP
#endif
};

static struct dev_ops pcic_devops = {
	DEVO_REV,
	0,
	pcic_getinfo,
	nulldev,
	pcic_probe,
	pcic_attach,
	pcic_detach,
	nulldev,
	&pcic_cbops,
	&pcmciabus_ops,
	NULL
};

void *pcic_soft_state_p = NULL;
static int pcic_maxinst = -1;
static timeout_id_t pcic_delayed_resume_toid;

int pcic_do_insertion = 1;
int pcic_do_removal = 1;

struct irqmap {
	int irq;
	int count;
} pcic_irq_map[16];


int pcic_debug = 0x0;
static  void    pcic_err(dev_info_t *dip, int level, const char *fmt, ...);
extern void cardbus_dump_pci_config(dev_info_t *dip);
extern void cardbus_dump_socket(dev_info_t *dip);
extern int cardbus_validate_iline(dev_info_t *dip, ddi_acc_handle_t handle);
static void pcic_dump_debqueue(char *msg);

#if defined(PCIC_DEBUG)
static void xxdmp_all_regs(pcicdev_t *, int, uint32_t);

#define	pcic_mutex_enter(a)	\
	{ \
		pcic_err(NULL, 10, "Set lock at %d\n", __LINE__); \
		mutex_enter(a); \
	};

#define	pcic_mutex_exit(a)	\
	{ \
		pcic_err(NULL, 10, "Clear lock at %d\n", __LINE__); \
		mutex_exit(a); \
	};

#else
#define	pcic_mutex_enter(a)	mutex_enter(a)
#define	pcic_mutex_exit(a)	mutex_exit(a)
#endif

#define	PCIC_VCC_3VLEVEL	1
#define	PCIC_VCC_5VLEVEL	2
#define	PCIC_VCC_12LEVEL	3

/* bit patterns to select voltage levels */
int pcic_vpp_levels[13] = {
	0, 0, 0,
	1,	/* 3.3V */
	0,
	1,	/* 5V */
	0, 0, 0, 0, 0, 0,
	2	/* 12V */
};

uint8_t pcic_cbv_levels[13] = {
	0, 0, 0,
	3,			/* 3.3V */
	0,
	2,			/* 5V */
	0, 0, 0, 0, 0, 0,
	1			/* 12V */
};

struct power_entry pcic_power[4] = {
	{
		0, VCC|VPP1|VPP2
	},
	{
		33,		/* 3.3Volt */
		VCC|VPP1|VPP2
	},
	{
		5*10,		/* 5Volt */
		VCC|VPP1|VPP2	/* currently only know about this */
	},
	{
		12*10,		/* 12Volt */
		VPP1|VPP2
	}
};

/*
 * Base used to allocate ranges of PCI memory on x86 systems
 * Each instance gets a chunk above the base that is used to map
 * in the memory and I/O windows for that device.
 * Pages below the base are also allocated for the EXCA registers,
 * one per instance.
 */
#define	PCIC_PCI_MEMCHUNK	0x1000000

static int pcic_wait_insert_time = 5000000;	/* In micro-seconds */
static int pcic_debounce_time = 200000; /* In micro-seconds */

struct debounce {
	pcic_socket_t *pcs;
	clock_t expire;
	struct debounce *next;
};

static syshw_t pcic_syshw = {
	0, "PC Card Socket 0", SH_CONNECTION,
	SYSHW_CAN_SIGNAL_CHANGE|SYSHW_STATE_VALID|SYSHW_VAL0_VALID,
	B_FALSE, {2, 0, 0, 0}
};

static struct debounce *pcic_deb_queue = NULL;
static kmutex_t pcic_deb_mtx;
static kcondvar_t pcic_deb_cv;
static kthread_t *pcic_deb_threadid;

static inthandler_t *pcic_handlers;

static void pcic_setup_adapter(pcicdev_t *);
static int pcic_change(pcicdev_t *, int);
static int pcic_ll_reset(pcicdev_t *, int);
static void pcic_mswait(pcicdev_t *, int, int);
static boolean_t pcic_check_ready(pcicdev_t *, int);
static void pcic_set_cdtimers(pcicdev_t *, int, uint32_t, int);
static void pcic_ready_wait(pcicdev_t *, int);
extern int pcmcia_get_intr(dev_info_t *, int);
extern int pcmcia_return_intr(dev_info_t *, int);

static int pcic_callback(dev_info_t *, int (*)(), int);
static int pcic_inquire_adapter(dev_info_t *, inquire_adapter_t *);
static int pcic_get_adapter(dev_info_t *, get_adapter_t *);
static int pcic_get_page(dev_info_t *, get_page_t *);
static int pcic_get_socket(dev_info_t *, get_socket_t *);
static int pcic_get_status(dev_info_t *, get_ss_status_t *);
static int pcic_get_window(dev_info_t *, get_window_t *);
static int pcic_inquire_socket(dev_info_t *, inquire_socket_t *);
static int pcic_inquire_window(dev_info_t *, inquire_window_t *);
static int pcic_reset_socket(dev_info_t *, int, int);
static int pcic_set_page(dev_info_t *, set_page_t *);
static int pcic_set_window(dev_info_t *, set_window_t *);
static int pcic_set_socket(dev_info_t *, set_socket_t *);
static int pcic_set_interrupt(dev_info_t *, set_irq_handler_t *);
static int pcic_clear_interrupt(dev_info_t *, clear_irq_handler_t *);
static void pcic_pm_detection(void *);
static void pcic_iomem_pci_ctl(ddi_acc_handle_t, uchar_t *, unsigned);
static int clext_reg_read(pcicdev_t *, int, uchar_t);
static void clext_reg_write(pcicdev_t *, int, uchar_t, uchar_t);
static int pcic_calc_speed(pcicdev_t *, uint32_t);
static int pcic_card_state(pcicdev_t *, pcic_socket_t *);
static int pcic_find_pci_type(pcicdev_t *);
static void pcic_82092_smiirq_ctl(pcicdev_t *, int, int, int);
static void pcic_handle_cd_change(pcicdev_t *, pcic_socket_t *, uint8_t);
static uint_t pcic_cd_softint(caddr_t, caddr_t);
static uint8_t pcic_getb(pcicdev_t *, int, int);
static void pcic_putb(pcicdev_t *, int, int, int8_t);
static int pcic_set_vcc_level(pcicdev_t *, set_socket_t *);
static uint_t pcic_softintr(caddr_t, caddr_t);

static void pcic_debounce(pcic_socket_t *);
static void pcic_delayed_resume(void *);
static void *pcic_add_debqueue(pcic_socket_t *, int);
static void pcic_rm_debqueue(void *);
static void pcic_deb_thread();

static boolean_t pcic_load_cardbus(pcicdev_t *pcic, const pcic_socket_t *sockp);
static void pcic_unload_cardbus(pcicdev_t *pcic, const pcic_socket_t *sockp);
static uint32_t pcic_getcb(pcicdev_t *pcic, int reg);
static void pcic_putcb(pcicdev_t *pcic, int reg, uint32_t value);
static void pcic_cb_enable_intr(dev_info_t *);
static void pcic_cb_disable_intr(dev_info_t *);
static void pcic_enable_io_intr(pcicdev_t *pcic, int socket, int irq);
static void pcic_disable_io_intr(pcicdev_t *pcic, int socket);

static cb_nexus_cb_t pcic_cbnexus_ops = {
	pcic_cb_enable_intr,
	pcic_cb_disable_intr
};

static int pcic_exca_powerctl(pcicdev_t *pcic, int socket, int powerlevel);
static int pcic_cbus_powerctl(pcicdev_t *pcic, int socket);

static void pcic_syshw_cardstate(syshw_t *, void *);

#if defined(__sparc)
static int pcic_fault(enum pci_fault_ops op, void *arg);
#endif

/*
 * Default to support for Voyager IIi if sparc is defined.
 * Appart from the PCI base addresses this only effect the TI1250.
 */
#if defined(sparc)
#define	VOYAGER
#endif


/*
 * pcmcia_attach() uses 0 and 128 upwards for the initpcmcia and devctl
 * interfaces so we use 254.
 */
#define	SYSHW_MINOR	254

/*
 * Forward declarations for syshw interface (See end of file).
 */
static void syshw_attach(pcicdev_t *);
static void syshw_detach(pcicdev_t *);
static void syshw_resume(pcicdev_t *);

#ifdef VOYAGER
static uint_t syshw_intr(caddr_t);
static uint_t syshw_intr_hi(pcicdev_t *);
#endif

static int syshw_open(dev_t *, int, int, cred_t *);
static int syshw_close(dev_t, int, int, cred_t *);
static int syshw_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
static uint32_t syshw_add2map(syshw_t *, void (*)(syshw_t *, void *), void *);
static void syshw_send_signal(int);

/*
 * pcmcia interface operations structure
 * this is the private interface that is exported to the nexus
 */
pcmcia_if_t pcic_if_ops = {
	PCIF_MAGIC,
	PCIF_VERSION,
	pcic_callback,
	pcic_get_adapter,
	pcic_get_page,
	pcic_get_socket,
	pcic_get_status,
	pcic_get_window,
	pcic_inquire_adapter,
	pcic_inquire_socket,
	pcic_inquire_window,
	pcic_reset_socket,
	pcic_set_page,
	pcic_set_window,
	pcic_set_socket,
	pcic_set_interrupt,
	pcic_clear_interrupt,
	NULL,
};

/*
 * chip type identification routines
 * this list of functions is searched until one of them succeeds
 * or all fail.  i82365SL is assumed if failed.
 */
static int pcic_ci_cirrus(pcicdev_t *);
static int pcic_ci_vadem(pcicdev_t *);
static int pcic_ci_ricoh(pcicdev_t *);

int (*pcic_ci_funcs[])(pcicdev_t *) = {
	pcic_ci_cirrus,
	pcic_ci_vadem,
	pcic_ci_ricoh,
	NULL
};

static struct modldrv modldrv = {
	&mod_driverops,		/* Type of module. This one is a driver */
	"PCIC PCMCIA adapter driver %I%",	/* Name of the module. */
	&pcic_devops,		/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modldrv, NULL
};

int
_init()
{
	int stat;

	/* Allocate soft state */
	if ((stat = ddi_soft_state_init(&pcic_soft_state_p,
	    SOFTC_SIZE, 2)) != DDI_SUCCESS)
		return (stat);

	if ((stat = mod_install(&modlinkage)) != 0)
		ddi_soft_state_fini(&pcic_soft_state_p);

	return (stat);
}

int
_fini()
{
	int stat = 0;

	if ((stat = mod_remove(&modlinkage)) != 0)
		return (stat);

	if (pcic_deb_threadid) {
		mutex_enter(&pcic_deb_mtx);
		pcic_deb_threadid = 0;
		while (!pcic_deb_threadid)
			cv_wait(&pcic_deb_cv, &pcic_deb_mtx);
		pcic_deb_threadid = 0;
		mutex_exit(&pcic_deb_mtx);

		mutex_destroy(&pcic_deb_mtx);
		cv_destroy(&pcic_deb_cv);
	}

	ddi_soft_state_fini(&pcic_soft_state_p);

	return (stat);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

/*
 * pcic_getinfo()
 *	provide instance/device information about driver
 */
/*ARGSUSED*/
static int
pcic_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
	anp_t *anp;
	int error = DDI_SUCCESS;
	minor_t minor;

	switch (cmd) {
	    case DDI_INFO_DEVT2DEVINFO:
		minor = getminor((dev_t)arg);
		if (minor == SYSHW_MINOR)
			minor = 0;
		else
			minor &= 0x7f;
		if (!(anp = ddi_get_soft_state(pcic_soft_state_p, minor)))
			*result = NULL;
		else
			*result = anp->an_dip;
		break;
	    case DDI_INFO_DEVT2INSTANCE:
		minor = getminor((dev_t)arg);
		if (minor == SYSHW_MINOR)
			minor = 0;
		else
			minor &= 0x7f;
		*result = (void *)((long)minor);
		break;
	    default:
		error = DDI_FAILURE;
		break;
	}
	return (error);
}

static int
pcic_probe(dev_info_t *dip)
{
	int value;
	ddi_device_acc_attr_t attr;
	ddi_acc_handle_t handle;
	uchar_t *index, *data;

	if (ddi_dev_is_sid(dip) == DDI_SUCCESS)
	    return (DDI_PROBE_DONTCARE);

	/*
	 * find a PCIC device (any vendor)
	 * while there can be up to 4 such devices in
	 * a system, we currently only look for 1
	 * per probe.  There will be up to 2 chips per
	 * instance since they share I/O space
	 */
	attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
	attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

	if (ddi_regs_map_setup(dip, PCIC_ISA_CONTROL_REG_NUM,
				(caddr_t *)&index,
				PCIC_ISA_CONTROL_REG_OFFSET,
				PCIC_ISA_CONTROL_REG_LENGTH,
				&attr, &handle) != DDI_SUCCESS)
	    return (DDI_PROBE_FAILURE);

	data = index + 1;

#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "pcic_probe: entered\n");
	if (pcic_debug)
		cmn_err(CE_CONT, "\tindex=%p\n", (void *)index);
#endif
	ddi_put8(handle, index, PCIC_CHIP_REVISION);
	ddi_put8(handle, data, 0);
	value = ddi_get8(handle, data);
#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "\tchip revision register = %x\n", value);
#endif
	if ((value & PCIC_REV_MASK) >= PCIC_REV_LEVEL_LOW &&
	    (value & 0x30) == 0) {
		/*
		 * we probably have a PCIC chip in the system
		 * do a little more checking.  If we find one,
		 * reset everything in case of softboot
		 */
		ddi_put8(handle, index, PCIC_MAPPING_ENABLE);
		ddi_put8(handle, data, 0);
		value = ddi_get8(handle, data);
#if defined(PCIC_DEBUG)
		if (pcic_debug)
			cmn_err(CE_CONT, "\tzero test = %x\n", value);
#endif
		/* should read back as zero */
		if (value == 0) {
			/*
			 * we do have one and it is off the bus
			 */
#if defined(PCIC_DEBUG)
			if (pcic_debug)
				cmn_err(CE_CONT, "pcic_probe: success\n");
#endif
			ddi_regs_map_free(&handle);
			return (DDI_PROBE_SUCCESS);
		}
	}
#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "pcic_probe: failed\n");
#endif
	ddi_regs_map_free(&handle);
	return (DDI_PROBE_FAILURE);
}

/*
 * These are just defaults they can also be changed via a property in the
 * conf file.
 */
static int pci_config_reg_num = PCIC_PCI_CONFIG_REG_NUM;
static int pci_control_reg_num = PCIC_PCI_CONTROL_REG_NUM;
static int pcic_do_pcmcia_sr = 0;
static int pcic_use_cbpwrctl = PCF_CBPWRCTL;

/*
 * enable insertion/removal interrupt for 32bit cards
 */
static int
cardbus_enable_cd_intr(dev_info_t *dip)
{
	ddi_acc_handle_t	iohandle;
	caddr_t	ioaddr;
	ddi_device_acc_attr_t attr;
	attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
	attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
	(void) ddi_regs_map_setup(dip, 1,
				(caddr_t *)&ioaddr,
				0,
				4096,
				&attr, &iohandle);

	/* CSC Interrupt: Card detect interrupt on */
	ddi_put32(iohandle, (uint32_t *)(ioaddr+CB_STATUS_MASK),
		ddi_get32(iohandle,
		(uint32_t *)(ioaddr+CB_STATUS_MASK)) | CB_SE_CCDMASK);

	ddi_put32(iohandle, (uint32_t *)(ioaddr+CB_STATUS_EVENT),
		ddi_get32(iohandle, (uint32_t *)(ioaddr+CB_STATUS_EVENT)));

	ddi_regs_map_free(&iohandle);
	return (1);
}

/*
 * pcic_attach()
 *	attach the PCIC (Intel 82365SL/CirrusLogic/Toshiba) driver
 *	to the system.  This is a child of "sysbus" since that is where
 *	the hardware lives, but it provides services to the "pcmcia"
 *	nexus driver.  It gives a pointer back via its private data
 *	structure which contains both the dip and socket services entry
 *	points
 */
static int
pcic_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	anp_t *pcic_nexus;
	pcicdev_t *pcic;
	int irqlevel, value;
	int pci_cfrn, pci_ctrn;
	int i, j, smi, actual;
	char *typename;
	char bus_type[16] = "(unknown)";
	int len = sizeof (bus_type);
	ddi_device_acc_attr_t attr;
	anp_t *anp = ddi_get_driver_private(dip);
	uint_t	pri;
	syshw_t *shwp;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "pcic_attach: entered\n");
	}
#endif
	switch (cmd) {
	case DDI_ATTACH:
		break;
	case DDI_RESUME:
		pcic = anp->an_private;
		/*
		 * for now, this is a simulated resume.
		 * a real one may need different things.
		 */
		if (pcic != NULL && pcic->pc_flags & PCF_SUSPENDED) {
			mutex_enter(&pcic->pc_lock);
			/* should probe for new sockets showing up */
			pcic_setup_adapter(pcic);
			syshw_resume(pcic);
			pcic->pc_flags &= ~PCF_SUSPENDED;
			mutex_exit(&pcic->pc_lock);
			(void) pcmcia_begin_resume(dip);
			/*
			 * this will do the CARD_INSERTION
			 * due to needing time for threads to
			 * run, it must be delayed for a short amount
			 * of time.  pcmcia_wait_insert checks for all
			 * children to be removed and then triggers insert.
			 */
			/*
			 * The reason for having a single timeout here
			 * rather than seperate timeout()s for each instance
			 * is due to the limited number (2) of callout threads
			 * available in Solaris 2.6. A single 1250A ends up
			 * as two instances of the interface with one slot each.
			 * The pcic_delayed_resume() function ends by calling
			 * pcmcia_wait_insert() which at one point does a
			 * delay(). delay() is implemented with a timeout()
			 * call so you end up with both the callout()
			 * threads waiting to be woken up by another callout().
			 * This situation locks up the machine hence the
			 * convolution here to only use one timeout.
			 */
			if (!pcic_delayed_resume_toid)
				pcic_delayed_resume_toid =
				    timeout(pcic_delayed_resume, (caddr_t)0,
				    drv_usectohz(pcic_wait_insert_time));

			/*
			 * for complete implementation need END_RESUME (later)
			 */
			return (DDI_SUCCESS);

		}
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	/*
	 * Allocate soft state associated with this instance.
	 */
	if (ddi_soft_state_zalloc(pcic_soft_state_p,
				ddi_get_instance(dip)) != DDI_SUCCESS) {
		cmn_err(CE_CONT, "pcic%d: Unable to alloc state\n",
			ddi_get_instance(dip));
		return (DDI_FAILURE);
	}

	pcic_nexus = ddi_get_soft_state(pcic_soft_state_p,
	    ddi_get_instance(dip));

	pcic = kmem_zalloc(sizeof (pcicdev_t), KM_SLEEP);

	pcic->dip = dip;
	pcic_nexus->an_dip = dip;
	pcic_nexus->an_if = &pcic_if_ops;
	pcic_nexus->an_private = pcic;
	pcic->pc_numpower = sizeof (pcic_power)/sizeof (pcic_power[0]);
	pcic->pc_power = pcic_power;

	pci_ctrn = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_CANSLEEP,
	    "pci-control-reg-number", pci_control_reg_num);
	pci_cfrn = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_CANSLEEP,
	    "pci-config-reg-number", pci_config_reg_num);

	ddi_set_driver_private(dip, pcic_nexus);

	/*
	 * pcic->pc_irq is really the IPL level we want to run at
	 * set the default values here and override from intr spec
	 */
	pcic->pc_irq = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_CANSLEEP,
					"interrupt-priorities", -1);

	if (pcic->pc_irq == -1) {
		int			actual;
		uint_t			pri;
		ddi_intr_handle_t	hdl;

		/* see if intrspec tells us different */
		if (ddi_intr_alloc(dip, &hdl, DDI_INTR_TYPE_FIXED,
		    0, 1, &actual, DDI_INTR_ALLOC_NORMAL) == DDI_SUCCESS) {
			if (ddi_intr_get_pri(hdl, &pri) == DDI_SUCCESS)
				pcic->pc_irq = pri;
			else
				pcic->pc_irq = LOCK_LEVEL + 1;
			(void) ddi_intr_free(hdl);
		}
	}
	pcic_nexus->an_ipl = pcic->pc_irq;

	/*
	 * Check our parent bus type. We do different things based on which
	 * bus we're on.
	 */
	if (ddi_prop_op(DDI_DEV_T_ANY, ddi_get_parent(dip),
				PROP_LEN_AND_VAL_BUF, DDI_PROP_CANSLEEP,
				"device_type", (caddr_t)&bus_type[0], &len) !=
							DDI_PROP_SUCCESS) {
		if (ddi_prop_op(DDI_DEV_T_ANY, ddi_get_parent(dip),
				PROP_LEN_AND_VAL_BUF, DDI_PROP_CANSLEEP,
				"bus-type", (caddr_t)&bus_type[0], &len) !=
							DDI_PROP_SUCCESS) {

			cmn_err(CE_CONT,
				"pcic%d: can't find parent bus type\n",
				ddi_get_instance(dip));

			kmem_free(pcic, sizeof (pcicdev_t));
			return (DDI_FAILURE);
		}
	} /* ddi_prop_op("device_type") */

	if (strcmp(bus_type, DEVI_PCI_NEXNAME) == 0) {
		pcic->pc_flags = PCF_PCIBUS;
	} else {
#if defined(__sparc)
		cmn_err(CE_CONT, "pcic%d: unsupported parent bus type: [%s]\n",
			ddi_get_instance(dip), bus_type);

		kmem_free(pcic, sizeof (pcicdev_t));
		return (DDI_FAILURE);
#else
		pcic->pc_flags = 0;
#endif
	}

	if ((pcic->bus_speed = ddi_getprop(DDI_DEV_T_ANY, ddi_get_parent(dip),
						DDI_PROP_CANSLEEP,
						"clock-frequency", 0)) == 0) {
		if (pcic->pc_flags & PCF_PCIBUS)
			pcic->bus_speed = PCIC_PCI_DEF_SYSCLK;
		else
			pcic->bus_speed = PCIC_ISA_DEF_SYSCLK;
	} else {
		/*
		 * OBP can declare the speed in Hz...
		 */
		if (pcic->bus_speed > 1000000)
			pcic->bus_speed /= 1000000;
	} /* ddi_prop_op("clock-frequency") */

	pcic->pc_io_type = PCIC_IO_TYPE_82365SL; /* default mode */

#ifdef	PCIC_DEBUG
	if (pcic_debug) {
		cmn_err(CE_CONT,
			"pcic%d: parent bus type = [%s], speed = %d MHz\n",
			ddi_get_instance(dip),
			bus_type, pcic->bus_speed);
	}
#endif

	/*
	 * The reg properties on a PCI node are different than those
	 *	on a non-PCI node. Handle that difference here.
	 *	If it turns out to be a CardBus chip, we have even more
	 *	differences.
	 */
	if (pcic->pc_flags & PCF_PCIBUS) {
		int class_code;
#if defined(__i386) || defined(__amd64)
		pcic->pc_base = 0x1000000;
		pcic->pc_bound = (uint32_t)~0;
		pcic->pc_iobase = 0x1000;
		pcic->pc_iobound = 0xefff;
#elif defined(__sparc)
		pcic->pc_base = 0x0;
		pcic->pc_bound = (uint32_t)~0;
		pcic->pc_iobase = 0x00000;
		pcic->pc_iobound = 0xffff;
#endif

		/* usually need to get at config space so map first */
		attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
		attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
		attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

		if (ddi_regs_map_setup(dip, pci_cfrn,
					(caddr_t *)&pcic->cfgaddr,
					PCIC_PCI_CONFIG_REG_OFFSET,
					PCIC_PCI_CONFIG_REG_LENGTH,
					&attr,
					&pcic->cfg_handle) !=
		    DDI_SUCCESS) {
			cmn_err(CE_CONT,
				"pcic%d: unable to map config space"
				"regs\n",
				ddi_get_instance(dip));

			kmem_free(pcic, sizeof (pcicdev_t));
			return (DDI_FAILURE);
		} /* ddi_regs_map_setup */

		class_code = ddi_getprop(DDI_DEV_T_ANY, dip,
					DDI_PROP_CANSLEEP|DDI_PROP_DONTPASS,
					"class-code", -1);
#ifdef  PCIC_DEBUG
		if (pcic_debug) {
			cmn_err(CE_CONT, "pcic_attach class_code=%x\n",
			    class_code);
		}
#endif

		switch (class_code) {
		case PCIC_PCI_CARDBUS:
			pcic->pc_flags |= PCF_CARDBUS;
			pcic->pc_io_type = PCIC_IO_TYPE_YENTA;
			/*
			 * Get access to the adapter registers on the
			 * PCI bus.  A 4K memory page
			 */
#if defined(PCIC_DEBUG)
			pcic_err(dip, 8, "Is Cardbus device\n");
			if (pcic_debug) {
				int nr;
				long rs;
				(void) ddi_dev_nregs(dip, &nr);
				pcic_err(dip, 9, "\tdev, cfgaddr 0x%p,"
				    "cfghndl 0x%p nregs %d",
				    (void *)pcic->cfgaddr,
				    (void *)pcic->cfg_handle, nr);

				(void) ddi_dev_regsize(dip,
				    PCIC_PCI_CONTROL_REG_NUM, &rs);

				pcic_err(dip, 9, "\tsize of reg %d is 0x%x\n",
				    PCIC_PCI_CONTROL_REG_NUM, (int)rs);
			}
#endif
			attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
			attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
			attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

			if (ddi_regs_map_setup(dip, pci_ctrn,
						(caddr_t *)&pcic->ioaddr,
						PCIC_PCI_CONTROL_REG_OFFSET,
						PCIC_CB_CONTROL_REG_LENGTH,
						&attr, &pcic->handle) !=
			    DDI_SUCCESS) {
				cmn_err(CE_CONT,
					"pcic%d: unable to map PCI regs\n",
					ddi_get_instance(dip));
				ddi_regs_map_free(&pcic->cfg_handle);
				kmem_free(pcic, sizeof (pcicdev_t));
				return (DDI_FAILURE);
			} /* ddi_regs_map_setup */

			/*
			 * Find out the chip type - If we're on a PCI bus,
			 *	the adapter has that information in the PCI
			 *	config space.
			 * Note that we call pcic_find_pci_type here since
			 *	it needs a valid mapped pcic->handle to
			 *	access some of the adapter registers in
			 *	some cases.
			 */
			if (pcic_find_pci_type(pcic) != DDI_SUCCESS) {
				ddi_regs_map_free(&pcic->handle);
				ddi_regs_map_free(&pcic->cfg_handle);
				kmem_free(pcic, sizeof (pcicdev_t));
				cmn_err(CE_WARN, "pcic: %s: unsupported "
								"bridge\n",
							ddi_get_name_addr(dip));
				return (DDI_FAILURE);
			}
			break;

		default:
		case PCIC_PCI_PCMCIA:
			/*
			 * Get access to the adapter IO registers on the
			 * PCI bus config space.
			 */
			attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
			attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
			attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

			/*
			 * We need a default mapping to the adapter's IO
			 *	control register space. For most adapters
			 *	that are of class PCIC_PCI_PCMCIA (or of
			 *	a default class) the control registers
			 *	will be using the 82365-type control/data
			 *	format.
			 */
			if (ddi_regs_map_setup(dip, pci_ctrn,
						(caddr_t *)&pcic->ioaddr,
						PCIC_PCI_CONTROL_REG_OFFSET,
						PCIC_PCI_CONTROL_REG_LENGTH,
						&attr,
						&pcic->handle) != DDI_SUCCESS) {
				cmn_err(CE_CONT,
					"pcic%d: unable to map PCI regs\n",
					ddi_get_instance(dip));
				ddi_regs_map_free(&pcic->cfg_handle);
				kmem_free(pcic, sizeof (pcicdev_t));
				return (DDI_FAILURE);
			} /* ddi_regs_map_setup */

			/*
			 * Find out the chip type - If we're on a PCI bus,
			 *	the adapter has that information in the PCI
			 *	config space.
			 * Note that we call pcic_find_pci_type here since
			 *	it needs a valid mapped pcic->handle to
			 *	access some of the adapter registers in
			 *	some cases.
			 */
			if (pcic_find_pci_type(pcic) != DDI_SUCCESS) {
				ddi_regs_map_free(&pcic->handle);
				ddi_regs_map_free(&pcic->cfg_handle);
				kmem_free(pcic, sizeof (pcicdev_t));
				cmn_err(CE_WARN, "pcic: %s: unsupported "
								"bridge\n",
							ddi_get_name_addr(dip));
				return (DDI_FAILURE);
			}

			/*
			 * Some PCI-PCMCIA(R2) adapters are Yenta-compliant
			 *	for extended registers even though they are
			 *	not CardBus adapters. For those adapters,
			 *	re-map pcic->handle to be large enough to
			 *	encompass the Yenta registers.
			 */
			switch (pcic->pc_type) {
			    case PCIC_TI_PCI1031:
				ddi_regs_map_free(&pcic->handle);

				if (ddi_regs_map_setup(dip,
						PCIC_PCI_CONTROL_REG_NUM,
						(caddr_t *)&pcic->ioaddr,
						PCIC_PCI_CONTROL_REG_OFFSET,
						PCIC_CB_CONTROL_REG_LENGTH,
						&attr,
						&pcic->handle) != DDI_SUCCESS) {
					cmn_err(CE_CONT,
						"pcic%d: unable to map "
								"PCI regs\n",
						ddi_get_instance(dip));
					ddi_regs_map_free(&pcic->cfg_handle);
					kmem_free(pcic, sizeof (pcicdev_t));
					return (DDI_FAILURE);
				} /* ddi_regs_map_setup */
				break;
			    default:
				break;
			} /* switch (pcic->pc_type) */
			break;
		} /* switch (class_code) */
	} else {
		/*
		 * We're not on a PCI bus, so assume an ISA bus type
		 * register property. Get access to the adapter IO
		 * registers on a non-PCI bus.
		 */
		attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
		attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
		attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
		pcic->mem_reg_num = PCIC_ISA_MEM_REG_NUM;
		pcic->io_reg_num = PCIC_ISA_IO_REG_NUM;

		if (ddi_regs_map_setup(dip, PCIC_ISA_CONTROL_REG_NUM,
					(caddr_t *)&pcic->ioaddr,
					PCIC_ISA_CONTROL_REG_OFFSET,
					PCIC_ISA_CONTROL_REG_LENGTH,
					&attr,
					&pcic->handle) != DDI_SUCCESS) {
			cmn_err(CE_CONT,
				"pcic%d: unable to map ISA registers\n",
				ddi_get_instance(dip));

			kmem_free(pcic, sizeof (pcicdev_t));
			return (DDI_FAILURE);
		} /* ddi_regs_map_setup */

		/* ISA bus is limited to 24-bits, but not first 640K */
		pcic->pc_base = 0xd0000;
		pcic->pc_bound = (uint32_t)~0;
		pcic->pc_iobase = 0x1000;
		pcic->pc_iobound = 0xefff;
	} /* !PCF_PCIBUS */

#ifdef  PCIC_DEBUG
	if (pcic_debug) {
		cmn_err(CE_CONT, "pcic_attach pc_flags=%x pc_type=%x\n",
		    pcic->pc_flags, pcic->pc_type);
	}
#endif

	/*
	 * Setup various adapter registers for the PCI case. For the
	 * non-PCI case, find out the chip type.
	 */
	if (pcic->pc_flags & PCF_PCIBUS) {
		int iline;
#if defined(__sparc)
		iline = 0;
#else
		iline = cardbus_validate_iline(dip, pcic->cfg_handle);
#endif

		/* set flags and socket counts based on chip type */
		switch (pcic->pc_type) {
			uint32_t cfg;
		case PCIC_INTEL_i82092:
			cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_82092_PCICON);
			/* we can only support 4 Socket version */
			if (cfg & PCIC_82092_4_SOCKETS) {
			    pcic->pc_numsockets = 4;
			    pcic->pc_type = PCIC_INTEL_i82092;
			    if (iline != 0xFF)
				    pcic->pc_intr_mode = PCIC_INTR_MODE_PCI_1;
			    else
				    pcic->pc_intr_mode = PCIC_INTR_MODE_ISA;
			} else {
			    cmn_err(CE_CONT,
				    "pcic%d: Intel 82092 adapter "
				    "in unsupported configuration: 0x%x",
				    ddi_get_instance(pcic->dip), cfg);
			    pcic->pc_numsockets = 0;
			} /* PCIC_82092_4_SOCKETS */
			break;
		case PCIC_CL_PD6730:
		case PCIC_CL_PD6729:
			pcic->pc_intr_mode = PCIC_INTR_MODE_PCI_1;
			cfg = ddi_getprop(DDI_DEV_T_ANY, dip,
						DDI_PROP_CANSLEEP,
						"interrupts", 0);
			/* if not interrupt pin then must use ISA style IRQs */
			if (cfg == 0 || iline == 0xFF)
				pcic->pc_intr_mode = PCIC_INTR_MODE_ISA;
			else {
				/*
				 * we have the option to use PCI interrupts.
				 * this might not be optimal but in some cases
				 * is the only thing possible (sparc case).
				 * we now deterine what is possible.
				 */
				pcic->pc_intr_mode = PCIC_INTR_MODE_PCI_1;
			}
			pcic->pc_numsockets = 2;
			pcic->pc_flags |= PCF_IO_REMAP;
			break;
		case PCIC_TI_PCI1031:
			/* this chip doesn't do CardBus but looks like one */
			pcic->pc_flags &= ~PCF_CARDBUS;
			/* FALLTHROUGH */
		default:
			pcic->pc_flags |= PCF_IO_REMAP;
			/* FALLTHROUGH */
			/* indicate feature even if not supported */
			pcic->pc_flags |= PCF_DMA | PCF_ZV;
			/* Not sure if these apply to all these chips */
			pcic->pc_flags |= (PCF_VPPX|PCF_33VCAP);
			pcic->pc_flags |= pcic_use_cbpwrctl;

			pcic->pc_numsockets = 1; /* one per function */
			if (iline != 0xFF) {
				uint8_t cfg;
				pcic->pc_intr_mode = PCIC_INTR_MODE_PCI_1;

				cfg = ddi_get8(pcic->cfg_handle,
					(pcic->cfgaddr + PCIC_BRIDGE_CTL_REG));
				cfg &= (~PCIC_FUN_INT_MOD_ISA);
				ddi_put8(pcic->cfg_handle, (pcic->cfgaddr +
					PCIC_BRIDGE_CTL_REG), cfg);
			}
			else
				pcic->pc_intr_mode = PCIC_INTR_MODE_ISA;
			pcic->pc_io_type = PCIC_IOTYPE_YENTA;
			break;
		}
	} else {
		/*
		 * We're not on a PCI bus so do some more
		 *	checking for adapter type here.
		 * For the non-PCI bus case:
		 * It could be any one of a number of different chips
		 * If we can't determine anything else, it is assumed
		 * to be an Intel 82365SL.  The Cirrus Logic PD6710
		 * has an extension register that provides unique
		 * identification. Toshiba chip isn't detailed as yet.
		 */

		/* Init the CL id mode */
		pcic_putb(pcic, 0, PCIC_CHIP_INFO, 0);
		value = pcic_getb(pcic, 0, PCIC_CHIP_INFO);

		/* default to Intel i82365SL and then refine */
		pcic->pc_type = PCIC_I82365SL;
		pcic->pc_chipname = PCIC_TYPE_I82365SL;
		for (value = 0; pcic_ci_funcs[value] != NULL; value++) {
			/* go until one succeeds or none left */
			if (pcic_ci_funcs[value](pcic))
				break;
		}

		/* any chip specific flags get set here */
		switch (pcic->pc_type) {
		case PCIC_CL_PD6722:
			pcic->pc_flags |= PCF_DMA;
		}

		for (i = 0; i < PCIC_MAX_SOCKETS; i++) {
			/*
			 * look for total number of sockets.
			 * basically check each possible socket for
			 * presence like in probe
			 */

			/* turn all windows off */
			pcic_putb(pcic, i, PCIC_MAPPING_ENABLE, 0);
			value = pcic_getb(pcic, i, PCIC_MAPPING_ENABLE);

			/*
			 * if a zero is read back, then this socket
			 * might be present. It would be except for
			 * some systems that map the secondary PCIC
			 * chip space back to the first.
			 */
			if (value != 0) {
				/* definitely not so skip */
				/* note: this is for Compaq support */
				continue;
			}

			/* further tests */
			value = pcic_getb(pcic, i, PCIC_CHIP_REVISION) &
				PCIC_REV_MASK;
			if (!(value >= PCIC_REV_LEVEL_LOW &&
				value <= PCIC_REV_LEVEL_HI))
				break;

			pcic_putb(pcic, i, PCIC_SYSMEM_0_STARTLOW, 0xaa);
			pcic_putb(pcic, i, PCIC_SYSMEM_1_STARTLOW, 0x55);
			value = pcic_getb(pcic, i, PCIC_SYSMEM_0_STARTLOW);

			j = pcic_getb(pcic, i, PCIC_SYSMEM_1_STARTLOW);
			if (value != 0xaa || j != 0x55)
				break;

			/*
			 * at this point we know if we have hardware
			 * of some type and not just the bus holding
			 * a pattern for us. We still have to determine
			 * the case where more than 2 sockets are
			 * really the same due to peculiar mappings of
			 * hardware.
			 */
			j = pcic->pc_numsockets++;
			pcic->pc_sockets[j].pcs_flags = 0;
			pcic->pc_sockets[j].pcs_io = pcic->ioaddr;
			pcic->pc_sockets[j].pcs_socket = i;

			/* put PC Card into RESET, just in case */
			value = pcic_getb(pcic, i, PCIC_INTERRUPT);
			pcic_putb(pcic, i, PCIC_INTERRUPT,
					value & ~PCIC_RESET);
		}

#if defined(PCIC_DEBUG)
		if (pcic_debug)
			cmn_err(CE_CONT, "num sockets = %d\n",
				pcic->pc_numsockets);
#endif
		if (pcic->pc_numsockets == 0) {
			ddi_regs_map_free(&pcic->handle);
			kmem_free(pcic, sizeof (pcicdev_t));
			return (DDI_FAILURE);
		}

		/*
		 * need to think this through again in light of
		 * Compaq not following the model that all the
		 * chip vendors recommend.  IBM 755 seems to be
		 * afflicted as well.  Basically, if the vendor
		 * wired things wrong, socket 0 responds for socket 2
		 * accesses, etc.
		 */
		if (pcic->pc_numsockets > 2) {
			int count = pcic->pc_numsockets / 4;
			for (i = 0; i < count; i++) {
				/* put pattern into socket 0 */
				pcic_putb(pcic, i,
						PCIC_SYSMEM_0_STARTLOW, 0x11);

				/* put pattern into socket 2 */
				pcic_putb(pcic, i + 2,
						PCIC_SYSMEM_0_STARTLOW, 0x33);

				/* read back socket 0 */
				value = pcic_getb(pcic, i,
						    PCIC_SYSMEM_0_STARTLOW);

				/* read back chip 1 socket 0 */
				j = pcic_getb(pcic, i + 2,
						PCIC_SYSMEM_0_STARTLOW);
				if (j == value) {
					pcic->pc_numsockets -= 2;
				}
			}
		}

		smi = 0xff;	/* no more override */

		if (ddi_getprop(DDI_DEV_T_NONE, dip,
				DDI_PROP_DONTPASS, "need-mult-irq",
				0xffff) != 0xffff)
			pcic->pc_flags |= PCF_MULT_IRQ;

	} /* !PCF_PCIBUS */

	/*
	 * some platforms/busses need to have resources setup
	 * this is temporary until a real resource allocator is
	 * implemented.
	 */

	pcic_init_assigned(dip);

	typename = pcic->pc_chipname;

#ifdef	PCIC_DEBUG
	if (pcic_debug) {
		int nregs, nintrs;

		if (ddi_dev_nregs(dip, &nregs) != DDI_SUCCESS)
			nregs = 0;

		if (ddi_dev_nintrs(dip, &nintrs) != DDI_SUCCESS)
			nintrs = 0;

		cmn_err(CE_CONT,
			"pcic%d: %d register sets, %d interrupts\n",
			ddi_get_instance(dip), nregs, nintrs);

		nintrs = 0;
		while (nregs--) {
			off_t size;

			if (ddi_dev_regsize(dip, nintrs, &size) ==
			    DDI_SUCCESS) {
				cmn_err(CE_CONT,
					"\tregnum %d size %ld (0x%lx)"
					"bytes",
					nintrs, size, size);
				if (nintrs ==
				    (pcic->pc_io_type == PCIC_IO_TYPE_82365SL ?
				    PCIC_ISA_CONTROL_REG_NUM :
				    PCIC_PCI_CONTROL_REG_NUM))
					cmn_err(CE_CONT,
						" mapped at: 0x%p\n",
						(void *)pcic->ioaddr);
				else
					cmn_err(CE_CONT, "\n");
			} else {
				cmn_err(CE_CONT,
					"\tddi_dev_regsize(rnumber"
					"= %d) returns DDI_FAILURE\n",
					nintrs);
			}
			nintrs++;
		} /* while */
	} /* if (pcic_debug) */
#endif

	cv_init(&pcic->pm_cv, NULL, CV_DRIVER, NULL);

	if (!ddi_getprop(DDI_DEV_T_NONE, dip, DDI_PROP_DONTPASS,
						"disable-audio", 0))
		pcic->pc_flags |= PCF_AUDIO;

	if (ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_CANSLEEP,
	    "disable-cardbus", 0))
		pcic->pc_flags &= ~PCF_CARDBUS;

	(void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, PCICPROP_CTL,
	    typename);

	/*
	 * Init all socket SMI levels to 0 (no SMI)
	 */
	for (i = 0; i < PCIC_MAX_SOCKETS; i++) {
	    pcic->pc_sockets[i].pcs_smi = 0;
	    pcic->pc_sockets[i].pcs_debounce_id = 0;
	    pcic->pc_sockets[i].pcs_pcic = pcic;
	}
	pcic->pc_lastreg = -1; /* just to make sure we are in sync */

	/*
	 * Setup the IRQ handler(s)
	 */
	switch (pcic->pc_intr_mode) {
		int xx;
	case PCIC_INTR_MODE_ISA:
	/*
	 * On a non-PCI bus, we just use whatever SMI IRQ level was
	 *	specified above, and the IO IRQ levels are allocated
	 *	dynamically.
	 */
		for (xx = 15, smi = 0; xx >= 0; xx--) {
			if (PCIC_IRQ(xx) &
			    PCIC_AVAIL_IRQS) {
				smi = pcmcia_get_intr(dip, xx);
				if (smi >= 0)
					break;
			}
		}
#if defined(PCIC_DEBUG)
		if (pcic_debug)
			cmn_err(CE_NOTE, "\tselected IRQ %d as SMI\n", smi);
#endif
		/* init to same so share is easy */
		for (i = 0; i < pcic->pc_numsockets; i++)
			pcic->pc_sockets[i].pcs_smi = smi;
		/* any special handling of IRQ levels */
		if (pcic->pc_flags & PCF_MULT_IRQ) {
			for (i = 2; i < pcic->pc_numsockets; i++) {
				if ((i & 1) == 0) {
					int xx;
					for (xx = 15, smi = 0; xx >= 0; xx--) {
						if (PCIC_IRQ(xx) &
						    PCIC_AVAIL_IRQS) {
							smi =
							    pcmcia_get_intr(dip,
									    xx);
							if (smi >= 0)
								break;
						}
					}
				}
				if (smi >= 0)
					pcic->pc_sockets[i].pcs_smi = smi;
			}
		}
		pcic->pc_intr_htblp = kmem_alloc(pcic->pc_numsockets *
		    sizeof (ddi_intr_handle_t), KM_SLEEP);
		for (i = 0, irqlevel = -1; i < pcic->pc_numsockets; i++) {
			struct intrspec *ispecp;
			struct ddi_parent_private_data *pdp;

			if (irqlevel == pcic->pc_sockets[i].pcs_smi)
				continue;
			else {
				irqlevel = pcic->pc_sockets[i].pcs_smi;
			}
			/*
			 * now convert the allocated IRQ into an intrspec
			 * and ask our parent to add it.  Don't use
			 * the ddi_add_intr since we don't have a
			 * default intrspec in all cases.
			 *
			 * note: this sort of violates DDI but we don't
			 *	 get hardware intrspecs for many of the devices.
			 *	 at the same time, we know how to allocate them
			 *	 so we do the right thing.
			 */
			if (ddi_intr_alloc(dip, &pcic->pc_intr_htblp[i],
			    DDI_INTR_TYPE_FIXED, 0, 1, &actual,
			    DDI_INTR_ALLOC_NORMAL) != DDI_SUCCESS) {
				cmn_err(CE_WARN, "%s: ddi_intr_alloc failed",
				    ddi_get_name(dip));
				goto isa_exit1;
			}

			/*
			 * See earlier note:
			 * Since some devices don't have 'intrspec'
			 * we make one up in rootnex.
			 *
			 * However, it is not properly initialized as
			 * the data it needs is present in this driver
			 * and there is no interface to pass that up.
			 * Specially 'irqlevel' is very important and
			 * it is part of pcic struct.
			 *
			 * Set 'intrspec' up here; otherwise adding the
			 * interrupt will fail.
			 */
			pdp = ddi_get_parent_data(dip);
			ispecp = (struct intrspec *)&pdp->par_intr[0];
			ispecp->intrspec_vec = irqlevel;
			ispecp->intrspec_pri = pcic->pc_irq;

			/* Stay compatible w/ PCMCIA */
			pcic->pc_pri = (ddi_iblock_cookie_t)
			    (uintptr_t)pcic->pc_irq;
			pcic->pc_dcookie.idev_priority =
			    (uintptr_t)pcic->pc_pri;
			pcic->pc_dcookie.idev_vector = (ushort_t)irqlevel;

			(void) ddi_intr_set_pri(pcic->pc_intr_htblp[i],
			    pcic->pc_irq);

			if (i == 0) {
				mutex_init(&pcic->intr_lock, NULL, MUTEX_DRIVER,
				    DDI_INTR_PRI(pcic->pc_irq));
				mutex_init(&pcic->pc_lock, NULL, MUTEX_DRIVER,
				    NULL);
			}

			if (ddi_intr_add_handler(pcic->pc_intr_htblp[i],
			    pcic_intr, (caddr_t)pcic, NULL)) {
				cmn_err(CE_WARN,
				    "%s: ddi_intr_add_handler failed",
				    ddi_get_name(dip));
				goto isa_exit2;
			}

			if (ddi_intr_enable(pcic->pc_intr_htblp[i])) {
				cmn_err(CE_WARN, "%s: ddi_intr_enable failed",
				    ddi_get_name(dip));
				for (j = i; j < 0; j--)
					(void) ddi_intr_remove_handler(
					    pcic->pc_intr_htblp[j]);
				goto isa_exit2;
			}
		}
		break;
	case PCIC_INTR_MODE_PCI_1:
	case PCIC_INTR_MODE_PCI:
		/*
		 * If we're on a PCI bus, we route all interrupts, both SMI
		 * and IO interrupts, through a single interrupt line.
		 * Assign the SMI IRQ level to the IO IRQ level here.
		 */
		pcic->pc_pci_intr_hdlp = kmem_alloc(sizeof (ddi_intr_handle_t),
		    KM_SLEEP);
		if (ddi_intr_alloc(dip, pcic->pc_pci_intr_hdlp,
		    DDI_INTR_TYPE_FIXED, 0, 1, &actual,
		    DDI_INTR_ALLOC_NORMAL) != DDI_SUCCESS)
			goto pci_exit1;

		if (ddi_intr_get_pri(pcic->pc_pci_intr_hdlp[0],
		    &pri) != DDI_SUCCESS) {
			(void) ddi_intr_free(pcic->pc_pci_intr_hdlp[0]);
			goto pci_exit1;
		}

		pcic->pc_pri = (void *)(uintptr_t)pri;
		mutex_init(&pcic->intr_lock, NULL, MUTEX_DRIVER, pcic->pc_pri);
		mutex_init(&pcic->pc_lock, NULL, MUTEX_DRIVER, NULL);

		if (ddi_intr_add_handler(pcic->pc_pci_intr_hdlp[0],
		    pcic_intr, (caddr_t)pcic, NULL))
			goto pci_exit2;

		if (ddi_intr_enable(pcic->pc_pci_intr_hdlp[0])) {
			(void) ddi_intr_remove_handler(
			    pcic->pc_pci_intr_hdlp[0]);
			goto pci_exit2;
		}

		/* Stay compatible w/ PCMCIA */
		pcic->pc_dcookie.idev_priority = (ushort_t)pri;

		/* init to same (PCI) so share is easy */
		for (i = 0; i < pcic->pc_numsockets; i++)
			pcic->pc_sockets[i].pcs_smi = 0xF; /* any valid */
		break;
	}

	/*
	 * Setup the adapter hardware to some reasonable defaults.
	 */
	mutex_enter(&pcic->pc_lock);
	/* mark the driver state as attached */
	pcic->pc_flags |= PCF_ATTACHED;
	pcic_setup_adapter(pcic);

	for (j = 0; j < pcic->pc_numsockets; j++)
		if (ddi_intr_add_softint(dip,
		    &pcic->pc_sockets[j].pcs_cd_softint_hdl,
		    PCIC_SOFTINT_PRI_VAL, pcic_cd_softint,
		    (caddr_t)&pcic->pc_sockets[j]) != DDI_SUCCESS)
			goto pci_exit2;

#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "type = %s sockets = %d\n", typename,
						pcic->pc_numsockets);
#endif

	pcic_nexus->an_iblock = &pcic->pc_pri;
	pcic_nexus->an_idev = &pcic->pc_dcookie;

	mutex_exit(&pcic->pc_lock);

#ifdef CARDBUS
	(void) cardbus_enable_cd_intr(dip);
	if (pcic_debug) {

		cardbus_dump_pci_config(dip);
		cardbus_dump_socket(dip);
	}

	/*
	 * Give the Cardbus misc module a chance to do it's per-adapter
	 * instance setup. Note that there is no corresponding detach()
	 * call.
	 */
	if (pcic->pc_flags & PCF_CARDBUS)
		if (cardbus_attach(dip, &pcic_cbnexus_ops) != DDI_SUCCESS) {
			cmn_err(CE_CONT,
			    "pcic_attach: cardbus_attach failed\n");
			goto pci_exit2;
		}
#endif

	/*
	 * Give the PCMCIA misc module a chance to do it's per-adapter
	 *	instance setup.
	 */
	if ((i = pcmcia_attach(dip, pcic_nexus)) != DDI_SUCCESS)
		goto pci_exit2;

	syshw_attach(pcic);
	if (pcic_maxinst == -1) {
		/* This assumes that all instances run at the same IPL. */
		mutex_init(&pcic_deb_mtx, NULL, MUTEX_DRIVER, NULL);
		cv_init(&pcic_deb_cv, NULL, CV_DRIVER, NULL);
		pcic_deb_threadid = thread_create((caddr_t)NULL, 0,
		    pcic_deb_thread, (caddr_t)NULL, 0, &p0, TS_RUN,
		    v.v_maxsyspri - 2);
	}
	pcic_maxinst = max(pcic_maxinst, ddi_get_instance(dip));
	/*
	 * Setup a debounce timeout to do an initial card detect
	 * and enable interrupts.
	 */
	for (j = 0; j < pcic->pc_numsockets; j++) {
		shwp = kmem_alloc(sizeof (syshw_t), KM_SLEEP);
		if (shwp) {
			bcopy(&pcic_syshw, shwp, sizeof (pcic_syshw));
			pcic_syshw.id_string[15]++;
			pcic->pc_sockets[j].pcs_syshwsig =
			    syshw_add2map(shwp, pcic_syshw_cardstate,
				&pcic->pc_sockets[j]);
		}
		pcic->pc_sockets[j].pcs_debounce_id =
		    pcic_add_debqueue(&pcic->pc_sockets[j],
			drv_usectohz(pcic_debounce_time));
	}

	return (i);

isa_exit2:
	mutex_destroy(&pcic->intr_lock);
	mutex_destroy(&pcic->pc_lock);
	for (j = i; j < 0; j--)
		(void) ddi_intr_free(pcic->pc_intr_htblp[j]);
isa_exit1:
	(void) pcmcia_return_intr(dip, pcic->pc_sockets[i].pcs_smi);
	ddi_regs_map_free(&pcic->handle);
	if (pcic->pc_flags & PCF_PCIBUS)
		ddi_regs_map_free(&pcic->cfg_handle);
	kmem_free(pcic->pc_intr_htblp, pcic->pc_numsockets *
	    sizeof (ddi_intr_handle_t));
	kmem_free(pcic, sizeof (pcicdev_t));
		return (DDI_FAILURE);

pci_exit2:
	mutex_destroy(&pcic->intr_lock);
	mutex_destroy(&pcic->pc_lock);
	(void) ddi_intr_free(pcic->pc_pci_intr_hdlp[0]);
pci_exit1:
	ddi_regs_map_free(&pcic->handle);
	if (pcic->pc_flags & PCF_PCIBUS)
		ddi_regs_map_free(&pcic->cfg_handle);
	kmem_free(pcic->pc_pci_intr_hdlp, sizeof (ddi_intr_handle_t));
	kmem_free(pcic, sizeof (pcicdev_t));
	return (DDI_FAILURE);
}

/*
 * pcic_detach()
 *	request to detach from the system
 */
static int
pcic_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int i;

	switch (cmd) {
	case DDI_DETACH:
		/* don't detach if the nexus still talks to us */
		if (pcic->pc_callback != NULL)
			return (DDI_FAILURE);
		syshw_detach(pcic);

		/* kill off the pm simulation */
		if (pcic->pc_pmtimer)
			(void) untimeout(pcic->pc_pmtimer);

		/* turn everything off for all sockets and chips */
		for (i = 0; i < pcic->pc_numsockets; i++) {
			if (pcic->pc_sockets[i].pcs_debounce_id)
				pcic_rm_debqueue(
				    pcic->pc_sockets[i].pcs_debounce_id);
			pcic->pc_sockets[i].pcs_debounce_id = 0;

			pcic_putb(pcic, i, PCIC_MANAGEMENT_INT, 0);
			pcic_putb(pcic, i, PCIC_CARD_DETECT, 0);
			pcic_putb(pcic, i, PCIC_MAPPING_ENABLE, 0);
			/* disable interrupts and put card into RESET */
			pcic_putb(pcic, i, PCIC_INTERRUPT, 0);
		}
		(void) ddi_intr_disable(pcic->pc_pci_intr_hdlp[0]);
		(void) ddi_intr_remove_handler(pcic->pc_pci_intr_hdlp[0]);
		(void) ddi_intr_free(pcic->pc_pci_intr_hdlp[0]);
		kmem_free(pcic->pc_pci_intr_hdlp, sizeof (ddi_intr_handle_t));
		pcic->pc_flags = 0;
		mutex_destroy(&pcic->pc_lock);
		mutex_destroy(&pcic->intr_lock);
		cv_destroy(&pcic->pm_cv);
		if (pcic->pc_flags & PCF_PCIBUS)
		    ddi_regs_map_free(&pcic->cfg_handle);
		if (pcic->handle)
		    ddi_regs_map_free(&pcic->handle);
		kmem_free(pcic, sizeof (pcicdev_t));
		ddi_soft_state_free(pcic_soft_state_p, ddi_get_instance(dip));
		return (DDI_SUCCESS);

	case DDI_SUSPEND:
	case DDI_PM_SUSPEND:
		/*
		 * we got a suspend event (either real or imagined)
		 * so notify the nexus proper that all existing cards
		 * should go away.
		 */
		mutex_enter(&pcic->pc_lock);
#ifdef CARDBUS
		if (pcic->pc_flags & PCF_CARDBUS)
			for (i = 0; i < pcic->pc_numsockets; i++)
				if ((pcic->pc_sockets[i].pcs_flags &
				    (PCS_CARD_PRESENT|PCS_CARD_ISCARDBUS)) ==
				    (PCS_CARD_PRESENT|PCS_CARD_ISCARDBUS))
					if (!cardbus_can_suspend(dip)) {
						mutex_exit(&pcic->pc_lock);
						cmn_err(CE_WARN,
						    "Please unconfigure all "
						    "CardBus devices before "
						    "attempting to suspend\n");
						return (DDI_FAILURE);
					}
#endif
		/* turn everything off for all sockets and chips */
		for (i = 0; i < pcic->pc_numsockets; i++) {
			if (pcic->pc_sockets[i].pcs_debounce_id)
				pcic_rm_debqueue(
				    pcic->pc_sockets[i].pcs_debounce_id);
			pcic->pc_sockets[i].pcs_debounce_id = 0;

			pcic_putb(pcic, i, PCIC_MANAGEMENT_INT, 0);
			pcic_putb(pcic, i, PCIC_CARD_DETECT, 0);
			pcic_putb(pcic, i, PCIC_MAPPING_ENABLE, 0);
			/* disable interrupts and put card into RESET */
			pcic_putb(pcic, i, PCIC_INTERRUPT, 0);
			pcic_putb(pcic, i, PCIC_POWER_CONTROL, 0);
			if (pcic->pc_flags & PCF_CBPWRCTL)
				pcic_putcb(pcic, CB_CONTROL, 0);

			if (pcic->pc_sockets[i].pcs_flags & PCS_CARD_PRESENT) {
				pcic->pc_sockets[i].pcs_flags = PCS_STARTING;
				/*
				 * Because we are half way through a save
				 * all this does is schedule a removal event
				 * to cs for when the system comes back.
				 * This doesn't actually matter.
				 */
				if (!pcic_do_pcmcia_sr && pcic_do_removal &&
				    pcic->pc_callback) {
					PC_CALLBACK(pcic->dip, pcic->pc_cb_arg,
					    PCE_CARD_REMOVAL,
					    pcic->pc_sockets[i].pcs_socket);
				}
			}
		}

		pcic->pc_flags |= PCF_SUSPENDED;
		mutex_exit(&pcic->pc_lock);
		pcic_delayed_resume_toid = 0;

		/*
		 * when true power management exists, save the adapter
		 * state here to enable a recovery.  For the emulation
		 * condition, the state is gone
		 */
		return (DDI_SUCCESS);

	default:
		return (EINVAL);
	}
}

static uint32_t pcic_tisysctl_onbits = ((1<<27) | (1<<15) | (1<<14));
static uint32_t pcic_tisysctl_offbits = 0;
static uint32_t pcic_default_latency = 0x40;

static void
pcic_setup_adapter(pcicdev_t *pcic)
{
	int i;
	int value, flags;

	if (pcic->pc_flags & PCF_PCIBUS) {
		/*
		 * all PCI-to-PCMCIA bus bridges need memory and I/O enabled
		 */
		flags = (PCIC_ENABLE_IO | PCIC_ENABLE_MEM);
		pcic_iomem_pci_ctl(pcic->cfg_handle, pcic->cfgaddr, flags);
	}
	/* enable each socket */
	for (i = 0; i < pcic->pc_numsockets; i++) {
		pcic->pc_sockets[i].pcs_flags = 0;
		/* find out the socket capabilities (I/O vs memory) */
		value = pcic_getb(pcic, i,
					PCIC_CHIP_REVISION) & PCIC_REV_ID_MASK;
		if (value == PCIC_REV_ID_IO || value == PCIC_REV_ID_BOTH)
			pcic->pc_sockets[i].pcs_flags |= PCS_SOCKET_IO;

		/* disable all windows just in case */
		pcic_putb(pcic, i, PCIC_MAPPING_ENABLE, 0);

		switch (pcic->pc_type) {
			uint32_t cfg32;
			uint16_t cfg16;
			uint8_t cfg;

		    /* enable extended registers for Vadem */
		    case PCIC_VADEM_VG469:
		    case PCIC_VADEM:

			/* enable card status change interrupt for socket */
			break;

		    case PCIC_I82365SL:
			break;

		    case PCIC_CL_PD6710:
			pcic_putb(pcic, 0, PCIC_MISC_CTL_2, PCIC_LED_ENABLE);
			break;

			/*
			 * On the CL_6730, we need to set up the interrupt
			 * signalling mode (PCI mode) and set the SMI and
			 * IRQ interrupt lines to PCI/level-mode.
			 */
		    case PCIC_CL_PD6730:
			switch (pcic->pc_intr_mode) {
			case PCIC_INTR_MODE_PCI_1:
				clext_reg_write(pcic, i, PCIC_CLEXT_MISC_CTL_3,
						((clext_reg_read(pcic, i,
						PCIC_CLEXT_MISC_CTL_3) &
						~PCIC_CLEXT_INT_PCI) |
						PCIC_CLEXT_INT_PCI));
				clext_reg_write(pcic, i, PCIC_CLEXT_EXT_CTL_1,
						(PCIC_CLEXT_IRQ_LVL_MODE |
						PCIC_CLEXT_SMI_LVL_MODE));
				cfg = PCIC_CL_LP_DYN_MODE;
				pcic_putb(pcic, i, PCIC_MISC_CTL_2, cfg);
				break;
			case PCIC_INTR_MODE_ISA:
				break;
			}
			break;
			/*
			 * On the CL_6729, we set the SMI and IRQ interrupt
			 *	lines to PCI/level-mode. as well as program the
			 *	correct clock speed divider bit.
			 */
		    case PCIC_CL_PD6729:
			switch (pcic->pc_intr_mode) {
			case PCIC_INTR_MODE_PCI_1:
				clext_reg_write(pcic, i, PCIC_CLEXT_EXT_CTL_1,
						(PCIC_CLEXT_IRQ_LVL_MODE |
						PCIC_CLEXT_SMI_LVL_MODE));

				break;
			case PCIC_INTR_MODE_ISA:
				break;
			}
			if (pcic->bus_speed > PCIC_PCI_25MHZ && i == 0) {
				cfg = 0;
				cfg |= PCIC_CL_TIMER_CLK_DIV;
				pcic_putb(pcic, i, PCIC_MISC_CTL_2, cfg);
			}
			break;
		    case PCIC_INTEL_i82092:
			cfg = PCIC_82092_EN_TIMING;
			if (pcic->bus_speed < PCIC_SYSCLK_33MHZ)
			    cfg |= PCIC_82092_PCICLK_25MHZ;
			ddi_put8(pcic->cfg_handle, pcic->cfgaddr +
						PCIC_82092_PCICON, cfg);
			break;
		    case PCIC_TI_PCI1130:
		    case PCIC_TI_PCI1131:
		    case PCIC_TI_PCI1250:
		    case PCIC_TI_PCI1031:
			cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_DEVCTL_REG);
			cfg &= ~PCIC_DEVCTL_INTR_MASK;
			switch (pcic->pc_intr_mode) {
			case PCIC_INTR_MODE_ISA:
				cfg |= PCIC_DEVCTL_INTR_ISA;
				break;
			}
#ifdef PCIC_DEBUG
			if (pcic_debug) {
				cmn_err(CE_CONT, "pcic_setup_adapter: "
				    "write reg 0x%x=%x \n",
				    PCIC_DEVCTL_REG, cfg);
			}
#endif
			ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_DEVCTL_REG,
					cfg);

			cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_CRDCTL_REG);
			cfg &= ~(PCIC_CRDCTL_PCIINTR|PCIC_CRDCTL_PCICSC|
					PCIC_CRDCTL_PCIFUNC);
			switch (pcic->pc_intr_mode) {
			case PCIC_INTR_MODE_PCI_1:
				cfg |= PCIC_CRDCTL_PCIINTR |
					PCIC_CRDCTL_PCICSC |
					PCIC_CRDCTL_PCIFUNC;
				pcic->pc_flags |= PCF_USE_SMI;
				break;
			}
#ifdef PCIC_DEBUG
			if (pcic_debug) {
				cmn_err(CE_CONT, "pcic_setup_adapter: "
				    " write reg 0x%x=%x \n",
				    PCIC_CRDCTL_REG, cfg);
			}
#endif
			ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_CRDCTL_REG,
					cfg);
			break;
		    case PCIC_TI_PCI1221:
		    case PCIC_TI_PCI1225:
			cfg = ddi_get8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DEVCTL_REG);
			cfg |= (PCIC_DEVCTL_INTR_DFLT | PCIC_DEVCTL_3VCAPABLE);
#ifdef PCIC_DEBUG
			if (pcic_debug) {
				cmn_err(CE_CONT, "pcic_setup_adapter: "
				    " write reg 0x%x=%x \n",
				    PCIC_DEVCTL_REG, cfg);
			}
#endif
			ddi_put8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DEVCTL_REG, cfg);

			cfg = ddi_get8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DIAG_REG);
			if (pcic->pc_type == PCIC_TI_PCI1225) {
				cfg |= (PCIC_DIAG_CSC | PCIC_DIAG_ASYNC);
			} else {
				cfg |= PCIC_DIAG_ASYNC;
			}
			pcic->pc_flags |= PCF_USE_SMI;
#ifdef PCIC_DEBUG
			if (pcic_debug) {
				cmn_err(CE_CONT, "pcic_setup_adapter: "
				    " write reg 0x%x=%x \n",
				    PCIC_DIAG_REG, cfg);
			}
#endif
			ddi_put8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DIAG_REG, cfg);
			break;
		    case PCIC_TI_PCI1520:
		    case PCIC_TI_VENDOR:
			if (pcic->pc_intr_mode == PCIC_INTR_MODE_ISA) {
				cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG);
				cfg |= PCIC_FUN_INT_MOD_ISA;
				ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG,
					cfg);
			}
			cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_DEVCTL_REG);
			cfg &= ~PCIC_DEVCTL_INTR_MASK;
			if (pcic->pc_intr_mode == PCIC_INTR_MODE_ISA)
				cfg |= PCIC_DEVCTL_INTR_ISA;
			ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_DEVCTL_REG,
					cfg);

			/* tie INTA and INTB together */
			cfg = ddi_get8(pcic->cfg_handle,
				(pcic->cfgaddr + PCIC_SYSCTL_REG + 3));
			cfg |= PCIC_SYSCTL_INTRTIE;
			ddi_put8(pcic->cfg_handle, (pcic->cfgaddr +
				PCIC_SYSCTL_REG + 3), cfg);
			cfg = ddi_get8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DIAG_REG);
			cfg |= (PCIC_DIAG_CSC | PCIC_DIAG_ASYNC);
			ddi_put8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DIAG_REG, cfg);
			break;
		    case PCIC_TI_PCI1410:
			cfg = ddi_get8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DIAG_REG);
			cfg |= (PCIC_DIAG_CSC | PCIC_DIAG_ASYNC);
			ddi_put8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_DIAG_REG, cfg);
			break;
		    case PCIC_TOSHIBA_TOPIC100:
		    case PCIC_TOSHIBA_TOPIC95:
		    case PCIC_TOSHIBA_VENDOR:
			cfg = ddi_get8(pcic->cfg_handle, pcic->cfgaddr +
				PCIC_TOSHIBA_SLOT_CTL_REG);
			cfg |= (PCIC_TOSHIBA_SCR_SLOTON |
				PCIC_TOSHIBA_SCR_SLOTEN);
			cfg &= (~PCIC_TOSHIBA_SCR_PRT_MASK);
			cfg |= PCIC_TOSHIBA_SCR_PRT_3E2;
			ddi_put8(pcic->cfg_handle, pcic->cfgaddr +
				PCIC_TOSHIBA_SLOT_CTL_REG, cfg);
			cfg = ddi_get8(pcic->cfg_handle, pcic->cfgaddr +
				PCIC_TOSHIBA_INTR_CTL_REG);
			switch (pcic->pc_intr_mode) {
			case PCIC_INTR_MODE_ISA:
				cfg &= ~PCIC_TOSHIBA_ICR_SRC;
				ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr +
					PCIC_TOSHIBA_INTR_CTL_REG, cfg);

				cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG);
				cfg |= PCIC_FUN_INT_MOD_ISA;
				ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG,
					cfg);
				break;
			case PCIC_INTR_MODE_PCI_1:
				cfg |= PCIC_TOSHIBA_ICR_SRC;
				cfg &= (~PCIC_TOSHIBA_ICR_PIN_MASK);
				cfg |= PCIC_TOSHIBA_ICR_PIN_INTA;
				ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr +
					PCIC_TOSHIBA_INTR_CTL_REG, cfg);
				break;
			}
			break;
		    case PCIC_O2MICRO_VENDOR:
			cfg32 = ddi_get32(pcic->cfg_handle,
				(uint32_t *)(pcic->cfgaddr +
				PCIC_O2MICRO_MISC_CTL));
			switch (pcic->pc_intr_mode) {
			case PCIC_INTR_MODE_ISA:
				cfg32 |= (PCIC_O2MICRO_ISA_LEGACY |
					PCIC_O2MICRO_INT_MOD_PCI);
				ddi_put32(pcic->cfg_handle,
					(uint32_t *)(pcic->cfgaddr +
					PCIC_O2MICRO_MISC_CTL),
					cfg32);
				cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG);
				cfg |= PCIC_FUN_INT_MOD_ISA;
				ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG,
					cfg);
				break;
			case PCIC_INTR_MODE_PCI_1:
				cfg32 &= ~PCIC_O2MICRO_ISA_LEGACY;
				cfg32 |= PCIC_O2MICRO_INT_MOD_PCI;
				ddi_put32(pcic->cfg_handle,
					(uint32_t *)(pcic->cfgaddr +
					PCIC_O2MICRO_MISC_CTL),
					cfg32);
				break;
			}
			break;
		    case PCIC_RICOH_VENDOR:
			if (pcic->pc_intr_mode == PCIC_INTR_MODE_ISA) {
				cfg16 = ddi_get16(pcic->cfg_handle,
					(uint16_t *)(pcic->cfgaddr +
					PCIC_RICOH_MISC_CTL_2));
				cfg16 |= (PCIC_RICOH_CSC_INT_MOD |
					PCIC_RICOH_FUN_INT_MOD);
				ddi_put16(pcic->cfg_handle,
					(uint16_t *)(pcic->cfgaddr +
					PCIC_RICOH_MISC_CTL_2),
					cfg16);

				cfg16 = ddi_get16(pcic->cfg_handle,
					(uint16_t *)(pcic->cfgaddr +
					PCIC_RICOH_MISC_CTL));
				cfg16 |= PCIC_RICOH_SIRQ_EN;
				ddi_put16(pcic->cfg_handle,
					(uint16_t *)(pcic->cfgaddr +
					PCIC_RICOH_MISC_CTL),
					cfg16);

				cfg = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG);
				cfg |= PCIC_FUN_INT_MOD_ISA;
				ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_BRIDGE_CTL_REG,
					cfg);
			}
			break;
		    default:
			break;
		} /* switch */

		/* setup general card status change interrupt */
		switch (pcic->pc_type) {
			case PCIC_TI_PCI1225:
			case PCIC_TI_PCI1221:
			case PCIC_TI_PCI1031:
			case PCIC_TI_PCI1520:
			case PCIC_TI_PCI1410:
				pcic_putb(pcic, i, PCIC_MANAGEMENT_INT,
				    PCIC_CHANGE_DEFAULT);
				break;
			default:
				if (pcic->pc_intr_mode ==
					PCIC_INTR_MODE_PCI_1) {
					pcic_putb(pcic, i, PCIC_MANAGEMENT_INT,
						PCIC_CHANGE_DEFAULT);
					break;
				} else {
					pcic_putb(pcic, i, PCIC_MANAGEMENT_INT,
						PCIC_CHANGE_DEFAULT |
					(pcic->pc_sockets[i].pcs_smi << 4));
					break;
				}
		}

		pcic->pc_flags |= PCF_INTRENAB;

		/* take card out of RESET */
		pcic_putb(pcic, i, PCIC_INTERRUPT, PCIC_RESET);
		/* turn power off and let CS do this */
		pcic_putb(pcic, i, PCIC_POWER_CONTROL, 0);

		/* final chip specific initialization */
		switch (pcic->pc_type) {
		    case PCIC_VADEM:
			pcic_putb(pcic, i, PCIC_VG_CONTROL,
					PCIC_VC_DELAYENABLE);
			pcic->pc_flags |= PCF_DEBOUNCE;
			/* FALLTHROUGH */
		    case PCIC_I82365SL:
			pcic_putb(pcic, i, PCIC_GLOBAL_CONTROL,
					PCIC_GC_CSC_WRITE);
			/* clear any pending interrupts */
			value = pcic_getb(pcic, i, PCIC_CARD_STATUS_CHANGE);
			pcic_putb(pcic, i, PCIC_CARD_STATUS_CHANGE, value);
			break;
		    /* The 82092 uses PCI config space to enable interrupts */
		    case PCIC_INTEL_i82092:
			pcic_82092_smiirq_ctl(pcic, i, PCIC_82092_CTL_SMI,
							PCIC_82092_INT_ENABLE);
			break;
		    case PCIC_CL_PD6729:
			if (pcic->bus_speed >= PCIC_PCI_DEF_SYSCLK && i == 0) {
				value = pcic_getb(pcic, i, PCIC_MISC_CTL_2);
				pcic_putb(pcic, i, PCIC_MISC_CTL_2,
						value | PCIC_CL_TIMER_CLK_DIV);
			}
			break;
		} /* switch */

#if defined(PCIC_DEBUG)
		if (pcic_debug)
			cmn_err(CE_CONT,
				"socket %d value=%x, flags = %x (%s)\n",
				i, value, pcic->pc_sockets[i].pcs_flags,
				(pcic->pc_sockets[i].pcs_flags &
					PCS_CARD_PRESENT) ?
						"card present" : "no card");
#endif
	}
}

/*
 * pcic_intr(caddr_t, caddr_t)
 *	interrupt handler for the PCIC style adapter
 *	handles all basic interrupts and also checks
 *	for status changes and notifies the nexus if
 *	necessary
 *
 *	On PCI bus adapters, also handles all card
 *	IO interrupts.
 */
/*ARGSUSED*/
uint32_t
pcic_intr(caddr_t arg1, caddr_t arg2)
{
	pcicdev_t *pcic = (pcicdev_t *)arg1;
	int value = 0, i, ret = DDI_INTR_UNCLAIMED;
	uint8_t status;
	uint_t io_ints;

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 0xf,
		"pcic_intr: enter pc_flags=0x%x PCF_ATTACHED=0x%x"
		" pc_numsockets=%d \n",
		pcic->pc_flags, PCF_ATTACHED, pcic->pc_numsockets);
#endif

	if (!(pcic->pc_flags & PCF_ATTACHED))
	    return (DDI_INTR_UNCLAIMED);

	mutex_enter(&pcic->intr_lock);

	if (pcic->pc_flags & PCF_SUSPENDED) {
		mutex_exit(&pcic->intr_lock);
		return (ret);
	}

	/*
	 * need to change to only ACK and touch the slot that
	 * actually caused the interrupt.  Currently everything
	 * is acked
	 *
	 * we need to look at all known sockets to determine
	 * what might have happened, so step through the list
	 * of them
	 */
#ifdef VOYAGER
	ret = syshw_intr_hi(pcic);
#endif

	/*
	 * Set the bitmask for IO interrupts to initially include all sockets
	 */
	io_ints = (1 << pcic->pc_numsockets) - 1;

	for (i = 0; i < pcic->pc_numsockets; i++) {
		int card_type;
		pcic_socket_t *sockp;
		int value_cb = 0;

		sockp = &pcic->pc_sockets[i];
		/* get the socket's I/O addresses */

		if (sockp->pcs_flags & PCS_WAITING) {
			io_ints &= ~(1 << i);
			continue;
		}

		if (sockp->pcs_flags & PCS_CARD_IO)
			card_type = IF_IO;
		else
			card_type = IF_MEMORY;

		if (pcic->pc_io_type == PCIC_IO_TYPE_YENTA)
			value_cb = pcic_getcb(pcic, CB_STATUS_EVENT);

		value = pcic_change(pcic, i);

		if ((value != 0) || (value_cb != 0)) {
			int x = pcic->pc_cb_arg;

			ret = DDI_INTR_CLAIMED;

#if defined(PCIC_DEBUG)
			pcic_err(pcic->dip, 0x9,
			    "card_type = %d, value_cb = 0x%x\n",
			    card_type,
			    value_cb ? value_cb :
				pcic_getcb(pcic, CB_STATUS_EVENT));
			if (pcic_debug)
				cmn_err(CE_CONT,
					"\tchange on socket %d (%x)\n", i,
					value);
#endif
			/* find out what happened */
			status = pcic_getb(pcic, i, PCIC_INTERFACE_STATUS);

			/* acknowledge the interrupt */
			if (value_cb)
				pcic_putcb(pcic, CB_STATUS_EVENT, value_cb);

			if (value)
				pcic_putb(pcic, i, PCIC_CARD_STATUS_CHANGE,
				    value);

			if (pcic->pc_callback == NULL) {
				/* if not callback handler, nothing to do */
				continue;
			}

			/* Card Detect */
			if (value & PCIC_CD_DETECT ||
			    value_cb & CB_PS_CCDMASK) {
				uint8_t irq;
#if defined(PCIC_DEBUG)
				if (pcic_debug)
					cmn_err(CE_CONT,
						"\tcd_detect: status=%x,"
						" flags=%x\n",
						status, sockp->pcs_flags);
#else
#ifdef lint
				if (status == 0)
				    status++;
#endif
#endif
				/*
				 * Turn off all interrupts for this socket here.
				 */
				irq = pcic_getb(pcic, sockp->pcs_socket,
				    PCIC_MANAGEMENT_INT);
				irq &= ~PCIC_CHANGE_MASK;
				pcic_putb(pcic, sockp->pcs_socket,
				    PCIC_MANAGEMENT_INT, irq);

				pcic_putcb(pcic, CB_STATUS_MASK, 0x0);

				if (!sockp->pcs_cd_softint_flg) {
					sockp->pcs_cd_softint_flg = 1;
					(void) ddi_intr_trigger_softint(
					    sockp->pcs_cd_softint_hdl, NULL);
				}

				io_ints &= ~(1 << i);
			} /* PCIC_CD_DETECT */

			/* Ready/Change Detect */
			sockp->pcs_state ^= SBM_RDYBSY;
			if (card_type == IF_MEMORY && value & PCIC_RD_DETECT) {
				sockp->pcs_flags |= PCS_READY;
				PC_CALLBACK(pcic->dip, x, PCE_CARD_READY, i);
			}

			/* Battery Warn Detect */
			if (card_type == IF_MEMORY &&
			    value & PCIC_BW_DETECT &&
			    !(sockp->pcs_state & SBM_BVD2)) {
				sockp->pcs_state |= SBM_BVD2;
				PC_CALLBACK(pcic->dip, x,
						PCE_CARD_BATTERY_WARN, i);
			}

			/* Battery Dead Detect */
			if (value & PCIC_BD_DETECT) {
				/*
				 * need to work out event if RI not enabled
				 * and card_type == IF_IO
				 */
				if (card_type == IF_MEMORY &&
					!(sockp->pcs_state & SBM_BVD1)) {
					sockp->pcs_state |= SBM_BVD1;
					PC_CALLBACK(pcic->dip, x,
							PCE_CARD_BATTERY_DEAD,
							i);
				} else {
					/*
					 * information in pin replacement
					 * register if one is available
					 */
					PC_CALLBACK(pcic->dip, x,
							PCE_CARD_STATUS_CHANGE,
							i);
				} /* IF_MEMORY */
			} /* PCIC_BD_DETECT */
		} /* if pcic_change */
		/*
		 * for any controllers that we can detect whether a socket
		 * had an interrupt for the PC Card, we should sort that out
		 * here.
		 */
	} /* for pc_numsockets */

	/*
	 * If we're on a PCI bus, we may need to cycle through each IO
	 *	interrupt handler that is registered since they all
	 *	share the same interrupt line.
	 */


#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 0xf,
	    "pcic_intr: pc_intr_mode=%d pc_type=%x io_ints=0x%x\n",
	    pcic->pc_intr_mode, pcic->pc_type, io_ints);
#endif

	switch (pcic->pc_intr_mode) {
	case PCIC_INTR_MODE_PCI_1:
		value = ~0;
		/* fix value if adapter can tell us about I/O intrs */
		switch (pcic->pc_type) {

		case PCIC_TI_PCI1031:
		case PCIC_TI_PCI1130:
		case PCIC_TI_PCI1131:
		case PCIC_TI_PCI1250:
		case PCIC_TI_PCI1225:
		case PCIC_TI_PCI1221:
		case PCIC_TI_PCI1520:
		case PCIC_TI_PCI1410:
		case PCIC_TI_VENDOR:
			i = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_CRDCTL_REG);
			if (i & PCIC_CRDCTL_IFG)
				value = 1;
			else
				value = 0;
			i |= PCIC_CRDCTL_IFG;
			/* clear the condition */
			ddi_put8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_CRDCTL_REG, i);
			break;
		case PCIC_TOSHIBA_TOPIC100:
		case PCIC_TOSHIBA_TOPIC95:
		case PCIC_TOSHIBA_VENDOR:
		case PCIC_RICOH_VENDOR:
		case PCIC_O2MICRO_VENDOR:
		default:
			value = 1;
			break;
		}
		if (value && pcic_do_io_intr(pcic, value) == DDI_INTR_CLAIMED)
			ret = DDI_INTR_CLAIMED;
		break;
	default:
		break;
	}

	mutex_exit(&pcic->intr_lock);

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 0xf,
	    "pcic_intr: ret=%d value=%d DDI_INTR_CLAIMED=%d\n",
	    ret, value, DDI_INTR_CLAIMED);
#endif

	return (ret);
}

/*
 * pcic_change()
 *	check to see if this socket had a change in state
 *	by checking the status change register
 */
static int
pcic_change(pcicdev_t *pcic, int socket)
{
	return (pcic_getb(pcic, socket, PCIC_CARD_STATUS_CHANGE));
}

/*
 * pcic_do_io_intr - calls client interrupt handlers
 */
static int
pcic_do_io_intr(pcicdev_t *pcic, uint32_t sockets)
{
	inthandler_t *tmp;
	int ret = DDI_INTR_UNCLAIMED;

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 0xf,
		"pcic_do_io_intr: pcic=%p sockets=%d irq_top=%p\n",
		(void *)pcic, (int)sockets, (void *)pcic->irq_top);
#endif

	if (pcic->irq_top != NULL) {
	    tmp = pcic->irq_current;

	    do {
		int cur = pcic->irq_current->socket;
		pcic_socket_t *sockp =
				&pcic->pc_sockets[cur];

#if defined(PCIC_DEBUG)
		pcic_err(pcic->dip, 0xf,
		    "\t pcs_flags=0x%x PCS_CARD_PRESENT=0x%x\n",
		    sockp->pcs_flags, PCS_CARD_PRESENT);
		pcic_err(pcic->dip, 0xf,
		    "\t sockets=%d cur=%d intr=%p arg1=%p "
		    "arg2=%p\n",
		    sockets, cur, (void *)pcic->irq_current->intr,
		    pcic->irq_current->arg1,
		    pcic->irq_current->arg2);
#endif
		if (sockp->pcs_flags & PCS_CARD_PRESENT &&
		    sockets & (1 << cur)) {

			if ((*pcic->irq_current->intr)(pcic->irq_current->arg1,
			    pcic->irq_current->arg2) == DDI_INTR_CLAIMED)
				ret = DDI_INTR_CLAIMED;

#if defined(PCIC_DEBUG)
			pcic_err(pcic->dip, 0xf,
			    "\t ret=%d DDI_INTR_CLAIMED=%d\n",
			    ret, DDI_INTR_CLAIMED);
#endif
		}


		if ((pcic->irq_current = pcic->irq_current->next) == NULL)
					pcic->irq_current = pcic->irq_top;

	    } while (pcic->irq_current != tmp);

	    if ((pcic->irq_current = pcic->irq_current->next) == NULL)
					pcic->irq_current = pcic->irq_top;

	} else {
		ret = DDI_INTR_UNCLAIMED;
	}

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 0xf,
		"pcic_do_io_intr: exit ret=%d DDI_INTR_CLAIMED=%d\n",
		ret, DDI_INTR_CLAIMED);
#endif

	return (ret);

}

/*
 * pcic_inquire_adapter()
 *	SocketServices InquireAdapter function
 *	get characteristics of the physical adapter
 */
/*ARGSUSED*/
static int
pcic_inquire_adapter(dev_info_t *dip, inquire_adapter_t *config)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;

	config->NumSockets = pcic->pc_numsockets;
	config->NumWindows = pcic->pc_numsockets * PCIC_NUMWINSOCK;
	config->NumEDCs = 0;
	config->AdpCaps = 0;
	config->ActiveHigh = 0;
	config->ActiveLow = PCIC_AVAIL_IRQS;
	config->NumPower = pcic->pc_numpower;
	config->power_entry = pcic->pc_power; /* until we resolve this */
#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "pcic_inquire_adapter:\n");
		cmn_err(CE_CONT, "\tNumSockets=%d\n", config->NumSockets);
		cmn_err(CE_CONT, "\tNumWindows=%d\n", config->NumWindows);
	}
#endif
	config->ResourceFlags = 0;
	switch (pcic->pc_intr_mode) {
	case PCIC_INTR_MODE_PCI_1:
		config->ResourceFlags |= RES_OWN_IRQ | RES_IRQ_NEXUS |
			RES_IRQ_SHAREABLE;
		break;
	}
	return (SUCCESS);
}

/*
 * pcic_callback()
 *	The PCMCIA nexus calls us via this function
 *	in order to set the callback function we are
 *	to call the nexus with
 */
/*ARGSUSED*/
static int
pcic_callback(dev_info_t *dip, int (*handler)(), int arg)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;

	if (handler != NULL) {
		pcic->pc_callback = handler;
		pcic->pc_cb_arg  = arg;
		pcic->pc_flags |= PCF_CALLBACK;
	} else {
		pcic->pc_callback = NULL;
		pcic->pc_cb_arg = 0;
		pcic->pc_flags &= ~PCF_CALLBACK;
	}
	/*
	 * we're now registered with the nexus
	 * it is acceptable to do callbacks at this point.
	 * don't call back from here though since it could block
	 */
	return (PC_SUCCESS);
}

/*
 * pcic_calc_speed (pcicdev_t *pcic, uint32_t speed)
 *	calculate the speed bits from the specified memory speed
 *	there may be more to do here
 */

static int
pcic_calc_speed(pcicdev_t *pcic, uint32_t speed)
{
	uint32_t wspeed = 1;	/* assume 1 wait state when unknown */
	uint32_t bspeed = PCIC_ISA_DEF_SYSCLK;

	switch (pcic->pc_type) {
	    case PCIC_I82365SL:
	    case PCIC_VADEM:
	    case PCIC_VADEM_VG469:
	    default:
		/* Intel chip wants it in waitstates */
		wspeed = mhztons(PCIC_ISA_DEF_SYSCLK) * 3;
		if (speed <= wspeed)
			wspeed = 0;
		else if (speed <= (wspeed += mhztons(bspeed)))
			wspeed = 1;
		else if (speed <= (wspeed += mhztons(bspeed)))
			wspeed = 2;
		else
			wspeed = 3;
		wspeed <<= 6; /* put in right bit positions */
		break;

	    case PCIC_INTEL_i82092:
		wspeed = SYSMEM_82092_80NS;
		if (speed > 80)
		    wspeed = SYSMEM_82092_100NS;
		if (speed > 100)
		    wspeed = SYSMEM_82092_150NS;
		if (speed > 150)
		    wspeed = SYSMEM_82092_200NS;
		if (speed > 200)
		    wspeed = SYSMEM_82092_250NS;
		if (speed > 250)
		    wspeed = SYSMEM_82092_600NS;
		wspeed <<= 5;	/* put in right bit positions */
		break;

	} /* switch */

	return (wspeed);
}

/*
 * These values are taken from the PC Card Standard Electrical Specification.
 * Generally the larger value is taken if 2 are possible.
 */
static struct pcic_card_times {
	uint16_t cycle;	/* Speed as found in the atribute space of he card. */
	uint16_t setup;	/* Corresponding address setup time. */
	uint16_t width;	/* Corresponding width, OE or WE. */
	uint16_t hold;	/* Corresponding data or address hold time. */
} pcic_card_times[] = {

/*
 * Note: The rounded up times for 250, 200 & 150 have been increased
 * due to problems with the 3-Com ethernet cards (pcelx) on UBIIi.
 * See BugID 00663.
 */

/*
 * Rounded up times           Original times from
 * that add up to the         the PCMCIA Spec.
 * cycle time.
 */
	{600, 180, 370, 140},	/* 100, 300,  70 */
	{400, 120, 300, 90},	/* Made this one up */
	{250, 100, 190, 70},	/*  30, 150,  30 */
	{200, 80, 170, 70},	/*  20, 120,  30 */
	{150, 50, 110, 40},	/*  20,  80,  20 */
	{100, 40, 80, 40},	/*  10,  60,  15 */
	{0, 10, 60, 15}		/*  10,  60,  15 */
};

/*
 * pcic_set_cdtimers
 *	This is specific to several Cirrus Logic chips
 */
static void
pcic_set_cdtimers(pcicdev_t *pcic, int socket, uint32_t speed, int tset)
{
	int cmd, set, rec, offset, clk_pulse;
	struct pcic_card_times *ctp;

	if ((tset == IOMEM_CLTIMER_SET_1) || (tset == SYSMEM_CLTIMER_SET_1))
		offset = 3;
	else
		offset = 0;

	clk_pulse = mhztons(pcic->bus_speed);
	for (ctp = pcic_card_times; speed < ctp->cycle; ctp++);

	/*
	 * Add (clk_pulse/2) and an extra 1 to account for rounding errors.
	 */
	set = ((ctp->setup + 10 + 1 + (clk_pulse/2))/clk_pulse) - 1;
	if (set < 0)
		set = 0;

	cmd = ((ctp->width + 10 + 1 + (clk_pulse/2))/clk_pulse) - 1;
	if (cmd < 0)
		cmd = 0;

	rec = ((ctp->hold + 10 + 1 + (clk_pulse/2))/clk_pulse) - 2;
	if (rec < 0)
		rec = 0;

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 8, "pcic_set_cdtimers(%d, Timer Set %d)\n"
	    "ct=%d, cp=%d, cmd=0x%x, setup=0x%x, rec=0x%x\n",
	    (unsigned)speed, offset == 3 ? 1 : 0,
	    ctp->cycle, clk_pulse, cmd, set, rec);
#endif

	pcic_putb(pcic, socket, PCIC_TIME_COMMAND_0 + offset, cmd);
	pcic_putb(pcic, socket, PCIC_TIME_SETUP_0 + offset, set);
	pcic_putb(pcic, socket, PCIC_TIME_RECOVER_0 + offset, rec);
}

/*
 * pcic_set_window
 *	essentially the same as the Socket Services specification
 *	We use socket and not adapter since they are identifiable
 *	but the rest is the same
 *
 *	dip	pcic driver's device information
 *	window	parameters for the request
 */
static int
pcic_set_window(dev_info_t *dip, set_window_t *window)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int select;
	int socket, pages, which, ret;
	pcic_socket_t *sockp = &pcic->pc_sockets[window->socket];
	ra_return_t res;
	ndi_ra_request_t req;
	uint32_t base = window->base;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "pcic_set_window: entered\n");
		cmn_err(CE_CONT,
			"\twindow=%d, socket=%d, WindowSize=%d, speed=%d\n",
			window->window, window->socket, window->WindowSize,
			window->speed);
		cmn_err(CE_CONT,
			"\tbase=%x, state=%x\n", (unsigned)window->base,
			(unsigned)window->state);
	}
#endif

	/*
	 * do some basic sanity checking on what we support
	 * we don't do paged mode
	 */
	if (window->state & WS_PAGED) {
		cmn_err(CE_WARN, "pcic_set_window: BAD_ATTRIBUTE\n");
		return (BAD_ATTRIBUTE);
	}

	/*
	 * we don't care about previous mappings.
	 * Card Services will deal with that so don't
	 * even check
	 */

	socket = window->socket;

	if (!(window->state & WS_IO)) {
		int win, tmp;
		pcs_memwin_t *memp;
#if defined(PCIC_DEBUG)
		if (pcic_debug)
			cmn_err(CE_CONT, "\twindow type is memory\n");
#endif
		/* this is memory window mapping */
		win = window->window % PCIC_NUMWINSOCK;
		tmp = window->window / PCIC_NUMWINSOCK;

		/* only windows 2-6 can do memory mapping */
		if (tmp != window->socket || win < PCIC_IOWINDOWS) {
			cmn_err(CE_CONT,
				"\tattempt to map to non-mem window\n");
			return (BAD_WINDOW);
		}

		if (window->WindowSize == 0)
			window->WindowSize = MEM_MIN;
		else if ((window->WindowSize & (PCIC_PAGE-1)) != 0) {
			cmn_err(CE_WARN, "pcic_set_window: BAD_SIZE\n");
			return (BAD_SIZE);
		}

		mutex_enter(&pcic->pc_lock); /* protect the registers */

		memp = &sockp->pcs_windows[win].mem;
		memp->pcw_speed = window->speed;

		win -= PCIC_IOWINDOWS; /* put in right range */

		if (window->WindowSize != memp->pcw_len)
			which = memp->pcw_len;
		else
			which = 0;

		if (window->state & WS_ENABLED) {
			uint32_t wspeed;
#if defined(PCIC_DEBUG)
			if (pcic_debug) {
				cmn_err(CE_CONT,
					"\tbase=%x, win=%d\n", (unsigned)base,
					win);
				if (which)
					cmn_err(CE_CONT,
						"\tneed to remap window\n");
			}
#endif

			if (which && (memp->pcw_status & PCW_MAPPED)) {
				ddi_regs_map_free(&memp->pcw_handle);
				res.ra_addr_lo = memp->pcw_base;
				res.ra_len = memp->pcw_len;
				(void) pcmcia_free_mem(dip, &res);
				memp->pcw_status &= ~(PCW_MAPPED|PCW_ENABLED);
				memp->pcw_hostmem = NULL;
				memp->pcw_base = NULL;
				memp->pcw_len = 0;
			}

			which = window->WindowSize >> PAGE_SHIFT;

			if (!(memp->pcw_status & PCW_MAPPED)) {
				ret = 0;

				memp->pcw_base = base;
				bzero(&req, sizeof (req));
				req.ra_len = which << PAGE_SHIFT;
				req.ra_addr = (uint64_t)memp->pcw_base;
				req.ra_boundbase = pcic->pc_base;
				req.ra_boundlen  = pcic->pc_bound;
				req.ra_flags = (memp->pcw_base ?
					NDI_RA_ALLOC_SPECIFIED : 0) |
					NDI_RA_ALLOC_BOUNDED;
				req.ra_align_mask =
					(PAGESIZE - 1) | (PCIC_PAGE - 1);
#if defined(PCIC_DEBUG)
				    pcic_err(dip, 8,
					    "\tlen 0x%"PRIx64
					    "addr 0x%"PRIx64"bbase 0x%"PRIx64
					    " blen 0x%"PRIx64" flags 0x%x"
					    " algn 0x%"PRIx64"\n",
					    req.ra_len, req.ra_addr,
					    req.ra_boundbase,
					    req.ra_boundlen, req.ra_flags,
					    req.ra_align_mask);
#endif

				ret = pcmcia_alloc_mem(dip, &req, &res);
				if (ret == DDI_FAILURE) {
					mutex_exit(&pcic->pc_lock);
					cmn_err(CE_WARN,
					"\tpcmcia_alloc_mem() failed\n");
					return (BAD_SIZE);
				}
				memp->pcw_base = res.ra_addr_lo;
				base = memp->pcw_base;

#if defined(PCIC_DEBUG)
				if (pcic_debug)
					cmn_err(CE_CONT,
						"\tsetwindow: new base=%x\n",
						(unsigned)memp->pcw_base);
#endif
				memp->pcw_len = window->WindowSize;

				which = pcmcia_map_reg(pcic->dip,
						window->child,
						&res,
						(uint32_t)(window->state &
						    0xffff) |
						    (window->socket << 16),
						(caddr_t *)&memp->pcw_hostmem,
						&memp->pcw_handle,
						&window->attr, NULL);

				if (which != DDI_SUCCESS) {

					cmn_err(CE_WARN, "\tpcmcia_map_reg() "
						"failed\n");

				    res.ra_addr_lo = memp->pcw_base;
				    res.ra_len = memp->pcw_len;
				    (void) pcmcia_free_mem(pcic->dip, &res);

				    mutex_exit(&pcic->pc_lock);

				    return (BAD_WINDOW);
				}
				memp->pcw_status |= PCW_MAPPED;
#if defined(PCIC_DEBUG)
				if (pcic_debug)
					cmn_err(CE_CONT,
						"\tmap=%x, hostmem=%p\n",
						which,
						(void *)memp->pcw_hostmem);
#endif
			} else {
				base = memp->pcw_base;
			}

			/* report the handle back to caller */
			window->handle = memp->pcw_handle;

#if defined(PCIC_DEBUG)
			if (pcic_debug) {
				cmn_err(CE_CONT,
					"\twindow mapped to %x@%x len=%d\n",
					(unsigned)window->base,
					(unsigned)memp->pcw_base,
					memp->pcw_len);
			}
#endif

			/* find the register set offset */
			select = win * PCIC_MEM_1_OFFSET;
#if defined(PCIC_DEBUG)
			if (pcic_debug)
				cmn_err(CE_CONT, "\tselect=%x\n", select);
#endif

			/*
			 * at this point, the register window indicator has
			 * been converted to be an offset from the first
			 * set of registers that are used for programming
			 * the window mapping and the offset used to select
			 * the correct set of registers to access the
			 * specified socket.  This allows basing everything
			 * off the _0 window
			 */

			/* map the physical page base address */
			which = (window->state & WS_16BIT) ? SYSMEM_DATA_16 : 0;
			which |= (window->speed <= MEM_SPEED_MIN) ?
				SYSMEM_ZERO_WAIT : 0;

			/* need to select register set */
			select = PCIC_MEM_1_OFFSET * win;

			pcic_putb(pcic, socket,
					PCIC_SYSMEM_0_STARTLOW + select,
					SYSMEM_LOW(base));
			pcic_putb(pcic, socket,
					PCIC_SYSMEM_0_STARTHI + select,
					SYSMEM_HIGH(base) | which);

			/*
			 * Some adapters can decode window addresses greater
			 * than 16-bits worth, so handle them here.
			 */
			switch (pcic->pc_type) {
			case PCIC_INTEL_i82092:
				pcic_putb(pcic, socket,
						PCIC_82092_CPAGE,
						SYSMEM_EXT(base));
				break;
			case PCIC_CL_PD6729:
			case PCIC_CL_PD6730:
				clext_reg_write(pcic, socket,
						PCIC_CLEXT_MMAP0_UA + win,
						SYSMEM_EXT(base));
				break;
			case PCIC_TI_PCI1130:
				/*
				 * Note that the TI chip has one upper byte
				 * per socket so all windows get bound to a
				 * 16MB segment.  This must be detected and
				 * handled appropriately.  We can detect that
				 * it is done by seeing if the pc_base has
				 * changed and changing when the register
				 * is first set.  This will force the bounds
				 * to be correct.
				 */
				if (pcic->pc_bound == 0xffffffff) {
					pcic_putb(pcic, socket,
						    PCIC_TI_WINDOW_PAGE_PCI,
						    SYSMEM_EXT(base));
					pcic->pc_base = SYSMEM_EXT(base) << 24;
					pcic->pc_bound = 0x1000000;
				}
				break;
			case PCIC_TI_PCI1031:
			case PCIC_TI_PCI1131:
			case PCIC_TI_PCI1250:
			case PCIC_TI_PCI1225:
			case PCIC_TI_PCI1221:
			case PCIC_SMC_34C90:
			case PCIC_CL_PD6832:
			case PCIC_RICOH_RL5C466:
			case PCIC_TI_PCI1410:
			case PCIC_ENE_1410:
			case PCIC_TI_PCI1510:
			case PCIC_TI_PCI1520:
			case PCIC_O2_OZ6912:
			case PCIC_TI_PCI1420:
			case PCIC_ENE_1420:
			case PCIC_TI_VENDOR:
			case PCIC_TOSHIBA_TOPIC100:
			case PCIC_TOSHIBA_TOPIC95:
			case PCIC_TOSHIBA_VENDOR:
			case PCIC_RICOH_VENDOR:
			case PCIC_O2MICRO_VENDOR:
				pcic_putb(pcic, socket,
						PCIC_YENTA_MEM_PAGE + win,
						SYSMEM_EXT(base));
				break;
			default:
				cmn_err(CE_NOTE, "pcic_set_window: unknown "
						"cardbus vendor:0x%X\n",
						pcic->pc_type);
				pcic_putb(pcic, socket,
						PCIC_YENTA_MEM_PAGE + win,
						SYSMEM_EXT(base));

				break;
			} /* switch */

			/*
			 * specify the length of the mapped range
			 * we convert to pages (rounding up) so that
			 * the hardware gets the right thing
			 */
			pages = (window->WindowSize+PCIC_PAGE-1)/PCIC_PAGE;

			/*
			 * Setup this window's timing.
			 */
			switch (pcic->pc_type) {
			case PCIC_CL_PD6729:
			case PCIC_CL_PD6730:
			case PCIC_CL_PD6710:
			case PCIC_CL_PD6722:
				wspeed = SYSMEM_CLTIMER_SET_0;
				pcic_set_cdtimers(pcic, socket,
							window->speed,
							wspeed);
				break;

			case PCIC_INTEL_i82092:
			default:
				wspeed = pcic_calc_speed(pcic, window->speed);
				break;
			} /* switch */

#if defined(PCIC_DEBUG)
			if (pcic_debug)
				cmn_err(CE_CONT,
					"\twindow %d speed bits = %x for "
					"%dns\n",
					win, (unsigned)wspeed, window->speed);
#endif

			pcic_putb(pcic, socket, PCIC_SYSMEM_0_STOPLOW + select,
					SYSMEM_LOW(base +
						    (pages * PCIC_PAGE)-1));

			wspeed |= SYSMEM_HIGH(base + (pages * PCIC_PAGE)-1);
			pcic_putb(pcic, socket, PCIC_SYSMEM_0_STOPHI + select,
					wspeed);

			/*
			 * now map the card's memory pages - we start with page
			 * 0
			 * we also default to AM -- set page might change it
			 */
			base = memp->pcw_base;
			pcic_putb(pcic, socket,
					PCIC_CARDMEM_0_LOW + select,
					CARDMEM_LOW(0 - (uint32_t)base));

			pcic_putb(pcic, socket,
					PCIC_CARDMEM_0_HI + select,
					CARDMEM_HIGH(0 - (uint32_t)base) |
					CARDMEM_REG_ACTIVE);

			/*
			 * enable the window even though redundant
			 * and SetPage may do it again.
			 */
			select = pcic_getb(pcic, socket,
					PCIC_MAPPING_ENABLE);
			select |= SYSMEM_WINDOW(win);
			pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE, select);
			memp->pcw_offset = 0;
			memp->pcw_status |= PCW_ENABLED;
		} else {
			/*
			 * not only do we unmap the memory, the
			 * window has been turned off.
			 */
			if (which && memp->pcw_status & PCW_MAPPED) {
				ddi_regs_map_free(&memp->pcw_handle);
				res.ra_addr_lo = memp->pcw_base;
				res.ra_len = memp->pcw_len;
				(void) pcmcia_free_mem(pcic->dip, &res);
				memp->pcw_hostmem = NULL;
				memp->pcw_status &= ~PCW_MAPPED;
			}

			/* disable current mapping */
			select = pcic_getb(pcic, socket, PCIC_MAPPING_ENABLE);
			select &= ~SYSMEM_WINDOW(win);
			pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE, select);
			memp->pcw_status &= ~PCW_ENABLED;
		}
		memp->pcw_len = window->WindowSize;
		window->handle = memp->pcw_handle;
#if defined(PCIC_DEBUG)
		if (pcic_debug)
			xxdmp_all_regs(pcic, window->socket, -1);
#endif
	} else {
		/*
		 * This is a request for an IO window
		 */
		int win, tmp;
		pcs_iowin_t *winp;
				/* I/O windows */
#if defined(PCIC_DEBUG)
		if (pcic_debug)
			cmn_err(CE_CONT, "\twindow type is I/O\n");
#endif

		/* only windows 0 and 1 can do I/O */
		win = window->window % PCIC_NUMWINSOCK;
		tmp = window->window / PCIC_NUMWINSOCK;

		if (win >= PCIC_IOWINDOWS || tmp != window->socket) {
			cmn_err(CE_WARN,
				"\twindow is out of range (%d)\n",
				window->window);
			return (BAD_WINDOW);
		}

		mutex_enter(&pcic->pc_lock); /* protect the registers */

		winp = &sockp->pcs_windows[win].io;
		winp->pcw_speed = window->speed;
		if (window->WindowSize != 1 && window->WindowSize & 1) {
			/* we don't want an odd-size window */
			window->WindowSize++;
		}
		winp->pcw_len = window->WindowSize;

		if (window->state & WS_ENABLED) {
			if (winp->pcw_status & PCW_MAPPED) {
				ddi_regs_map_free(&winp->pcw_handle);
				res.ra_addr_lo = winp->pcw_base;
				res.ra_len = winp->pcw_len;
				(void) pcmcia_free_io(pcic->dip, &res);
				winp->pcw_status &= ~(PCW_MAPPED|PCW_ENABLED);
			}

			/*
			 * if the I/O address wasn't allocated, allocate
			 *	it now. If it was allocated, it better
			 *	be free to use.
			 * The winp->pcw_offset value is set and used
			 *	later on if the particular adapter
			 *	that we're running on has the ability
			 *	to translate IO accesses to the card
			 *	(such as some adapters  in the Cirrus
			 *	Logic family).
			 */
			winp->pcw_offset = 0;

			/*
			 * Setup the request parameters for the
			 *	requested base and length. If
			 *	we're on an adapter that has
			 *	IO window offset registers, then
			 *	we don't need a specific base
			 *	address, just a length, and then
			 *	we'll cause the correct IO address
			 *	to be generated on the socket by
			 *	setting up the IO window offset
			 *	registers.
			 * For adapters that support this capability, we
			 *	always use the IO window offset registers,
			 *	even if the passed base/length would be in
			 *	range.
			 */
			base = window->base;
			bzero(&req, sizeof (req));
			req.ra_len = window->WindowSize;

			req.ra_addr = (uint64_t)
				((pcic->pc_flags & PCF_IO_REMAP) ? 0 : base);
			req.ra_flags = (req.ra_addr) ?
						NDI_RA_ALLOC_SPECIFIED : 0;

			req.ra_flags |= NDI_RA_ALIGN_SIZE;
			/* need to rethink this */
			req.ra_boundbase = pcic->pc_iobase;
			req.ra_boundlen = pcic->pc_iobound;
			req.ra_flags |= NDI_RA_ALLOC_BOUNDED;

#if defined(PCIC_DEBUG)
			    pcic_err(dip, 8,
					"\tlen 0x%"PRIx64" addr 0x%"PRIx64
					"bbase 0x%"PRIx64
					"blen 0x%"PRIx64" flags 0x%x algn 0x%"
					PRIx64"\n",
					req.ra_len, (uint64_t)req.ra_addr,
					req.ra_boundbase,
					req.ra_boundlen, req.ra_flags,
					req.ra_align_mask);
#endif

			/*
			 * Try to allocate the space. If we fail this,
			 *	return the appropriate error depending
			 *	on whether the caller specified a
			 *	specific base address or not.
			 */
			if (pcmcia_alloc_io(dip, &req, &res) == DDI_FAILURE) {
				winp->pcw_status &= ~PCW_ENABLED;
				mutex_exit(&pcic->pc_lock);
				cmn_err(CE_WARN, "Failed to alloc I/O:\n"
					"\tlen 0x%" PRIx64 " addr 0x%" PRIx64
					"bbase 0x%" PRIx64
					"blen 0x%" PRIx64 "flags 0x%x"
					"algn 0x%" PRIx64 "\n",
					req.ra_len, req.ra_addr,
					req.ra_boundbase,
					req.ra_boundlen, req.ra_flags,
					req.ra_align_mask);

				return (base?BAD_BASE:BAD_SIZE);
			} /* pcmcia_alloc_io */

			/*
			 * Don't change the original base. Either we use
			 * the offset registers below (PCF_IO_REMAP is set)
			 * or it was allocated correctly anyway.
			 */
			winp->pcw_base = res.ra_addr_lo;

#if defined(PCIC_DEBUG)
			    pcic_err(dip, 8,
				    "\tsetwindow: new base=%x orig base 0x%x\n",
				    (unsigned)winp->pcw_base, base);
#endif

			if ((which = pcmcia_map_reg(pcic->dip,
						window->child,
						&res,
						(uint32_t)(window->state &
						    0xffff) |
						    (window->socket << 16),
						(caddr_t *)&winp->pcw_hostmem,
						&winp->pcw_handle,
						&window->attr,
						base)) != DDI_SUCCESS) {

					cmn_err(CE_WARN, "pcmcia_map_reg()"
						"failed\n");

				    res.ra_addr_lo = winp->pcw_base;
				    res.ra_len = winp->pcw_len;
				    (void) pcmcia_free_io(pcic->dip, &res);

				    mutex_exit(&pcic->pc_lock);
				    return (BAD_WINDOW);
			}

			window->handle = winp->pcw_handle;
			winp->pcw_status |= PCW_MAPPED;

			/* find the register set offset */
			select = win * PCIC_IO_OFFSET;

#if defined(PCIC_DEBUG)
			if (pcic_debug) {
				cmn_err(CE_CONT,
					"\tenable: window=%d, select=%x, "
					"base=%x, handle=%p\n",
					win, select,
					(unsigned)window->base,
					(void *)window->handle);
			}
#endif
			/*
			 * at this point, the register window indicator has
			 * been converted to be an offset from the first
			 * set of registers that are used for programming
			 * the window mapping and the offset used to select
			 * the correct set of registers to access the
			 * specified socket.  This allows basing everything
			 * off the _0 window
			 */

			/* map the I/O base in */
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STARTLOW + select,
					LOW_BYTE((uint32_t)winp->pcw_base));
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STARTHI + select,
					HIGH_BYTE((uint32_t)winp->pcw_base));

			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STOPLOW + select,
					LOW_BYTE((uint32_t)winp->pcw_base +
						window->WindowSize - 1));
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STOPHI + select,
					HIGH_BYTE((uint32_t)winp->pcw_base +
						window->WindowSize - 1));

			/*
			 * We've got the requested IO space, now see if we
			 *	need to adjust the IO window offset registers
			 *	so that the correct IO address is generated
			 *	at the socket. If this window doesn't have
			 *	this capability, then we're all done setting
			 *	up the IO resources.
			 */
			if (pcic->pc_flags & PCF_IO_REMAP) {


				/*
				 * Note that only 16 bits are used to program
				 * the registers but leave 32 bits on pcw_offset
				 * so that we can generate the original base
				 * in get_window()
				 */
				winp->pcw_offset = (base - winp->pcw_base);

				pcic_putb(pcic, socket,
					PCIC_IO_OFFSET_LOW +
					(win * PCIC_IO_OFFSET_OFFSET),
					winp->pcw_offset & 0x0ff);
				pcic_putb(pcic, socket,
					PCIC_IO_OFFSET_HI +
					(win * PCIC_IO_OFFSET_OFFSET),
					(winp->pcw_offset >> 8) & 0x0ff);

			} /* PCF_IO_REMAP */

			/* now get the other details (size, etc) right */

			/*
			 * Set the data size control bits here. Most of the
			 *	adapters will ignore IOMEM_16BIT when
			 *	IOMEM_IOCS16 is set, except for the Intel
			 *	82092, which only pays attention to the
			 *	IOMEM_16BIT bit. Sigh... Intel can't even
			 *	make a proper clone of their own chip.
			 * The 82092 also apparently can't set the timing
			 *	of I/O windows.
			 */
			which = (window->state & WS_16BIT) ?
					(IOMEM_16BIT | IOMEM_IOCS16) : 0;

			switch (pcic->pc_type) {
			case PCIC_CL_PD6729:
			case PCIC_CL_PD6730:
			case PCIC_CL_PD6710:
			case PCIC_CL_PD6722:
			case PCIC_CL_PD6832:
				/*
				 * Select Timer Set 1 - this will take
				 *	effect when the PCIC_IO_CONTROL
				 *	register is written to later on;
				 *	the call to pcic_set_cdtimers
				 *	just sets up the timer itself.
				 */
				which |= IOMEM_CLTIMER_SET_1;
				pcic_set_cdtimers(pcic, socket,
							window->speed,
							IOMEM_CLTIMER_SET_1);
				which |= IOMEM_IOCS16;
				break;
			case PCIC_TI_PCI1031:

				if (window->state & WS_16BIT)
				    which |= IOMEM_WAIT16;

				break;
			case PCIC_TI_PCI1130:

				if (window->state & WS_16BIT)
				    which |= IOMEM_WAIT16;

				break;
			case PCIC_INTEL_i82092:
				break;
			default:
				if (window->speed >
						mhztons(pcic->bus_speed) * 3)
				    which |= IOMEM_WAIT16;
#ifdef notdef
				if (window->speed <
						mhztons(pcic->bus_speed) * 6)
				    which |= IOMEM_ZERO_WAIT;
#endif
				break;
			} /* switch (pc_type) */

			/*
			 * Setup the data width and timing
			 */
			select = pcic_getb(pcic, socket, PCIC_IO_CONTROL);
			select &= ~(PCIC_IO_WIN_MASK << (win * 4));
			select |= IOMEM_SETWIN(win, which);
			pcic_putb(pcic, socket, PCIC_IO_CONTROL, select);

			/*
			 * Enable the IO window
			 */
			select = pcic_getb(pcic, socket, PCIC_MAPPING_ENABLE);
			pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE,
						select | IOMEM_WINDOW(win));

			winp->pcw_status |= PCW_ENABLED;

#if defined(PCIC_DEBUG)
			if (pcic_debug) {
				cmn_err(CE_CONT,
					"\twhich = %x, select = %x (%x)\n",
					which, select,
					IOMEM_SETWIN(win, which));
				xxdmp_all_regs(pcic, window->socket * 0x40, 24);
			}
#endif
		} else {
			/*
			 * not only do we unmap the IO space, the
			 * window has been turned off.
			 */
			if (winp->pcw_status & PCW_MAPPED) {
				ddi_regs_map_free(&winp->pcw_handle);
				res.ra_addr_lo = winp->pcw_base;
				res.ra_len = winp->pcw_len;
				(void) pcmcia_free_io(pcic->dip, &res);
				winp->pcw_status &= ~PCW_MAPPED;
			}

			/* disable current mapping */
			select = pcic_getb(pcic, socket,
						PCIC_MAPPING_ENABLE);
			pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE,
					select &= ~IOMEM_WINDOW(win));
			winp->pcw_status &= ~PCW_ENABLED;

			winp->pcw_base = 0;
			winp->pcw_len = 0;
			winp->pcw_offset = 0;
			window->base = 0;
			/* now make sure we don't accidentally re-enable */
			/* find the register set offset */
			select = win * PCIC_IO_OFFSET;
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STARTLOW + select, 0);
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STARTHI + select, 0);
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STOPLOW + select, 0);
			pcic_putb(pcic, socket,
					PCIC_IO_ADDR_0_STOPHI + select, 0);
		}
	}
	mutex_exit(&pcic->pc_lock);

	return (SUCCESS);
}

/*
 * pcic_card_state()
 *	compute the instantaneous Card State information
 */
static int
pcic_card_state(pcicdev_t *pcic, pcic_socket_t *sockp)
{
	int value, result;
#if defined(PCIC_DEBUG)
	int orig_value;
#endif

	mutex_enter(&pcic->pc_lock); /* protect the registers */

	value = pcic_getb(pcic, sockp->pcs_socket, PCIC_INTERFACE_STATUS);

#if defined(PCIC_DEBUG)
	orig_value = value;
	if (pcic_debug >= 8)
		cmn_err(CE_CONT, "pcic_card_state(%p) if status = %b for %d\n",
			(void *)sockp,
			value,
			"\020\1BVD1\2BVD2\3CD1\4CD2\5WP\6RDY\7PWR\10~GPI",
			sockp->pcs_socket);
#endif
	/*
	 * Lie to socket services if we are not ready.
	 * This is when we are starting up or during debounce timeouts
	 * or if the card is a cardbus card.
	 */
	if (!(sockp->pcs_flags & (PCS_STARTING|PCS_CARD_ISCARDBUS)) &&
	    !sockp->pcs_debounce_id &&
	    (value & PCIC_ISTAT_CD_MASK) == PCIC_CD_PRESENT_OK) {
		result = SBM_CD;

		if (value & PCIC_WRITE_PROTECT || !(value & PCIC_POWER_ON))
			result |= SBM_WP;
		if (value & PCIC_POWER_ON) {
			if (value & PCIC_READY)
				result |= SBM_RDYBSY;
			value = (~value) & (PCIC_BVD1 | PCIC_BVD2);
			if (value & PCIC_BVD1)
				result |= SBM_BVD1;
			if (value & PCIC_BVD2)
				result |= SBM_BVD2;
		}
	} else
		result = 0;

	mutex_exit(&pcic->pc_lock);

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 8,
	    "pcic_card_state(%p) if status = %b for %d (rval=0x%x)\n",
	    (void *) sockp, orig_value,
	    "\020\1BVD1\2BVD2\3CD1\4CD2\5WP\6RDY\7PWR\10~GPI",
	    sockp->pcs_socket, result);
#endif

	return (result);
}

/*
 * pcic_set_page()
 *	SocketServices SetPage function
 *	set the page of PC Card memory that should be in the mapped
 *	window
 */
/*ARGSUSED*/
static int
pcic_set_page(dev_info_t *dip, set_page_t *page)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int select;
	int which, socket, window;
	uint32_t base;
	pcs_memwin_t *memp;

	/* get real socket/window numbers */
	window = page->window % PCIC_NUMWINSOCK;
	socket = page->window / PCIC_NUMWINSOCK;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
			"pcic_set_page: window=%d, socket=%d, page=%d\n",
			window, socket, page->page);
	}
#endif
	/* only windows 2-6 work on memory */
	if (window < PCIC_IOWINDOWS)
		return (BAD_WINDOW);

	/* only one page supported (but any size) */
	if (page->page != 0)
		return (BAD_PAGE);

	mutex_enter(&pcic->pc_lock); /* protect the registers */

	memp = &pcic->pc_sockets[socket].pcs_windows[window].mem;
	window -= PCIC_IOWINDOWS;

#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "\tpcw_base=%x, pcw_hostmem=%p, pcw_len=%x\n",
			(uint32_t)memp->pcw_base,
			(void *)memp->pcw_hostmem, memp->pcw_len);
#endif

	/* window must be enabled */
	if (!(memp->pcw_status & PCW_ENABLED))
		return (BAD_ATTRIBUTE);

	/* find the register set offset */
	select = window * PCIC_MEM_1_OFFSET;
#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "\tselect=%x\n", select);
#endif

	/*
	 * now map the card's memory pages - we start with page 0
	 */

	which = 0;		/* assume simple case */
	if (page->state & PS_ATTRIBUTE) {
		which |= CARDMEM_REG_ACTIVE;
		memp->pcw_status |= PCW_ATTRIBUTE;
	} else {
		memp->pcw_status &= ~PCW_ATTRIBUTE;
	}

	/*
	 * if caller says Write Protect, enforce it.
	 */
	if (page->state & PS_WP) {
		which |= CARDMEM_WRITE_PROTECT;
		memp->pcw_status |= PCW_WP;
	} else {
		memp->pcw_status &= ~PCW_WP;
	}
#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "\tmemory type = %s\n",
			(which & CARDMEM_REG_ACTIVE) ? "attribute" : "common");
		if (which & CARDMEM_WRITE_PROTECT)
			cmn_err(CE_CONT, "\twrite protect\n");
		cmn_err(CE_CONT, "\tpage offset=%x pcw_base=%x (%x)\n",
			(unsigned)page->offset,
			(unsigned)memp->pcw_base,
			(int)page->offset - (int)memp->pcw_base & 0xffffff);
	}
#endif
	/* address computation based on 64MB range and not larger */
	base = (uint32_t)memp->pcw_base & 0x3ffffff;
	pcic_putb(pcic, socket, PCIC_CARDMEM_0_LOW + select,
	    CARDMEM_LOW((int)page->offset - (int)base));
	(void) pcic_getb(pcic, socket, PCIC_CARDMEM_0_LOW + select);
	pcic_putb(pcic, socket, PCIC_CARDMEM_0_HI + select,
	    CARDMEM_HIGH((int)page->offset - base) | which);
	(void) pcic_getb(pcic, socket, PCIC_CARDMEM_0_HI + select);

	/*
	 * while not really necessary, this just makes sure
	 * nothing turned the window off behind our backs
	 */
	which = pcic_getb(pcic, socket, PCIC_MAPPING_ENABLE);
	which |= SYSMEM_WINDOW(window);
	pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE, which);
	(void) pcic_getb(pcic, socket, PCIC_MAPPING_ENABLE);

	memp->pcw_offset = (off_t)page->offset;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "\tbase=%p, *base=%x\n",
			(void *)memp->pcw_hostmem,
			(uint32_t)*memp->pcw_hostmem);

		xxdmp_all_regs(pcic, socket, -1);

		cmn_err(CE_CONT, "\tbase=%p, *base=%x\n",
			(void *)memp->pcw_hostmem,
			(uint32_t)*memp->pcw_hostmem);
	}
#endif

	if (which & PCW_ATTRIBUTE)
		pcic_mswait(pcic, socket, 2);

	mutex_exit(&pcic->pc_lock);

	return (SUCCESS);
}

/*
 * pcic_set_vcc_level()
 *
 *	set voltage based on adapter information
 *
 *	this routine implements a limited solution for support of 3.3v cards.
 *	the general solution, which would fully support the pcmcia spec
 *	as far as allowing client drivers to request which voltage levels
 *	to be set, requires more framework support and driver changes - ess
 */
static int
pcic_set_vcc_level(pcicdev_t *pcic, set_socket_t *socket)
{
	uint32_t socket_present_state;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
			"pcic_set_vcc_level(pcic=%p, VccLevel=%d)\n",
			(void *)pcic, socket->VccLevel);
	}
#endif

	/*
	 * check VccLevel
	 * if this is zero, power is being turned off
	 * if it is non-zero, power is being turned on.
	 */
	if (socket->VccLevel == 0) {
		return (0);
	}

	/*
	 * range checking for sanity's sake
	 */
	if (socket->VccLevel >= pcic->pc_numpower) {
		return (BAD_VCC);
	}

	switch (pcic->pc_io_type) {
	/*
	 * Yenta-compliant adapters have vcc info in the extended registers
	 * Other adapters can be added as needed, but the 'default' case
	 * has been left as it was previously so as not to break existing
	 * adapters.
	 */
	case PCIC_IO_TYPE_YENTA:
		/*
		 * Here we ignore the VccLevel passed in and read the
		 * card type from the adapter socket present state register
		 */
		socket_present_state =
			ddi_get32(pcic->handle, (uint32_t *)(pcic->ioaddr +
				PCIC_PRESENT_STATE_REG));
#if defined(PCIC_DEBUG)
		if (pcic_debug) {
			cmn_err(CE_CONT,
				"socket present state = 0x%x\n",
				socket_present_state);
		}
#endif
		switch (socket_present_state & PCIC_VCC_MASK) {
			case PCIC_VCC_3VCARD:
				/* fall through */
			case PCIC_VCC_3VCARD|PCIC_VCC_5VCARD:
				socket->VccLevel = PCIC_VCC_3VLEVEL;
				return
				    (POWER_3VCARD_ENABLE|POWER_OUTPUT_ENABLE);
			case PCIC_VCC_5VCARD:
				socket->VccLevel = PCIC_VCC_5VLEVEL;
				return
				    (POWER_CARD_ENABLE|POWER_OUTPUT_ENABLE);
			default:
				/*
				 * if no card is present, this can be the
				 * case of a client making a SetSocket call
				 * after card removal. In this case we return
				 * the current power level
				 */
				return ((unsigned)ddi_get8(pcic->handle,
				    pcic->ioaddr + CB_R2_OFFSET +
					PCIC_POWER_CONTROL));
		}

	default:

		switch (socket->VccLevel) {
		case PCIC_VCC_3VLEVEL:
			return (BAD_VCC);
		case PCIC_VCC_5VLEVEL:
			/* enable Vcc */
			return (POWER_CARD_ENABLE|POWER_OUTPUT_ENABLE);
		default:
			return (BAD_VCC);
		}
	}
}


/*
 * pcic_set_socket()
 *	Socket Services SetSocket call
 *	sets basic socket configuration
 */
static int
pcic_set_socket(dev_info_t *dip, set_socket_t *socket)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	pcic_socket_t *sockp = &pcic->pc_sockets[socket->socket];
	int irq, interrupt, mirq;
	int powerlevel = 0;
	int ind, value, orig_pwrctl;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
		    "pcic_set_socket(dip=%p, socket=%d)"
		    " Vcc=%d Vpp1=%d Vpp2=%d\n", (void *)dip,
		    socket->socket, socket->VccLevel, socket->Vpp1Level,
		    socket->Vpp2Level);
	}
#endif
	/*
	 * check VccLevel, etc. before setting mutex
	 * if this is zero, power is being turned off
	 * if it is non-zero, power is being turned on.
	 * the default case is to assume Vcc only.
	 */

	/* this appears to be very implementation specific */

	if (socket->Vpp1Level != socket->Vpp2Level)
		return (BAD_VPP);

	if (socket->VccLevel == 0 || !(sockp->pcs_flags & PCS_CARD_PRESENT)) {
		powerlevel = 0;
		sockp->pcs_vcc = 0;
		sockp->pcs_vpp1 = 0;
		sockp->pcs_vpp2 = 0;
	} else {
#if defined(PCIC_DEBUG)
		pcic_err(dip, 9, "\tVcc=%d Vpp1Level=%d, Vpp2Level=%d\n",
		    socket->VccLevel, socket->Vpp1Level, socket->Vpp2Level);
#endif
		/* valid Vcc power level? */
		if (socket->VccLevel >= pcic->pc_numpower)
			return (BAD_VCC);

		switch (pcic_power[socket->VccLevel].PowerLevel) {
		case 33:	/* 3.3V */
		case 60:	/* for bad CIS in Option GPRS card */
			if (!(pcic->pc_flags & PCF_33VCAP)) {
				cmn_err(CE_WARN,
				    "%s%d: Bad Request for 3.3V "
				    "(Controller incapable)\n",
				    ddi_get_name(pcic->dip),
				    ddi_get_instance(pcic->dip));
				return (BAD_VCC);
			}
			/* FALLTHROUGH */
		case 50:	/* 5V */
			if ((pcic->pc_io_type == PCIC_IO_TYPE_YENTA) &&
			    pcic_getcb(pcic, CB_PRESENT_STATE) &
			    CB_PS_33VCARD) {
				/*
				 * This is actually a 3.3V card.
				 * Solaris Card Services
				 * doesn't understand 3.3V
				 * so we cheat and change
				 * the setting to the one appropriate to 3.3V.
				 * Note that this is the entry number
				 * in the pcic_power[] array.
				 */
				sockp->pcs_vcc = PCIC_VCC_3VLEVEL;
			} else
				sockp->pcs_vcc = socket->VccLevel;
			break;
		default:
			return (BAD_VCC);
		}

		/* enable Vcc */
		powerlevel = POWER_CARD_ENABLE;

#if defined(PCIC_DEBUG)
		if (pcic_debug) {
			cmn_err(CE_CONT, "\tVcc=%d powerlevel=%x\n",
			    socket->VccLevel, powerlevel);
		}
#endif
		ind = 0;		/* default index to 0 power */
		if ((int)socket->Vpp1Level >= 0 &&
		    socket->Vpp1Level < pcic->pc_numpower) {
			if (!(pcic_power[socket->Vpp1Level].ValidSignals
			    & VPP1)) {
				return (BAD_VPP);
			}
			ind = pcic_power[socket->Vpp1Level].PowerLevel/10;
			powerlevel |= pcic_vpp_levels[ind];
			sockp->pcs_vpp1 = socket->Vpp1Level;
		}
		if ((int)socket->Vpp2Level >= 0 &&
		    socket->Vpp2Level < pcic->pc_numpower) {
			if (!(pcic_power[socket->Vpp2Level].ValidSignals
			    & VPP2)) {
				return (BAD_VPP);
			}
			ind = pcic_power[socket->Vpp2Level].PowerLevel/10;
			powerlevel |= (pcic_vpp_levels[ind] << 2);
			sockp->pcs_vpp2 = socket->Vpp2Level;
		}

		if (pcic->pc_flags & PCF_VPPX) {
			/*
			 * this adapter doesn't allow separate Vpp1/Vpp2
			 * if one is turned on, both are turned on and only
			 * the Vpp1 bits should be set
			 */
			if (sockp->pcs_vpp2 != sockp->pcs_vpp1) {
				/* must be the same if one not zero */
				if (sockp->pcs_vpp1 != 0 &&
				    sockp->pcs_vpp2 != 0) {
					cmn_err(CE_WARN,
					    "%s%d: Bad Power Request "
					    "(Vpp1/2 not the same)\n",
					    ddi_get_name(pcic->dip),
					    ddi_get_instance(pcic->dip));
					return (BAD_VPP);
				}
			}
			powerlevel &= ~(3<<2);
		}

#if defined(PCIC_DEBUG)
		if (pcic_debug) {
			cmn_err(CE_CONT, "\tpowerlevel=%x, ind=%x\n",
			    powerlevel, ind);
		}
#endif
	}
	mutex_enter(&pcic->pc_lock); /* protect the registers */

	/* turn socket->IREQRouting off while programming */
	interrupt = pcic_getb(pcic, socket->socket, PCIC_INTERRUPT);
	interrupt &= ~PCIC_INTR_MASK;
	if (pcic->pc_flags & PCF_USE_SMI)
		interrupt |= PCIC_INTR_ENABLE;
	pcic_putb(pcic, socket->socket, PCIC_INTERRUPT, interrupt);

	switch (pcic->pc_type) {
	    case PCIC_INTEL_i82092:
		pcic_82092_smiirq_ctl(pcic, socket->socket, PCIC_82092_CTL_IRQ,
						PCIC_82092_INT_DISABLE);
		break;
	    default:
		break;
	} /* switch */

	/* the SCIntMask specifies events to detect */
	mirq = pcic_getb(pcic, socket->socket, PCIC_MANAGEMENT_INT);

#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT,
			"\tSCIntMask=%x, interrupt=%x, mirq=%x\n",
			socket->SCIntMask, interrupt, mirq);
#endif
	mirq &= ~(PCIC_BD_DETECT|PCIC_BW_DETECT|PCIC_RD_DETECT);
	pcic_putb(pcic, socket->socket, PCIC_MANAGEMENT_INT,
	    mirq & ~PCIC_CHANGE_MASK);

	/* save the mask we want to use */
	sockp->pcs_intmask = socket->SCIntMask;

	/*
	 * Until there is a card present it's not worth enabling
	 * any interrupts except "Card detect". This is done
	 * elsewhere in the driver so don't change things if
	 * there is no card!
	 */
	if (sockp->pcs_flags & PCS_CARD_PRESENT) {

		/* now update the hardware to reflect events desired */
		if (sockp->pcs_intmask & SBM_BVD1 || socket->IFType == IF_IO)
			mirq |= PCIC_BD_DETECT;

		if (sockp->pcs_intmask & SBM_BVD2)
			mirq |= PCIC_BW_DETECT;

		if (sockp->pcs_intmask & SBM_RDYBSY)
			mirq |= PCIC_RD_DETECT;

		if (sockp->pcs_intmask & SBM_CD)
			mirq |= PCIC_CD_DETECT;
	}

	if (sockp->pcs_flags & PCS_READY) {
		/*
		 * card just came ready.
		 * make sure enough time elapses
		 * before touching it.
		 */
		sockp->pcs_flags &= ~PCS_READY;
		pcic_mswait(pcic, socket->socket, 10);
	}

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "\tstatus change set to %x\n", mirq);
	}
#endif

	switch (pcic->pc_type) {
	    case PCIC_I82365SL:
	    case PCIC_VADEM:
	    case PCIC_VADEM_VG469:
		/*
		 * The Intel version has different options. This is a
		 * special case of GPI which might be used for eject
		 */

		irq = pcic_getb(pcic, socket->socket, PCIC_CARD_DETECT);
		if (sockp->pcs_intmask & (SBM_EJECT|SBM_INSERT) &&
		    pcic->pc_flags & PCF_GPI_EJECT) {
			irq |= PCIC_GPI_ENABLE;
		} else {
			irq &= ~PCIC_GPI_ENABLE;
		}
		pcic_putb(pcic, socket->socket, PCIC_CARD_DETECT, irq);
		break;
	    case PCIC_CL_PD6710:
	    case PCIC_CL_PD6722:
		if (socket->IFType == IF_IO) {
			pcic_putb(pcic, socket->socket, PCIC_MISC_CTL_2, 0x0);
			value = pcic_getb(pcic, socket->socket,
						PCIC_MISC_CTL_1);
			if (pcic->pc_flags & PCF_AUDIO)
				value |= PCIC_MC_SPEAKER_ENB;
			pcic_putb(pcic, socket->socket, PCIC_MISC_CTL_1,
					value);
		} else {
			value = pcic_getb(pcic, socket->socket,
						PCIC_MISC_CTL_1);
			value &= ~PCIC_MC_SPEAKER_ENB;
			pcic_putb(pcic, socket->socket, PCIC_MISC_CTL_1,
					value);
		}
		break;
	    case PCIC_CL_PD6729:
	    case PCIC_CL_PD6730:
	    case PCIC_CL_PD6832:
		value = pcic_getb(pcic, socket->socket, PCIC_MISC_CTL_1);
		if ((socket->IFType == IF_IO) && (pcic->pc_flags & PCF_AUDIO)) {
		    value |= PCIC_MC_SPEAKER_ENB;
		} else {
		    value &= ~PCIC_MC_SPEAKER_ENB;
		}

		if (pcic_power[sockp->pcs_vcc].PowerLevel == 33)
			value |= PCIC_MC_3VCC;
		else
			value &= ~PCIC_MC_3VCC;

		pcic_putb(pcic, socket->socket, PCIC_MISC_CTL_1, value);
		break;

	    case PCIC_O2_OZ6912:
		value = pcic_getcb(pcic, CB_MISCCTRL);
		if ((socket->IFType == IF_IO) && (pcic->pc_flags & PCF_AUDIO))
			value |= (1<<25);
		else
			value &= ~(1<<25);
		pcic_putcb(pcic, CB_MISCCTRL, value);
		if (pcic_power[sockp->pcs_vcc].PowerLevel == 33)
			powerlevel |= 0x08;
		break;

	    case PCIC_TI_PCI1250:
	    case PCIC_TI_PCI1221:
	    case PCIC_TI_PCI1225:
	    case PCIC_TI_PCI1410:
	    case PCIC_ENE_1410:
	    case PCIC_TI_PCI1510:
	    case PCIC_TI_PCI1520:
	    case PCIC_TI_PCI1420:
	    case PCIC_ENE_1420:
		value = ddi_get8(pcic->cfg_handle,
		    pcic->cfgaddr + PCIC_CRDCTL_REG);
		if ((socket->IFType == IF_IO) && (pcic->pc_flags & PCF_AUDIO)) {
			value |= PCIC_CRDCTL_SPKR_ENBL;
		} else {
			value &= ~PCIC_CRDCTL_SPKR_ENBL;
		}
		ddi_put8(pcic->cfg_handle,
		    pcic->cfgaddr + PCIC_CRDCTL_REG, value);
		if (pcic_power[sockp->pcs_vcc].PowerLevel == 33)
			powerlevel |= 0x08;
		break;
	}

	/*
	 * ctlind processing -- we can ignore this
	 * there aren't any outputs on the chip for this and
	 * the GUI will display what it thinks is correct
	 */

	/*
	 * If outputs are enabled and the power is going off
	 * turn off outputs first.
	 */

	/* power setup -- if necessary */
	orig_pwrctl = pcic_getb(pcic, socket->socket, PCIC_POWER_CONTROL);
	if ((orig_pwrctl & POWER_OUTPUT_ENABLE) && sockp->pcs_vcc == 0) {
		orig_pwrctl &= ~POWER_OUTPUT_ENABLE;
		pcic_putb(pcic, socket->socket,
		    PCIC_POWER_CONTROL, orig_pwrctl);
		(void) pcic_getb(pcic, socket->socket, PCIC_POWER_CONTROL);
	}

	if (pcic->pc_flags & PCF_CBPWRCTL) {
		value = pcic_cbus_powerctl(pcic, socket->socket);
		powerlevel = 0;
	} else
		value = pcic_exca_powerctl(pcic, socket->socket, powerlevel);

	if (value != SUCCESS) {
		mutex_exit(&pcic->pc_lock);
		return (value);
	}

	/*
	 * If outputs were disabled and the power is going on
	 * turn on outputs afterwards.
	 */
	if (!(orig_pwrctl & POWER_OUTPUT_ENABLE) && sockp->pcs_vcc != 0) {
		orig_pwrctl = pcic_getb(pcic, socket->socket,
		    PCIC_POWER_CONTROL);
		orig_pwrctl |= POWER_OUTPUT_ENABLE;
		pcic_putb(pcic, socket->socket,
		    PCIC_POWER_CONTROL, orig_pwrctl);
		(void) pcic_getb(pcic, socket->socket, PCIC_POWER_CONTROL);
	}

	/*
	 * Once we have done the power stuff can re-enable management
	 * interrupts.
	 */
	pcic_putb(pcic, socket->socket, PCIC_MANAGEMENT_INT, mirq);

#if defined(PCIC_DEBUG)
	pcic_err(dip, 8, "\tmanagement int set to %x pwrctl to 0x%x "
	    "cbctl 0x%x\n",
	    mirq, pcic_getb(pcic, socket->socket, PCIC_POWER_CONTROL),
	    pcic_getcb(pcic, CB_CONTROL));
#endif

	/* irq processing */
	if (socket->IFType == IF_IO) {
		/* IRQ only for I/O */
		irq = socket->IREQRouting & PCIC_INTR_MASK;
		value = pcic_getb(pcic, socket->socket, PCIC_INTERRUPT);
		value &= ~PCIC_INTR_MASK;

		/* to enable I/O operation */
		value |= PCIC_IO_CARD | PCIC_RESET;
		sockp->pcs_flags |= PCS_CARD_IO;
		if (irq != sockp->pcs_irq) {
			if (sockp->pcs_irq != 0)
				cmn_err(CE_CONT,
					"SetSocket: IRQ mismatch %x != %x!\n",
					irq, sockp->pcs_irq);
			else
				sockp->pcs_irq = irq;
		}
		irq = sockp->pcs_irq;

		pcic_putb(pcic, socket->socket, PCIC_INTERRUPT, value);
		if (socket->IREQRouting & IRQ_ENABLE) {
			pcic_enable_io_intr(pcic, socket->socket, irq);
			sockp->pcs_flags |= PCS_IRQ_ENABLED;
		} else {
			pcic_disable_io_intr(pcic, socket->socket);
			sockp->pcs_flags &= ~PCS_IRQ_ENABLED;
		}
#if defined(PCIC_DEBUG)
		if (pcic_debug) {
			cmn_err(CE_CONT,
				"\tsocket type is I/O and irq %x is %s\n", irq,
				(socket->IREQRouting & IRQ_ENABLE) ?
				"enabled" : "not enabled");
			xxdmp_all_regs(pcic, socket->socket, 20);
		}
#endif
	} else {
		/* make sure I/O mode is off */

		sockp->pcs_irq = 0;

		value = pcic_getb(pcic, socket->socket, PCIC_INTERRUPT);
		value &= ~PCIC_IO_CARD;
		pcic_putb(pcic, socket->socket, PCIC_INTERRUPT, value);
		pcic_disable_io_intr(pcic, socket->socket);
		sockp->pcs_flags &= ~(PCS_CARD_IO|PCS_IRQ_ENABLED);
	}

	sockp->pcs_state &= ~socket->State;

	mutex_exit(&pcic->pc_lock);
	return (SUCCESS);
}

/*
 * pcic_inquire_socket()
 *	SocketServices InquireSocket function
 *	returns basic characteristics of the socket
 */
/*ARGSUSED*/
static int
pcic_inquire_socket(dev_info_t *dip, inquire_socket_t *socket)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int value;

	socket->SCIntCaps = PCIC_DEFAULT_INT_CAPS;
	socket->SCRptCaps = PCIC_DEFAULT_RPT_CAPS;
	socket->CtlIndCaps = PCIC_DEFAULT_CTL_CAPS;
	value = pcic->pc_sockets[socket->socket].pcs_flags;
	socket->SocketCaps = (value & PCS_SOCKET_IO) ? IF_IO : IF_MEMORY;
	socket->ActiveHigh = 0;
	/* these are the usable IRQs */
	socket->ActiveLow = 0xfff0;
	return (SUCCESS);
}

/*
 * pcic_inquire_window()
 *	SocketServices InquireWindow function
 *	returns detailed characteristics of the window
 *	this is where windows get tied to sockets
 */
/*ARGSUSED*/
static int
pcic_inquire_window(dev_info_t *dip, inquire_window_t *window)
{
	int type, socket;

	type = window->window % PCIC_NUMWINSOCK;
	socket = window->window / PCIC_NUMWINSOCK;

#if defined(PCIC_DEBUG)
	if (pcic_debug >= 8)
		cmn_err(CE_CONT,
			"pcic_inquire_window: window = %d/%d socket=%d\n",
			window->window, type, socket);
#endif
	if (type < PCIC_IOWINDOWS) {
		window->WndCaps = WC_IO|WC_WAIT;
		type = IF_IO;
	} else {
		window->WndCaps = WC_COMMON|WC_ATTRIBUTE|WC_WAIT;
		type = IF_MEMORY;
	}

	/* initialize the socket map - one socket per window */
	PR_ZERO(window->Sockets);
	PR_SET(window->Sockets, socket);

	if (type == IF_IO) {
		iowin_char_t *io;
		io = &window->iowin_char;
		io->IOWndCaps = WC_BASE|WC_SIZE|WC_WENABLE|WC_8BIT|
			WC_16BIT;
		io->FirstByte = (baseaddr_t)IOMEM_FIRST;
		io->LastByte = (baseaddr_t)IOMEM_LAST;
		io->MinSize = IOMEM_MIN;
		io->MaxSize = IOMEM_MAX;
		io->ReqGran = IOMEM_GRAN;
		io->AddrLines = IOMEM_DECODE;
		io->EISASlot = 0;
	} else {
		mem_win_char_t *mem;
		mem = &window->mem_win_char;
		mem->MemWndCaps = WC_BASE|WC_SIZE|WC_WENABLE|WC_8BIT|
			WC_16BIT|WC_WP;

		mem->FirstByte = (baseaddr_t)MEM_FIRST;
		mem->LastByte = (baseaddr_t)MEM_LAST;

		mem->MinSize = MEM_MIN;
		mem->MaxSize = MEM_MAX;
		mem->ReqGran = PCIC_PAGE;
		mem->ReqBase = 0;
		mem->ReqOffset = PCIC_PAGE;
		mem->Slowest = MEM_SPEED_MAX;
		mem->Fastest = MEM_SPEED_MIN;
	}
	return (SUCCESS);
}

/*
 * pcic_get_adapter()
 *	SocketServices GetAdapter function
 *	this is nearly a no-op.
 */
/*ARGSUSED*/
static int
pcic_get_adapter(dev_info_t *dip, get_adapter_t *adapt)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;

	if (pcic->pc_flags & PCF_INTRENAB)
		adapt->SCRouting = IRQ_ENABLE;
	adapt->state = 0;
	return (SUCCESS);
}

/*
 * pcic_get_page()
 *	SocketServices GetPage function
 *	returns info about the window
 */
/*ARGSUSED*/
static int
pcic_get_page(dev_info_t *dip, get_page_t *page)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int socket, window;
	pcs_memwin_t *winp;

	socket = page->window / PCIC_NUMWINSOCK;
	window = page->window % PCIC_NUMWINSOCK;

	/* I/O windows are the first two */
	if (window < PCIC_IOWINDOWS || socket >= pcic->pc_numsockets) {
		return (BAD_WINDOW);
	}

	winp = &pcic->pc_sockets[socket].pcs_windows[window].mem;

	if (page->page != 0)
		return (BAD_PAGE);

	page->state = 0;
	if (winp->pcw_status & PCW_ENABLED)
		page->state |= PS_ENABLED;
	if (winp->pcw_status & PCW_ATTRIBUTE)
		page->state |= PS_ATTRIBUTE;
	if (winp->pcw_status & PCW_WP)
		page->state |= PS_WP;

	page->offset = (off_t)winp->pcw_offset;

	return (SUCCESS);
}

/*
 * pcic_get_socket()
 *	SocketServices GetSocket
 *	returns information about the current socket setting
 */
/*ARGSUSED*/
static int
pcic_get_socket(dev_info_t *dip, get_socket_t *socket)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int socknum, irq_enabled;
	pcic_socket_t *sockp;

	socknum = socket->socket;
	sockp = &pcic->pc_sockets[socknum];

	socket->SCIntMask = sockp->pcs_intmask;
	sockp->pcs_state = pcic_card_state(pcic, sockp);

	socket->state = sockp->pcs_state;
	if (socket->state & SBM_CD) {
		socket->VccLevel = sockp->pcs_vcc;
		socket->Vpp1Level = sockp->pcs_vpp1;
		socket->Vpp2Level = sockp->pcs_vpp2;
		irq_enabled = (sockp->pcs_flags & PCS_IRQ_ENABLED) ?
		    IRQ_ENABLE : 0;
		socket->IRQRouting = sockp->pcs_irq | irq_enabled;
		socket->IFType = (sockp->pcs_flags & PCS_CARD_IO) ?
		    IF_IO : IF_MEMORY;
	} else {
		socket->VccLevel = 0;
		socket->Vpp1Level = 0;
		socket->Vpp2Level = 0;
		socket->IRQRouting = 0;
		socket->IFType = IF_MEMORY;
	}
	socket->CtlInd = 0;	/* no indicators */

	return (SUCCESS);
}

/*
 * pcic_get_status()
 *	SocketServices GetStatus
 *	returns status information about the PC Card in
 *	the selected socket
 */
/*ARGSUSED*/
static int
pcic_get_status(dev_info_t *dip, get_ss_status_t *status)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int socknum, irq_enabled;
	pcic_socket_t *sockp;

	socknum = status->socket;
	sockp = &pcic->pc_sockets[socknum];

	status->CardState = pcic_card_state(pcic, sockp);
	status->SocketState = sockp->pcs_state;
	status->CtlInd = 0;	/* no indicators */

	if (sockp->pcs_flags & PCS_CARD_PRESENT)
		status->SocketState |= SBM_CD;
	if (status->CardState & SBM_CD) {
		irq_enabled = (sockp->pcs_flags & PCS_CARD_ENABLED) ?
		    IRQ_ENABLE : 0;
		status->IRQRouting = sockp->pcs_irq | irq_enabled;
		status->IFType = (sockp->pcs_flags & PCS_CARD_IO) ?
		    IF_IO : IF_MEMORY;
	} else {
		status->IRQRouting = 0;
		status->IFType = IF_MEMORY;
	}

#if defined(PCIC_DEBUG)
	if (pcic_debug >= 8)
		cmn_err(CE_CONT, "pcic_get_status: socket=%d, CardState=%x,"
			"SocketState=%x\n",
			socknum, status->CardState, status->SocketState);
#endif
	switch (pcic->pc_type) {
	uint32_t present_state;
	case PCIC_TI_PCI1410:
	case PCIC_TI_PCI1520:
	case PCIC_TI_PCI1420:
	case PCIC_ENE_1420:
	case PCIC_TOSHIBA_TOPIC100:
	case PCIC_TOSHIBA_TOPIC95:
	case PCIC_TOSHIBA_VENDOR:
	case PCIC_O2MICRO_VENDOR:
	case PCIC_TI_VENDOR:
	case PCIC_RICOH_VENDOR:
		present_state = pcic_getcb(pcic, CB_PRESENT_STATE);
		if (present_state & PCIC_CB_CARD)
			status->IFType = IF_CARDBUS;
#if defined(PCIC_DEBUG)
		if (pcic_debug >= 8)
		    cmn_err(CE_CONT, "pcic_get_status: present_state=0x%x\n",
			present_state);
#endif
		break;
	default:
		break;
	}

	return (SUCCESS);
}

/*
 * pcic_get_window()
 *	SocketServices GetWindow function
 *	returns state information about the specified window
 */
/*ARGSUSED*/
static int
pcic_get_window(dev_info_t *dip, get_window_t *window)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int socket, win;
	pcic_socket_t *sockp;
	pcs_memwin_t *winp;

	socket = window->window / PCIC_NUMWINSOCK;
	win = window->window % PCIC_NUMWINSOCK;
#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT, "pcic_get_window(socket=%d, window=%d)\n",
			socket, win);
	}
#endif

	if (socket > pcic->pc_numsockets)
		return (BAD_WINDOW);

	sockp = &pcic->pc_sockets[socket];
	winp = &sockp->pcs_windows[win].mem;

	window->socket = socket;
	window->size = winp->pcw_len;
	window->speed = winp->pcw_speed;
	window->handle = (ddi_acc_handle_t)winp->pcw_handle;
	window->base = (uint32_t)winp->pcw_base + winp->pcw_offset;

	if (win >= PCIC_IOWINDOWS) {
		window->state = 0;
	} else {
		window->state = WS_IO;
	}
	if (winp->pcw_status & PCW_ENABLED)
		window->state |= WS_ENABLED;

	if (winp->pcw_status & PCS_CARD_16BIT)
		window->state |= WS_16BIT;
#if defined(PCIC_DEBUG)
	if (pcic_debug)
		cmn_err(CE_CONT, "\tsize=%d, speed=%d, base=%p, state=%x\n",
			window->size, (unsigned)window->speed,
			(void *)window->handle, window->state);
#endif

	return (SUCCESS);
}

/*
 * pcic_ll_reset
 *	low level reset
 *	separated out so it can be called when already locked
 *
 *	There are two variables that control the RESET timing:
 *		pcic_prereset_time - time in mS before asserting RESET
 *		pcic_reset_time - time in mS to assert RESET
 *
 */
int pcic_prereset_time = 1;
int pcic_reset_time = 10;
int pcic_postreset_time = 20;
int pcic_vpp_is_vcc_during_reset = 0;

static int
pcic_ll_reset(pcicdev_t *pcic, int socket)
{
	int windowbits, iobits;
	uint32_t pwr;

	/* save windows that were on */
	windowbits = pcic_getb(pcic, socket, PCIC_MAPPING_ENABLE);
	if (pcic_reset_time == 0)
	    return (windowbits);
	/* turn all windows off */
	pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE, 0);

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 6,
		"pcic_ll_reset(socket %d) powerlevel=%x cbctl 0x%x cbps 0x%x\n",
		socket, pcic_getb(pcic, socket, PCIC_POWER_CONTROL),
		pcic_getcb(pcic, CB_CONTROL),
		pcic_getcb(pcic, CB_PRESENT_STATE));
#endif

	if (pcic_vpp_is_vcc_during_reset) {

	/*
	 * Set VPP to VCC for the duration of the reset - for aironet
	 * card.
	 */
	    if (pcic->pc_flags & PCF_CBPWRCTL) {
		pwr = pcic_getcb(pcic, CB_CONTROL);
		pcic_putcb(pcic, CB_CONTROL, (pwr&~CB_C_VPPMASK)|CB_C_VPPVCC);
		(void) pcic_getcb(pcic, CB_CONTROL);
	    } else {
		pwr = pcic_getb(pcic, socket, PCIC_POWER_CONTROL);
		pcic_putb(pcic, socket, PCIC_POWER_CONTROL,
		    pwr | 1);
		(void) pcic_getb(pcic, socket, PCIC_POWER_CONTROL);
	    }
	}

	if (pcic_prereset_time > 0) {
		pcic_err(pcic->dip, 8, "pcic_ll_reset pre_wait %d mS\n",
		    pcic_prereset_time);
		pcic_mswait(pcic, socket, pcic_prereset_time);
	}

	/* turn interrupts off and start a reset */
	pcic_err(pcic->dip, 8,
		"pcic_ll_reset turn interrupts off and start a reset\n");
	iobits = pcic_getb(pcic, socket, PCIC_INTERRUPT);
	iobits &= ~(PCIC_INTR_MASK | PCIC_RESET);
	pcic_putb(pcic, socket, PCIC_INTERRUPT, iobits);
	(void) pcic_getb(pcic, socket, PCIC_INTERRUPT);

	switch (pcic->pc_type) {
	    case PCIC_INTEL_i82092:
		pcic_82092_smiirq_ctl(pcic, socket, PCIC_82092_CTL_IRQ,
						PCIC_82092_INT_DISABLE);
		break;
	    default:
		break;
	} /* switch */

	pcic->pc_sockets[socket].pcs_state = 0;

	if (pcic_reset_time > 0) {
		pcic_err(pcic->dip, 8, "pcic_ll_reset reset_wait %d mS\n",
		    pcic_reset_time);
		pcic_mswait(pcic, socket, pcic_reset_time);
	}

	pcic_err(pcic->dip, 8, "pcic_ll_reset take it out of reset now\n");

	/* take it out of RESET now */
	pcic_putb(pcic, socket, PCIC_INTERRUPT, PCIC_RESET | iobits);
	(void) pcic_getb(pcic, socket, PCIC_INTERRUPT);

	/*
	 * can't access the card for 20ms, but we really don't
	 * want to sit around that long. The pcic is still usable.
	 * memory accesses must wait for RDY to come up.
	 */
	if (pcic_postreset_time > 0) {
		pcic_err(pcic->dip, 8, "pcic_ll_reset post_wait %d mS\n",
		    pcic_postreset_time);
		pcic_mswait(pcic, socket, pcic_postreset_time);
	}

	if (pcic_vpp_is_vcc_during_reset > 1) {

	/*
	 * Return VPP power to whatever it was before.
	 */
	    if (pcic->pc_flags & PCF_CBPWRCTL) {
		pcic_putcb(pcic, CB_CONTROL, pwr);
		(void) pcic_getcb(pcic, CB_CONTROL);
	    } else {
		pcic_putb(pcic, socket, PCIC_POWER_CONTROL, pwr);
		(void) pcic_getb(pcic, socket, PCIC_POWER_CONTROL);
	    }
	}

	pcic_err(pcic->dip, 7, "pcic_ll_reset returning 0x%x\n", windowbits);

	return (windowbits);
}

/*
 * pcic_reset_socket()
 *	SocketServices ResetSocket function
 *	puts the PC Card in the socket into the RESET state
 *	and then takes it out after the the cycle time
 *	The socket is back to initial state when done
 */
static int
pcic_reset_socket(dev_info_t *dip, int socket, int mode)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int value;
	int i, mint;
	pcic_socket_t *sockp;

#if defined(PCIC_DEBUG)
	if (pcic_debug >= 8)
		cmn_err(CE_CONT, "pcic_reset_socket(%p, %d, %d/%s)\n",
		    (void *)dip, socket, mode,
			mode == RESET_MODE_FULL ? "full" : "partial");
#endif

	mutex_enter(&pcic->pc_lock); /* protect the registers */

	/* Turn off management interupts. */
	mint = pcic_getb(pcic, socket, PCIC_MANAGEMENT_INT);
	pcic_putb(pcic, socket, PCIC_MANAGEMENT_INT, mint & ~PCIC_CHANGE_MASK);

	sockp = &pcic->pc_sockets[socket];

	value = pcic_ll_reset(pcic, socket);
	if (mode == RESET_MODE_FULL) {
		/* disable and unmap all mapped windows */
		for (i = 0; i < PCIC_NUMWINSOCK; i++) {
			if (i < PCIC_IOWINDOWS) {
				if (sockp->pcs_windows[i].io.pcw_status &
				    PCW_MAPPED) {
					pcs_iowin_t *io;
					io = &sockp->pcs_windows[i].io;
					io->pcw_status &= ~PCW_ENABLED;
				}
			} else {
				if (sockp->pcs_windows[i].mem.pcw_status &
				    PCW_MAPPED) {
					pcs_memwin_t *mem;
					mem = &sockp->pcs_windows[i].mem;
					mem->pcw_status &= ~PCW_ENABLED;
				}
			}
		}
	} else {
				/* turn windows back on */
		pcic_putb(pcic, socket, PCIC_MAPPING_ENABLE, value);
		/* wait the rest of the time here */
		pcic_mswait(pcic, socket, 10);
	}
	pcic_putb(pcic, socket, PCIC_MANAGEMENT_INT, mint);
	mutex_exit(&pcic->pc_lock);
	return (SUCCESS);
}

/*
 * pcic_set_interrupt()
 *	SocketServices SetInterrupt function
 */
static int
pcic_set_interrupt(dev_info_t *dip, set_irq_handler_t *handler)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	int value = DDI_SUCCESS;
	inthandler_t *intr;

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
			"pcic_set_interrupt: entered pc_intr_mode=0x%x\n",
			pcic->pc_intr_mode);
		cmn_err(CE_CONT,
			"\t irq_top=%p handler=%p handler_id=%x\n",
			(void *)pcic->irq_top, (void *)handler->handler,
			handler->handler_id);
	}
#endif

	/*
	 * If we're on a PCI bus, we route all IO IRQs through a single
	 *	PCI interrupt (typically INT A#) so we don't have to do
	 *	much other than add the caller to general interrupt handler
	 *	and set some state.
	 */

	intr = kmem_zalloc(sizeof (inthandler_t), KM_NOSLEEP);
	if (intr == NULL)
		return (NO_RESOURCE);

	switch (pcic->pc_intr_mode) {
	case PCIC_INTR_MODE_PCI_1:
		/*
		 * We only allow above-lock-level IO IRQ handlers
		 *	in the PCI bus case.
		 */

		mutex_enter(&pcic->intr_lock);

		if (pcic->irq_top == NULL) {
		    pcic->irq_top = intr;
		    pcic->irq_current = pcic->irq_top;
		} else {
		    while (pcic->irq_current->next != NULL)
			pcic->irq_current = pcic->irq_current->next;
		    pcic->irq_current->next = intr;
		    pcic->irq_current = pcic->irq_current->next;
		}

		pcic->irq_current->intr =
		    (ddi_intr_handler_t *)handler->handler;
		pcic->irq_current->handler_id = handler->handler_id;
		pcic->irq_current->arg1 = handler->arg1;
		pcic->irq_current->arg2 = handler->arg2;
		pcic->irq_current->socket = handler->socket;

		mutex_exit(&pcic->intr_lock);

		handler->iblk_cookie = &pcic->pc_pri;
		handler->idev_cookie = &pcic->pc_dcookie;
		break;

	default:
		intr->intr = (ddi_intr_handler_t *)handler->handler;
		intr->handler_id = handler->handler_id;
		intr->arg1 = handler->arg1;
		intr->arg2 = handler->arg2;
		intr->socket = handler->socket;
		intr->irq = handler->irq;

		/*
		 * need to revisit this to see if interrupts can be
		 * shared someday. Note that IRQ is set in the common
		 * code.
		 */
		mutex_enter(&pcic->pc_lock);
		if (pcic->pc_handlers == NULL) {
			pcic->pc_handlers = intr;
			intr->next = intr->prev = intr;
		} else {
			insque(intr, pcic->pc_handlers);
		}
		mutex_exit(&pcic->pc_lock);

		break;
	}

	/*
	 * need to fill in cookies in event of multiple high priority
	 * interrupt handlers on same IRQ
	 */

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
			"pcic_set_interrupt: exit irq_top=%p value=%d\n",
			(void *)pcic->irq_top, value);
	}
#endif

	if (value == DDI_SUCCESS) {
		return (SUCCESS);
	} else {
		return (BAD_IRQ);
	}
}

/*
 * pcic_clear_interrupt()
 *	SocketServices ClearInterrupt function
 *
 *	Interrupts for PCIC are complicated by the fact that we must
 *	follow several different models for interrupts.
 *	ISA: there is an interrupt per adapter and per socket and
 *		they can't be shared.
 *	PCI: some adapters have one PCI interrupt available while others
 *		have up to 4.  Solaris may or may not allow us to use more
 *		than 1 so we essentially share them all at this point.
 *	Hybrid: PCI bridge but interrupts wired to host interrupt controller.
 *		This is like ISA but we have to fudge and create an intrspec
 *		that PCI's parent understands and bypass the PCI nexus.
 *	multifunction: this requires sharing the interrupts on a per-socket
 *		basis.
 */
static int
pcic_clear_interrupt(dev_info_t *dip, clear_irq_handler_t *handler)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;
	inthandler_t *intr, *prev, *current;
	int i;

	/*
	 * If we're on a PCI bus, we route all IO IRQs through a single
	 *	PCI interrupt (typically INT A#) so we don't have to do
	 *	much other than remove the caller from the general
	 *	interrupt handler callout list.
	 */

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
			"pcic_clear_interrupt: entered pc_intr_mode=0x%x\n",
			pcic->pc_intr_mode);
		cmn_err(CE_CONT,
			"\t irq_top=%p handler=%p handler_id=%x\n",
			(void *)pcic->irq_top, (void *)handler->handler,
			handler->handler_id);
	}
#endif

	switch (pcic->pc_intr_mode) {
	case PCIC_INTR_MODE_PCI_1:

		mutex_enter(&pcic->intr_lock);
		if (pcic->irq_top == NULL) {
			mutex_exit(&pcic->intr_lock);
			return (BAD_IRQ);
		}

		intr = NULL;
		pcic->irq_current = pcic->irq_top;

		while ((pcic->irq_current != NULL) &&
				(pcic->irq_current->handler_id !=
						handler->handler_id)) {
			intr = pcic->irq_current;
			pcic->irq_current = pcic->irq_current->next;
		}

		if (pcic->irq_current == NULL) {
			mutex_exit(&pcic->intr_lock);
			return (BAD_IRQ);
		}

		if (intr != NULL) {
			intr->next = pcic->irq_current->next;
		} else {
			pcic->irq_top = pcic->irq_current->next;
		}

		current = pcic->irq_current;
		pcic->irq_current = pcic->irq_top;
		mutex_exit(&pcic->intr_lock);
		kmem_free(current, sizeof (inthandler_t));

		break;

	default:

		mutex_enter(&pcic->pc_lock);
		intr = pcic_handlers;
		prev = (inthandler_t *)&pcic_handlers;

		while (intr != NULL) {
		    if (intr->handler_id == handler->handler_id) {
			i = intr->irq & PCIC_INTR_MASK;
			if (--pcic_irq_map[i].count == 0) {
				/* multi-handler form */
				(void) ddi_intr_disable(pcic->pc_intr_htblp[i]);
				(void) ddi_intr_remove_handler(
				    pcic->pc_intr_htblp[i]);
				(void) ddi_intr_free(pcic->pc_intr_htblp[i]);
				(void) pcmcia_return_intr(pcic->dip, i);
#if defined(PCIC_DEBUG)
				if (pcic_debug) {
					cmn_err(CE_CONT,
						"removing interrupt %d at %s "
						"priority\n", i, "high");
					cmn_err(CE_CONT,
						"ddi_remove_intr(%p, %x, %p)\n",
						(void *)dip,
						0,
						(void *)intr->iblk_cookie);
				}
#endif
			}
			prev->next = intr->next;
			kmem_free(intr, sizeof (inthandler_t));
			intr = prev->next;
		    } else {
			prev = intr;
			intr = intr->next;
		    } /* if (handler_id) */
		} /* while */

		mutex_exit(&pcic->pc_lock);
	}

#if defined(PCIC_DEBUG)
	if (pcic_debug) {
		cmn_err(CE_CONT,
		"pcic_clear_interrupt: exit irq_top=%p\n",
		(void *)pcic->irq_top);
	}
#endif


	return (SUCCESS);
}

struct intel_regs {
	char *name;
	int   off;
	char *fmt;
} iregs[] = {
	{"ident     ", 0},
	{"if-status ", 1, "\020\1BVD1\2BVD2\3CD1\4CD2\5WP\6RDY\7PWR\10~GPI"},
	{"power     ", 2, "\020\1Vpp1c0\2Vpp1c1\3Vpp2c0\4Vpp2c1\5PE\6AUTO"
		"\7DRD\10OE"},
	{"cardstatus", 4, "\020\1BD\2BW\3RC\4CD\5GPI\6R1\7R2\010R3"},
	{"enable    ", 6, "\020\1MW0\2MW1\3MW2\4MW3\5MW4\6MEM16\7IO0\10IO1"},
	{"cd-gcr    ", 0x16, "\020\1MDI16\2CRE\3GPIE\4GPIT\5CDR\6S/W"},
	{"GCR       ", 0x1e, "\020\1PD\2LEVEL\3WCSC\4PLS14"},
	{"int-gcr   ", 3, "\020\5INTR\6IO\7~RST\10RI"},
	{"management", 5, "\020\1BDE\2BWE\3RE\4CDE"},
	{"volt-sense", 0x1f, "\020\1A_VS1\2A_VS2\3B_VS1\4B_VS2"},
	{"volt-sel  ", 0x2f, "\020\5EXTCONF\6BUSSELECT\7MIXEDV\10ISAV"},
	{"VG ext A  ", 0x3c, "\20\3IVS\4CABLE\5CSTEP\6TEST\7RIO"},
	{"io-ctrl   ", 7, "\020\1DS0\2IOCS0\3ZWS0\4WS0\5DS1\6IOS1\7ZWS1\10WS1"},
	{"io0-slow  ", 8},
	{"io0-shi   ", 9},
	{"io0-elow  ", 0xa},
	{"io0-ehi   ", 0xb},
	{"io1-slow  ", 0xc},
	{"io1-shi   ", 0xd},
	{"io1-elow  ", 0xe},
	{"io1-ehi   ", 0xf},
	{"mem0-slow ", 0x10},
	{"mem0-shi  ", 0x11, "\020\7ZW\10DS"},
	{"mem0-elow ", 0x12},
	{"mem0-ehi  ", 0x13, "\020\7WS0\10WS1"},
	{"card0-low ", 0x14},
	{"card0-hi  ", 0x15, "\020\7AM\10WP"},
	{"mem1-slow ", 0x18},
	{"mem1-shi  ", 0x19, "\020\7ZW\10DS"},
	{"mem1-elow ", 0x1a},
	{"mem1-ehi  ", 0x1b, "\020\7WS0\10WS1"},
	{"card1-low ", 0x1c},
	{"card1-hi  ", 0x1d, "\020\7AM\10WP"},
	{"mem2-slow ", 0x20},
	{"mem2-shi  ", 0x21, "\020\7ZW\10DS"},
	{"mem2-elow ", 0x22},
	{"mem2-ehi  ", 0x23, "\020\7WS0\10WS1"},
	{"card2-low ", 0x24},
	{"card2-hi  ", 0x25, "\020\7AM\10WP"},
	{"mem3-slow ", 0x28},
	{"mem3-shi  ", 0x29, "\020\7ZW\10DS"},
	{"mem3-elow ", 0x2a},
	{"mem3-ehi  ", 0x2b, "\020\7WS0\10WS1"},
	{"card3-low ", 0x2c},
	{"card3-hi  ", 0x2d, "\020\7AM\10WP"},

	{"mem4-slow ", 0x30},
	{"mem4-shi  ", 0x31, "\020\7ZW\10DS"},
	{"mem4-elow ", 0x32},
	{"mem4-ehi  ", 0x33, "\020\7WS0\10WS1"},
	{"card4-low ", 0x34},
	{"card4-hi  ", 0x35, "\020\7AM\10WP"},
	{"mpage0    ", 0x40},
	{"mpage1    ", 0x41},
	{"mpage2    ", 0x42},
	{"mpage3    ", 0x43},
	{"mpage4    ", 0x44},
	{NULL},
};

static struct intel_regs cregs[] = {
	{"misc-ctl1 ", 0x16, "\20\2VCC3\3PMI\4PSI\5SPKR\10INPACK"},
	{"fifo      ", 0x17, "\20\6DIOP\7DMEMP\10EMPTY"},
	{"misc-ctl2 ", 0x1e, "\20\1XCLK\2LOW\3SUSP\4CORE5V\5TCD\10RIOUT"},
	{"chip-info ", 0x1f, "\20\6DUAL"},
	{"IO-offlow0", 0x36},
	{"IO-offhi0 ", 0x37},
	{"IO-offlow1", 0x38},
	{"IO-offhi1 ", 0x39},
	NULL,
};

static struct intel_regs cxregs[] = {
	{"ext-ctl-1 ", 0x03,
		"\20\1VCCLCK\2AUTOCLR\3LED\4INVIRQC\5INVIRQM\6PUC"},
	{"misc-ctl3 ", 0x25, "\20\5HWSUSP"},
	{"mem0-up   ", 0x05},
	{"mem1-up   ", 0x06},
	{"mem2-up   ", 0x07},
	{"mem3-up   ", 0x08},
	{"mem4-up   ", 0x09},
	{NULL}
};

void
xxdmp_cl_regs(pcicdev_t *pcic, int socket, uint32_t len)
{
	int i, value, j;
	char buff[256];
	char *fmt;

	cmn_err(CE_CONT, "--------- Cirrus Logic Registers --------\n");
	for (buff[0] = '\0', i = 0; cregs[i].name != NULL && len-- != 0; i++) {
		int sval;
		if (cregs[i].off == PCIC_MISC_CTL_2)
			sval = 0;
		else
			sval = socket;
		value = pcic_getb(pcic, sval, cregs[i].off);
		if (i & 1) {
			if (cregs[i].fmt)
				fmt = "%s\t%s\t%b\n";
			else
				fmt = "%s\t%s\t%x\n";
			cmn_err(CE_CONT, fmt, buff,
				cregs[i].name, value, cregs[i].fmt);
			buff[0] = '\0';
		} else {
			if (cregs[i].fmt)
				fmt = "\t%s\t%b";
			else
				fmt = "\t%s\t%x";
			(void) sprintf(buff, fmt,
				cregs[i].name, value, cregs[i].fmt);
			for (j = strlen(buff); j < 40; j++)
				buff[j] = ' ';
			buff[40] = '\0';
		}
	}
	cmn_err(CE_CONT, "%s\n", buff);

	i = pcic_getb(pcic, socket, PCIC_TIME_SETUP_0);
	j = pcic_getb(pcic, socket, PCIC_TIME_SETUP_1);
	cmn_err(CE_CONT, "\tsetup-tim0\t%x\tsetup-tim1\t%x\n", i, j);

	i = pcic_getb(pcic, socket, PCIC_TIME_COMMAND_0);
	j = pcic_getb(pcic, socket, PCIC_TIME_COMMAND_1);
	cmn_err(CE_CONT, "\tcmd-tim0  \t%x\tcmd-tim1  \t%x\n", i, j);

	i = pcic_getb(pcic, socket, PCIC_TIME_RECOVER_0);
	j = pcic_getb(pcic, socket, PCIC_TIME_RECOVER_1);
	cmn_err(CE_CONT, "\trcvr-tim0 \t%x\trcvr-tim1 \t%x\n", i, j);

	cmn_err(CE_CONT, "--------- Extended Registers  --------\n");

	for (buff[0] = '\0', i = 0; cxregs[i].name != NULL && len-- != 0; i++) {
		value = clext_reg_read(pcic, socket, cxregs[i].off);
		if (i & 1) {
			if (cxregs[i].fmt)
				fmt = "%s\t%s\t%b\n";
			else
				fmt = "%s\t%s\t%x\n";
			cmn_err(CE_CONT, fmt, buff,
				cxregs[i].name, value, cxregs[i].fmt);
			buff[0] = '\0';
		} else {
			if (cxregs[i].fmt)
				fmt = "\t%s\t%b";
			else
				fmt = "\t%s\t%x";
			(void) sprintf(buff, fmt,
				cxregs[i].name, value, cxregs[i].fmt);
			for (j = strlen(buff); j < 40; j++)
				buff[j] = ' ';
			buff[40] = '\0';
		}
	}
}

#if defined(PCIC_DEBUG)
static void
xxdmp_all_regs(pcicdev_t *pcic, int socket, uint32_t len)
{
	int i, value, j;
	char buff[256];
	char *fmt;

#if defined(PCIC_DEBUG)
	if (pcic_debug < 2)
		return;
#endif
	cmn_err(CE_CONT,
		"----------- PCIC Registers for socket %d---------\n",
		socket);
	cmn_err(CE_CONT,
		"\tname       value                        name       value\n");

	for (buff[0] = '\0', i = 0; iregs[i].name != NULL && len-- != 0; i++) {
		value = pcic_getb(pcic, socket, iregs[i].off);
		if (i & 1) {
			if (iregs[i].fmt)
				fmt = "%s\t%s\t%b\n";
			else
				fmt = "%s\t%s\t%x\n";
			cmn_err(CE_CONT, fmt, buff,
				iregs[i].name, value, iregs[i].fmt);
			buff[0] = '\0';
		} else {
			if (iregs[i].fmt)
				fmt = "\t%s\t%b";
			else
				fmt = "\t%s\t%x";
			(void) sprintf(buff, fmt,
				iregs[i].name, value, iregs[i].fmt);
			for (j = strlen(buff); j < 40; j++)
				buff[j] = ' ';
			buff[40] = '\0';
		}
	}
	switch (pcic->pc_type) {
	case PCIC_CL_PD6710:
	case PCIC_CL_PD6722:
	case PCIC_CL_PD6729:
	case PCIC_CL_PD6832:
		(void) xxdmp_cl_regs(pcic, socket, 0xFFFF);
		break;
	}
	cmn_err(CE_CONT, "%s\n", buff);
}
#endif

/*
 * pcic_mswait(ms)
 *	sleep ms milliseconds
 *	call drv_usecwait once for each ms
 */
static void
pcic_mswait(pcicdev_t *pcic, int socket, int ms)
{
	if (ms) {
		pcic->pc_sockets[socket].pcs_flags |= PCS_WAITING;
		pcic_mutex_exit(&pcic->pc_lock);
		delay(drv_usectohz(ms*1000));
		pcic_mutex_enter(&pcic->pc_lock);
		pcic->pc_sockets[socket].pcs_flags &= ~PCS_WAITING;
	}
}

/*
 * pcic_check_ready(pcic, index, off)
 *      Wait for card to come ready
 *      We only wait if the card is NOT in RESET
 *      and power is on.
 */
static boolean_t
pcic_check_ready(pcicdev_t *pcic, int socket)
{
	int ifstate, intstate;

	intstate = pcic_getb(pcic, socket, PCIC_INTERRUPT);
	ifstate = pcic_getb(pcic, socket, PCIC_INTERFACE_STATUS);

	if ((intstate & PCIC_RESET) &&
	    ((ifstate & (PCIC_READY|PCIC_POWER_ON|PCIC_ISTAT_CD_MASK)) ==
	    (PCIC_READY|PCIC_POWER_ON|PCIC_CD_PRESENT_OK)))
		return (B_TRUE);

#ifdef  PCIC_DEBUG
	pcic_err(NULL, 5, "pcic_check_read: Card not ready, intstate = 0x%x, "
	    "ifstate = 0x%x\n", intstate, ifstate);
	if (pcic_debug) {
		pcic_debug += 4;
		xxdmp_all_regs(pcic, socket, -1);
		pcic_debug -= 4;
	}
#endif
	return (B_FALSE);
}

/*
 * Cirrus Logic extended register read/write routines
 */
static int
clext_reg_read(pcicdev_t *pcic, int sn, uchar_t ext_reg)
{
	int val;

	switch (pcic->pc_io_type) {
	case PCIC_IO_TYPE_YENTA:
		val = ddi_get8(pcic->handle,
		    pcic->ioaddr + CB_CLEXT_OFFSET + ext_reg);
		break;
	default:
		pcic_putb(pcic, sn, PCIC_CL_EXINDEX, ext_reg);
		val = pcic_getb(pcic, sn, PCIC_CL_EXINDEX + 1);
		break;
	}

	return (val);
}

static void
clext_reg_write(pcicdev_t *pcic, int sn, uchar_t ext_reg, uchar_t value)
{
	switch (pcic->pc_io_type) {
	case PCIC_IO_TYPE_YENTA:
		ddi_put8(pcic->handle,
		    pcic->ioaddr + CB_CLEXT_OFFSET + ext_reg, value);
		break;
	default:
		pcic_putb(pcic, sn, PCIC_CL_EXINDEX, ext_reg);
		pcic_putb(pcic, sn, PCIC_CL_EXINDEX + 1, value);
		break;
	}
}

/*
 * Misc PCI functions
 */
static void
pcic_iomem_pci_ctl(ddi_acc_handle_t handle, uchar_t *cfgaddr, unsigned flags)
{
	unsigned cmd;

	if (flags & (PCIC_ENABLE_IO | PCIC_ENABLE_MEM)) {
		cmd = ddi_get16(handle, (ushort_t *)(cfgaddr + 4));
		if ((cmd & (PCI_COMM_IO|PCI_COMM_MAE)) ==
		    (PCI_COMM_IO|PCI_COMM_MAE))
			return;

		if (flags & PCIC_ENABLE_IO)
		    cmd |= PCI_COMM_IO;

		if (flags & PCIC_ENABLE_MEM)
		    cmd |= PCI_COMM_MAE;

		ddi_put16(handle, (ushort_t *)(cfgaddr + 4), cmd);
	} /* if (PCIC_ENABLE_IO | PCIC_ENABLE_MEM) */
}

/*
 * pcic_find_pci_type - Find and return PCI-PCMCIA adapter type
 */
static int
pcic_find_pci_type(pcicdev_t *pcic)
{
	uint32_t vend, device;

	vend = ddi_getprop(DDI_DEV_T_ANY, pcic->dip,
				DDI_PROP_CANSLEEP|DDI_PROP_DONTPASS,
				"vendor-id", -1);
	device = ddi_getprop(DDI_DEV_T_ANY, pcic->dip,
				DDI_PROP_CANSLEEP|DDI_PROP_DONTPASS,
				"device-id", -1);

	device = PCI_ID(vend, device);
	pcic->pc_type = device;
	pcic->pc_chipname = "PCI:unknown";

	switch (device) {
	case PCIC_INTEL_i82092:
		pcic->pc_chipname = PCIC_TYPE_i82092;
		break;
	case PCIC_CL_PD6729:
		pcic->pc_chipname = PCIC_TYPE_PD6729;
		/*
		 * Some 6730's incorrectly identify themselves
		 *	as a 6729, so we need to do some more tests
		 *	here to see if the device that's claiming
		 *	to be a 6729 is really a 6730.
		 */
		if ((clext_reg_read(pcic, 0, PCIC_CLEXT_MISC_CTL_3) &
			PCIC_CLEXT_MISC_CTL_3_REV_MASK) ==
				0) {
			pcic->pc_chipname = PCIC_TYPE_PD6730;
			pcic->pc_type = PCIC_CL_PD6730;
		}
		break;
	case PCIC_CL_PD6730:
		pcic->pc_chipname = PCIC_TYPE_PD6730;
		break;
	case PCIC_CL_PD6832:
		pcic->pc_chipname = PCIC_TYPE_PD6832;
		break;
	case PCIC_SMC_34C90:
		pcic->pc_chipname = PCIC_TYPE_34C90;
		break;
	case PCIC_TOSHIBA_TOPIC95:
		pcic->pc_chipname = PCIC_TYPE_TOPIC95;
		break;
	case PCIC_TOSHIBA_TOPIC100:
		pcic->pc_chipname = PCIC_TYPE_TOPIC100;
		break;
	case PCIC_TI_PCI1031:
		pcic->pc_chipname = PCIC_TYPE_PCI1031;
		break;
	case PCIC_TI_PCI1130:
		pcic->pc_chipname = PCIC_TYPE_PCI1130;
		break;
	case PCIC_TI_PCI1131:
		pcic->pc_chipname = PCIC_TYPE_PCI1131;
		break;
	case PCIC_TI_PCI1250:
		pcic->pc_chipname = PCIC_TYPE_PCI1250;
		break;
	case PCIC_TI_PCI1225:
		pcic->pc_chipname = PCIC_TYPE_PCI1225;
		break;
	case PCIC_TI_PCI1410:
		pcic->pc_chipname = PCIC_TYPE_PCI1410;
		break;
	case PCIC_TI_PCI1510:
		pcic->pc_chipname = PCIC_TYPE_PCI1510;
		break;
	case PCIC_TI_PCI1520:
		pcic->pc_chipname = PCIC_TYPE_PCI1520;
		break;
	case PCIC_TI_PCI1221:
		pcic->pc_chipname = PCIC_TYPE_PCI1221;
		break;
	case PCIC_TI_PCI1050:
		pcic->pc_chipname = PCIC_TYPE_PCI1050;
		break;
	case PCIC_ENE_1410:
		pcic->pc_chipname = PCIC_TYPE_1410;
		break;
	case PCIC_O2_OZ6912:
		pcic->pc_chipname = PCIC_TYPE_OZ6912;
		break;
	case PCIC_RICOH_RL5C466:
		pcic->pc_chipname = PCIC_TYPE_RL5C466;
		break;
	case PCIC_TI_PCI1420:
		pcic->pc_chipname = PCIC_TYPE_PCI1420;
		break;
	case PCIC_ENE_1420:
		pcic->pc_chipname = PCIC_TYPE_1420;
		break;
	default:
		switch (PCI_ID(vend, (uint32_t)0)) {
		case PCIC_TOSHIBA_VENDOR:
			pcic->pc_chipname = PCIC_TYPE_TOSHIBA;
			pcic->pc_type = PCIC_TOSHIBA_VENDOR;
			break;
		case PCIC_TI_VENDOR:
			pcic->pc_chipname = PCIC_TYPE_TI;
			pcic->pc_type = PCIC_TI_VENDOR;
			break;
		case PCIC_O2MICRO_VENDOR:
			pcic->pc_chipname = PCIC_TYPE_O2MICRO;
			pcic->pc_type = PCIC_O2MICRO_VENDOR;
			break;
		case PCIC_RICOH_VENDOR:
			pcic->pc_chipname = PCIC_TYPE_RICOH;
			pcic->pc_type = PCIC_RICOH_VENDOR;
			break;
		default:
			if (!(pcic->pc_flags & PCF_CARDBUS))
				return (DDI_FAILURE);
			pcic->pc_chipname = PCIC_TYPE_YENTA;
			break;
		}
	}
	return (DDI_SUCCESS);
}

static void
pcic_82092_smiirq_ctl(pcicdev_t *pcic, int socket, int intr, int state)
{
	uchar_t ppirr = ddi_get8(pcic->cfg_handle,
					pcic->cfgaddr + PCIC_82092_PPIRR);
	uchar_t val;

	if (intr == PCIC_82092_CTL_SMI) {
		val = PCIC_82092_SMI_CTL(socket,
						PCIC_82092_INT_DISABLE);
		ppirr &= ~val;
		val = PCIC_82092_SMI_CTL(socket, state);
		ppirr |= val;
	} else {
		val = PCIC_82092_IRQ_CTL(socket,
						PCIC_82092_INT_DISABLE);
		ppirr &= ~val;
		val = PCIC_82092_IRQ_CTL(socket, state);
		ppirr |= val;
	}
	ddi_put8(pcic->cfg_handle, pcic->cfgaddr + PCIC_82092_PPIRR,
			ppirr);
}

static uint_t
pcic_cd_softint(caddr_t arg1, caddr_t arg2)
{
	pcic_socket_t *sockp = (pcic_socket_t *)arg1;
	uint_t rc = DDI_INTR_UNCLAIMED;

	_NOTE(ARGUNUSED(arg2))

	mutex_enter(&sockp->pcs_pcic->pc_lock);
	if (sockp->pcs_cd_softint_flg) {
		uint8_t status;
		sockp->pcs_cd_softint_flg = 0;
		rc = DDI_INTR_CLAIMED;
		status = pcic_getb(sockp->pcs_pcic, sockp->pcs_socket,
			PCIC_INTERFACE_STATUS);
		pcic_handle_cd_change(sockp->pcs_pcic, sockp, status);
	}
	mutex_exit(&sockp->pcs_pcic->pc_lock);
	return (rc);
}

int pcic_debounce_cnt = PCIC_REM_DEBOUNCE_CNT;
int pcic_debounce_intr_time = PCIC_REM_DEBOUNCE_TIME;
int pcic_debounce_cnt_ok = PCIC_DEBOUNCE_OK_CNT;

#ifdef CARDBUS
static uint32_t pcic_cbps_on = 0;
static uint32_t pcic_cbps_off = CB_PS_NOTACARD | CB_PS_CCDMASK |
				CB_PS_XVCARD | CB_PS_YVCARD;
#else
static uint32_t pcic_cbps_on = CB_PS_16BITCARD;
static uint32_t pcic_cbps_off = CB_PS_NOTACARD | CB_PS_CCDMASK |
				CB_PS_CBCARD |
				CB_PS_XVCARD | CB_PS_YVCARD;
#endif
static void
pcic_handle_cd_change(pcicdev_t *pcic, pcic_socket_t *sockp, uint8_t status)
{
	boolean_t	do_debounce = B_FALSE;
	int		debounce_time = drv_usectohz(pcic_debounce_time);
	uint8_t		irq;
	timeout_id_t	debounce;

	/*
	 * Always reset debounce but may need to check original state later.
	 */
	debounce = sockp->pcs_debounce_id;
	sockp->pcs_debounce_id = 0;

	/*
	 * Check to see whether a card is present or not. There are
	 *	only two states that we are concerned with - the state
	 *	where both CD pins are asserted, which means that the
	 *	card is fully seated, and the state where neither CD
	 *	pin is asserted, which means that the card is not
	 *	present.
	 * The CD signals are generally very noisy and cause a lot of
	 *	contact bounce as the card is being inserted and
	 *	removed, so we need to do some software debouncing.
	 */

#ifdef PCIC_DEBUG
	    pcic_err(pcic->dip, 6,
		    "pcic%d handle_cd_change: socket %d card status 0x%x"
		    " deb 0x%p\n", ddi_get_instance(pcic->dip),
		    sockp->pcs_socket, status, debounce);
#endif
	switch (status & PCIC_ISTAT_CD_MASK) {
	case PCIC_CD_PRESENT_OK:
	    sockp->pcs_flags &= ~(PCS_CARD_REMOVED|PCS_CARD_CBREM);
	    if (!(sockp->pcs_flags & PCS_CARD_PRESENT)) {
		uint32_t cbps;
#ifdef PCIC_DEBUG
		pcic_err(pcic->dip, 8, "New card (0x%x)\n", sockp->pcs_flags);
#endif
		cbps = pcic_getcb(pcic, CB_PRESENT_STATE);
#ifdef PCIC_DEBUG
		pcic_err(pcic->dip, 8, "CBus PS (0x%x)\n", cbps);
#endif
		/*
		 * Check the CB bits are sane.
		 */
		if ((cbps & pcic_cbps_on) != pcic_cbps_on ||
		    cbps & pcic_cbps_off) {
		    cmn_err(CE_WARN,
			    "%s%d: Odd Cardbus Present State 0x%x\n",
			    ddi_get_name(pcic->dip),
			    ddi_get_instance(pcic->dip),
			    cbps);
		    pcic_putcb(pcic, CB_EVENT_FORCE, CB_EF_CVTEST);
		    debounce = 0;
		    debounce_time = drv_usectohz(1000000);
		}
		if (debounce) {
		    sockp->pcs_flags |= PCS_CARD_PRESENT;
		    if (pcic_do_insertion) {

			cbps = pcic_getcb(pcic, CB_PRESENT_STATE);

			if (cbps & CB_PS_16BITCARD) {
			    pcic_err(pcic->dip, 8, "16 bit card inserted\n");
			    sockp->pcs_flags |= PCS_CARD_IS16BIT;
			    /* calls pcm_adapter_callback() */
			    if (pcic->pc_callback) {

				(void) ddi_prop_update_string(DDI_DEV_T_NONE,
					pcic->dip, PCM_DEVICETYPE,
					"pccard");
				PC_CALLBACK(pcic->dip, pcic->pc_cb_arg,
					    PCE_CARD_INSERT,
					    sockp->pcs_socket);
			    }
			} else if (cbps & CB_PS_CBCARD) {
			    pcic_err(pcic->dip, 8, "32 bit card inserted\n");

			    if (pcic->pc_flags & PCF_CARDBUS) {
				sockp->pcs_flags |= PCS_CARD_ISCARDBUS;
#ifdef CARDBUS
				if (!pcic_load_cardbus(pcic, sockp)) {
				    pcic_unload_cardbus(pcic, sockp);
				}

#else
				cmn_err(CE_NOTE,
					"32 bit Cardbus not supported in"
					" this device driver\n");
#endif
			    } else {
				/*
				 * Ignore the card
				 */
				cmn_err(CE_NOTE,
					"32 bit Cardbus not supported on this"
					" device\n");
			    }
			} else {
			    cmn_err(CE_NOTE,
				"Unsupported PCMCIA card inserted\n");
			}
		    }
		    syshw_send_signal(sockp->pcs_syshwsig);
		} else {
		    do_debounce = B_TRUE;
		}
	    } else {
		/*
		 * It is possible to come through here if the system
		 * starts up with cards already inserted. Do nothing
		 * and don't worry about it.
		 */
#ifdef PCIC_DEBUG
		pcic_err(pcic->dip, 5,
			"pcic%d: Odd card insertion indication on socket %d\n",
			ddi_get_instance(pcic->dip),
			sockp->pcs_socket);
#endif
	    }
	    break;

	default:
	    if (!(sockp->pcs_flags & PCS_CARD_PRESENT)) {
		/*
		 * Someone has started to insert a card so delay a while.
		 */
		do_debounce = B_TRUE;
		break;
	    }
		/*
		 * Otherwise this is basically the same as not present
		 * so fall through.
		 */

		/* FALLTHRU */
	case 0:
	    if (sockp->pcs_flags & PCS_CARD_PRESENT) {
		if (pcic->pc_flags & PCF_CBPWRCTL) {
		    pcic_putcb(pcic, CB_CONTROL, 0);
		} else {
		    pcic_putb(pcic, sockp->pcs_socket, PCIC_POWER_CONTROL, 0);
		    (void) pcic_getb(pcic, sockp->pcs_socket,
			PCIC_POWER_CONTROL);
		}
#ifdef PCIC_DEBUG
		pcic_err(pcic->dip, 8, "Card removed\n");
#endif
		sockp->pcs_flags &= ~PCS_CARD_PRESENT;

		if (sockp->pcs_flags & PCS_CARD_IS16BIT) {
		    sockp->pcs_flags &= ~PCS_CARD_IS16BIT;
		    if (pcic_do_removal && pcic->pc_callback) {
			PC_CALLBACK(pcic->dip, pcic->pc_cb_arg,
				    PCE_CARD_REMOVAL, sockp->pcs_socket);
		    }
		}
		if (sockp->pcs_flags & PCS_CARD_ISCARDBUS) {
		    sockp->pcs_flags &= ~PCS_CARD_ISCARDBUS;
		    sockp->pcs_flags |= PCS_CARD_CBREM;
		}
		sockp->pcs_flags |= PCS_CARD_REMOVED;

		do_debounce = B_TRUE;
	    }
	    if (debounce && (sockp->pcs_flags & PCS_CARD_REMOVED)) {
		if (sockp->pcs_flags & PCS_CARD_CBREM) {
		/*
		 * Ensure that we do the unloading in the
		 * debounce handler, that way we're not doing
		 * nasty things in an interrupt handler. e.g.
		 * a USB device will wait for data which will
		 * obviously never come because we've
		 * unplugged the device, but the wait will
		 * wait forever because no interrupts can
		 * come in...
		 */
#ifdef CARDBUS
		    pcic_unload_cardbus(pcic, sockp);
		    /* pcic_dump_all(pcic); */
#endif
		    sockp->pcs_flags &= ~PCS_CARD_CBREM;
		}
		syshw_send_signal(sockp->pcs_syshwsig);
		sockp->pcs_flags &= ~PCS_CARD_REMOVED;
	    }
	    break;
	} /* switch */

	if (do_debounce) {
	/*
	 * Delay doing
	 * anything for a while so that things can settle
	 * down a little. Interrupts are already disabled.
	 * Reset the state and we'll reevaluate the
	 * whole kit 'n kaboodle when the timeout fires
	 */
#ifdef PCIC_DEBUG
		pcic_err(pcic->dip, 8, "Queueing up debounce timeout for "
			"socket %d.%d\n",
			ddi_get_instance(pcic->dip),
			sockp->pcs_socket);
#endif
	    sockp->pcs_debounce_id = pcic_add_debqueue(sockp, debounce_time);

	/*
	 * We bug out here without re-enabling interrupts. They will
	 * be re-enabled when the debounce timeout swings through
	 * here.
	 */
	    return;
	}

	/*
	 * Turn on Card detect interrupts. Other interrupts will be
	 * enabled during set_socket calls.
	 *
	 * Note that set_socket only changes interrupt settings when there
	 * is a card present.
	 */
	irq = pcic_getb(pcic, sockp->pcs_socket, PCIC_MANAGEMENT_INT);
	irq |= PCIC_CD_DETECT;
	pcic_putb(pcic, sockp->pcs_socket, PCIC_MANAGEMENT_INT, irq);

	pcic_err(pcic->dip, 7, "Leaving pcic_handle_cd_change\n");
}

/*
 * pcic_getb()
 *	get an I/O byte based on the yardware decode method
 */
static uint8_t
pcic_getb(pcicdev_t *pcic, int socket, int reg)
{
	int work;

#if defined(PCIC_DEBUG)
	if (pcic_debug == 0x7fff) {
		cmn_err(CE_CONT, "pcic_getb0: pcic=%p socket=%d reg=%d\n",
			(void *)pcic, socket, reg);
		cmn_err(CE_CONT, "pcic_getb1: type=%d handle=%p ioaddr=%p \n",
			pcic->pc_io_type, (void *)pcic->handle,
			(void *)pcic->ioaddr);
	}
#endif

	switch (pcic->pc_io_type) {
	case PCIC_IO_TYPE_YENTA:
		return (ddi_get8(pcic->handle,
		    pcic->ioaddr + CB_R2_OFFSET + reg));
	default:
		work = (socket * PCIC_SOCKET_1) | reg;
		ddi_put8(pcic->handle, pcic->ioaddr, work);
		return (ddi_get8(pcic->handle, pcic->ioaddr + 1));
	}
}

static void
pcic_putb(pcicdev_t *pcic, int socket, int reg, int8_t value)
{
	int work;

#if defined(PCIC_DEBUG)
	if (pcic_debug == 0x7fff) {
		cmn_err(CE_CONT,
			"pcic_putb0: pcic=%p socket=%d reg=%d value=%x \n",
			(void *)pcic, socket, reg, value);
		cmn_err(CE_CONT,
			"pcic_putb1: type=%d handle=%p ioaddr=%p \n",
			pcic->pc_io_type, (void *)pcic->handle,
			(void *)pcic->ioaddr);
	}
#endif


	switch (pcic->pc_io_type) {
	case PCIC_IO_TYPE_YENTA:
		ddi_put8(pcic->handle, pcic->ioaddr + CB_R2_OFFSET + reg,
				value);
		break;
	default:
		work = (socket * PCIC_SOCKET_1) | reg;
		ddi_put8(pcic->handle, pcic->ioaddr, work);
		ddi_put8(pcic->handle, pcic->ioaddr + 1, value);
		break;
	}
}

/*
 * chip identification functions
 */

/*
 * chip identification: Cirrus Logic PD6710/6720/6722
 */
static int
pcic_ci_cirrus(pcicdev_t *pcic)
{
	int value1, value2;

	/* Init the CL id mode */
	value1 = pcic_getb(pcic, 0, PCIC_CHIP_INFO);
	pcic_putb(pcic, 0, PCIC_CHIP_INFO, 0);
	value1 = pcic_getb(pcic, 0, PCIC_CHIP_INFO);
	value2 = pcic_getb(pcic, 0, PCIC_CHIP_INFO);

	if ((value1 & PCIC_CI_ID) == PCIC_CI_ID &&
	    (value2 & PCIC_CI_ID) == 0) {
		/* chip is a Cirrus Logic and not Intel */
		pcic->pc_type = PCIC_CL_PD6710;
		if (value1 & PCIC_CI_SLOTS)
			pcic->pc_chipname = PCIC_TYPE_PD6720;
		else
			pcic->pc_chipname = PCIC_TYPE_PD6710;
		/* now fine tune things just in case a 6722 */
		value1 = clext_reg_read(pcic, 0, PCIC_CLEXT_DMASK_0);
		if (value1 == 0) {
			clext_reg_write(pcic, 0, PCIC_CLEXT_SCRATCH, 0x55);
			value1 = clext_reg_read(pcic, 0, PCIC_CLEXT_SCRATCH);
			if (value1 == 0x55) {
				pcic->pc_chipname = PCIC_TYPE_PD6722;
				pcic->pc_type = PCIC_CL_PD6722;
				clext_reg_write(pcic, 0, PCIC_CLEXT_SCRATCH, 0);
			}
		}
		return (1);
	}
	return (0);
}

/*
 * chip identification: Vadem (VG365/465/468/469)
 */

static void
pcic_vadem_enable(pcicdev_t *pcic)
{
	ddi_put8(pcic->handle, pcic->ioaddr, PCIC_VADEM_P1);
	ddi_put8(pcic->handle, pcic->ioaddr, PCIC_VADEM_P2);
	ddi_put8(pcic->handle, pcic->ioaddr, pcic->pc_lastreg);
}

static int
pcic_ci_vadem(pcicdev_t *pcic)
{
	int value;

	pcic_vadem_enable(pcic);
	value = pcic_getb(pcic, 0, PCIC_CHIP_REVISION);
	pcic_putb(pcic, 0, PCIC_CHIP_REVISION, 0xFF);
	if (pcic_getb(pcic, 0, PCIC_CHIP_REVISION) ==
	    (value | PCIC_VADEM_D3) ||
	    (pcic_getb(pcic, 0, PCIC_CHIP_REVISION) & PCIC_REV_MASK) ==
	    PCIC_VADEM_469) {
		int vadem, new;
		pcic_vadem_enable(pcic);
		vadem = pcic_getb(pcic, 0, PCIC_VG_DMA) &
			~(PCIC_V_UNLOCK | PCIC_V_VADEMREV);
		new = vadem | (PCIC_V_VADEMREV|PCIC_V_UNLOCK);
		pcic_putb(pcic, 0, PCIC_VG_DMA, new);
		value = pcic_getb(pcic, 0, PCIC_CHIP_REVISION);

		/* want to lock but leave mouse or other on */
		pcic_putb(pcic, 0, PCIC_VG_DMA, vadem);
		switch (value & PCIC_REV_MASK) {
		case PCIC_VADEM_365:
			pcic->pc_chipname = PCIC_VG_365;
			pcic->pc_type = PCIC_VADEM;
			break;
		case PCIC_VADEM_465:
			pcic->pc_chipname = PCIC_VG_465;
			pcic->pc_type = PCIC_VADEM;
			pcic->pc_flags |= PCF_1SOCKET;
			break;
		case PCIC_VADEM_468:
			pcic->pc_chipname = PCIC_VG_468;
			pcic->pc_type = PCIC_VADEM;
			break;
		case PCIC_VADEM_469:
			pcic->pc_chipname = PCIC_VG_469;
			pcic->pc_type = PCIC_VADEM_VG469;
			break;
		}
		return (1);
	}
	return (0);
}

/*
 * chip identification: Ricoh
 */
static int
pcic_ci_ricoh(pcicdev_t *pcic)
{
	int value;

	value = pcic_getb(pcic, 0, PCIC_RF_CHIP_IDENT);
	switch (value) {
	case PCIC_RF_296:
		pcic->pc_type = PCIC_RICOH;
		pcic->pc_chipname = PCIC_TYPE_RF5C296;
		return (1);
	case PCIC_RF_396:
		pcic->pc_type = PCIC_RICOH;
		pcic->pc_chipname = PCIC_TYPE_RF5C396;
		return (1);
	}
	return (0);
}


/*
 * set up available address spaces in busra
 */
static void
pcic_init_assigned(dev_info_t *dip)
{
	pcm_regs_t *pcic_avail_p;
	pci_regspec_t *pci_avail_p, *regs;
	int len, entries, rlen;
	dev_info_t *pdip;

	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "available", (caddr_t)&pcic_avail_p, &len) == DDI_PROP_SUCCESS) {
		/*
		 * found "available" property at the cardbus/pcmcia node
		 * need to translate address space entries from pcmcia
		 * format to pci format
		 */
		entries = len / sizeof (pcm_regs_t);
		pci_avail_p = kmem_alloc(sizeof (pci_regspec_t) * entries,
			KM_SLEEP);
		if (pcic_apply_avail_ranges(dip, pcic_avail_p, pci_avail_p,
		    entries) == DDI_SUCCESS)
			(void) pci_resource_setup_avail(dip, pci_avail_p,
				entries);
		kmem_free(pcic_avail_p, len);
		kmem_free(pci_avail_p, entries * sizeof (pci_regspec_t));
		return;
	}

	/*
	 * "legacy" platforms will have "available" property in pci node
	 */
	for (pdip = ddi_get_parent(dip); pdip; pdip = ddi_get_parent(pdip)) {
		if (ddi_getlongprop(DDI_DEV_T_ANY, pdip, DDI_PROP_DONTPASS,
		    "available", (caddr_t)&pci_avail_p, &len) ==
		    DDI_PROP_SUCCESS) {
			/* (void) pci_resource_setup(pdip); */
			kmem_free(pci_avail_p, len);
			break;
		}
	}

	if (pdip == NULL) {
		int len;
		char bus_type[16] = "(unknown)";
		dev_info_t *par;

		cmn_err(CE_CONT,
		    "?pcic_init_assigned: no available property for pcmcia\n");

		/*
		 * This code is taken from pci_resource_setup() but does
		 * not attempt to use the "available" property to populate
		 * the ndi maps that are created.
		 * The fact that we will actually
		 * free some resource below (that was allocated by OBP)
		 * should be enough to be going on with.
		 */
		for (par = dip; par != NULL; par = ddi_get_parent(par)) {
			len = sizeof (bus_type);

			if ((ddi_prop_op(DDI_DEV_T_ANY, par,
			    PROP_LEN_AND_VAL_BUF,
			    DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
			    "device_type",
			    (caddr_t)&bus_type, &len) == DDI_SUCCESS) &&
			    (strcmp(bus_type, "pci") == 0))
				break;
		}
		if (par != NULL &&
		    (ndi_ra_map_setup(par, NDI_RA_TYPE_MEM) != NDI_SUCCESS ||
		    ndi_ra_map_setup(par, NDI_RA_TYPE_IO) != NDI_SUCCESS))
			par = NULL;
	} else {
#ifdef CARDBUS
		cardbus_bus_range_t *bus_range;
		int k;

		if (ddi_getlongprop(DDI_DEV_T_ANY, pdip, 0, "bus-range",
		    (caddr_t)&bus_range, &k) == DDI_PROP_SUCCESS) {
			if (bus_range->lo != bus_range->hi)
				pcic_err(pdip, 9, "allowable bus range is "
				    "%u->%u\n", bus_range->lo, bus_range->hi);
			else {
				pcic_err(pdip, 0,
				    "!No spare PCI bus numbers, range is "
				    "%u->%u, cardbus isn't usable\n",
				    bus_range->lo, bus_range->hi);
			}
			kmem_free(bus_range, k);
		} else
			pcic_err(pdip, 0, "!No bus-range property seems to "
			    "have been set up\n");
#endif
		/*
		 * Have a valid parent with the "available" property
		 */
		(void) pci_resource_setup(pdip);
	}

	if ((strcmp(ddi_get_name(dip), "pcma") == 0) &&
	    ddi_getlongprop(DDI_DEV_T_NONE, dip, DDI_PROP_DONTPASS,
	    "assigned-addresses",
	    (caddr_t)&regs, &rlen) == DDI_SUCCESS) {
		ra_return_t ra;

		/*
		 * On the UltraBook IIi the ranges are assigned under
		 * openboot. If we don't free them here the first I/O
		 * space that can be used is up above 0x10000 which
		 * doesn't work for this driver due to restrictions
		 * on the PCI I/O addresses the controllers can cope with.
		 * They are never going to be used by anything else
		 * so free them up to the general pool. AG.
		 */
		pcic_err(dip, 1, "Free assigned addresses\n");

		if ((PCI_REG_ADDR_G(regs[0].pci_phys_hi) ==
		    PCI_REG_ADDR_G(PCI_ADDR_MEM32)) &&
		    regs[0].pci_size_low == 0x1000000) {
			ra.ra_addr_lo = regs[0].pci_phys_low;
			ra.ra_len = regs[0].pci_size_low;
			(void) pcmcia_free_mem(dip, &ra);
		}
		if ((PCI_REG_ADDR_G(regs[1].pci_phys_hi) ==
		    PCI_REG_ADDR_G(PCI_ADDR_IO)) &&
		    (regs[1].pci_size_low == 0x8000 ||
		    regs[1].pci_size_low == 0x4000))   /* UB-IIi || UB-I */
		{
			ra.ra_addr_lo = regs[1].pci_phys_low;
			ra.ra_len = regs[1].pci_size_low;
			(void) pcmcia_free_io(dip, &ra);
		}
		kmem_free((caddr_t)regs, rlen);
	}
}

/*
 * translate "available" from pcmcia format to pci format
 */
static int
pcic_apply_avail_ranges(dev_info_t *dip, pcm_regs_t *pcic_p,
    pci_regspec_t *pci_p, int entries)
{
	int i, range_len, range_entries;
	pcic_ranges_t *pcic_range_p;

	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "ranges",
		    (caddr_t)&pcic_range_p, &range_len) != DDI_PROP_SUCCESS) {
		cmn_err(CE_CONT, "?pcic_apply_avail_ranges: "
			"no ranges property for pcmcia\n");
		return (DDI_FAILURE);
	}

	range_entries = range_len / sizeof (pcic_ranges_t);

	/* for each "available" entry to be translated */
	for (i = 0; i < entries; i++, pcic_p++, pci_p++) {
		int j;
		pcic_ranges_t *range_p = pcic_range_p;
		pci_p->pci_phys_hi = -1u; /* default invalid value */

		/* for each "ranges" entry to be searched */
		for (j = 0; j < range_entries; j++, range_p++) {
			uint64_t range_end = range_p->pcic_range_caddrlo +
				range_p->pcic_range_size;
			uint64_t avail_end = pcic_p->phys_lo + pcic_p->phys_len;

			if ((range_p->pcic_range_caddrhi != pcic_p->phys_hi) ||
			    (range_p->pcic_range_caddrlo > pcic_p->phys_lo) ||
			    (range_end < avail_end))
				continue;

			pci_p->pci_phys_hi = range_p->pcic_range_paddrhi;
			pci_p->pci_phys_mid = range_p->pcic_range_paddrmid;
			pci_p->pci_phys_low = range_p->pcic_range_paddrlo
			    + (pcic_p->phys_lo - range_p->pcic_range_caddrlo);
			pci_p->pci_size_hi = 0;
			pci_p->pci_size_low = pcic_p->phys_len;
		}
	}
	kmem_free(pcic_range_p, range_len);
	return (DDI_SUCCESS);
}

static int
pcic_open(dev_t *dev, int flag, int otyp, cred_t *cred)
{
	if (getminor(*dev) == SYSHW_MINOR)
		return (syshw_open(dev, flag, otyp, cred));
#ifdef CARDBUS
	if (cardbus_is_cb_minor(*dev))
		return (cardbus_open(dev, flag, otyp, cred));
#endif
	return (EINVAL);
}

static int
pcic_close(dev_t dev, int flag, int otyp, cred_t *cred)
{
	if (getminor(dev) == SYSHW_MINOR)
		return (syshw_close(dev, flag, otyp, cred));
#ifdef CARDBUS
	if (cardbus_is_cb_minor(dev))
		return (cardbus_close(dev, flag, otyp, cred));
#endif
	return (EINVAL);
}

static int
pcic_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred,
	int *rval)
{
	if (getminor(dev) == SYSHW_MINOR)
		return (syshw_ioctl(dev, cmd, arg, mode, cred, rval));
#ifdef CARDBUS
	if (cardbus_is_cb_minor(dev))
		return (cardbus_ioctl(dev, cmd, arg, mode, cred, rval));
#endif
	return (EINVAL);
}


static boolean_t
pcic_load_cardbus(pcicdev_t *pcic, const pcic_socket_t *sockp)
{
	uint32_t present_state;
	dev_info_t *dip = pcic->dip;
	set_socket_t s;
	get_socket_t g;
	boolean_t retval;
	unsigned vccLevel;

	pcic_err(dip, 8, "entering pcic_load_cardbus\n");

	pcic_mutex_exit(&pcic->pc_lock);

	bzero(&s, sizeof (set_socket_t));
	s.socket = sockp->pcs_socket;
	s.SCIntMask = SBM_CD|SBM_RDYBSY;
	s.IFType = IF_CARDBUS;
	s.State = (unsigned)~0;

	present_state = pcic_getcb(pcic, CB_PRESENT_STATE);
	if (present_state & PCIC_VCC_3VCARD)
		s.VccLevel = PCIC_VCC_3VLEVEL;
	else if (present_state & PCIC_VCC_5VCARD)
		s.VccLevel = PCIC_VCC_5VLEVEL;
	else {
		cmn_err(CE_CONT,
		    "pcic_load_cardbus: unsupported card voltage\n");
		goto failure;
	}
	vccLevel = s.VccLevel;
	s.Vpp1Level = s.Vpp2Level = 0;

	if (pcic_set_socket(dip, &s) != SUCCESS)
		goto failure;

	if (pcic_reset_socket(dip, sockp->pcs_socket,
	    RESET_MODE_CARD_ONLY) != SUCCESS)
		goto failure;

	bzero(&g, sizeof (get_socket_t));
	g.socket = sockp->pcs_socket;
	if (pcic_get_socket(dip, &g) != SUCCESS)
		goto failure;

	bzero(&s, sizeof (set_socket_t));
	s.socket = sockp->pcs_socket;
	s.SCIntMask = SBM_CD;
	s.IREQRouting = g.IRQRouting;
	s.IFType = g.IFType;
	s.CtlInd = g.CtlInd;
	s.State = (unsigned)~0;
	s.VccLevel = vccLevel;
	s.Vpp1Level = s.Vpp2Level = 0;

	if (pcic_set_socket(dip, &s) != SUCCESS)
		goto failure;

	retval = cardbus_load_cardbus(dip, sockp->pcs_socket, pcic->pc_base);
	goto exit;

failure:
	retval = B_FALSE;

exit:
	pcic_mutex_enter(&pcic->pc_lock);
	pcic_err(dip, 8, "exit pcic_load_cardbus (%s)\n",
	    retval ? "success" : "failure");
	return (retval);
}

static void
pcic_unload_cardbus(pcicdev_t *pcic, const pcic_socket_t *sockp)
{
	dev_info_t *dip = pcic->dip;
	set_socket_t s;

	pcic_mutex_exit(&pcic->pc_lock);

	cardbus_unload_cardbus(dip);

	bzero(&s, sizeof (set_socket_t));
	s.socket = sockp->pcs_socket;
	s.SCIntMask = SBM_CD|SBM_RDYBSY;
	s.IREQRouting = 0;
	s.IFType = IF_MEMORY;
	s.CtlInd = 0;
	s.State = 0;
	s.VccLevel = s.Vpp1Level = s.Vpp2Level = 0;

	(void) pcic_set_socket(dip, &s);

	pcic_mutex_enter(&pcic->pc_lock);
}

static uint32_t
pcic_getcb(pcicdev_t *pcic, int reg)
{
	ASSERT(pcic->pc_io_type == PCIC_IO_TYPE_YENTA);

	return (ddi_get32(pcic->handle,
	    (uint32_t *)(pcic->ioaddr + CB_CB_OFFSET + reg)));
}

static void
pcic_putcb(pcicdev_t *pcic, int reg, uint32_t value)
{
	ASSERT(pcic->pc_io_type == PCIC_IO_TYPE_YENTA);

	ddi_put32(pcic->handle,
	    (uint32_t *)(pcic->ioaddr + CB_CB_OFFSET + reg), value);
}

static void
pcic_enable_io_intr(pcicdev_t *pcic, int socket, int irq)
{
	uint8_t value;
	uint16_t brdgctl;

	value = pcic_getb(pcic, socket, PCIC_INTERRUPT) & ~PCIC_INTR_MASK;
	pcic_putb(pcic, socket, PCIC_INTERRUPT, value | irq);

	switch (pcic->pc_type) {
	case PCIC_INTEL_i82092:
		pcic_82092_smiirq_ctl(pcic, socket, PCIC_82092_CTL_IRQ,
		    PCIC_82092_INT_ENABLE);
		break;
	case PCIC_O2_OZ6912:
		value = pcic_getb(pcic, 0, PCIC_CENTDMA);
		value |= 0x8;
		pcic_putb(pcic, 0, PCIC_CENTDMA, value);
		break;
	case PCIC_CL_PD6832:
	case PCIC_TI_PCI1250:
	case PCIC_TI_PCI1221:
	case PCIC_TI_PCI1225:
	case PCIC_TI_PCI1410:
	case PCIC_ENE_1410:
	case PCIC_TI_PCI1510:
	case PCIC_TI_PCI1520:
	case PCIC_TI_PCI1420:
	case PCIC_ENE_1420:
		/* route card functional interrupts to PCI interrupts */
		brdgctl = ddi_get16(pcic->cfg_handle,
		    (uint16_t *)(pcic->cfgaddr + PCI_CBUS_BRIDGE_CTRL));
		pcic_err(NULL, 1,
		    "pcic_enable_io_intr brdgctl(0x%x) was: 0x%x\n",
		    PCI_CBUS_BRIDGE_CTRL, brdgctl);
		brdgctl &= ~PCIC_BRDGCTL_INTR_MASK;
		ddi_put16(pcic->cfg_handle,
		    (uint16_t *)(pcic->cfgaddr + PCI_CBUS_BRIDGE_CTRL),
		    brdgctl);
		/* Flush the write */
		(void) ddi_get16(pcic->cfg_handle,
		    (uint16_t *)(pcic->cfgaddr + PCI_CBUS_BRIDGE_CTRL));
		break;
	default:
		break;
	}
}

static void
pcic_disable_io_intr(pcicdev_t *pcic, int socket)
{
	uint8_t value;
	uint16_t brdgctl;

	value = pcic_getb(pcic, socket, PCIC_INTERRUPT) & ~PCIC_INTR_MASK;
	pcic_putb(pcic, socket, PCIC_INTERRUPT, value);

	switch (pcic->pc_type) {
	case PCIC_INTEL_i82092:
		pcic_82092_smiirq_ctl(pcic, socket, PCIC_82092_CTL_IRQ,
		    PCIC_82092_INT_DISABLE);
		break;
	case PCIC_O2_OZ6912:
		value = pcic_getb(pcic, 0, PCIC_CENTDMA);
		value &= ~0x8;
		pcic_putb(pcic, 0, PCIC_CENTDMA, value);
		/* Flush the write */
		(void) pcic_getb(pcic, 0, PCIC_CENTDMA);
		break;
	case PCIC_CL_PD6832:
	case PCIC_TI_PCI1250:
	case PCIC_TI_PCI1221:
	case PCIC_TI_PCI1225:
	case PCIC_TI_PCI1410:
	case PCIC_ENE_1410:
	case PCIC_TI_PCI1510:
	case PCIC_TI_PCI1520:
	case PCIC_TI_PCI1420:
	case PCIC_ENE_1420:
		/*
		 * This maps I/O interrupts to ExCA which
		 * have been turned off by the write to
		 * PCIC_INTERRUPT above. It would appear to
		 * be the only way to actually turn I/O Ints off
		 * while retaining CS Ints.
		 */
		brdgctl = ddi_get16(pcic->cfg_handle,
		    (uint16_t *)(pcic->cfgaddr + PCI_CBUS_BRIDGE_CTRL));
		pcic_err(NULL, 1,
		    "pcic_disable_io_intr brdgctl(0x%x) was: 0x%x\n",
		    PCI_CBUS_BRIDGE_CTRL, brdgctl);
		brdgctl |= PCIC_BRDGCTL_INTR_MASK;
		ddi_put16(pcic->cfg_handle,
		    (uint16_t *)(pcic->cfgaddr + PCI_CBUS_BRIDGE_CTRL),
		    brdgctl);
		/* Flush the write */
		(void) ddi_get16(pcic->cfg_handle,
		    (uint16_t *)(pcic->cfgaddr + PCI_CBUS_BRIDGE_CTRL));
		break;
	default:
		break;
	}
}

static void
pcic_cb_enable_intr(dev_info_t *dip)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;

	mutex_enter(&pcic->pc_lock);
	pcic_enable_io_intr(pcic, 0, pcic->pc_sockets[0].pcs_irq);
	mutex_exit(&pcic->pc_lock);
}

static void
pcic_cb_disable_intr(dev_info_t *dip)
{
	anp_t *anp = ddi_get_driver_private(dip);
	pcicdev_t *pcic = anp->an_private;

	mutex_enter(&pcic->pc_lock);
	pcic_disable_io_intr(pcic, 0);
	mutex_exit(&pcic->pc_lock);
}

static int
log_pci_cfg_err(ushort_t e, int bridge_secondary)
{
	int	nerr = 0;
	if (e & PCI_STAT_PERROR) {
		nerr++;
		cmn_err(CE_CONT, "detected parity error.\n");
	}
	if (e & PCI_STAT_S_SYSERR) {
		nerr++;
		if (bridge_secondary)
			cmn_err(CE_CONT, "received system error.\n");
		else
			cmn_err(CE_CONT, "signalled system error.\n");
	}
	if (e & PCI_STAT_R_MAST_AB) {
		nerr++;
		cmn_err(CE_CONT, "received master abort.\n");
	}
	if (e & PCI_STAT_R_TARG_AB)
		cmn_err(CE_CONT, "received target abort.\n");
	if (e & PCI_STAT_S_TARG_AB)
		cmn_err(CE_CONT, "signalled target abort\n");
	if (e & PCI_STAT_S_PERROR) {
		nerr++;
		cmn_err(CE_CONT, "signalled parity error\n");
	}
	return (nerr);
}

#if defined(__sparc)
static int
pcic_fault(enum pci_fault_ops op, void *arg)
{
	pcicdev_t *pcic = (pcicdev_t *)arg;
	ushort_t pci_cfg_stat =
	    pci_config_get16(pcic->cfg_handle, PCI_CONF_STAT);
	ushort_t pci_cfg_sec_stat =
	    pci_config_get16(pcic->cfg_handle, 0x16);
	char	nm[24];
	int	nerr = 0;

	cardbus_dump_pci_config(pcic->dip);

	switch (op) {
	case FAULT_LOG:
		(void) sprintf(nm, "%s-%d", ddi_driver_name(pcic->dip),
		    ddi_get_instance(pcic->dip));

		cmn_err(CE_WARN, "%s: PCIC fault log start:\n", nm);
		cmn_err(CE_WARN, "%s: primary err (%x):\n", nm, pci_cfg_stat);
		nerr += log_pci_cfg_err(pci_cfg_stat, 0);
		cmn_err(CE_WARN, "%s: sec err (%x):\n", nm, pci_cfg_sec_stat);
		nerr += log_pci_cfg_err(pci_cfg_sec_stat, 1);
		cmn_err(CE_CONT, "%s: PCI fault log end.\n", nm);
		return (nerr);
	case FAULT_POKEFINI:
	case FAULT_RESET:
		pci_config_put16(pcic->cfg_handle,
		    PCI_CONF_STAT, pci_cfg_stat);
		pci_config_put16(pcic->cfg_handle, 0x16, pci_cfg_sec_stat);
		break;
	case FAULT_POKEFLT:
		if (!(pci_cfg_stat & PCI_STAT_S_SYSERR))
			return (1);
		if (!(pci_cfg_sec_stat & PCI_STAT_R_MAST_AB))
			return (1);
		break;
	default:
		break;
	}
	return (DDI_SUCCESS);
}
#endif

static void
pcic_delayed_resume(void *arg)
{
	int	i, j, interrupt;
	anp_t *pcic_nexus;
	pcicdev_t *pcic;

	_NOTE(ARGUNUSED(arg))

#if defined(PCIC_DEBUG)
	pcic_err(NULL, 6, "pcic_delayed_resume(): entered\n");
#endif
	for (j = 0; j <= pcic_maxinst; j++) {

		pcic_nexus = ddi_get_soft_state(pcic_soft_state_p, j);
		if (!pcic_nexus)
			continue;
		pcic = (pcicdev_t *)pcic_nexus->an_private;
		if (!pcic)
			continue;

		pcic_mutex_enter(&pcic->pc_lock); /* protect the registers */
		for (i = 0; i < pcic->pc_numsockets; i++) {
			/* Enable interrupts  on PCI if needs be */
			interrupt = pcic_getb(pcic, i, PCIC_INTERRUPT);
			if (pcic->pc_flags & PCF_USE_SMI)
				interrupt |= PCIC_INTR_ENABLE;
			pcic_putb(pcic, i, PCIC_INTERRUPT,
			    PCIC_RESET | interrupt);
			pcic->pc_sockets[i].pcs_debounce_id =
			    pcic_add_debqueue(&pcic->pc_sockets[i],
			    drv_usectohz(pcic_debounce_time));
		}
		pcic_mutex_exit(&pcic->pc_lock); /* protect the registers */
		if (pcic_do_pcmcia_sr)
			(void) pcmcia_wait_insert(pcic->dip);
	}
}

static void
pcic_debounce(pcic_socket_t *pcs)
{
	uint8_t status, stschng;

	pcic_mutex_enter(&pcs->pcs_pcic->pc_lock);
	pcs->pcs_flags &= ~PCS_STARTING;
	stschng = pcic_getb(pcs->pcs_pcic, pcs->pcs_socket,
	    PCIC_CARD_STATUS_CHANGE);
	status = pcic_getb(pcs->pcs_pcic, pcs->pcs_socket,
	    PCIC_INTERFACE_STATUS);
#ifdef PCIC_DEBUG
	pcic_err(pcs->pcs_pcic->dip, 8,
	    "pcic_debounce(0x%p, dip=0x%p) socket %d st 0x%x "
	    "chg 0x%x flg 0x%x\n",
	    (void *)pcs, (void *) pcs->pcs_pcic->dip, pcs->pcs_socket,
	    status, stschng, pcs->pcs_flags);
#endif

	pcic_putb(pcs->pcs_pcic, pcs->pcs_socket, PCIC_CARD_STATUS_CHANGE,
	    PCIC_CD_DETECT);
	pcic_handle_cd_change(pcs->pcs_pcic, pcs, status);
	pcic_mutex_exit(&pcs->pcs_pcic->pc_lock);
}

static void
pcic_deb_thread()
{
	callb_cpr_t cprinfo;
	struct debounce *debp;
	clock_t lastt;

	CALLB_CPR_INIT(&cprinfo, &pcic_deb_mtx,
	    callb_generic_cpr, "pcic debounce thread");
	mutex_enter(&pcic_deb_mtx);
	while (pcic_deb_threadid) {
		while (pcic_deb_queue) {
#ifdef PCIC_DEBUG
			pcic_dump_debqueue("Thread");
#endif
			debp = pcic_deb_queue;
			(void) drv_getparm(LBOLT, &lastt);
			if (lastt >= debp->expire) {
				pcic_deb_queue = debp->next;
				mutex_exit(&pcic_deb_mtx);
				pcic_debounce(debp->pcs);
				mutex_enter(&pcic_deb_mtx);
				kmem_free(debp, sizeof (*debp));
			} else {
				(void) cv_timedwait(&pcic_deb_cv,
				    &pcic_deb_mtx, debp->expire);
			}
		}
		CALLB_CPR_SAFE_BEGIN(&cprinfo);
		cv_wait(&pcic_deb_cv, &pcic_deb_mtx);
		CALLB_CPR_SAFE_END(&cprinfo, &pcic_deb_mtx);
	}
	pcic_deb_threadid = (kthread_t *)1;
	cv_signal(&pcic_deb_cv);
	CALLB_CPR_EXIT(&cprinfo);	/* Also exits the mutex */
	thread_exit();
}

static void *
pcic_add_debqueue(pcic_socket_t *pcs, int clocks)
{
	clock_t lbolt;
	struct debounce *dbp, **dbpp = &pcic_deb_queue;

	(void) drv_getparm(LBOLT, &lbolt);
	dbp = kmem_alloc(sizeof (struct debounce), KM_NOSLEEP);

	dbp->expire = lbolt + clocks;
	dbp->pcs = pcs;
	mutex_enter(&pcic_deb_mtx);
	while (*dbpp) {
		if (dbp->expire > (*dbpp)->expire)
			dbpp = &((*dbpp)->next);
		else
			break;
	}
	dbp->next = *dbpp;
	*dbpp = dbp;
#ifdef PCIC_DEBUG
	pcic_dump_debqueue("Add");
#endif
	cv_signal(&pcic_deb_cv);
	mutex_exit(&pcic_deb_mtx);
	return (dbp);
}

static void
pcic_rm_debqueue(void *id)
{
	struct debounce *dbp, **dbpp = &pcic_deb_queue;

	dbp = (struct debounce *)id;
	mutex_enter(&pcic_deb_mtx);
	while (*dbpp) {
		if (*dbpp == dbp) {
			*dbpp = dbp->next;
			kmem_free(dbp, sizeof (*dbp));
#ifdef PCIC_DEBUG
			pcic_dump_debqueue("Remove");
#endif
			cv_signal(&pcic_deb_cv);
			mutex_exit(&pcic_deb_mtx);
			return;
		}
		dbpp = &((*dbpp)->next);
	}
	pcic_err(NULL, 6, "pcic: Failed to find debounce id 0x%p\n", id);
	mutex_exit(&pcic_deb_mtx);
}


static int	pcic_powerdelay = 0;

static int
pcic_exca_powerctl(pcicdev_t *pcic, int socket, int powerlevel)
{
	int	ind, value, orig_pwrctl;

	/* power setup -- if necessary */
	orig_pwrctl = pcic_getb(pcic, socket, PCIC_POWER_CONTROL);

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 6,
	    "pcic_exca_powerctl(socket %d) powerlevel=%x orig 0x%x\n",
	    socket, powerlevel, orig_pwrctl);
#endif
	/* Preserve the PCIC_OUTPUT_ENABLE (control lines output enable) bit. */
	powerlevel = (powerlevel & ~POWER_OUTPUT_ENABLE) |
	    (orig_pwrctl & POWER_OUTPUT_ENABLE);
	if (powerlevel != orig_pwrctl) {
		if (powerlevel & ~POWER_OUTPUT_ENABLE) {
			int	ifs;
			/*
			 * set power to socket
			 * note that the powerlevel was calculated earlier
			 */
			pcic_putb(pcic, socket, PCIC_POWER_CONTROL, powerlevel);
			(void) pcic_getb(pcic, socket, PCIC_POWER_CONTROL);

			/*
			 * this second write to the power control register
			 * is needed to resolve a problem on
			 * the IBM ThinkPad 750
			 * where the first write doesn't latch.
			 * The second write appears to always work and
			 * doesn't hurt the operation of other chips
			 * so we can just use it -- this is good since we can't
			 * determine what chip the 750 actually uses
			 * (I suspect an early Ricoh).
			 */
			pcic_putb(pcic, socket, PCIC_POWER_CONTROL, powerlevel);

			value = pcic_getb(pcic, socket, PCIC_POWER_CONTROL);
			pcic_mswait(pcic, socket, pcic_powerdelay);
#if defined(PCIC_DEBUG)
			pcic_err(pcic->dip, 8,
			    "\tpowerlevel reg = %x (ifs %x)\n",
			    value, pcic_getb(pcic, socket,
			    PCIC_INTERFACE_STATUS));
			pcic_err(pcic->dip, 8,
			    "CBus regs: PS 0x%x, Control 0x%x\n",
			    pcic_getcb(pcic, CB_PRESENT_STATE),
			    pcic_getcb(pcic, CB_CONTROL));
#endif
			/*
			 * since power was touched, make sure it says it
			 * is on.  This lets it become stable.
			 */
			for (ind = 0; ind < 20; ind++) {
				ifs = pcic_getb(pcic, socket,
				    PCIC_INTERFACE_STATUS);
				if (ifs & PCIC_POWER_ON)
					break;
				else {
					pcic_putb(pcic, socket,
					    PCIC_POWER_CONTROL, 0);
					(void) pcic_getb(pcic, socket,
					    PCIC_POWER_CONTROL);
					pcic_mswait(pcic, socket, 40);
					if (ind == 10) {
						pcic_putcb(pcic, CB_EVENT_FORCE,
						    CB_EF_CVTEST);
						pcic_mswait(pcic, socket, 100);
					}
					pcic_putb(pcic, socket,
					    PCIC_POWER_CONTROL,
					    powerlevel & ~POWER_OUTPUT_ENABLE);
					(void) pcic_getb(pcic, socket,
					    PCIC_POWER_CONTROL);
					pcic_mswait(pcic, socket,
					    pcic_powerdelay);
					pcic_putb(pcic, socket,
					    PCIC_POWER_CONTROL, powerlevel);
					(void) pcic_getb(pcic, socket,
					    PCIC_POWER_CONTROL);
					pcic_mswait(pcic, socket,
					    pcic_powerdelay);
				}
			}

			if (!(ifs & PCIC_POWER_ON)) {
				cmn_err(CE_WARN,
				    "pcic socket %d: Power didn't get turned"
				    "on!\nif status 0x%x pwrc 0x%x(x%x) "
				    "misc1 0x%x igc 0x%x ind %d\n",
				    socket, ifs,
				    pcic_getb(pcic, socket, PCIC_POWER_CONTROL),
				    orig_pwrctl,
				    pcic_getb(pcic, socket, PCIC_MISC_CTL_1),
				    pcic_getb(pcic, socket, PCIC_INTERRUPT),
				    ind);
				return (BAD_VCC);
			}
#if defined(PCIC_DEBUG)
			pcic_err(pcic->dip, 8,
			    "\tind = %d, if status %x pwrc 0x%x "
			    "misc1 0x%x igc 0x%x\n",
			    ind, ifs,
			    pcic_getb(pcic, socket, PCIC_POWER_CONTROL),
			    pcic_getb(pcic, socket, PCIC_MISC_CTL_1),
			    pcic_getb(pcic, socket, PCIC_INTERRUPT));
#endif
		} else {
			/* explicitly turned off the power */
			pcic_putb(pcic, socket, PCIC_POWER_CONTROL, powerlevel);
			(void) pcic_getb(pcic, socket, PCIC_POWER_CONTROL);
		}
	}
	return (SUCCESS);
}

static int pcic_cbdoreset_during_poweron = 1;
static int
pcic_cbus_powerctl(pcicdev_t *pcic, int socket)
{
	uint32_t cbctl = 0, orig_cbctl, cbstev, cbps;
	int ind, iobits;
	pcic_socket_t *sockp = &pcic->pc_sockets[socket];

	pcic_putcb(pcic, CB_STATUS_EVENT, CB_SE_POWER_CYCLE);

	ind = pcic_power[sockp->pcs_vpp1].PowerLevel/10;
	cbctl |= pcic_cbv_levels[ind];

	ind = pcic_power[sockp->pcs_vcc].PowerLevel/10;
	cbctl |= (pcic_cbv_levels[ind]<<4);

	orig_cbctl = pcic_getcb(pcic, CB_CONTROL);

#if defined(PCIC_DEBUG)
	pcic_err(pcic->dip, 6,
	    "pcic_cbus_powerctl(socket %d) vcc %d vpp1 %d "
	    "cbctl 0x%x->0x%x\n",
	    socket, sockp->pcs_vcc, sockp->pcs_vpp1, orig_cbctl, cbctl);
#endif
	if (cbctl != orig_cbctl) {
	    if (pcic_cbdoreset_during_poweron &&
		(orig_cbctl & (CB_C_VCCMASK|CB_C_VPPMASK)) == 0) {
		iobits = pcic_getb(pcic, socket, PCIC_INTERRUPT);
		pcic_putb(pcic, socket, PCIC_INTERRUPT, iobits & ~PCIC_RESET);
	    }
	    pcic_putcb(pcic, CB_CONTROL, cbctl);

	    if ((cbctl & CB_C_VCCMASK) == (orig_cbctl & CB_C_VCCMASK)) {
		pcic_mswait(pcic, socket, pcic_powerdelay);
		return (SUCCESS);
	    }
	    for (ind = 0; ind < 20; ind++) {
		cbstev = pcic_getcb(pcic, CB_STATUS_EVENT);

		if (cbstev & CB_SE_POWER_CYCLE) {

		/*
		 * delay 400 ms: though the standard defines that the Vcc
		 * set-up time is 20 ms, some PC-Card bridge requires longer
		 * duration.
		 * Note: We should check the status AFTER the delay to give time
		 * for things to stabilize.
		 */
		    pcic_mswait(pcic, socket, 400);

		    cbps = pcic_getcb(pcic, CB_PRESENT_STATE);
		    if (cbctl && !(cbps & CB_PS_POWER_CYCLE)) {
			/* break; */
			cmn_err(CE_WARN, "cbus_powerctl: power off??\n");
		    }
		    if (cbctl & CB_PS_BADVCC) {
			cmn_err(CE_WARN, "cbus_powerctl: bad power request\n");
			break;
		    }

#if defined(PCIC_DEBUG)
		    pcic_err(pcic->dip, 8,
			"cbstev = 0x%x cbps = 0x%x cbctl 0x%x(0x%x)",
			cbstev, pcic_getcb(pcic, CB_PRESENT_STATE),
			cbctl, orig_cbctl);
#endif
		    if (pcic_cbdoreset_during_poweron &&
			(orig_cbctl & (CB_C_VCCMASK|CB_C_VPPMASK)) == 0) {
			pcic_putb(pcic, socket, PCIC_INTERRUPT, iobits);
		    }
		    return (SUCCESS);
		}
		pcic_mswait(pcic, socket, 40);
	    }
	    if (pcic_cbdoreset_during_poweron &&
		(orig_cbctl & (CB_C_VCCMASK|CB_C_VPPMASK)) == 0) {
		pcic_putb(pcic, socket, PCIC_INTERRUPT, iobits);
	    }
	    cmn_err(CE_WARN,
		    "pcic socket %d: Power didn't get turned on/off!\n"
		    "cbstev = 0x%x cbps = 0x%x cbctl 0x%x(0x%x) "
		    "vcc %d vpp1 %d", socket, cbstev,
		    pcic_getcb(pcic, CB_PRESENT_STATE),
		    cbctl, orig_cbctl, sockp->pcs_vcc, sockp->pcs_vpp1);
	    return (BAD_VCC);
	}
	return (SUCCESS);
}

static int	pcic_do_pprintf = 0;

static void
pcic_dump_debqueue(char *msg)
{
	struct debounce *debp = pcic_deb_queue;
	clock_t lbolt;

	(void) drv_getparm(LBOLT, &lbolt);
	pcic_err(NULL, 6, debp ? "pcic debounce list (%s) lbolt 0x%x:\n" :
	    "pcic debounce_list (%s) EMPTY lbolt 0x%x\n", msg, lbolt);
	while (debp) {
		pcic_err(NULL, 6, "%p: exp 0x%x next 0x%p id 0x%p\n",
		    (void *) debp, (int)debp->expire, (void *) debp->next,
		    debp->pcs->pcs_debounce_id);
		debp = debp->next;
	}
}


/* PRINTFLIKE3 */
static void
pcic_err(dev_info_t *dip, int level, const char *fmt, ...)
{
	if (pcic_debug && (level <= pcic_debug)) {
		va_list adx;
		int	instance;
		char	buf[256];
		const char	*name;
#if !defined(PCIC_DEBUG)
		int	ce;
		char	qmark = 0;

		if (level <= 3)
			ce = CE_WARN;
		else
			ce = CE_CONT;
		if (level == 4)
			qmark = 1;
#endif

		if (dip) {
			instance = ddi_get_instance(dip);
			/* name = ddi_binding_name(dip); */
			name = ddi_driver_name(dip);
		} else {
			instance = 0;
			name = "";
		}

		va_start(adx, fmt);
		(void) vsprintf(buf, fmt, adx);
		va_end(adx);

#if defined(PCIC_DEBUG)
		if (pcic_do_pprintf) {
			if (dip) {
				if (instance >= 0)
					prom_printf("%s(%d),0x%p: %s", name,
					    instance, dip, buf);
				else
					prom_printf("%s,0x%p: %s",
					    name, dip, buf);
			} else
				prom_printf(buf);
		} else {
			if (dip) {
				if (instance >= 0)
					cmn_err(CE_CONT, "%s(%d),0x%p: %s",
					    name, instance, (void *) dip, buf);
				else
					cmn_err(CE_CONT, "%s,0x%p: %s",
					    name, (void *) dip, buf);
			} else
				cmn_err(CE_CONT, buf);
		}
#else
		if (dip)
			cmn_err(ce, qmark ? "?%s%d: %s" : "%s%d: %s", name,
			    instance, buf);
		else
			cmn_err(ce, qmark ? "?%s" : buf, buf);
#endif
	}
}


static void
pcic_syshw_cardstate(syshw_t *item, void *arg)
{
	pcic_socket_t *pcs = (pcic_socket_t *)arg;

	if (pcs->pcs_flags & PCS_CARD_PRESENT) {
		item->state = B_TRUE;
		if (pcs->pcs_flags & PCS_CARD_IS16BIT)
			item->values[0] = 1;
		else if (pcs->pcs_flags & PCS_CARD_ISCARDBUS)
			item->values[0] = 2;
		else
			item->values[0] = 0;
	} else {
		item->state = B_FALSE;
		item->values[0] = 0;
	}
}

/*
 * Tadpole additional for the syshw interface used to control the
 * start/stop switch which is physically linked to the GPIO1 pin
 * on the 1250a.
 */

#define	CLIENT_CALLED	0x8000000
#define	NCE_EVENT_MASK	0xffff

typedef struct _client {
	pid_t	pid;		/* set by kernel */
	int	flags;		/* NCE_REGISTER...  */
	int	priority;	/* >100 unless root */
	int	events;		/* pending event flags */
	int	event_sig;	/* SIG... etc */
	struct _client *next;	/* set by kernel */
	struct _client *prev;	/* set by kernel */
} client_data;

static client_data	*cl_data;
static int	n_clients;
static kmutex_t	client_mtx, intr_mtx;

static void	delete_client(int);

#ifdef VOYAGER
static uint32_t	runstop_sig;
static ddi_softintr_t	softint_id;
static uchar_t	softint_flag;
static int	switch_debounce_time = 100;	/* in milliseconds */
static timeout_id_t	switch_to_id;

static syshw_t syshw_run_stop = {
	    0, "Run/Stop", SH_SWITCH,
	    SYSHW_CAN_SIGNAL_CHANGE|SYSHW_STATE_VALID,
	    B_FALSE, { 0 } };

static void
syshw_get_run_stop(syshw_t *item, void *arg)
{
	pcicdev_t *pcic = (pcicdev_t *)arg;

	if (ddi_get8(pcic->cfg_handle,
	    pcic->cfgaddr + PCIC_GPIO1_REG) & PCIC_GPIO_DIN)
		item->state = B_TRUE;
	else
		item->state = B_FALSE;
}


#endif

static void
syshw_attach(pcicdev_t *pcic)
{
	if (ddi_get_instance(pcic->dip) != 0)
		return;

#ifdef VOYAGER
	if (pcic->pc_type == PCIC_TI_PCI1250) {

		/*
		 * Only setup run/stop on a Voyager.
		 * This is currently defined as
		 * a TI1250 on a SPARC architecture. May have to make this a
		 * property definition in the future.
		 */
		if (ddi_add_softintr(pcic->dip,
		    DDI_SOFTINT_LOW, &softint_id,
		    NULL, NULL, syshw_intr,
		    (caddr_t)pcic) == DDI_SUCCESS) {
			runstop_sig = syshw_add2map(&syshw_run_stop,
			    syshw_get_run_stop, pcic);
			mutex_init(&intr_mtx, NULL, MUTEX_DRIVER,
			    pcic->pc_pri);
			ddi_put8(pcic->cfg_handle,
			    pcic->cfgaddr + PCIC_GPIO1_REG,
			    PCIC_GPIO_FINPUT | PCIC_GPIO_INTENBL |
			    PCIC_GPIO_DELTA);
		}
	}
#endif
	mutex_init(&client_mtx, "syshw client", MUTEX_DRIVER, NULL);
	(void) ddi_create_minor_node(pcic->dip, "syshw", S_IFCHR,
	    SYSHW_MINOR, NULL, NULL);
}

static void
syshw_detach(pcicdev_t *pcic)
{
#ifdef VOYAGER
	if (pcic->pc_type == PCIC_TI_PCI1250) {
		pcic_mutex_enter(&intr_mtx);

		/*
		 * Turn off this interrupt.
		 */
		ddi_put8(pcic->cfg_handle, pcic->cfgaddr + PCIC_GPIO1_REG,
		    PCIC_GPIO_FINPUT);

		if (switch_to_id)
			(void) untimeout(switch_to_id);
		switch_to_id = 0;
		softint_flag = 0;

		pcic_mutex_exit(&intr_mtx);
		ddi_remove_softintr(softint_id);
		mutex_destroy(&intr_mtx);
	}
#endif

	ddi_remove_minor_node(pcic->dip, NULL);
	mutex_destroy(&client_mtx);
}

static void
syshw_resume(pcicdev_t *pcic)
{
#ifdef VOYAGER
	if (pcic->pc_type == PCIC_TI_PCI1250) {
		ddi_put8(pcic->cfg_handle, pcic->cfgaddr + PCIC_GPIO1_REG,
		    PCIC_GPIO_FINPUT | PCIC_GPIO_INTENBL | PCIC_GPIO_DELTA);
	}
#else
	_NOTE(ARGUNUSED(pcic))
#endif
}

#ifdef VOYAGER
static uint_t
syshw_intr_hi(pcicdev_t *pcic)
{
	uchar_t regval;

	if (pcic->pc_type != PCIC_TI_PCI1250)
		return (DDI_INTR_UNCLAIMED);

	regval = ddi_get8(pcic->cfg_handle, pcic->cfgaddr + PCIC_GPIO1_REG);
	if (regval & PCIC_GPIO_DELTA) {
		pcic_mutex_enter(&intr_mtx);
		if (softint_flag == 0 && switch_to_id == 0) {
			softint_flag = 1;
			ddi_trigger_softintr(softint_id);
		}
		ddi_put8(pcic->cfg_handle, pcic->cfgaddr + PCIC_GPIO1_REG,
		    regval);
		pcic_mutex_exit(&intr_mtx);
		return (DDI_INTR_CLAIMED);
	}

	return (DDI_INTR_UNCLAIMED);
}

/*
 * Don't deliver the signal until the debounce period has expired.
 * Unfortuately this means it end up as a three tier interrupt just
 * to indicate a bit change.
 */
static void
syshw_debounce_to(void *arg)
{
	_NOTE(ARGUNUSED(arg))

	if (switch_to_id) {
		pcic_mutex_enter(&intr_mtx);
		switch_to_id = 0;
		pcic_mutex_exit(&intr_mtx);
		syshw_send_signal(runstop_sig);
		return;
	}
}

static uint_t
syshw_intr(caddr_t arg)
{
	_NOTE(ARGUNUSED(arg))

	if (softint_flag) {
		pcic_mutex_enter(&intr_mtx);
		softint_flag = 0;
		if (!switch_to_id)
			switch_to_id = timeout(syshw_debounce_to, arg,
			    drv_usectohz(switch_debounce_time * 1000));
		pcic_mutex_exit(&intr_mtx);
		return (DDI_INTR_CLAIMED);
	}
	return (DDI_INTR_UNCLAIMED);
}
#endif

/*
 * Send signals to the registered clients
 */
static void
syshw_send_signal(int events)
{
	client_data *ptr;
	proc_t	*pr;
	int	done_flag;

	ptr = cl_data;
	while (ptr != NULL) {
		done_flag = CLIENT_CALLED;

		if ((ptr->flags & events) &&
		    (ptr->event_sig != 0) &&
		    ((ptr->flags & done_flag) == 0)) {

			/*
			 * only call the process if:
			 * it has not already received the nce signal
			 * its signal was not zero (just in case)
			 * and it is registered to receive this signal
			 */
			pcic_mutex_enter(&pidlock);
			pr = prfind(ptr->pid);
			pcic_mutex_exit(&pidlock);
			if (pr == NULL) {
				/*
				 * This process has died,
				 * so we free its memory and move on
				 * start at the begining again:
				 * a waste of cycles but it makes things easy..
				 */
				delete_client(ptr->pid);
				ptr = cl_data;
			} else {
				ptr->events |= (events & ptr->flags &
				    NCE_EVENT_MASK);
				psignal(pr, ptr->event_sig);
				ptr->flags |= done_flag;
				ptr = ptr->next;
			}
		} else {
			ptr = ptr->next;
		}
	}

	ptr = cl_data;
	while (ptr != NULL) {
		ptr->flags &= ~done_flag;
		ptr = ptr->next;
	}
}

static int
syshw_open(dev_t *dev, int flag, int otyp, cred_t *cred)
{
	_NOTE(ARGUNUSED(dev, flag, cred))

	if (otyp != OTYP_CHR)
		return (EINVAL);

	return (0);
}

static int
syshw_close(dev_t dev, int flag, int otyp, cred_t *cred)
{
	_NOTE(ARGUNUSED(dev, flag, otyp, cred))

	return (0);
}

/*
 * Add a client to the list of interested processes
 */
static void
add_client(client_data *new)
{
	client_data * ptr;

	n_clients++;
	if (cl_data == NULL) {
		cl_data = new;
		return;
	}

	ptr = cl_data;
	while ((ptr->next != NULL) && (ptr->priority <= new->priority))
		ptr = ptr->next;

	if (ptr == cl_data) {
		/* at head of the list */
		cl_data = new;
		new->next = ptr;
		new->prev = NULL;
		if (ptr != NULL)
			ptr->prev = new;
	} else {
		/* somewhere else in the list - insert after */
		new->next = ptr->next;
		ptr->next = new;
		new->prev = ptr;
		if (new->next != NULL)
			(new->next)->prev = new;
	}
}

/*
 * Locate a client data structure in the client list by looking for a PID match.
 */
static client_data *
locate_client(pid_t pid)
{
	client_data * ptr = cl_data;

	while ((ptr != NULL) && (ptr->pid != pid))
		ptr = ptr->next;

	return (ptr);
}

/*
 * Remove a client record from the client list
 */
static void
delete_client(pid_t pid)
{
	client_data * ptr;

	ptr = locate_client(pid);
	if (ptr == NULL)
		return;	/* hmmm!! */

	n_clients--;

	if (ptr == cl_data) {
		/* remove the head of the list */
		cl_data = ptr->next;
	}
	if (ptr->prev != NULL)
		(ptr->prev)->next = ptr->next;
	if (ptr->next != NULL)
		(ptr->next)->prev = ptr->prev;

	kmem_free(ptr, sizeof (client_data));
}

static void
unregister_event_client()
{
	pcic_mutex_enter(&client_mtx);
	delete_client(ddi_get_pid());
	pcic_mutex_exit(&client_mtx);
}

static int
register_event_client(client_data *u_client)
{
	int	error;
	client_data * client;

	pcic_mutex_enter(&client_mtx);
	client = locate_client(ddi_get_pid());
	if (client) {
		/*
		 * we are re-registering ourself
		 * so we delete the previous entry
		 */
		delete_client(ddi_get_pid());
	}

	client = (client_data *)kmem_alloc(sizeof (client_data), KM_SLEEP);

	if (client) {
		client->pid = ddi_get_pid();
		client->priority = u_client->priority;
		client->flags = u_client->flags & NCE_EVENT_MASK;
		client->events = 0;
		client->event_sig = u_client->event_sig;
		client->next = NULL;
		client->prev = NULL;
		add_client(client);
		error = 0;
	} else
		error = EIO;

	pcic_mutex_exit(&client_mtx);
	return (error);
}

/*
 * Read the currently pending event flags for the process in question
 */
static int
check_events_pending(caddr_t data)
{
	client_data * client;
	int	error = 0;

	pcic_mutex_enter(&client_mtx);
	client = locate_client(ddi_get_pid());
	if (client) {
		if (copyout((caddr_t)&client->events, data, sizeof (int)))
			error = EFAULT;
		else
			client->events = 0;
	} else
		error = EINVAL;

	pcic_mutex_exit(&client_mtx);
	return (error);
}


#define	MAXITEMS	8
static syshw_t *syshw_map[MAXITEMS];
static void	(*syshw_getfuncs[MAXITEMS])(syshw_t *, void *);
static void	*syshw_getfunc_args[MAXITEMS];
static int	nsyshw_items = 0;
#define	NSYSHW_ITEMS	nsyshw_items

static uint32_t
syshw_add2map(syshw_t *item, void (*getfunc)(syshw_t *, void *), void *getarg)
{
	uint32_t rval = (1 << nsyshw_items);
	if (nsyshw_items == MAXITEMS)
		return (0);
	item->hw_id = nsyshw_items;
	syshw_map[nsyshw_items] = item;
	syshw_getfuncs[nsyshw_items] = getfunc;
	syshw_getfunc_args[nsyshw_items] = getarg;
	nsyshw_items++;
	return (rval);
}

static int
syshw_ioctl(dev_t dev, int cmd, intptr_t ioctldata, int mode,
cred_t *cred, int *rval)
{
	caddr_t data = (caddr_t)ioctldata;
	syshw_t sh;
	hwev_t hwev;
	client_data dummy_client;
	int	rc = 0, i;

	_NOTE(ARGUNUSED(dev, mode, cred, rval))

	switch (cmd) {
	default:
		rc = EINVAL;
		break;

	case SYSHW_GET_ITEM:
	case SYSHW_GET_ITEM_MAXVALUES:
		if (copyin(data, (caddr_t)&sh, sizeof (sh))) {
			rc = EFAULT;
			break;
		}

		if (sh.hw_id >= NSYSHW_ITEMS) {
			rc = EINVAL;
			break;
		}

		sh = *syshw_map[sh.hw_id];
		if (!sh.id_string[0]) {
			rc = ENOTTY;
			break;
		}
		if (cmd == SYSHW_GET_ITEM) {
			if (syshw_getfuncs[sh.hw_id])
				syshw_getfuncs[sh.hw_id](&sh,
				    syshw_getfunc_args[sh.hw_id]);
			else
				rc = ENOTTY;
		}

		if (copyout((caddr_t)&sh, data, sizeof (sh))) {
			rc = EFAULT;
			break;
		}
		break;

	case SYSHW_SET_ITEM:
		if (copyin(data, (caddr_t)&sh, sizeof (sh))) {
			rc = EFAULT;
			break;
		}

		if (sh.hw_id >= NSYSHW_ITEMS ||
		    !syshw_map[sh.hw_id]->id_string[0] ||
		    !(syshw_map[sh.hw_id]->capabilities &
		    (SYSHW_STATE_MODIFY | SYSHW_VAL0_MODIFY |
		    SYSHW_VAL1_MODIFY | SYSHW_VAL2_MODIFY |
		    SYSHW_VAL3_MODIFY))) {
			rc = EINVAL;
			break;
		}

		switch (sh.hw_id) {
		default:
			rc = EINVAL;
			break;
		}
		break;

	case SYSHW_EVREG:
		if (copyin(data, (caddr_t)&hwev, sizeof (hwev))) {
			rc = EFAULT;
			break;
		}

		for (i = 0; i < NSYSHW_ITEMS; i++) {
			if (hwev.events & (1 << i) &&
			    !(syshw_map[i]->capabilities &
			    SYSHW_CAN_SIGNAL_CHANGE)) {
				rc = EINVAL;
				break;
			}
		}
		if (hwev.event_sig != SIGUSR1 && hwev.event_sig != SIGUSR2)
			rc = EINVAL;

		if (!rc) {
			dummy_client.priority = 100;
			dummy_client.flags = hwev.events;
			dummy_client.event_sig = hwev.event_sig;
			rc = register_event_client(&dummy_client);
		}
		break;

	case SYSHW_EVUNREG:
		unregister_event_client();
		break;

	case SYSHW_CHKEV:
		rc = check_events_pending(data);
		break;
	}
	return (rc);
}