[linux-2.6-block.git] / drivers / scsi / aacraid / dpcsup.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *	Adaptec AAC series RAID controller driver
 *	(c) Copyright 2001 Red Hat Inc.
 *
 * based on the old aacraid driver that is..
 * Adaptec aacraid device driver for Linux.
 *
 * Copyright (c) 2000-2010 Adaptec, Inc.
 *               2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
 *		 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
 *
 * Module Name:
 *  dpcsup.c
 *
 * Abstract: All DPC processing routines for the cyclone board occur here.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/completion.h>
#include <linux/blkdev.h>

#include "aacraid.h"

/**
 *	aac_response_normal	-	Handle command replies
 *	@q: Queue to read from
 *
 *	This DPC routine will be run when the adapter interrupts us to let us
 *	know there is a response on our normal priority queue. We will pull off
 *	all QE there are and wake up all the waiters before exiting. We will
 *	take a spinlock out on the queue before operating on it.
 */

unsigned int aac_response_normal(struct aac_queue * q)
{
	struct aac_dev * dev = q->dev;
	struct aac_entry *entry;
	struct hw_fib * hwfib;
	struct fib * fib;
	int consumed = 0;
	unsigned long flags, mflags;

	spin_lock_irqsave(q->lock, flags);
	/*
	 *	Keep pulling response QEs off the response queue and waking
	 *	up the waiters until there are no more QEs. We then return
	 *	back to the system. If no response was requested we just
	 *	deallocate the Fib here and continue.
	 */
	while(aac_consumer_get(dev, q, &entry))
	{
		int fast;
		u32 index = le32_to_cpu(entry->addr);
		fast = index & 0x01;
		fib = &dev->fibs[index >> 2];
		hwfib = fib->hw_fib_va;
		
		aac_consumer_free(dev, q, HostNormRespQueue);
		/*
		 *	Remove this fib from the Outstanding I/O queue.
		 *	But only if it has not already been timed out.
		 *
		 *	If the fib has been timed out already, then just 
		 *	continue. The caller has already been notified that
		 *	the fib timed out.
		 */
		atomic_dec(&dev->queues->queue[AdapNormCmdQueue].numpending);

		if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
			spin_unlock_irqrestore(q->lock, flags);
			aac_fib_complete(fib);
			aac_fib_free(fib);
			spin_lock_irqsave(q->lock, flags);
			continue;
		}
		spin_unlock_irqrestore(q->lock, flags);

		if (fast) {
			/*
			 *	Doctor the fib
			 */
			*(__le32 *)hwfib->data = cpu_to_le32(ST_OK);
			hwfib->header.XferState |= cpu_to_le32(AdapterProcessed);
			fib->flags |= FIB_CONTEXT_FLAG_FASTRESP;
		}

		FIB_COUNTER_INCREMENT(aac_config.FibRecved);

		if (hwfib->header.Command == cpu_to_le16(NuFileSystem))
		{
			__le32 *pstatus = (__le32 *)hwfib->data;
			if (*pstatus & cpu_to_le32(0xffff0000))
				*pstatus = cpu_to_le32(ST_OK);
		}
		if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected | Async)) 
		{
	        	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected))
				FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved);
			else 
				FIB_COUNTER_INCREMENT(aac_config.AsyncRecved);
			/*
			 *	NOTE:  we cannot touch the fib after this
			 *	    call, because it may have been deallocated.
			 */
			fib->callback(fib->callback_data, fib);
		} else {
			unsigned long flagv;
			spin_lock_irqsave(&fib->event_lock, flagv);
			if (!fib->done) {
				fib->done = 1;
				complete(&fib->event_wait);
			}
			spin_unlock_irqrestore(&fib->event_lock, flagv);

			spin_lock_irqsave(&dev->manage_lock, mflags);
			dev->management_fib_count--;
			spin_unlock_irqrestore(&dev->manage_lock, mflags);

			FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
			if (fib->done == 2) {
				spin_lock_irqsave(&fib->event_lock, flagv);
				fib->done = 0;
				spin_unlock_irqrestore(&fib->event_lock, flagv);
				aac_fib_complete(fib);
				aac_fib_free(fib);
			}
		}
		consumed++;
		spin_lock_irqsave(q->lock, flags);
	}

	if (consumed > aac_config.peak_fibs)
		aac_config.peak_fibs = consumed;
	if (consumed == 0) 
		aac_config.zero_fibs++;

	spin_unlock_irqrestore(q->lock, flags);
	return 0;
}


/**
 *	aac_command_normal	-	handle commands
 *	@q: queue to process
 *
 *	This DPC routine will be queued when the adapter interrupts us to 
 *	let us know there is a command on our normal priority queue. We will 
 *	pull off all QE there are and wake up all the waiters before exiting.
 *	We will take a spinlock out on the queue before operating on it.
 */
 
unsigned int aac_command_normal(struct aac_queue *q)
{
	struct aac_dev * dev = q->dev;
	struct aac_entry *entry;
	unsigned long flags;

	spin_lock_irqsave(q->lock, flags);

	/*
	 *	Keep pulling response QEs off the response queue and waking
	 *	up the waiters until there are no more QEs. We then return
	 *	back to the system.
	 */
	while(aac_consumer_get(dev, q, &entry))
	{
		struct fib fibctx;
		struct hw_fib * hw_fib;
		u32 index;
		struct fib *fib = &fibctx;
		
		index = le32_to_cpu(entry->addr) / sizeof(struct hw_fib);
		hw_fib = &dev->aif_base_va[index];
		
		/*
		 *	Allocate a FIB at all costs. For non queued stuff
		 *	we can just use the stack so we are happy. We need
		 *	a fib object in order to manage the linked lists
		 */
		if (dev->aif_thread)
			if((fib = kmalloc(sizeof(struct fib), GFP_ATOMIC)) == NULL)
				fib = &fibctx;
		
		memset(fib, 0, sizeof(struct fib));
		INIT_LIST_HEAD(&fib->fiblink);
		fib->type = FSAFS_NTC_FIB_CONTEXT;
		fib->size = sizeof(struct fib);
		fib->hw_fib_va = hw_fib;
		fib->data = hw_fib->data;
		fib->dev = dev;
		
				
		if (dev->aif_thread && fib != &fibctx) {
		        list_add_tail(&fib->fiblink, &q->cmdq);
	 	        aac_consumer_free(dev, q, HostNormCmdQueue);
		        wake_up_interruptible(&q->cmdready);
		} else {
	 	        aac_consumer_free(dev, q, HostNormCmdQueue);
			spin_unlock_irqrestore(q->lock, flags);
			/*
			 *	Set the status of this FIB
			 */
			*(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
			aac_fib_adapter_complete(fib, sizeof(u32));
			spin_lock_irqsave(q->lock, flags);
		}		
	}
	spin_unlock_irqrestore(q->lock, flags);
	return 0;
}

/*
 *
 * aac_aif_callback
 * @context: the context set in the fib - here it is scsi cmd
 * @fibptr: pointer to the fib
 *
 * Handles the AIFs - new method (SRC)
 *
 */

static void aac_aif_callback(void *context, struct fib * fibptr)
{
	struct fib *fibctx;
	struct aac_dev *dev;
	struct aac_aifcmd *cmd;
	int status;

	fibctx = (struct fib *)context;
	BUG_ON(fibptr == NULL);
	dev = fibptr->dev;

	if ((fibptr->hw_fib_va->header.XferState &
	    cpu_to_le32(NoMoreAifDataAvailable)) ||
		dev->sa_firmware) {
		aac_fib_complete(fibptr);
		aac_fib_free(fibptr);
		return;
	}

	aac_intr_normal(dev, 0, 1, 0, fibptr->hw_fib_va);

	aac_fib_init(fibctx);
	cmd = (struct aac_aifcmd *) fib_data(fibctx);
	cmd->command = cpu_to_le32(AifReqEvent);

	status = aac_fib_send(AifRequest,
		fibctx,
		sizeof(struct hw_fib)-sizeof(struct aac_fibhdr),
		FsaNormal,
		0, 1,
		(fib_callback)aac_aif_callback, fibctx);
}


/**
 *	aac_intr_normal	-	Handle command replies
 *	@dev: Device
 *	@index: completion reference
 *
 *	This DPC routine will be run when the adapter interrupts us to let us
 *	know there is a response on our normal priority queue. We will pull off
 *	all QE there are and wake up all the waiters before exiting.
 */
unsigned int aac_intr_normal(struct aac_dev *dev, u32 index, int isAif,
	int isFastResponse, struct hw_fib *aif_fib)
{
	unsigned long mflags;
	dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, index));
	if (isAif == 1) {	/* AIF - common */
		struct hw_fib * hw_fib;
		struct fib * fib;
		struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue];
		unsigned long flags;

		/*
		 *	Allocate a FIB. For non queued stuff we can just use
		 * the stack so we are happy. We need a fib object in order to
		 * manage the linked lists.
		 */
		if ((!dev->aif_thread)
		 || (!(fib = kzalloc(sizeof(struct fib),GFP_ATOMIC))))
			return 1;
		if (!(hw_fib = kzalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
			kfree (fib);
			return 1;
		}
		if (dev->sa_firmware) {
			fib->hbacmd_size = index;	/* store event type */
		} else if (aif_fib != NULL) {
			memcpy(hw_fib, aif_fib, sizeof(struct hw_fib));
		} else {
			memcpy(hw_fib, (struct hw_fib *)
				(((uintptr_t)(dev->regs.sa)) + index),
				sizeof(struct hw_fib));
		}
		INIT_LIST_HEAD(&fib->fiblink);
		fib->type = FSAFS_NTC_FIB_CONTEXT;
		fib->size = sizeof(struct fib);
		fib->hw_fib_va = hw_fib;
		fib->data = hw_fib->data;
		fib->dev = dev;
	
		spin_lock_irqsave(q->lock, flags);
		list_add_tail(&fib->fiblink, &q->cmdq);
	        wake_up_interruptible(&q->cmdready);
		spin_unlock_irqrestore(q->lock, flags);
		return 1;
	} else if (isAif == 2) {	/* AIF - new (SRC) */
		struct fib *fibctx;
		struct aac_aifcmd *cmd;

		fibctx = aac_fib_alloc(dev);
		if (!fibctx)
			return 1;
		aac_fib_init(fibctx);

		cmd = (struct aac_aifcmd *) fib_data(fibctx);
		cmd->command = cpu_to_le32(AifReqEvent);

		return aac_fib_send(AifRequest,
			fibctx,
			sizeof(struct hw_fib)-sizeof(struct aac_fibhdr),
			FsaNormal,
			0, 1,
			(fib_callback)aac_aif_callback, fibctx);
	} else {
		struct fib *fib = &dev->fibs[index];
		int start_callback = 0;

		/*
		 *	Remove this fib from the Outstanding I/O queue.
		 *	But only if it has not already been timed out.
		 *
		 *	If the fib has been timed out already, then just 
		 *	continue. The caller has already been notified that
		 *	the fib timed out.
		 */
		atomic_dec(&dev->queues->queue[AdapNormCmdQueue].numpending);

		if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
			aac_fib_complete(fib);
			aac_fib_free(fib);
			return 0;
		}

		FIB_COUNTER_INCREMENT(aac_config.FibRecved);

		if (fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) {

			if (isFastResponse)
				fib->flags |= FIB_CONTEXT_FLAG_FASTRESP;

			if (fib->callback) {
				start_callback = 1;
			} else {
				unsigned long flagv;
				int completed = 0;

				dprintk((KERN_INFO "event_wait up\n"));
				spin_lock_irqsave(&fib->event_lock, flagv);
				if (fib->done == 2) {
					fib->done = 1;
					completed = 1;
				} else {
					fib->done = 1;
					complete(&fib->event_wait);
				}
				spin_unlock_irqrestore(&fib->event_lock, flagv);

				spin_lock_irqsave(&dev->manage_lock, mflags);
				dev->management_fib_count--;
				spin_unlock_irqrestore(&dev->manage_lock,
					mflags);

				FIB_COUNTER_INCREMENT(aac_config.NativeRecved);
				if (completed)
					aac_fib_complete(fib);
			}
		} else {
			struct hw_fib *hwfib = fib->hw_fib_va;

			if (isFastResponse) {
				/* Doctor the fib */
				*(__le32 *)hwfib->data = cpu_to_le32(ST_OK);
				hwfib->header.XferState |=
					cpu_to_le32(AdapterProcessed);
				fib->flags |= FIB_CONTEXT_FLAG_FASTRESP;
			}

			if (hwfib->header.Command ==
				cpu_to_le16(NuFileSystem)) {
				__le32 *pstatus = (__le32 *)hwfib->data;

				if (*pstatus & cpu_to_le32(0xffff0000))
					*pstatus = cpu_to_le32(ST_OK);
			}
			if (hwfib->header.XferState &
				cpu_to_le32(NoResponseExpected | Async)) {
				if (hwfib->header.XferState & cpu_to_le32(
					NoResponseExpected))
					FIB_COUNTER_INCREMENT(
						aac_config.NoResponseRecved);
				else
					FIB_COUNTER_INCREMENT(
						aac_config.AsyncRecved);
				start_callback = 1;
			} else {
				unsigned long flagv;
				int completed = 0;

				dprintk((KERN_INFO "event_wait up\n"));
				spin_lock_irqsave(&fib->event_lock, flagv);
				if (fib->done == 2) {
					fib->done = 1;
					completed = 1;
				} else {
					fib->done = 1;
					complete(&fib->event_wait);
				}
				spin_unlock_irqrestore(&fib->event_lock, flagv);

				spin_lock_irqsave(&dev->manage_lock, mflags);
				dev->management_fib_count--;
				spin_unlock_irqrestore(&dev->manage_lock,
					mflags);

				FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
				if (completed)
					aac_fib_complete(fib);
			}
		}


		if (start_callback) {
			/*
			 * NOTE:  we cannot touch the fib after this
			 *  call, because it may have been deallocated.
			 */
			if (likely(fib->callback && fib->callback_data)) {
				fib->callback(fib->callback_data, fib);
			} else {
				aac_fib_complete(fib);
				aac_fib_free(fib);
			}

		}
		return 0;
	}
}
Commit	Line	Data
c82ee6d3	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
1da177e4 LT	3	* Adaptec AAC series RAID controller driver
fa195afe	4	* (c) Copyright 2001 Red Hat Inc.
1da177e4 LT	5	*
	6	* based on the old aacraid driver that is..
	7	* Adaptec aacraid device driver for Linux.
	8	*
e8b12f0f	9	* Copyright (c) 2000-2010 Adaptec, Inc.
f4babba0 RAR	10	* 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
f4babba0 RAR	11	* 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
1da177e4	12	*
1da177e4 LT	13	* Module Name:
	14	* dpcsup.c
	15	*
	16	* Abstract: All DPC processing routines for the cyclone board occur here.
1da177e4 LT	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/init.h>
	21	#include <linux/types.h>
1da177e4 LT	22	#include <linux/spinlock.h>
	23	#include <linux/slab.h>
	24	#include <linux/completion.h>
	25	#include <linux/blkdev.h>
1da177e4 LT	26
	27	#include "aacraid.h"
	28
	29	/**
	30	* aac_response_normal - Handle command replies
	31	* @q: Queue to read from
	32	*
	33	* This DPC routine will be run when the adapter interrupts us to let us
	34	* know there is a response on our normal priority queue. We will pull off
	35	* all QE there are and wake up all the waiters before exiting. We will
	36	* take a spinlock out on the queue before operating on it.
	37	*/
	38
	39	unsigned int aac_response_normal(struct aac_queue * q)
	40	{
	41	struct aac_dev * dev = q->dev;
	42	struct aac_entry *entry;
	43	struct hw_fib * hwfib;
	44	struct fib * fib;
	45	int consumed = 0;
cacb6dc3	46	unsigned long flags, mflags;
1da177e4	47
cacb6dc3	48	spin_lock_irqsave(q->lock, flags);
1da177e4 LT	49	/*
	50	* Keep pulling response QEs off the response queue and waking
	51	* up the waiters until there are no more QEs. We then return
d98e000c	52	* back to the system. If no response was requested we just
1da177e4 LT	53	* deallocate the Fib here and continue.
	54	*/
	55	while(aac_consumer_get(dev, q, &entry))
	56	{
	57	int fast;
	58	u32 index = le32_to_cpu(entry->addr);
	59	fast = index & 0x01;
8e0c5ebd	60	fib = &dev->fibs[index >> 2];
a8166a52	61	hwfib = fib->hw_fib_va;
1da177e4 LT	62
	63	aac_consumer_free(dev, q, HostNormRespQueue);
	64	/*
	65	* Remove this fib from the Outstanding I/O queue.
	66	* But only if it has not already been timed out.
	67	*
	68	* If the fib has been timed out already, then just
	69	* continue. The caller has already been notified that
	70	* the fib timed out.
	71	*/
ef616233	72	atomic_dec(&dev->queues->queue[AdapNormCmdQueue].numpending);
03d44337 MH	73
	74	if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
	75	spin_unlock_irqrestore(q->lock, flags);
	76	aac_fib_complete(fib);
	77	aac_fib_free(fib);
	78	spin_lock_irqsave(q->lock, flags);
1da177e4 LT	79	continue;
	80	}
	81	spin_unlock_irqrestore(q->lock, flags);
	82
	83	if (fast) {
	84	/*
	85	* Doctor the fib
	86	*/
56b58712	87	(__le32 )hwfib->data = cpu_to_le32(ST_OK);
1da177e4	88	hwfib->header.XferState \|= cpu_to_le32(AdapterProcessed);
85d22bbf	89	fib->flags \|= FIB_CONTEXT_FLAG_FASTRESP;
1da177e4 LT	90	}
	91
	92	FIB_COUNTER_INCREMENT(aac_config.FibRecved);
	93
	94	if (hwfib->header.Command == cpu_to_le16(NuFileSystem))
	95	{
56b58712	96	__le32 pstatus = (__le32 )hwfib->data;
1da177e4 LT	97	if (*pstatus & cpu_to_le32(0xffff0000))
	98	*pstatus = cpu_to_le32(ST_OK);
	99	}
	100	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected \| Async))
	101	{
	102	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected))
	103	FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved);
	104	else
	105	FIB_COUNTER_INCREMENT(aac_config.AsyncRecved);
	106	/*
	107	* NOTE: we cannot touch the fib after this
	108	* call, because it may have been deallocated.
	109	*/
	110	fib->callback(fib->callback_data, fib);
	111	} else {
	112	unsigned long flagv;
	113	spin_lock_irqsave(&fib->event_lock, flagv);
cacb6dc3	114	if (!fib->done) {
c8f7b073	115	fib->done = 1;
bc127d93	116	complete(&fib->event_wait);
cacb6dc3	117	}
1da177e4	118	spin_unlock_irqrestore(&fib->event_lock, flagv);
cacb6dc3 PNRCEH	119
	120	spin_lock_irqsave(&dev->manage_lock, mflags);
	121	dev->management_fib_count--;
	122	spin_unlock_irqrestore(&dev->manage_lock, mflags);
	123
1da177e4	124	FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
c8f7b073	125	if (fib->done == 2) {
cacb6dc3 PNRCEH	126	spin_lock_irqsave(&fib->event_lock, flagv);
	127	fib->done = 0;
	128	spin_unlock_irqrestore(&fib->event_lock, flagv);
c8f7b073 MH	129	aac_fib_complete(fib);
	130	aac_fib_free(fib);
	131	}
1da177e4 LT	132	}
	133	consumed++;
	134	spin_lock_irqsave(q->lock, flags);
	135	}
	136
	137	if (consumed > aac_config.peak_fibs)
	138	aac_config.peak_fibs = consumed;
	139	if (consumed == 0)
	140	aac_config.zero_fibs++;
	141
	142	spin_unlock_irqrestore(q->lock, flags);
	143	return 0;
	144	}
	145
	146
	147	/**
	148	* aac_command_normal - handle commands
	149	* @q: queue to process
	150	*
	151	* This DPC routine will be queued when the adapter interrupts us to
	152	* let us know there is a command on our normal priority queue. We will
	153	* pull off all QE there are and wake up all the waiters before exiting.
	154	* We will take a spinlock out on the queue before operating on it.
	155	*/
	156
	157	unsigned int aac_command_normal(struct aac_queue *q)
	158	{
	159	struct aac_dev * dev = q->dev;
	160	struct aac_entry *entry;
	161	unsigned long flags;
	162
	163	spin_lock_irqsave(q->lock, flags);
	164
	165	/*
	166	* Keep pulling response QEs off the response queue and waking
	167	* up the waiters until there are no more QEs. We then return
	168	* back to the system.
	169	*/
	170	while(aac_consumer_get(dev, q, &entry))
	171	{
	172	struct fib fibctx;
	173	struct hw_fib * hw_fib;
	174	u32 index;
	175	struct fib *fib = &fibctx;
	176
	177	index = le32_to_cpu(entry->addr) / sizeof(struct hw_fib);
	178	hw_fib = &dev->aif_base_va[index];
	179
	180	/*
	181	* Allocate a FIB at all costs. For non queued stuff
	182	* we can just use the stack so we are happy. We need
	183	* a fib object in order to manage the linked lists
	184	*/
	185	if (dev->aif_thread)
	186	if((fib = kmalloc(sizeof(struct fib), GFP_ATOMIC)) == NULL)
	187	fib = &fibctx;
	188
	189	memset(fib, 0, sizeof(struct fib));
	190	INIT_LIST_HEAD(&fib->fiblink);
	191	fib->type = FSAFS_NTC_FIB_CONTEXT;
	192	fib->size = sizeof(struct fib);
a8166a52	193	fib->hw_fib_va = hw_fib;
1da177e4 LT	194	fib->data = hw_fib->data;
	195	fib->dev = dev;
	196
	197
	198	if (dev->aif_thread && fib != &fibctx) {
	199	list_add_tail(&fib->fiblink, &q->cmdq);
	200	aac_consumer_free(dev, q, HostNormCmdQueue);
	201	wake_up_interruptible(&q->cmdready);
	202	} else {
	203	aac_consumer_free(dev, q, HostNormCmdQueue);
	204	spin_unlock_irqrestore(q->lock, flags);
	205	/*
	206	* Set the status of this FIB
	207	*/
56b58712	208	(__le32 )hw_fib->data = cpu_to_le32(ST_OK);
bfb35aa8	209	aac_fib_adapter_complete(fib, sizeof(u32));
1da177e4 LT	210	spin_lock_irqsave(q->lock, flags);
	211	}
	212	}
	213	spin_unlock_irqrestore(q->lock, flags);
	214	return 0;
	215	}
8e0c5ebd	216
e8b12f0f MR	217	/*
	218	*
	219	* aac_aif_callback
	220	* @context: the context set in the fib - here it is scsi cmd
	221	* @fibptr: pointer to the fib
	222	*
	223	* Handles the AIFs - new method (SRC)
	224	*
	225	*/
	226
	227	static void aac_aif_callback(void context, struct fib fibptr)
	228	{
	229	struct fib *fibctx;
	230	struct aac_dev *dev;
	231	struct aac_aifcmd *cmd;
	232	int status;
	233
	234	fibctx = (struct fib *)context;
	235	BUG_ON(fibptr == NULL);
	236	dev = fibptr->dev;
	237
3ffd6c5a RAR	238	if ((fibptr->hw_fib_va->header.XferState &
	239	cpu_to_le32(NoMoreAifDataAvailable)) \|\|
	240	dev->sa_firmware) {
e8b12f0f MR	241	aac_fib_complete(fibptr);
	242	aac_fib_free(fibptr);
	243	return;
	244	}
	245
	246	aac_intr_normal(dev, 0, 1, 0, fibptr->hw_fib_va);
	247
	248	aac_fib_init(fibctx);
	249	cmd = (struct aac_aifcmd *) fib_data(fibctx);
	250	cmd->command = cpu_to_le32(AifReqEvent);
	251
	252	status = aac_fib_send(AifRequest,
	253	fibctx,
	254	sizeof(struct hw_fib)-sizeof(struct aac_fibhdr),
	255	FsaNormal,
	256	0, 1,
	257	(fib_callback)aac_aif_callback, fibctx);
	258	}
	259
8e0c5ebd MH	260
	261	/**
	262	* aac_intr_normal - Handle command replies
	263	* @dev: Device
	264	* @index: completion reference
	265	*
	266	* This DPC routine will be run when the adapter interrupts us to let us
	267	* know there is a response on our normal priority queue. We will pull off
	268	* all QE there are and wake up all the waiters before exiting.
	269	*/
3ffd6c5a RAR	270	unsigned int aac_intr_normal(struct aac_dev *dev, u32 index, int isAif,
3ffd6c5a RAR	271	int isFastResponse, struct hw_fib *aif_fib)
8e0c5ebd	272	{
cacb6dc3	273	unsigned long mflags;
f3307f72	274	dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, index));
e8b12f0f	275	if (isAif == 1) { /* AIF - common */
8e0c5ebd MH	276	struct hw_fib * hw_fib;
	277	struct fib * fib;
	278	struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue];
	279	unsigned long flags;
	280
8e0c5ebd MH	281	/*
	282	* Allocate a FIB. For non queued stuff we can just use
	283	* the stack so we are happy. We need a fib object in order to
	284	* manage the linked lists.
	285	*/
	286	if ((!dev->aif_thread)
4dbc22d7	287	\|\| (!(fib = kzalloc(sizeof(struct fib),GFP_ATOMIC))))
8e0c5ebd	288	return 1;
4dbc22d7	289	if (!(hw_fib = kzalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
8e0c5ebd MH	290	kfree (fib);
	291	return 1;
	292	}
3ffd6c5a RAR	293	if (dev->sa_firmware) {
	294	fib->hbacmd_size = index; /* store event type */
	295	} else if (aif_fib != NULL) {
e8b12f0f MR	296	memcpy(hw_fib, aif_fib, sizeof(struct hw_fib));
e8b12f0f MR	297	} else {
3ffd6c5a RAR	298	memcpy(hw_fib, (struct hw_fib *)
	299	(((uintptr_t)(dev->regs.sa)) + index),
	300	sizeof(struct hw_fib));
e8b12f0f	301	}
8e0c5ebd MH	302	INIT_LIST_HEAD(&fib->fiblink);
	303	fib->type = FSAFS_NTC_FIB_CONTEXT;
	304	fib->size = sizeof(struct fib);
a8166a52	305	fib->hw_fib_va = hw_fib;
8e0c5ebd MH	306	fib->data = hw_fib->data;
	307	fib->dev = dev;
	308
	309	spin_lock_irqsave(q->lock, flags);
	310	list_add_tail(&fib->fiblink, &q->cmdq);
	311	wake_up_interruptible(&q->cmdready);
	312	spin_unlock_irqrestore(q->lock, flags);
	313	return 1;
e8b12f0f MR	314	} else if (isAif == 2) { /* AIF - new (SRC) */
	315	struct fib *fibctx;
	316	struct aac_aifcmd *cmd;
	317
	318	fibctx = aac_fib_alloc(dev);
	319	if (!fibctx)
	320	return 1;
	321	aac_fib_init(fibctx);
	322
	323	cmd = (struct aac_aifcmd *) fib_data(fibctx);
	324	cmd->command = cpu_to_le32(AifReqEvent);
	325
	326	return aac_fib_send(AifRequest,
	327	fibctx,
	328	sizeof(struct hw_fib)-sizeof(struct aac_fibhdr),
	329	FsaNormal,
	330	0, 1,
	331	(fib_callback)aac_aif_callback, fibctx);
8e0c5ebd	332	} else {
e8b12f0f	333	struct fib *fib = &dev->fibs[index];
423400e6	334	int start_callback = 0;
8e0c5ebd MH	335
	336	/*
	337	* Remove this fib from the Outstanding I/O queue.
	338	* But only if it has not already been timed out.
	339	*
	340	* If the fib has been timed out already, then just
	341	* continue. The caller has already been notified that
	342	* the fib timed out.
	343	*/
ef616233	344	atomic_dec(&dev->queues->queue[AdapNormCmdQueue].numpending);
03d44337 MH	345
	346	if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
	347	aac_fib_complete(fib);
	348	aac_fib_free(fib);
8e0c5ebd MH	349	return 0;
	350	}
	351
8e0c5ebd MH	352	FIB_COUNTER_INCREMENT(aac_config.FibRecved);
8e0c5ebd MH	353
423400e6 RAR	354	if (fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) {
	355
	356	if (isFastResponse)
	357	fib->flags \|= FIB_CONTEXT_FLAG_FASTRESP;
	358
	359	if (fib->callback) {
	360	start_callback = 1;
	361	} else {
	362	unsigned long flagv;
bc127d93	363	int completed = 0;
423400e6 RAR	364
	365	dprintk((KERN_INFO "event_wait up\n"));
	366	spin_lock_irqsave(&fib->event_lock, flagv);
	367	if (fib->done == 2) {
	368	fib->done = 1;
bc127d93	369	completed = 1;
423400e6 RAR	370	} else {
423400e6 RAR	371	fib->done = 1;
bc127d93	372	complete(&fib->event_wait);
423400e6 RAR	373	}
	374	spin_unlock_irqrestore(&fib->event_lock, flagv);
	375
	376	spin_lock_irqsave(&dev->manage_lock, mflags);
	377	dev->management_fib_count--;
	378	spin_unlock_irqrestore(&dev->manage_lock,
	379	mflags);
	380
	381	FIB_COUNTER_INCREMENT(aac_config.NativeRecved);
bc127d93	382	if (completed)
423400e6 RAR	383	aac_fib_complete(fib);
423400e6 RAR	384	}
8e0c5ebd	385	} else {
423400e6 RAR	386	struct hw_fib *hwfib = fib->hw_fib_va;
	387
	388	if (isFastResponse) {
	389	/* Doctor the fib */
	390	(__le32 )hwfib->data = cpu_to_le32(ST_OK);
	391	hwfib->header.XferState \|=
	392	cpu_to_le32(AdapterProcessed);
	393	fib->flags \|= FIB_CONTEXT_FLAG_FASTRESP;
cacb6dc3	394	}
cacb6dc3	395
423400e6 RAR	396	if (hwfib->header.Command ==
	397	cpu_to_le16(NuFileSystem)) {
	398	__le32 pstatus = (__le32 )hwfib->data;
cacb6dc3	399
423400e6 RAR	400	if (*pstatus & cpu_to_le32(0xffff0000))
	401	*pstatus = cpu_to_le32(ST_OK);
	402	}
	403	if (hwfib->header.XferState &
	404	cpu_to_le32(NoResponseExpected \| Async)) {
	405	if (hwfib->header.XferState & cpu_to_le32(
	406	NoResponseExpected))
	407	FIB_COUNTER_INCREMENT(
	408	aac_config.NoResponseRecved);
	409	else
	410	FIB_COUNTER_INCREMENT(
	411	aac_config.AsyncRecved);
	412	start_callback = 1;
	413	} else {
	414	unsigned long flagv;
bc127d93	415	int completed = 0;
423400e6 RAR	416
423400e6 RAR	417	dprintk((KERN_INFO "event_wait up\n"));
cacb6dc3	418	spin_lock_irqsave(&fib->event_lock, flagv);
423400e6 RAR	419	if (fib->done == 2) {
423400e6 RAR	420	fib->done = 1;
bc127d93	421	completed = 1;
423400e6 RAR	422	} else {
423400e6 RAR	423	fib->done = 1;
bc127d93	424	complete(&fib->event_wait);
423400e6	425	}
cacb6dc3	426	spin_unlock_irqrestore(&fib->event_lock, flagv);
423400e6 RAR	427
	428	spin_lock_irqsave(&dev->manage_lock, mflags);
	429	dev->management_fib_count--;
	430	spin_unlock_irqrestore(&dev->manage_lock,
	431	mflags);
	432
	433	FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
bc127d93	434	if (completed)
423400e6 RAR	435	aac_fib_complete(fib);
	436	}
	437	}
	438
	439
	440	if (start_callback) {
	441	/*
	442	* NOTE: we cannot touch the fib after this
	443	* call, because it may have been deallocated.
	444	*/
	445	if (likely(fib->callback && fib->callback_data)) {
	446	fib->callback(fib->callback_data, fib);
	447	} else {
cacb6dc3	448	aac_fib_complete(fib);
423400e6	449	aac_fib_free(fib);
cacb6dc3 PNRCEH	450	}
cacb6dc3 PNRCEH	451
8e0c5ebd MH	452	}
	453	return 0;
	454	}
	455	}