[mirror_ubuntu-artful-kernel.git] / drivers / scsi / aacraid / dpcsup.c

/*
 *	Adaptec AAC series RAID controller driver
 *	(c) Copyright 2001 Red Hat Inc.	<alan@redhat.com>
 *
 * based on the old aacraid driver that is..
 * Adaptec aacraid device driver for Linux.
 *
 * Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * 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 <asm/semaphore.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;

	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 requesed 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.
		 */
		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_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;
			up(&fib->event_wait);
			spin_unlock_irqrestore(&fib->event_lock, flagv);
			FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
			if (fib->done == 2) {
				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_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)
{
	u32 index = le32_to_cpu(Index);

	dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, Index));
	if ((index & 0x00000002L)) {
		struct hw_fib * hw_fib;
		struct fib * fib;
		struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue];
		unsigned long flags;

		if (index == 0xFFFFFFFEL) /* Special Case */
			return 0;	  /* Do nothing */
		/*
		 *	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 = kmalloc(sizeof(struct fib),GFP_ATOMIC))))
			return 1;
		if (!(hw_fib = kmalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
			kfree (fib);
			return 1;
		}
		memset(hw_fib, 0, sizeof(struct hw_fib));
		memcpy(hw_fib, (struct hw_fib *)(((ptrdiff_t)(dev->regs.sa)) +
		  (index & ~0x00000002L)), sizeof(struct hw_fib));
		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;
	
		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 {
		int fast = index & 0x01;
		struct fib * fib = &dev->fibs[index >> 2];
		struct hw_fib * hwfib = fib->hw_fib_va;

		/*
		 *	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.
		 */
		dev->queues->queue[AdapNormCmdQueue].numpending--;

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

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

		FIB_COUNTER_INCREMENT(aac_config.FibRecved);

		if (hwfib->header.Command == cpu_to_le16(NuFileSystem))
		{
			u32 *pstatus = (u32 *)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;
	  		dprintk((KERN_INFO "event_wait up\n"));
			spin_lock_irqsave(&fib->event_lock, flagv);
			if (!fib->done)
				fib->done = 1;
			up(&fib->event_wait);
			spin_unlock_irqrestore(&fib->event_lock, flagv);
			FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
		}
		return 0;
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Adaptec AAC series RAID controller driver
	3	* (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
	4	*
	5	* based on the old aacraid driver that is..
	6	* Adaptec aacraid device driver for Linux.
	7	*
03d44337	8	* Copyright (c) 2000-2007 Adaptec, Inc. (aacraid@adaptec.com)
1da177e4 LT	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2, or (at your option)
	13	* any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; see the file COPYING. If not, write to
	22	* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
	23	*
	24	* Module Name:
	25	* dpcsup.c
	26	*
	27	* Abstract: All DPC processing routines for the cyclone board occur here.
	28	*
	29	*
	30	*/
	31
	32	#include <linux/kernel.h>
	33	#include <linux/init.h>
	34	#include <linux/types.h>
1da177e4 LT	35	#include <linux/spinlock.h>
	36	#include <linux/slab.h>
	37	#include <linux/completion.h>
	38	#include <linux/blkdev.h>
	39	#include <asm/semaphore.h>
	40
	41	#include "aacraid.h"
	42
	43	/**
	44	* aac_response_normal - Handle command replies
	45	* @q: Queue to read from
	46	*
	47	* This DPC routine will be run when the adapter interrupts us to let us
	48	* know there is a response on our normal priority queue. We will pull off
	49	* all QE there are and wake up all the waiters before exiting. We will
	50	* take a spinlock out on the queue before operating on it.
	51	*/
	52
	53	unsigned int aac_response_normal(struct aac_queue * q)
	54	{
	55	struct aac_dev * dev = q->dev;
	56	struct aac_entry *entry;
	57	struct hw_fib * hwfib;
	58	struct fib * fib;
	59	int consumed = 0;
	60	unsigned long flags;
	61
	62	spin_lock_irqsave(q->lock, flags);
	63	/*
	64	* Keep pulling response QEs off the response queue and waking
	65	* up the waiters until there are no more QEs. We then return
	66	* back to the system. If no response was requesed we just
	67	* deallocate the Fib here and continue.
	68	*/
	69	while(aac_consumer_get(dev, q, &entry))
	70	{
	71	int fast;
	72	u32 index = le32_to_cpu(entry->addr);
	73	fast = index & 0x01;
8e0c5ebd	74	fib = &dev->fibs[index >> 2];
a8166a52	75	hwfib = fib->hw_fib_va;
1da177e4 LT	76
	77	aac_consumer_free(dev, q, HostNormRespQueue);
	78	/*
	79	* Remove this fib from the Outstanding I/O queue.
	80	* But only if it has not already been timed out.
	81	*
	82	* If the fib has been timed out already, then just
	83	* continue. The caller has already been notified that
	84	* the fib timed out.
	85	*/
03d44337 MH	86	dev->queues->queue[AdapNormCmdQueue].numpending--;
	87
	88	if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
	89	spin_unlock_irqrestore(q->lock, flags);
	90	aac_fib_complete(fib);
	91	aac_fib_free(fib);
	92	spin_lock_irqsave(q->lock, flags);
1da177e4 LT	93	continue;
	94	}
	95	spin_unlock_irqrestore(q->lock, flags);
	96
	97	if (fast) {
	98	/*
	99	* Doctor the fib
	100	*/
56b58712	101	(__le32 )hwfib->data = cpu_to_le32(ST_OK);
1da177e4 LT	102	hwfib->header.XferState \|= cpu_to_le32(AdapterProcessed);
	103	}
	104
	105	FIB_COUNTER_INCREMENT(aac_config.FibRecved);
	106
	107	if (hwfib->header.Command == cpu_to_le16(NuFileSystem))
	108	{
56b58712	109	__le32 pstatus = (__le32 )hwfib->data;
1da177e4 LT	110	if (*pstatus & cpu_to_le32(0xffff0000))
	111	*pstatus = cpu_to_le32(ST_OK);
	112	}
	113	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected \| Async))
	114	{
	115	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected))
	116	FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved);
	117	else
	118	FIB_COUNTER_INCREMENT(aac_config.AsyncRecved);
	119	/*
	120	* NOTE: we cannot touch the fib after this
	121	* call, because it may have been deallocated.
	122	*/
	123	fib->callback(fib->callback_data, fib);
	124	} else {
	125	unsigned long flagv;
	126	spin_lock_irqsave(&fib->event_lock, flagv);
c8f7b073 MH	127	if (!fib->done)
c8f7b073 MH	128	fib->done = 1;
1da177e4 LT	129	up(&fib->event_wait);
	130	spin_unlock_irqrestore(&fib->event_lock, flagv);
	131	FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
c8f7b073 MH	132	if (fib->done == 2) {
	133	aac_fib_complete(fib);
	134	aac_fib_free(fib);
	135	}
1da177e4 LT	136	}
	137	consumed++;
	138	spin_lock_irqsave(q->lock, flags);
	139	}
	140
	141	if (consumed > aac_config.peak_fibs)
	142	aac_config.peak_fibs = consumed;
	143	if (consumed == 0)
	144	aac_config.zero_fibs++;
	145
	146	spin_unlock_irqrestore(q->lock, flags);
	147	return 0;
	148	}
	149
	150
	151	/**
	152	* aac_command_normal - handle commands
	153	* @q: queue to process
	154	*
	155	* This DPC routine will be queued when the adapter interrupts us to
	156	* let us know there is a command on our normal priority queue. We will
	157	* pull off all QE there are and wake up all the waiters before exiting.
	158	* We will take a spinlock out on the queue before operating on it.
	159	*/
	160
	161	unsigned int aac_command_normal(struct aac_queue *q)
	162	{
	163	struct aac_dev * dev = q->dev;
	164	struct aac_entry *entry;
	165	unsigned long flags;
	166
	167	spin_lock_irqsave(q->lock, flags);
	168
	169	/*
	170	* Keep pulling response QEs off the response queue and waking
	171	* up the waiters until there are no more QEs. We then return
	172	* back to the system.
	173	*/
	174	while(aac_consumer_get(dev, q, &entry))
	175	{
	176	struct fib fibctx;
	177	struct hw_fib * hw_fib;
	178	u32 index;
	179	struct fib *fib = &fibctx;
	180
	181	index = le32_to_cpu(entry->addr) / sizeof(struct hw_fib);
	182	hw_fib = &dev->aif_base_va[index];
	183
	184	/*
	185	* Allocate a FIB at all costs. For non queued stuff
	186	* we can just use the stack so we are happy. We need
	187	* a fib object in order to manage the linked lists
	188	*/
	189	if (dev->aif_thread)
	190	if((fib = kmalloc(sizeof(struct fib), GFP_ATOMIC)) == NULL)
	191	fib = &fibctx;
	192
	193	memset(fib, 0, sizeof(struct fib));
	194	INIT_LIST_HEAD(&fib->fiblink);
	195	fib->type = FSAFS_NTC_FIB_CONTEXT;
	196	fib->size = sizeof(struct fib);
a8166a52	197	fib->hw_fib_va = hw_fib;
1da177e4 LT	198	fib->data = hw_fib->data;
	199	fib->dev = dev;
	200
	201
	202	if (dev->aif_thread && fib != &fibctx) {
	203	list_add_tail(&fib->fiblink, &q->cmdq);
	204	aac_consumer_free(dev, q, HostNormCmdQueue);
	205	wake_up_interruptible(&q->cmdready);
	206	} else {
	207	aac_consumer_free(dev, q, HostNormCmdQueue);
	208	spin_unlock_irqrestore(q->lock, flags);
	209	/*
	210	* Set the status of this FIB
	211	*/
56b58712	212	(__le32 )hw_fib->data = cpu_to_le32(ST_OK);
bfb35aa8	213	aac_fib_adapter_complete(fib, sizeof(u32));
1da177e4 LT	214	spin_lock_irqsave(q->lock, flags);
	215	}
	216	}
	217	spin_unlock_irqrestore(q->lock, flags);
	218	return 0;
	219	}
8e0c5ebd MH	220
	221
	222	/**
	223	* aac_intr_normal - Handle command replies
	224	* @dev: Device
	225	* @index: completion reference
	226	*
	227	* This DPC routine will be run when the adapter interrupts us to let us
	228	* know there is a response on our normal priority queue. We will pull off
	229	* all QE there are and wake up all the waiters before exiting.
	230	*/
	231
	232	unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index)
	233	{
	234	u32 index = le32_to_cpu(Index);
	235
	236	dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, Index));
	237	if ((index & 0x00000002L)) {
	238	struct hw_fib * hw_fib;
	239	struct fib * fib;
	240	struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue];
	241	unsigned long flags;
	242
	243	if (index == 0xFFFFFFFEL) /* Special Case */
	244	return 0; /* Do nothing */
	245	/*
	246	* Allocate a FIB. For non queued stuff we can just use
	247	* the stack so we are happy. We need a fib object in order to
	248	* manage the linked lists.
	249	*/
	250	if ((!dev->aif_thread)
	251	\|\| (!(fib = kmalloc(sizeof(struct fib),GFP_ATOMIC))))
	252	return 1;
	253	if (!(hw_fib = kmalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
	254	kfree (fib);
	255	return 1;
	256	}
	257	memset(hw_fib, 0, sizeof(struct hw_fib));
4dfb7cbe SM	258	memcpy(hw_fib, (struct hw_fib *)(((ptrdiff_t)(dev->regs.sa)) +
4dfb7cbe SM	259	(index & ~0x00000002L)), sizeof(struct hw_fib));
8e0c5ebd MH	260	memset(fib, 0, sizeof(struct fib));
	261	INIT_LIST_HEAD(&fib->fiblink);
	262	fib->type = FSAFS_NTC_FIB_CONTEXT;
	263	fib->size = sizeof(struct fib);
a8166a52	264	fib->hw_fib_va = hw_fib;
8e0c5ebd MH	265	fib->data = hw_fib->data;
	266	fib->dev = dev;
	267
	268	spin_lock_irqsave(q->lock, flags);
	269	list_add_tail(&fib->fiblink, &q->cmdq);
	270	wake_up_interruptible(&q->cmdready);
	271	spin_unlock_irqrestore(q->lock, flags);
	272	return 1;
	273	} else {
	274	int fast = index & 0x01;
	275	struct fib * fib = &dev->fibs[index >> 2];
a8166a52	276	struct hw_fib * hwfib = fib->hw_fib_va;
8e0c5ebd MH	277
	278	/*
	279	* Remove this fib from the Outstanding I/O queue.
	280	* But only if it has not already been timed out.
	281	*
	282	* If the fib has been timed out already, then just
	283	* continue. The caller has already been notified that
	284	* the fib timed out.
	285	*/
03d44337 MH	286	dev->queues->queue[AdapNormCmdQueue].numpending--;
	287
	288	if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
	289	aac_fib_complete(fib);
	290	aac_fib_free(fib);
8e0c5ebd MH	291	return 0;
	292	}
	293
8e0c5ebd MH	294	if (fast) {
	295	/*
	296	* Doctor the fib
	297	*/
	298	(__le32 )hwfib->data = cpu_to_le32(ST_OK);
	299	hwfib->header.XferState \|= cpu_to_le32(AdapterProcessed);
	300	}
	301
	302	FIB_COUNTER_INCREMENT(aac_config.FibRecved);
	303
	304	if (hwfib->header.Command == cpu_to_le16(NuFileSystem))
	305	{
	306	u32 pstatus = (u32 )hwfib->data;
	307	if (*pstatus & cpu_to_le32(0xffff0000))
	308	*pstatus = cpu_to_le32(ST_OK);
	309	}
	310	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected \| Async))
	311	{
	312	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected))
	313	FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved);
	314	else
	315	FIB_COUNTER_INCREMENT(aac_config.AsyncRecved);
	316	/*
	317	* NOTE: we cannot touch the fib after this
	318	* call, because it may have been deallocated.
	319	*/
	320	fib->callback(fib->callback_data, fib);
	321	} else {
	322	unsigned long flagv;
	323	dprintk((KERN_INFO "event_wait up\n"));
	324	spin_lock_irqsave(&fib->event_lock, flagv);
c8f7b073 MH	325	if (!fib->done)
c8f7b073 MH	326	fib->done = 1;
8e0c5ebd MH	327	up(&fib->event_wait);
	328	spin_unlock_irqrestore(&fib->event_lock, flagv);
	329	FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
	330	}
	331	return 0;
	332	}
	333	}