/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 *

 * 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

 */

/*

 * Use is subject to license terms.

 */

#ifndef	_SYS_SBBCVAR_H

#define	_SYS_SBBCVAR_H

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

#ifdef	__cplusplus

extern "C" {

#endif

typedef struct sbbc_intr_map {

	uint32_t sbbc_phys_hi;

	uint32_t sbbc_phys_mid;

	uint32_t sbbc_phys_low;

	uint32_t sbbc_intr;

	uint32_t intr_ctlr_nodeid;

	uint32_t ino;

}sbbc_intr_map_t;

struct sbbc_intr_map_mask {

	uint32_t sbbc_phys_hi;

	uint32_t sbbc_phys_mid;

	uint32_t sbbc_phys_low;

	uint32_t sbbc_intr;

};

/* sbbc intrspec for initializing its children. */

struct sbbc_intrspec {

	struct intrspec intr_spec;

	dev_info_t *dip;		/* Interrupt parent dip */

	uint32_t intr;			/* for lookup */

};

/*

 * definition of sbbc child reg spec entry:

 */

typedef struct {

	uint32_t addr_hi;

	uint32_t addr_low;

	uint32_t size;

} sbbc_child_regspec_t;

/* SBBC range entry */

typedef struct sbbc_pci_rangespec {

	uint32_t sbbc_phys_hi;		/* Child hi range address */

	uint32_t sbbc_phys_low;		/* Child low range address */

	uint32_t pci_phys_hi;		/* Parent hi rng addr */

	uint32_t pci_phys_mid;		/* Parent mid rng addr */

	uint32_t pci_phys_low;		/* Parent low rng addr */

	uint32_t rng_size;		/* Range size */

} sbbc_pci_rangespec_t;

typedef int procid_t;

/* Max. SBBC devices/children */

#define	MAX_SBBC_DEVICES	3

/* Only used for fixed or legacy interrupts */

#define	SBBC_INTR_STATE_DISABLE	0	/* disabled */

#define	SBBC_INTR_STATE_ENABLE	1	/* enabled */

typedef struct sbbc_child_intr {

	char *name;

	uint_t inum;

	uint_t status;

	uint_t (*intr_handler)();

	caddr_t arg1;

	caddr_t	arg2;

} sbbc_child_intr_t;

typedef struct sbbcsoft {

	int instance;

	int oflag;

	uint_t myinumber;

	dev_info_t *dip;			/* device information */

	pci_regspec_t *reg;

	int nreg;

	sbbc_pci_rangespec_t *rangep;

	int range_cnt;

	int range_len;

	ddi_acc_handle_t pci_sbbc_map_handle;

	ddi_iblock_cookie_t sbbc_iblock_cookie; /* interrupt block cookie */

	kmutex_t sbbc_intr_mutex;		/* lock for interrupts */

	sbbc_child_intr_t *child_intr[MAX_SBBC_DEVICES]; /* intr per device */

	boolean_t suspended;			/* TRUE if driver suspended */

	kmutex_t umutex;			/* lock for this structure */

} sbbcsoft_t;

#define	TRUE		1

#define	FALSE		0

#if defined(DEBUG)

#define	SBBC_DBG_ATTACH		0x1

#define	SBBC_DBG_DETACH		0x2

#define	SBBC_DBG_CTLOPS		0x4

#define	SBBC_DBG_INITCHILD	0x8

#define	SBBC_DBG_UNINITCHILD	0x10

#define	SBBC_DBG_BUSMAP		0x20

#define	SBBC_DBG_INTR		0x40

#define	SBBC_DBG_PCICONF	0x80

#define	SBBC_DBG_MAPRANGES	0x100

#define	SBBC_DBG_PROPERTIES	0x200

#define	SBBC_DBG_OPEN		0x400

#define	SBBC_DBG_CLOSE		0x800

#define	SBBC_DBG_IOCTL		0x1000

#define	SBBC_DBG_INTROPS	0x2000

#define	SBBC_DBG0(flag, dip, fmt) \

	sbbc_dbg(flag, dip, fmt, 0, 0, 0, 0, 0);

#define	SBBC_DBG1(flag, dip, fmt, a1) \

	sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), 0, 0, 0, 0);

#define	SBBC_DBG2(flag, dip, fmt, a1, a2) \

	sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), 0, 0, 0);

#define	SBBC_DBG3(flag, dip, fmt, a1, a2, a3) \

	sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), \

		(uintptr_t)(a3), 0, 0);

#define	SBBC_DBG4(flag, dip, fmt, a1, a2, a3, a4) \

	sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), \

		(uintptr_t)(a3), (uintptr_t)(a4), 0);

#define	SBBC_DBG5(flag, dip, fmt, a1, a2, a3, a4, a5) \

	sbbc_dbg(flag, dip, fmt, (uintptr_t)(a1), (uintptr_t)(a2), \

		(uintptr_t)(a3), (uintptr_t)(a4), (uintptr_t)(a5));

#else /* DEBUG */

#define	SBBC_DBG0(flag, dip, fmt)

#define	SBBC_DBG1(flag, dip, fmt, a1)

#define	SBBC_DBG2(flag, dip, fmt, a1, a2)

#define	SBBC_DBG3(flag, dip, fmt, a1, a2, a3)

#define	SBBC_DBG4(flag, dip, fmt, a1, a2, a3, a4)

#define	SBBC_DBG5(flag, dip, fmt, a1, a2, a3, a4, a5)

#endif /* DEBUG */

/* debugging flags */

/*

 * To enable tracing, uncomment this line:

 * #define	SBBC_TRACE	1

 */

#if defined(SBBC_TRACE)

#ifndef NSBBCTRACE

#define	NSBBCTRACE	1024

#endif

struct sbbctrace {

	int count;

	int function;		/* address of function */

	int trace_action;	/* descriptive 4 characters */

	int object;		/* object operated on */

};

/*

 * For debugging, allocate space for the trace buffer

 */

extern struct sbbctrace sbbctrace_buffer[];

extern struct sbbctrace *sbbctrace_ptr;

extern int sbbctrace_count;

#define	SBBCTRACEINIT() {				\

	if (sbbctrace_ptr == NULL)		\

		sbbctrace_ptr = sbbctrace_buffer; \

	}

#define	LOCK_TRACE()	(uint_t)ddi_enter_critical()

#define	UNLOCK_TRACE(x)	ddi_exit_critical((uint_t)x)

#define	SBBCTRACE(func, act, obj) {		\

	int __s = LOCK_TRACE();			\

	int *_p = &sbbctrace_ptr->count;	\

	*_p++ = ++sbbctrace_count;		\

	*_p++ = (int)(func);			\

	*_p++ = (int)(act);			\

	*_p++ = (int)(obj);			\

	if ((struct sbbctrace *)(void *)_p >= &sbbctrace_buffer[NSBBCTRACE])\

		sbbctrace_ptr = sbbctrace_buffer; \

	else					\

		sbbctrace_ptr = (struct sbbctrace *)(void *)_p; \

	UNLOCK_TRACE(__s);			\

	}

#else	/* !SBBC_TRACE */

/* If no tracing, define no-ops */

#define	SBBCTRACEINIT()

#define	SBBCTRACE(a, b, c)

#endif	/* !SBBC_TRACE */

#ifdef	__cplusplus

}

#endif

#endif	/* _SYS_SBBCVAR_H */