patch-2.4.15 linux/drivers/scsi/sym53c8xx_2/sym_glue.h

Next file: linux/drivers/scsi/sym53c8xx_2/sym_hipd.c
Previous file: linux/drivers/scsi/sym53c8xx_2/sym_glue.c
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v2.4.14/linux/drivers/scsi/sym53c8xx_2/sym_glue.h linux/drivers/scsi/sym53c8xx_2/sym_glue.h
@@ -0,0 +1,676 @@
+/*
+ * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 
+ * of PCI-SCSI IO processors.
+ *
+ * Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>
+ *
+ * This driver is derived from the Linux sym53c8xx driver.
+ * Copyright (C) 1998-2000  Gerard Roudier
+ *
+ * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 
+ * a port of the FreeBSD ncr driver to Linux-1.2.13.
+ *
+ * The original ncr driver has been written for 386bsd and FreeBSD by
+ *         Wolfgang Stanglmeier        <wolf@cologne.de>
+ *         Stefan Esser                <se@mi.Uni-Koeln.de>
+ * Copyright (C) 1994  Wolfgang Stanglmeier
+ *
+ * Other major contributions:
+ *
+ * NVRAM detection and reading.
+ * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
+ *
+ *-----------------------------------------------------------------------------
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * Where this Software is combined with software released under the terms of 
+ * the GNU Public License ("GPL") and the terms of the GPL would require the 
+ * combined work to also be released under the terms of the GPL, the terms
+ * and conditions of this License will apply in addition to those of the
+ * GPL with the exception of any terms or conditions of this License that
+ * conflict with, or are expressly prohibited by, the GPL.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef SYM_GLUE_H
+#define SYM_GLUE_H
+
+#if 0
+#define SYM_CONF_DMA_ADDRESSING_MODE 2
+#endif
+
+#define LinuxVersionCode(v, p, s) (((v)<<16)+((p)<<8)+(s))
+#include <linux/version.h>
+#if	LINUX_VERSION_CODE < LinuxVersionCode(2, 2, 0)
+#error	"This driver requires a kernel version not lower than 2.2.0"
+#endif
+
+#include <asm/dma.h>
+#include <asm/io.h>
+#include <asm/system.h>
+#if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,17)
+#include <linux/spinlock.h>
+#else
+#include <asm/spinlock.h>
+#endif
+#include <linux/delay.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/pci.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/ioport.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+#include <linux/stat.h>
+
+#include <linux/blk.h>
+
+#ifdef __sparc__
+#  include <asm/irq.h>
+#endif
+#include <linux/init.h>
+
+#ifndef	__init
+#define	__init
+#endif
+#ifndef	__initdata
+#define	__initdata
+#endif
+
+#include "../scsi.h"
+#include "../hosts.h"
+#include "../constants.h"
+#include "../sd.h"
+
+#include <linux/types.h>
+
+/*
+ *  Define BITS_PER_LONG for earlier linux versions.
+ */
+#ifndef	BITS_PER_LONG
+#if (~0UL) == 0xffffffffUL
+#define	BITS_PER_LONG	32
+#else
+#define	BITS_PER_LONG	64
+#endif
+#endif
+
+typedef	u_long	vm_offset_t;
+
+#ifndef bcopy
+#define bcopy(s, d, n)	memcpy((d), (s), (n))
+#endif
+
+#ifndef bzero
+#define bzero(d, n)	memset((d), 0, (n))
+#endif
+
+#ifndef bcmp
+#define bcmp(a, b, n)	memcmp((a), (b), (n))
+#endif
+
+/*
+ *  General driver includes.
+ */
+#include "sym53c8xx.h"
+#include "sym_misc.h"
+#include "sym_conf.h"
+#include "sym_defs.h"
+
+/*
+ * Configuration addendum for Linux.
+ */
+#if	LINUX_VERSION_CODE >= LinuxVersionCode(2,3,47)
+#define	SYM_LINUX_DYNAMIC_DMA_MAPPING
+#endif
+
+#define	SYM_CONF_TIMER_INTERVAL		((HZ+1)/2)
+
+#define SYM_OPT_HANDLE_DIR_UNKNOWN
+#define SYM_OPT_HANDLE_DEVICE_QUEUEING
+#define SYM_OPT_NVRAM_PRE_READ
+#define SYM_OPT_SNIFF_INQUIRY
+#define SYM_OPT_LIMIT_COMMAND_REORDERING
+#define	SYM_OPT_ANNOUNCE_TRANSFER_RATE
+
+#ifdef	SYM_LINUX_DYNAMIC_DMA_MAPPING
+#define	SYM_OPT_BUS_DMA_ABSTRACTION
+#endif
+
+/*
+ *  Print a message with severity.
+ */
+#define printf_emerg(args...)	printk(KERN_EMERG args)
+#define	printf_alert(args...)	printk(KERN_ALERT args)
+#define	printf_crit(args...)	printk(KERN_CRIT args)
+#define	printf_err(args...)	printk(KERN_ERR	args)
+#define	printf_warning(args...)	printk(KERN_WARNING args)
+#define	printf_notice(args...)	printk(KERN_NOTICE args)
+#define	printf_info(args...)	printk(KERN_INFO args)
+#define	printf_debug(args...)	printk(KERN_DEBUG args)
+#define	printf(args...)		printk(args)
+
+/*
+ *  Insert a delay in micro-seconds and milli-seconds.
+ */
+void sym_udelay(int us);
+void sym_mdelay(int ms);
+
+/*
+ *  Let the compiler know about driver data structure names.
+ */
+typedef struct sym_tcb *tcb_p;
+typedef struct sym_lcb *lcb_p;
+typedef struct sym_ccb *ccb_p;
+typedef struct sym_hcb *hcb_p;
+typedef struct sym_stcb *stcb_p;
+typedef struct sym_slcb *slcb_p;
+typedef struct sym_sccb *sccb_p;
+typedef struct sym_shcb *shcb_p;
+
+/*
+ *  Define a reference to the O/S dependant IO request.
+ */
+typedef Scsi_Cmnd *cam_ccb_p;	/* Generic */
+typedef Scsi_Cmnd *cam_scsiio_p;/* SCSI I/O */
+
+
+/*
+ *  IO functions definition for big/little endian CPU support.
+ *  For now, PCI chips are only supported in little endian addressing mode, 
+ */
+
+#ifdef	__BIG_ENDIAN
+
+#define	inw_l2b		inw
+#define	inl_l2b		inl
+#define	outw_b2l	outw
+#define	outl_b2l	outl
+#define	readw_l2b	readw
+#define	readl_l2b	readl
+#define	writew_b2l	writew
+#define	writel_b2l	writel
+
+#else	/* little endian */
+
+#if defined(__i386__)	/* i386 implements full FLAT memory/MMIO model */
+#define	inw_raw		inw
+#define	inl_raw		inl
+#define	outw_raw	outw
+#define	outl_raw	outl
+#define readb_raw(a)	(*(volatile unsigned char *) (a))
+#define readw_raw(a)	(*(volatile unsigned short *) (a))
+#define readl_raw(a)	(*(volatile unsigned int *) (a))
+#define writeb_raw(b,a)	((*(volatile unsigned char *) (a)) = (b))
+#define writew_raw(b,a)	((*(volatile unsigned short *) (a)) = (b))
+#define writel_raw(b,a)	((*(volatile unsigned int *) (a)) = (b))
+
+#else	/* Other little-endian */
+#define	inw_raw		inw
+#define	inl_raw		inl
+#define	outw_raw	outw
+#define	outl_raw	outl
+#define	readw_raw	readw
+#define	readl_raw	readl
+#define	writew_raw	writew
+#define	writel_raw	writel
+
+#endif
+#endif
+
+#ifdef	SYM_CONF_CHIP_BIG_ENDIAN
+#error	"Chips in BIG ENDIAN addressing mode are not (yet) supported"
+#endif
+
+
+/*
+ *  If the chip uses big endian addressing mode over the 
+ *  PCI, actual io register addresses for byte and word 
+ *  accesses must be changed according to lane routing.
+ *  Btw, sym_offb() and sym_offw() macros only apply to 
+ *  constants and so donnot generate bloated code.
+ */
+
+#if	defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define sym_offb(o)	(((o)&~3)+((~((o)&3))&3))
+#define sym_offw(o)	(((o)&~3)+((~((o)&3))&2))
+
+#else
+
+#define sym_offb(o)	(o)
+#define sym_offw(o)	(o)
+
+#endif
+
+/*
+ *  If the CPU and the chip use same endian-ness adressing,
+ *  no byte reordering is needed for script patching.
+ *  Macro cpu_to_scr() is to be used for script patching.
+ *  Macro scr_to_cpu() is to be used for getting a DWORD 
+ *  from the script.
+ */
+
+#if	defined(__BIG_ENDIAN) && !defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define cpu_to_scr(dw)	cpu_to_le32(dw)
+#define scr_to_cpu(dw)	le32_to_cpu(dw)
+
+#elif	defined(__LITTLE_ENDIAN) && defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define cpu_to_scr(dw)	cpu_to_be32(dw)
+#define scr_to_cpu(dw)	be32_to_cpu(dw)
+
+#else
+
+#define cpu_to_scr(dw)	(dw)
+#define scr_to_cpu(dw)	(dw)
+
+#endif
+
+/*
+ *  Access to the controller chip.
+ *
+ *  If SYM_CONF_IOMAPPED is defined, the driver will use 
+ *  normal IOs instead of the MEMORY MAPPED IO method  
+ *  recommended by PCI specifications.
+ *  If all PCI bridges, host brigdes and architectures 
+ *  would have been correctly designed for PCI, this 
+ *  option would be useless.
+ *
+ *  If the CPU and the chip use same endian-ness adressing,
+ *  no byte reordering is needed for accessing chip io 
+ *  registers. Functions suffixed by '_raw' are assumed 
+ *  to access the chip over the PCI without doing byte 
+ *  reordering. Functions suffixed by '_l2b' are 
+ *  assumed to perform little-endian to big-endian byte 
+ *  reordering, those suffixed by '_b2l' blah, blah,
+ *  blah, ...
+ */
+
+#if defined(SYM_CONF_IOMAPPED)
+
+/*
+ *  IO mapped only input / ouput
+ */
+
+#define	INB_OFF(o)        inb (np->s.io_port + sym_offb(o))
+#define	OUTB_OFF(o, val)  outb ((val), np->s.io_port + sym_offb(o))
+
+#if	defined(__BIG_ENDIAN) && !defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define	INW_OFF(o)        inw_l2b (np->s.io_port + sym_offw(o))
+#define	INL_OFF(o)        inl_l2b (np->s.io_port + (o))
+
+#define	OUTW_OFF(o, val)  outw_b2l ((val), np->s.io_port + sym_offw(o))
+#define	OUTL_OFF(o, val)  outl_b2l ((val), np->s.io_port + (o))
+
+#elif	defined(__LITTLE_ENDIAN) && defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define	INW_OFF(o)        inw_b2l (np->s.io_port + sym_offw(o))
+#define	INL_OFF(o)        inl_b2l (np->s.io_port + (o))
+
+#define	OUTW_OFF(o, val)  outw_l2b ((val), np->s.io_port + sym_offw(o))
+#define	OUTL_OFF(o, val)  outl_l2b ((val), np->s.io_port + (o))
+
+#else
+
+#define	INW_OFF(o)        inw_raw (np->s.io_port + sym_offw(o))
+#define	INL_OFF(o)        inl_raw (np->s.io_port + (o))
+
+#define	OUTW_OFF(o, val)  outw_raw ((val), np->s.io_port + sym_offw(o))
+#define	OUTL_OFF(o, val)  outl_raw ((val), np->s.io_port + (o))
+
+#endif	/* ENDIANs */
+
+#else	/* defined SYM_CONF_IOMAPPED */
+
+/*
+ *  MEMORY mapped IO input / output
+ */
+
+#define INB_OFF(o)        readb((char *)np->s.mmio_va + sym_offb(o))
+#define OUTB_OFF(o, val)  writeb((val), (char *)np->s.mmio_va + sym_offb(o))
+
+#if	defined(__BIG_ENDIAN) && !defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define INW_OFF(o)        readw_l2b((char *)np->s.mmio_va + sym_offw(o))
+#define INL_OFF(o)        readl_l2b((char *)np->s.mmio_va + (o))
+
+#define OUTW_OFF(o, val)  writew_b2l((val), (char *)np->s.mmio_va + sym_offw(o))
+#define OUTL_OFF(o, val)  writel_b2l((val), (char *)np->s.mmio_va + (o))
+
+#elif	defined(__LITTLE_ENDIAN) && defined(SYM_CONF_CHIP_BIG_ENDIAN)
+
+#define INW_OFF(o)        readw_b2l((char *)np->s.mmio_va + sym_offw(o))
+#define INL_OFF(o)        readl_b2l((char *)np->s.mmio_va + (o))
+
+#define OUTW_OFF(o, val)  writew_l2b((val), (char *)np->s.mmio_va + sym_offw(o))
+#define OUTL_OFF(o, val)  writel_l2b((val), (char *)np->s.mmio_va + (o))
+
+#else
+
+#define INW_OFF(o)        readw_raw((char *)np->s.mmio_va + sym_offw(o))
+#define INL_OFF(o)        readl_raw((char *)np->s.mmio_va + (o))
+
+#define OUTW_OFF(o, val)  writew_raw((val), (char *)np->s.mmio_va + sym_offw(o))
+#define OUTL_OFF(o, val)  writel_raw((val), (char *)np->s.mmio_va + (o))
+
+#endif
+
+#endif	/* defined SYM_CONF_IOMAPPED */
+
+#define OUTRAM_OFF(o, a, l) memcpy_toio(np->s.ram_va + (o), (a), (l))
+
+/*
+ *  Remap some status field values.
+ */
+#define CAM_REQ_CMP		DID_OK
+#define CAM_SEL_TIMEOUT		DID_NO_CONNECT
+#define CAM_CMD_TIMEOUT		DID_TIME_OUT
+#define CAM_REQ_ABORTED		DID_ABORT
+#define CAM_UNCOR_PARITY	DID_PARITY
+#define CAM_SCSI_BUS_RESET	DID_RESET	
+#define CAM_REQUEUE_REQ		DID_SOFT_ERROR
+#define	CAM_UNEXP_BUSFREE	DID_ERROR
+#define	CAM_SCSI_BUSY		DID_BUS_BUSY
+
+#define	CAM_DEV_NOT_THERE	DID_NO_CONNECT
+#define	CAM_REQ_INVALID		DID_ERROR
+#define	CAM_REQ_TOO_BIG		DID_ERROR
+
+#define	CAM_RESRC_UNAVAIL	DID_ERROR
+
+/*
+ *  Remap SCSI data direction values.
+ */
+#ifndef	SCSI_DATA_UNKNOWN
+#define	SCSI_DATA_UNKNOWN	0
+#define	SCSI_DATA_WRITE		1
+#define	SCSI_DATA_READ		2
+#define	SCSI_DATA_NONE		3
+#endif
+#define CAM_DIR_NONE		SCSI_DATA_NONE
+#define CAM_DIR_IN		SCSI_DATA_READ
+#define CAM_DIR_OUT		SCSI_DATA_WRITE
+#define CAM_DIR_UNKNOWN		SCSI_DATA_UNKNOWN
+
+/*
+ *  These ones are used as return code from 
+ *  error recovery handlers under Linux.
+ */
+#define SCSI_SUCCESS	SUCCESS
+#define SCSI_FAILED	FAILED
+
+/*
+ *  System specific target data structure.
+ *  None for now, under Linux.
+ */
+/* #define SYM_HAVE_STCB */
+
+/*
+ *  System specific lun data structure.
+ */
+#define SYM_HAVE_SLCB
+struct sym_slcb {
+	u_short	reqtags;	/* Number of tags requested by user */
+	u_short scdev_depth;	/* Queue depth set in select_queue_depth() */
+};
+
+/*
+ *  System specific command data structure.
+ *  Not needed under Linux.
+ */
+/* struct sym_sccb */
+
+/*
+ *  System specific host data structure.
+ */
+struct sym_shcb {
+	/*
+	 *  Chip and controller indentification.
+	 */
+	int		unit;
+	char		inst_name[16];
+	char		chip_name[8];
+	struct pci_dev	*device;
+
+	u_char		bus;		/* PCI BUS number		*/
+	u_char		device_fn;	/* PCI BUS device and function	*/
+
+	spinlock_t	smp_lock;	/* Lock for SMP threading       */
+
+	vm_offset_t	mmio_va;	/* MMIO kernel virtual address	*/
+	vm_offset_t	ram_va;		/* RAM  kernel virtual address	*/
+	u32		io_port;	/* IO port address		*/
+	u_short		io_ws;		/* IO window size		*/
+	int		irq;		/* IRQ number			*/
+
+	SYM_QUEHEAD	wait_cmdq;	/* Awaiting SCSI commands	*/
+	SYM_QUEHEAD	busy_cmdq;	/* Enqueued SCSI commands	*/
+
+	struct timer_list timer;	/* Timer handler link header	*/
+	u_long		lasttime;
+	u_long		settle_time;	/* Resetting the SCSI BUS	*/
+	u_char		settle_time_valid;
+#if LINUX_VERSION_CODE < LinuxVersionCode(2, 4, 0)
+	u_char		release_stage;	/* Synchronisation on release	*/
+#endif
+};
+
+/*
+ *  Return the name of the controller.
+ */
+#define sym_name(np) (np)->s.inst_name
+
+/*
+ *  Data structure used as input for the NVRAM reading.
+ *  Must resolve the IO macros and sym_name(), when  
+ *  used as sub-field 's' of another structure.
+ */
+typedef struct {
+	int	bus;
+	u_char	device_fn;
+	u_long	base;
+	u_long	base_2;
+	u_long	base_c;
+	u_long	base_2_c;
+	int	irq;
+/* port and address fields to fit INB, OUTB macros */
+	u_long	io_port;
+	vm_offset_t mmio_va;
+	char	inst_name[16];
+} sym_slot;
+
+typedef struct sym_nvram sym_nvram;
+typedef struct sym_pci_chip sym_chip;
+
+typedef struct {
+	struct pci_dev *pdev;
+	sym_slot  s;
+	sym_chip  chip;
+	sym_nvram *nvram;
+	u_short device_id;
+	u_char host_id;
+#ifdef	SYM_CONF_PQS_PDS_SUPPORT
+	u_char pqs_pds;
+#endif
+	int attach_done;
+} sym_device;
+
+typedef sym_device *sdev_p;
+
+/*
+ *  The driver definitions (sym_hipd.h) must know about a 
+ *  couple of things related to the memory allocator.
+ */
+typedef u_long m_addr_t;	/* Enough bits to represent any address */
+#define SYM_MEM_PAGE_ORDER 0	/* 1 PAGE  maximum */
+#define SYM_MEM_CLUSTER_SHIFT	(PAGE_SHIFT+SYM_MEM_PAGE_ORDER)
+#ifdef	MODULE
+#define SYM_MEM_FREE_UNUSED	/* Free unused pages immediately */
+#endif
+#ifdef	SYM_LINUX_DYNAMIC_DMA_MAPPING
+typedef struct pci_dev *m_pool_ident_t;
+#endif
+
+/*
+ *  Include driver soft definitions.
+ */
+#include "sym_fw.h"
+#include "sym_hipd.h"
+
+/*
+ *  Memory allocator related stuff.
+ */
+
+#define SYM_MEM_GFP_FLAGS	GFP_ATOMIC
+#define SYM_MEM_WARN	1	/* Warn on failed operations */
+
+#define sym_get_mem_cluster()	\
+	__get_free_pages(SYM_MEM_GFP_FLAGS, SYM_MEM_PAGE_ORDER)
+#define sym_free_mem_cluster(p)	\
+	free_pages(p, SYM_MEM_PAGE_ORDER)
+
+void *sym_calloc(int size, char *name);
+void sym_mfree(void *m, int size, char *name);
+
+#ifndef	SYM_LINUX_DYNAMIC_DMA_MAPPING
+/*
+ *  Simple case.
+ *  All the memory assummed DMAable and O/S providing virtual 
+ *  to bus physical address translation.
+ */
+#define __sym_calloc_dma(pool_id, size, name)	sym_calloc(size, name)
+#define __sym_mfree_dma(pool_id, m, size, name)	sym_mfree(m, size, name)
+#define __vtobus(b, p)				virt_to_bus(p)
+
+#else	/* SYM_LINUX_DYNAMIC_DMA_MAPPING */
+/*
+ *  Complex case.
+ *  We have to provide the driver memory allocator with methods for 
+ *  it to maintain virtual to bus physical address translations.
+ */
+
+#define sym_m_pool_match(mp_id1, mp_id2)	(mp_id1 == mp_id2)
+
+static __inline m_addr_t sym_m_get_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
+{
+	void *vaddr = 0;
+	dma_addr_t baddr = 0;
+
+	vaddr = pci_alloc_consistent(mp->dev_dmat,SYM_MEM_CLUSTER_SIZE, &baddr);
+	if (vaddr) {
+		vbp->vaddr = (m_addr_t) vaddr;
+		vbp->baddr = (m_addr_t) baddr;
+	}
+	return (m_addr_t) vaddr;
+}
+
+static __inline void sym_m_free_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
+{
+	pci_free_consistent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE,
+	                    (void *)vbp->vaddr, (dma_addr_t)vbp->baddr);
+}
+
+#define sym_m_create_dma_mem_tag(mp)	(0)
+
+#define sym_m_delete_dma_mem_tag(mp)	do { ; } while (0)
+
+void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name);
+void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name);
+m_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m);
+
+#endif	/* SYM_LINUX_DYNAMIC_DMA_MAPPING */
+
+/*
+ *  Set the status field of a CAM CCB.
+ */
+static __inline void 
+sym_set_cam_status(Scsi_Cmnd  *ccb, int status)
+{
+	ccb->result &= ~(0xff  << 16);
+	ccb->result |= (status << 16);
+}
+
+/*
+ *  Get the status field of a CAM CCB.
+ */
+static __inline int 
+sym_get_cam_status(Scsi_Cmnd  *ccb)
+{
+	return ((ccb->result >> 16) & 0xff);
+}
+
+/*
+ *  The dma mapping is mostly handled by the 
+ *  SCSI layer and the driver glue under Linux.
+ */
+#define sym_data_dmamap_create(np, cp)		(0)
+#define sym_data_dmamap_destroy(np, cp)		do { ; } while (0)
+#define sym_data_dmamap_unload(np, cp)		do { ; } while (0)
+#define sym_data_dmamap_presync(np, cp)		do { ; } while (0)
+#define sym_data_dmamap_postsync(np, cp)	do { ; } while (0)
+
+/*
+ *  Async handler for negotiations.
+ */
+void sym_xpt_async_nego_wide(hcb_p np, int target);
+#define sym_xpt_async_nego_sync(np, target)	\
+	sym_announce_transfer_rate(np, target)
+#define sym_xpt_async_nego_ppr(np, target)	\
+	sym_announce_transfer_rate(np, target)
+
+/*
+ *  Build CAM result for a successful IO and for a failed IO.
+ */
+static __inline void sym_set_cam_result_ok(hcb_p np, ccb_p cp, int resid)
+{
+	Scsi_Cmnd *cmd = cp->cam_ccb;
+
+#if LINUX_VERSION_CODE >= LinuxVersionCode(2,3,99)
+	cmd->resid = resid;
+#endif
+	cmd->result = (((DID_OK) << 16) + ((cp->ssss_status) & 0x7f));
+}
+void sym_set_cam_result_error(hcb_p np, ccb_p cp, int resid);
+
+/*
+ *  Other O/S specific methods.
+ */
+#define sym_cam_target_id(ccb)	(ccb)->target
+#define sym_cam_target_lun(ccb)	(ccb)->lun
+#define	sym_freeze_cam_ccb(ccb)	do { ; } while (0)
+void sym_xpt_done(hcb_p np, cam_ccb_p ccb);
+void sym_xpt_done2(hcb_p np, cam_ccb_p ccb, int cam_status);
+void sym_print_addr (ccb_p cp);
+void sym_xpt_async_bus_reset(hcb_p np);
+void sym_xpt_async_sent_bdr(hcb_p np, int target);
+int  sym_setup_data_and_start (hcb_p np, cam_scsiio_p csio, ccb_p cp);
+void sym_log_bus_error(hcb_p np);
+#ifdef	SYM_OPT_SNIFF_INQUIRY
+void sym_sniff_inquiry(hcb_p np, Scsi_Cmnd *cmd, int resid);
+#endif
+
+#endif /* SYM_GLUE_H */
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)