isp_linux.h

这个linux源代码是很全面的~基本完整了~使用c编译的~由于时间问题我没有亲自测试~但就算用来做参考资料也是非常好的

#define	NANOTIME_SUB		_isp_microtime_sub

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
#define	MAXISPREQUEST(isp)	256
#else
#define	MAXISPREQUEST(isp)	((IS_FC(isp) || IS_ULTRA2(isp))? 1024 : 256)
#endif

#if	defined(__i386__)
#define	MEMORYBARRIER(isp, type, offset, size)	barrier()
#elif	defined(__alpha__)
#define	MEMORYBARRIER(isp, type, offset, size)	mb()
#elif	defined(__sparc__)
#define	MEMORYBARRIER(isp, type, offset, size)	mb()
#elif	defined(__powerpc__)
#define	MEMORYBARRIER(isp, type, offset, size)	\
	__asm__ __volatile__("eieio" ::: "memory")
#else
#  ifdef mb
#    define	MEMORYBARRIER(isp, type, offset, size)	mb()
#  else
#    define	MEMORYBARRIER(isp, type, offset, size)	barrier()
#  endif
#endif

#define	MBOX_ACQUIRE(isp)						\
	/*								\
	 * Try and acquire semaphore the easy way first-		\
	 * with our lock already held.					\
	 */								\
	if (down_trylock(&isp->mbox_sem)) {				\
	    if (in_interrupt()) {					\
		mbp->param[0] = MBOX_HOST_INTERFACE_ERROR;		\
		isp_prt(isp, ISP_LOGERR, "cannot acquire MBOX sema");	\
		return;							\
	    }								\
	    ISP_DROP_LK_SOFTC(isp);					\
	    down(&isp->mbox_sem);					\
	    ISP_IGET_LK_SOFTC(isp);					\
	}

#define	MBOX_WAIT_COMPLETE(isp)						\
	if (ISP_MUST_POLL(isp)) {					\
		int j, lim = 5000000;					\
		if (isp->isp_mbxwrk0) {					\
			lim *= 12;					\
		}							\
		for (j = 0; j < 5000000; j += 100) {			\
			u_int16_t isr, sema, mbox;			\
			if (isp->isp_mboxbsy == 0) {			\
				break;					\
			}						\
			if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {	\
				isp_intr(isp, isr, sema, mbox);		\
				if (isp->isp_mboxbsy == 0) {		\
					break;				\
				}					\
			}						\
			ISP_DROP_LK_SOFTC(isp);				\
			udelay(100);					\
			ISP_IGET_LK_SOFTC(isp);				\
		}							\
		if (isp->isp_mboxbsy != 0) {				\
			isp_prt(isp, ISP_LOGWARN,			\
			    "Polled Mailbox Command (0x%x) Timeout",	\
			    isp->isp_lastmbxcmd);			\
			isp->isp_mboxbsy = 0;				\
		}							\
	} else {							\
		int lim = (isp->isp_mbxwrk0)? 60 : 5;			\
		init_timer(&isp->mbtimer);				\
		isp->mbtimer.data = (unsigned long) isp;		\
		isp->mbtimer.function = isplinux_mbtimer;		\
    		isp->mbtimer.expires = jiffies + (lim * HZ);		\
    		add_timer(&isp->mbtimer);				\
		isp->mbox_waiting = 1;					\
		ISP_DROP_LK_SOFTC(isp);					\
		down(&isp->mbox_c_sem);					\
		ISP_IGET_LK_SOFTC(isp);					\
		isp->mbox_waiting = 0;					\
    		del_timer(&isp->mbtimer);				\
		if (isp->isp_mboxbsy != 0) {				\
			isp_prt(isp, ISP_LOGWARN,			\
			    "Interrupting Mailbox Command (0x%x) Timeout",\
			    isp->isp_lastmbxcmd);			\
			isp->isp_mboxbsy = 0;				\
		}							\
	}

#define	MBOX_NOTIFY_COMPLETE(isp)					\
	if (isp->mbox_waiting) {					\
		isp->mbox_waiting = 0;					\
		up(&isp->mbox_c_sem);					\
	}								\
	isp->isp_mboxbsy = 0

#define	MBOX_RELEASE(isp)	up(&isp->mbox_sem)

#define	FC_SCRATCH_ACQUIRE(isp)						\
	/*								\
	 * Try and acquire semaphore the easy way first-		\
	 * with our lock already held.					\
	 */								\
	if (in_interrupt()) {						\
		while (down_trylock(&isp->fcs_sem)) {			\
			ISP_DROP_LK_SOFTC(isp);				\
			USEC_DELAY(5000);				\
			ISP_IGET_LK_SOFTC(isp);				\
		}							\
	} else {							\
	    ISP_DROP_LK_SOFTC(isp);					\
	    down(&isp->fcs_sem);					\
	    ISP_IGET_LK_SOFTC(isp);					\
	}

#define	FC_SCRATCH_RELEASE(isp)	up(&isp->fcs_sem)


#ifndef	SCSI_GOOD
#define	SCSI_GOOD	0x0
#endif
#ifndef	SCSI_CHECK
#define	SCSI_CHECK	0x2
#endif
#ifndef	SCSI_BUSY
#define	SCSI_BUSY	0x8
#endif
#ifndef	SCSI_QFULL
#define	SCSI_QFULL	0x28
#endif

#define	XS_T			Scsi_Cmnd
#define	XS_ISP(Cmnd)		((struct ispsoftc *) (Cmnd)->host->hostdata)
#define	XS_CHANNEL(Cmnd)	(Cmnd)->channel
#define	XS_TGT(Cmnd)		(Cmnd)->target
#define	XS_LUN(Cmnd)		(Cmnd)->lun
#define	XS_CDBP(Cmnd)		(Cmnd)->cmnd
#define	XS_CDBLEN(Cmnd)		(Cmnd)->cmd_len
#define	XS_XFRLEN(Cmnd)		(Cmnd)->request_bufflen
#define	XS_TIME(Cmnd)		(Cmnd)->timeout
#define	XS_RESID(Cmnd)		(Cmnd)->SCp.this_residual
#define	XS_STSP(Cmnd)		(&(Cmnd)->SCp.Status)
#define	XS_SNSP(Cmnd)		(Cmnd)->sense_buffer
#define	XS_SNSLEN(Cmnd)		(sizeof (Cmnd)->sense_buffer)
#define	XS_SNSKEY(Cmnd)		((Cmnd)->sense_buffer[2] & 0xf)
#define	XS_TAG_P(Cmnd)		(Cmnd->device->tagged_supported != 0)
#define	XS_TAG_TYPE(xs)		REQFLAG_STAG

#define	XS_SETERR(xs, v)	\
	if ((v) == HBA_TGTBSY) { \
		(xs)->SCp.Status = SCSI_BUSY; \
	} else { \
		(xs)->result &= ~0xff0000; \
		(xs)->result |= ((v) << 16); \
	}

#	define	HBA_NOERROR		DID_OK
#	define	HBA_BOTCH		DID_ERROR
#	define	HBA_CMDTIMEOUT		DID_TIME_OUT
#	define	HBA_SELTIMEOUT		DID_NO_CONNECT
#	define	HBA_TGTBSY		123456 /* special handling */
#	define	HBA_BUSRESET		DID_RESET
#	define	HBA_ABORTED		DID_ABORT
#	define	HBA_DATAOVR		DID_ERROR
#	define	HBA_ARQFAIL		DID_ERROR

#define	XS_ERR(xs)		host_byte((xs)->result)

#define	XS_NOERR(xs)		host_byte((xs)->result) == DID_OK

#define	XS_INITERR(xs)		(xs)->result = 0, (xs)->SCp.Status = 0

#define	XS_SAVE_SENSE(Cmnd, sp)				\
	MEMCPY(&Cmnd->sense_buffer, sp->req_sense_data, \
	    min(sizeof Cmnd->sense_buffer, sp->req_sense_len))

#define	XS_SET_STATE_STAT(a, b, c)

#define	DEFAULT_IID(x)		7
#define	DEFAULT_LOOPID(x)	111
#define	DEFAULT_NODEWWN(isp)	(isp)->isp_defwwnn
#define	DEFAULT_PORTWWN(isp)	(isp)->isp_defwwpn
#define	ISP_NODEWWN(isp)	(isp)->isp_nvramwwnn
#define	ISP_PORTWWN(isp)	(isp)->isp_nvramwwpn

#define	ISP_IOXPUT_8(isp, s, d)		*(d) = s
#define	ISP_IOXPUT_16(isp, s, d)	*(d) = cpu_to_le16(s)
#define	ISP_IOXPUT_32(isp, s, d)	*(d) = cpu_to_le32(s)

#define	ISP_IOXGET_8(isp, s, d)		d = *(s)
#define	ISP_IOXGET_16(isp, s, d)	d = le16_to_cpu(*((u_int16_t *)s))
#define	ISP_IOXGET_32(isp, s, d)	d = le32_to_cpu(*((u_int32_t *)s))

#define	ISP_SWIZZLE_NVRAM_WORD(isp, rp)	*rp = le16_to_cpu(*rp)


/*
 * Includes of common header files
 */
#include "ispreg.h"
#include "ispvar.h"
#include "ispmbox.h"

/*
 * isp_osinfo definitions, extensions and shorthand.
 */

/*
 * Parameter storage. The order of tags is important- sdparam && fcp
 * must come first because isp->isp_params is set to point there...
 */
union pstore {
    struct {
	sdparam _sdp[2];	/* they need to be sequential */
	u_char psc_opts[2][MAX_TARGETS];
	u_char dutydone;
    } parallel_scsi;
    struct {
	fcparam fcp;
	u_int64_t wwnn;
	u_int64_t wwpn;
	u_int64_t nvram_wwnn;
	u_int64_t nvram_wwpn;
    } fibre_scsi;
};
#define	isp_next	isp_osinfo.isp_next
#define	isp_name	isp_osinfo.hbaname
#define	isp_host	isp_osinfo.host
#define	isp_unit	isp_osinfo.instance
#define	isp_psco	isp_osinfo.storep->parallel_scsi.psc_opts
#define	isp_dutydone	isp_osinfo.storep->parallel_scsi.dutydone
#define	isp_defwwnn	isp_osinfo.storep->fibre_scsi.wwnn
#define	isp_defwwpn	isp_osinfo.storep->fibre_scsi.wwpn
#define	isp_nvramwwnn	isp_osinfo.storep->fibre_scsi.nvram_wwnn
#define	isp_nvramwwpn	isp_osinfo.storep->fibre_scsi.nvram_wwpn

/*
 * Driver prototypes..
 */
void isplinux_timer(unsigned long);
void isplinux_mbtimer(unsigned long);
void isplinux_intr(int, void *, struct pt_regs *);
void isplinux_common_init(struct ispsoftc *);
void isplinux_reinit(struct ispsoftc *);
void isplinux_sqd(struct Scsi_Host *, Scsi_Device *);

int isp_drain_reset(struct ispsoftc *, char *);
int isp_drain(struct ispsoftc *, char *);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
static inline void _isp_memcpy(void *, void *, size_t);
static inline void _isp_memzero(void *,  size_t);
#endif
static inline u_int64_t _isp_microtime_sub(struct timeval *, struct timeval *);
static inline void _isp_usec_delay(unsigned int);

int isplinux_proc_info(char *, char **, off_t, int, int, int);
int isplinux_detect(Scsi_Host_Template *);
#ifdef	MODULE
int isplinux_release(struct Scsi_Host *);
#else
#define	isplinux_release	NULL
#endif
const char *isplinux_info(struct Scsi_Host *);
int isplinux_queuecommand(Scsi_Cmnd *, void (* done)(Scsi_Cmnd *));
int isplinux_biosparam(Disk *, kdev_t, int[]);


/*
 * Driver wide data...
 */
extern int isp_debug;
extern int isp_unit_seed;
extern int isp_disable;
extern int isp_nofwreload;
extern int isp_nonvram;
extern int isp_fcduplex;
extern int isp_maxlun;
extern struct ispsoftc *isplist;

/*
 * Platform private flags
 */
#ifndef NULL
#define NULL ((void *) 0)
#endif

#define	ISP_WATCH_TIME		HZ

#ifndef	min
#define min(a,b) (((a)<(b))?(a):(b))
#endif
#ifndef	max
#define	max(a, b)		(((a) > (b)) ? (a) : (b))
#endif
#ifndef	roundup
#define	roundup(x, y)	((((x)+((y)-1))/(y))*(y))
#endif
#ifndef	ARGSUSED
#define	ARGSUSED(x)	x = x
#endif




/*
 * Platform specific 'inline' or support functions
 */

#ifdef	__sparc__
#define	_SBSWAP(isp, b, c)						\
	if (isp->isp_bustype == ISP_BT_SBUS) {				\
		u_int8_t tmp = b;					\
		b = c;							\
		c = tmp;						\
	}
#else
#define	_SBSWAP(a, b, c)
#endif

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
static inline void
_isp_memcpy(void *to, void *from, size_t amt)
{
	unsigned char *x = to; unsigned char *y = from;
	while (amt-- != 0) *x++ = *y++;
}

static inline void
_isp_memzero(void *to, size_t amt)
{
	unsigned char *x = to;
	while (amt-- != 0) *x++ = 0;
}

static inline unsigned long IspOrder(int);
static inline unsigned long
IspOrder(int nelem)
{
    unsigned long order, rsize;

    order = 0;
    rsize = PAGE_SIZE;
    while (rsize < (unsigned long) ISP_QUEUE_SIZE(nelem)) {
	order++;
	rsize <<= 1;
    }
    return (order);
}
#endif

static inline u_int64_t
_isp_microtime_sub(struct timeval *b, struct timeval *a)
{
	u_int64_t elapsed;
	struct timeval x = *b;
	x.tv_sec -= a->tv_sec;
	x.tv_usec -= a->tv_usec;
        if (x.tv_usec < 0) {
                x.tv_sec--;
                x.tv_usec += 1000000;
        }
        if (x.tv_usec >= 1000000) {
                x.tv_sec++;
                x.tv_usec -= 1000000;
        }
	elapsed = GET_NANOSEC(&x);
	if (elapsed == 0)
		elapsed++;
	if ((int64_t) elapsed < 0)	/* !!!! */
		return (1000);
	return (elapsed * 1000);
}

static inline void
_isp_usec_delay(unsigned int usecs)
{
    while (usecs > 1000) {
	mdelay(1);
	usecs -= 1000;
    }
    if (usecs)
	udelay(usecs);
}

#define	GetPages(a)	__get_dma_pages(GFP_ATOMIC|GFP_DMA, a)
#define	RlsPages(a, b)	free_pages((unsigned long) a, b)

char *isp_snprintf(char *, size_t, const char *, ...);

/*
 * Common inline functions
 */

#include "isp_inline.h"

#ifdef	ISP_TARGET_MODE
void isp_attach_target(ispsoftc_t *);
void isp_detach_target(ispsoftc_t *);
void isp_target_async(struct ispsoftc *, int, int);
int isp_target_notify(struct ispsoftc *, void *, u_int16_t *);
#endif
/*
 * Config data
 */

int isplinux_abort(Scsi_Cmnd *);
int isplinux_bdr(Scsi_Cmnd *);
int isplinux_sreset(Scsi_Cmnd *);
int isplinux_hreset(Scsi_Cmnd *);
#define QLOGICISP {							\
	next:				NULL,				\
	module:				NULL,				\
	proc_info:			isplinux_proc_info,		\
	name:				"Qlogic ISP 10X0/2X00",		\
	detect:				isplinux_detect,		\
	release:			isplinux_release,		\
	info:				isplinux_info,			\
	queuecommand:			isplinux_queuecommand,		\
	use_new_eh_code:		1,				\
	eh_abort_handler:		isplinux_abort,			\
	eh_device_reset_handler:	isplinux_bdr,			\
	eh_bus_reset_handler:		isplinux_sreset,		\
	eh_host_reset_handler:		isplinux_hreset,		\
	bios_param:			isplinux_biosparam,		\
	can_queue:			1,	   			\
	sg_tablesize:			SG_ALL,				\
	use_clustering:			ENABLE_CLUSTERING,		\
	cmd_per_lun:			1				\
}
/*
 * mode: c
 * Local variables:
 * c-indent-level: 4
 * c-brace-imaginary-offset: 0
 * c-brace-offset: -4
 * c-argdecl-indent: 4
 * c-label-offset: -4
 * c-continued-statement-offset: 4
 * c-continued-brace-offset: 0
 * End:
 */
#endif /* _ISP_LINUX_H */