mptscsih.c

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

				pci_unmap_sg(hd->ioc->pcidev, (struct scatterlist *) SCpnt->request_buffer,
					    SCpnt->use_sg, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
			} else if (SCpnt->request_bufflen) {
				scPrivate	*my_priv;
		
				my_priv = (scPrivate *) &SCpnt->SCp;
				pci_unmap_single(hd->ioc->pcidev, (dma_addr_t)(ulong)my_priv->p1,
					   SCpnt->request_bufflen,
					   scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
			}
			SCpnt->result = DID_RESET << 16;
			SCpnt->host_scribble = NULL;
                        MPT_HOST_LOCK(flags);
			SCpnt->scsi_done(SCpnt);	/* Issue the command callback */
                        MPT_HOST_UNLOCK(flags);

			/* Free Chain buffers */
			mptscsih_freeChainBuffers(hd, ii);

			/* Free Message frames */
			mpt_free_msg_frame(ScsiDoneCtx, hd->ioc->id, mf);
		}
	}

	return;
}

#ifdef DROP_TEST
/* 	mptscsih_flush_drop_test - Free resources and do callback if
 *		DROP_TEST enabled.
 *
 *	@hd: Pointer to a SCSI HOST structure
 *
 *	Returns: None.
 *
 *	Must be called while new I/Os are being queued.
 */
static void
mptscsih_flush_drop_test (MPT_SCSI_HOST *hd)
{
	Scsi_Cmnd	*sc;
	unsigned long	 flags;
	u16		 req_idx;

	/* Free resources for the drop test MF
	 * and chain buffers.
	 */
	if (dropMfPtr) {
		req_idx = le16_to_cpu(dropMfPtr->u.frame.hwhdr.msgctxu.fld.req_idx);
		sc = hd->ScsiLookup[req_idx];
		if (sc == NULL) {
			printk(MYIOC_s_ERR_FMT "Drop Test: NULL ScsiCmd ptr!\n",
					ioc->name);
		} else {
			/* unmap OS resources, set status, do callback
			 * free driver resources
			 */
			if (sc->use_sg) {
				pci_unmap_sg(ioc->pcidev, (struct scatterlist *) sc->request_buffer,
					    sc->use_sg, scsi_to_pci_dma_dir(sc->sc_data_direction));
			} else if (sc->request_bufflen) {
				scPrivate	*my_priv;

				my_priv = (scPrivate *) &sc->SCp;
				pci_unmap_single(ioc->pcidev, (dma_addr_t)(ulong)my_priv->p1,
					   sc->request_bufflen,
					   scsi_to_pci_dma_dir(sc->sc_data_direction));
			}

			sc->host_scribble = NULL;
			sc->result = DID_RESET << 16;
			hd->ScsiLookup[req_idx] = NULL;
			atomic_dec(&queue_depth);
			MPT_HOST_LOCK(flags);
			sc->scsi_done(sc);	/* Issue callback */
			MPT_HOST_UNLOCK(flags);
		}

		mptscsih_freeChainBuffers(hd, req_idx);
		mpt_free_msg_frame(ScsiDoneCtx, ioc->id, dropMfPtr);
		printk(MYIOC_s_INFO_FMT "Free'd Dropped cmd (%p)\n",
					hd->ioc->name, sc);
		printk(MYIOC_s_INFO_FMT "mf (%p) reqidx (%4x)\n",
					hd->ioc->name, dropMfPtr, req_idx);
		printk(MYIOC_s_INFO_FMT "Num Tot (%d) Good (%d) Bad (%d) \n",
				hd->ioc->name, dropTestNum,
				dropTestOK, dropTestBad);
	}
	dropMfPtr = NULL;

	return;
}
#endif

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mptscsih_initChainBuffers - Allocate memory for and initialize
 *	chain buffers, chain buffer control arrays and spinlock.
 *	@hd: Pointer to MPT_SCSI_HOST structure
 *	@init: If set, initialize the spin lock.
 */
static int
mptscsih_initChainBuffers (MPT_SCSI_HOST *hd, int init)
{
	MPT_FRAME_HDR	*chain;
	u8		*mem;
	unsigned long	flags;
	int		sz, ii, num_chain;
	int 		scale, num_sge;

	/* ReqToChain size must equal the req_depth
	 * index = req_idx
	 */
	sz = hd->ioc->req_depth * sizeof(int);
	if (hd->ReqToChain == NULL) {
		mem = kmalloc(sz, GFP_ATOMIC);
		if (mem == NULL)
			return -1;

		hd->ReqToChain = (int *) mem;
	} else {
		mem = (u8 *) hd->ReqToChain;
	}
	memset(mem, 0xFF, sz);


	/* ChainToChain size must equal the total number
	 * of chain buffers to be allocated.
	 * index = chain_idx
	 *
	 * Calculate the number of chain buffers needed(plus 1) per I/O 
	 * then multiply the the maximum number of simultaneous cmds
	 *
	 * num_sge = num sge in request frame + last chain buffer
	 * scale = num sge per chain buffer if no chain element
	 */
	scale = hd->ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
	if (sizeof(dma_addr_t) == sizeof(u64))
		num_sge =  scale + (hd->ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
	else
		num_sge =  1+ scale + (hd->ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));

	num_chain = 1;
	while (hd->max_sge - num_sge > 0) {
		num_chain++;
		num_sge += (scale - 1);
	}
	num_chain++;

	if ((int) hd->ioc->chip_type > (int) FC929)
		num_chain *= MPT_SCSI_CAN_QUEUE;
	else
		num_chain *= MPT_FC_CAN_QUEUE;

	hd->num_chain = num_chain;

	sz = num_chain * sizeof(int);
	if (hd->ChainToChain == NULL) {
		mem = kmalloc(sz, GFP_ATOMIC);
		if (mem == NULL)
			return -1;

		hd->ChainToChain = (int *) mem;
	} else {
		mem = (u8 *) hd->ChainToChain;
	}
	memset(mem, 0xFF, sz);

	sz = num_chain * hd->ioc->req_sz;
	if (hd->ChainBuffer == NULL) {
		/* Allocate free chain buffer pool
		 */
		mem = pci_alloc_consistent(hd->ioc->pcidev, sz, &hd->ChainBufferDMA);
		if (mem == NULL)
			return -1;

		hd->ChainBuffer = (u8*)mem;
	} else {
		mem = (u8 *) hd->ChainBuffer;
	}
	memset(mem, 0, sz);

	dprintk((KERN_INFO "  ChainBuffer    @ %p(%p), sz=%d\n",
		 hd->ChainBuffer, (void *)(ulong)hd->ChainBufferDMA, sz));

	/* Initialize the free chain Q.
	 */
	if (init) {
		spin_lock_init(&hd->FreeChainQlock);
	}

	spin_lock_irqsave (&hd->FreeChainQlock, flags);
	Q_INIT(&hd->FreeChainQ, MPT_FRAME_HDR);

	/* Post the chain buffers to the FreeChainQ.
	 */
	mem = (u8 *)hd->ChainBuffer;
	for (ii=0; ii < num_chain; ii++) {
		chain = (MPT_FRAME_HDR *) mem;
		Q_ADD_TAIL(&hd->FreeChainQ.head, &chain->u.frame.linkage, MPT_FRAME_HDR);
		mem += hd->ioc->req_sz;
	}
	spin_unlock_irqrestore(&hd->FreeChainQlock, flags);

	return 0;
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *  Hack! It might be nice to report if a device is returning QUEUE_FULL
 *  but maybe not each and every time...
 */
static long last_queue_full = 0;

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/*
 *	mptscsih_report_queue_full - Report QUEUE_FULL status returned
 *	from a SCSI target device.
 *	@sc: Pointer to Scsi_Cmnd structure
 *	@pScsiReply: Pointer to SCSIIOReply_t
 *	@pScsiReq: Pointer to original SCSI request
 *
 *	This routine periodically reports QUEUE_FULL status returned from a
 *	SCSI target device.  It reports this to the console via kernel
 *	printk() API call, not more than once every 10 seconds.
 */
static void
mptscsih_report_queue_full(Scsi_Cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
{
	long time = jiffies;

	if (time - last_queue_full > 10 * HZ) {
		char *ioc_str = "ioc?";

		if (sc->host != NULL && sc->host->hostdata != NULL)
			ioc_str = ((MPT_SCSI_HOST *)sc->host->hostdata)->ioc->name;
		printk(MYIOC_s_WARN_FMT "Device (%d:%d:%d) reported QUEUE_FULL!\n",
				ioc_str, 0, sc->target, sc->lun);
		last_queue_full = time;
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
static int BeenHereDoneThat = 0;

/*  SCSI host fops start here...  */
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
/**
 *	mptscsih_detect - Register MPT adapter(s) as SCSI host(s) with
 *	linux scsi mid-layer.
 *	@tpnt: Pointer to Scsi_Host_Template structure
 *
 *	(linux Scsi_Host_Template.detect routine)
 *
 *	Returns number of SCSI host adapters that were successfully
 *	registered with the linux scsi mid-layer via the scsi_register()
 *	API call.
 */
int
mptscsih_detect(Scsi_Host_Template *tpnt)
{
	struct Scsi_Host	*sh = NULL;
	MPT_SCSI_HOST		*hd = NULL;
	MPT_ADAPTER		*this;
	MPT_DONE_Q		*freedoneQ;
	unsigned long		 flags;
	int			 sz, ii;
	int			 numSGE = 0;
	int			 scale;
	u8			*mem;

	if (! BeenHereDoneThat++) {
		show_mptmod_ver(my_NAME, my_VERSION);

		ScsiDoneCtx = mpt_register(mptscsih_io_done, MPTSCSIH_DRIVER);
		ScsiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSCSIH_DRIVER);
		ScsiScanDvCtx = mpt_register(mptscsih_scandv_complete, MPTSCSIH_DRIVER);

#ifndef MPT_SCSI_USE_NEW_EH
		spin_lock_init(&mytaskQ_lock);
#endif

		if (mpt_event_register(ScsiDoneCtx, mptscsih_event_process) == 0) {
			dprintk((KERN_INFO MYNAM ": Registered for IOC event notifications\n"));
		} else {
			/* FIXME! */
		}

		if (mpt_reset_register(ScsiDoneCtx, mptscsih_ioc_reset) == 0) {
			dprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
		} else {
			/* FIXME! */
		}
	}
	dprintk((KERN_INFO MYNAM ": mpt_scsih_detect()\n"));

#ifdef MODULE
	/* Evaluate the command line arguments, if any */
	if (mptscsih)
		mptscsih_setup(mptscsih);
#endif
#ifndef MPT_SCSI_USE_NEW_EH
	atomic_set(&mpt_taskQdepth, 0);
#endif

	this = mpt_adapter_find_first();
	while (this != NULL) {
		int	 portnum;
		for (portnum=0; portnum < this->facts.NumberOfPorts; portnum++) {

			/* 20010215 -sralston
			 *  Added sanity check on SCSI Initiator-mode enabled
			 *  for this MPT adapter.
			 */
			if (!(this->pfacts[portnum].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR)) {
				printk(MYIOC_s_WARN_FMT "Skipping because SCSI Initiator mode is NOT enabled!\n",
						this->name);
				continue;
			}

			/* 20010202 -sralston
			 *  Added sanity check on readiness of the MPT adapter.
			 */
			if (this->last_state != MPI_IOC_STATE_OPERATIONAL) {
				printk(MYIOC_s_WARN_FMT "Skipping because it's not operational!\n",
						this->name);
				continue;
			}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
			tpnt->proc_dir = &proc_mpt_scsihost;
#endif
			sh = scsi_register(tpnt, sizeof(MPT_SCSI_HOST));
			if (sh != NULL) {
				mptscsih_lock(this, flags);
				sh->io_port = 0;
				sh->n_io_port = 0;
				sh->irq = 0;

				/* Yikes!  This is important!
				 * Otherwise, by default, linux
				 * only scans target IDs 0-7!
				 * pfactsN->MaxDevices unreliable
				 * (not supported in early
				 *	versions of the FW).
				 * max_id = 1 + actual max id,
				 * max_lun = 1 + actual last lun,
				 *	see hosts.h :o(
				 */
				if ((int)this->chip_type > (int)FC929)
					sh->max_id = MPT_MAX_SCSI_DEVICES;
				else {
					/* For FC, increase the queue depth
					 * from MPT_SCSI_CAN_QUEUE (31)
					 * to MPT_FC_CAN_QUEUE (63).
					 */
					sh->can_queue = MPT_FC_CAN_QUEUE;
					sh->max_id = MPT_MAX_FC_DEVICES<256 ? MPT_MAX_FC_DEVICES : 255;
				}
				sh->max_lun = MPT_LAST_LUN + 1;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
				sh->max_sectors = MPT_SCSI_MAX_SECTORS;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,1) || defined CONFIG_HIGHIO
				sh->highmem_io = 1;
#endif
				sh->this_id = this->pfacts[portnum].PortSCSIID;

				/* OS entry to allow host drivers to force
				 * a queue depth on a per device basis.
				 */
				sh->select_queue_depths = mptscsih_select_queue_depths;
				/* Required entry.
				 */
				sh->unique_id = this->id;

				/* Verify that we won't exceed the maximum
				 * number of chain buffers
				 * We can optimize:  ZZ = req_sz/sizeof(SGE)
				 * For 32bit SGE's:
				 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
				 *               + (req_sz - 64)/sizeof(SGE)
				 * A slightly different algorithm is required for
				 * 64bit SGEs.
				 */
				scale = this->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
				if (sizeof(dma_addr_t) == sizeof(u64)) {
					numSGE = (scale - 1) * (this->facts.MaxChainDepth-1) + scale +
						(this->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
				} else {
					numSGE = 1 + (scale - 1) * (this->facts.MaxChainDepth-1) + scale +
						(this->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
				} 

				if (numSGE < sh->sg_tablesize) {
					/* Reset this value */
					dprintk((MYIOC_s_INFO_FMT
						 "Resetting sg_tablesize to %d from %d\n",
						 this->name, numSGE, sh->sg_tablesize));
					sh->sg_tablesize = numSGE;
				}

				/* Set the pci device pointer in Scsi_Host structure.
				 */
				scsi_set_pci_device(sh, this->pcidev);

				mptscsih_unlock(this, flags);

				hd = (MPT_SCSI_HOST *) sh->hostdata;
				hd->ioc = this;
				hd->max_sge = sh->sg_tablesize;

				if ((int)this->chip_type > (int)FC929)
					hd->is_spi = 1;

				if (DmpService &&
				    (this->chip_type == FC919 || this->chip_type == FC929))
					hd->is_multipath = 1;

				hd->port = 0;		/* FIXME! */

				/* SCSI needs Scsi_Cmnd lookup table!
				 * (with size equal to req_depth*PtrSz!)
				 */
				sz = hd->ioc->req_depth * sizeof(void *);
				mem = kmalloc(sz, GFP_ATOMIC);
				if (mem == NULL)
					goto done;

				memset(mem, 0, sz);
				hd->ScsiLookup = (struct scsi_cmnd **) mem;

				dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p, sz=%d\n",
					 this->name, hd->ScsiLookup, sz));

				if (mptscsih_initChainBuffers(hd, 1) < 0)
					goto done;

				/* Allocate memory for free and doneQ's
				 */
				sz = sh->can_queue * sizeof(MPT_DONE_Q);
				mem = kmalloc(sz, GFP_ATOMIC);
				if (mem == NULL)
					goto done;

				memset(mem, 0xFF, sz);
				hd->memQ = mem;

				/* Initialize the free, done and pending Qs.
				 */
				Q_INIT(&hd->freeQ, MPT_DONE_Q);
				Q_INIT(&hd->doneQ, MPT_DONE_Q);
				Q_INIT(&hd->pendingQ, MPT_DONE_Q);
				spin_lock_init(&hd->freedoneQlock);

				mem = hd->memQ;
				for (ii=0; ii < sh->can_queue; ii++) {
					freedoneQ = (MPT_DONE_Q *) mem;
					Q_ADD_TAIL(&hd->freeQ.head, freedoneQ, MPT_DONE_Q);
					mem += sizeof(MPT_DONE_Q);
				}

				/* Initialize this Scsi_Host