[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / scsi / aacraid / rkt.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 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:
 *  rkt.c
 *
 * Abstract: Hardware miniport for Drawbridge specific hardware functions.
 *
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/pci.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/completion.h>
#include <linux/time.h>
#include <linux/interrupt.h>
#include <asm/semaphore.h>

#include <scsi/scsi_host.h>

#include "aacraid.h"

static irqreturn_t aac_rkt_intr(int irq, void *dev_id, struct pt_regs *regs)
{
	struct aac_dev *dev = dev_id;

	if (dev->new_comm_interface) {
		u32 Index = rkt_readl(dev, MUnit.OutboundQueue);
		if (Index == 0xFFFFFFFFL)
			Index = rkt_readl(dev, MUnit.OutboundQueue);
		if (Index != 0xFFFFFFFFL) {
			do {
				if (aac_intr_normal(dev, Index)) {
					rkt_writel(dev, MUnit.OutboundQueue, Index);
					rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
				}
				Index = rkt_readl(dev, MUnit.OutboundQueue);
			} while (Index != 0xFFFFFFFFL);
			return IRQ_HANDLED;
		}
	} else {
		unsigned long bellbits;
		u8 intstat;
		intstat = rkt_readb(dev, MUnit.OISR);
		/*
		 *	Read mask and invert because drawbridge is reversed.
		 *	This allows us to only service interrupts that have 
		 *	been enabled.
		 *	Check to see if this is our interrupt.  If it isn't just return
		 */
		if (intstat & ~(dev->OIMR))
		{
			bellbits = rkt_readl(dev, OutboundDoorbellReg);
			if (bellbits & DoorBellPrintfReady) {
				aac_printf(dev, rkt_readl (dev, IndexRegs.Mailbox[5]));
				rkt_writel(dev, MUnit.ODR,DoorBellPrintfReady);
				rkt_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
			}
			else if (bellbits & DoorBellAdapterNormCmdReady) {
				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
				aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
//				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
			}
			else if (bellbits & DoorBellAdapterNormRespReady) {
				rkt_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
				aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
			}
			else if (bellbits & DoorBellAdapterNormCmdNotFull) {
				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
			}
			else if (bellbits & DoorBellAdapterNormRespNotFull) {
				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
			}
			return IRQ_HANDLED;
		}
	}
	return IRQ_NONE;
}

/**
 *	aac_rkt_disable_interrupt	-	Disable interrupts
 *	@dev: Adapter
 */

static void aac_rkt_disable_interrupt(struct aac_dev *dev)
{
	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
}

/**
 *	rkt_sync_cmd	-	send a command and wait
 *	@dev: Adapter
 *	@command: Command to execute
 *	@p1: first parameter
 *	@ret: adapter status
 *
 *	This routine will send a synchronous command to the adapter and wait 
 *	for its	completion.
 */

static int rkt_sync_cmd(struct aac_dev *dev, u32 command,
	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
	u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4)
{
	unsigned long start;
	int ok;
	/*
	 *	Write the command into Mailbox 0
	 */
	rkt_writel(dev, InboundMailbox0, command);
	/*
	 *	Write the parameters into Mailboxes 1 - 6
	 */
	rkt_writel(dev, InboundMailbox1, p1);
	rkt_writel(dev, InboundMailbox2, p2);
	rkt_writel(dev, InboundMailbox3, p3);
	rkt_writel(dev, InboundMailbox4, p4);
	/*
	 *	Clear the synch command doorbell to start on a clean slate.
	 */
	rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
	/*
	 *	Disable doorbell interrupts
	 */
	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
	/*
	 *	Force the completion of the mask register write before issuing
	 *	the interrupt.
	 */
	rkt_readb (dev, MUnit.OIMR);
	/*
	 *	Signal that there is a new synch command
	 */
	rkt_writel(dev, InboundDoorbellReg, INBOUNDDOORBELL_0);

	ok = 0;
	start = jiffies;

	/*
	 *	Wait up to 30 seconds
	 */
	while (time_before(jiffies, start+30*HZ)) 
	{
		udelay(5);	/* Delay 5 microseconds to let Mon960 get info. */
		/*
		 *	Mon960 will set doorbell0 bit when it has completed the command.
		 */
		if (rkt_readl(dev, OutboundDoorbellReg) & OUTBOUNDDOORBELL_0) {
			/*
			 *	Clear the doorbell.
			 */
			rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
			ok = 1;
			break;
		}
		/*
		 *	Yield the processor in case we are slow 
		 */
		msleep(1);
	}
	if (ok != 1) {
		/*
		 *	Restore interrupt mask even though we timed out
		 */
		if (dev->new_comm_interface)
			rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
		else
			rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
		return -ETIMEDOUT;
	}
	/*
	 *	Pull the synch status from Mailbox 0.
	 */
	if (status)
		*status = rkt_readl(dev, IndexRegs.Mailbox[0]);
	if (r1)
		*r1 = rkt_readl(dev, IndexRegs.Mailbox[1]);
	if (r2)
		*r2 = rkt_readl(dev, IndexRegs.Mailbox[2]);
	if (r3)
		*r3 = rkt_readl(dev, IndexRegs.Mailbox[3]);
	if (r4)
		*r4 = rkt_readl(dev, IndexRegs.Mailbox[4]);
	/*
	 *	Clear the synch command doorbell.
	 */
	rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
	/*
	 *	Restore interrupt mask
	 */
	if (dev->new_comm_interface)
		rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
	else
		rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
	return 0;

}

/**
 *	aac_rkt_interrupt_adapter	-	interrupt adapter
 *	@dev: Adapter
 *
 *	Send an interrupt to the i960 and breakpoint it.
 */

static void aac_rkt_interrupt_adapter(struct aac_dev *dev)
{
	rkt_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0,
	  NULL, NULL, NULL, NULL, NULL);
}

/**
 *	aac_rkt_notify_adapter		-	send an event to the adapter
 *	@dev: Adapter
 *	@event: Event to send
 *
 *	Notify the i960 that something it probably cares about has
 *	happened.
 */

static void aac_rkt_notify_adapter(struct aac_dev *dev, u32 event)
{
	switch (event) {

	case AdapNormCmdQue:
		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_1);
		break;
	case HostNormRespNotFull:
		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_4);
		break;
	case AdapNormRespQue:
		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_2);
		break;
	case HostNormCmdNotFull:
		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3);
		break;
	case HostShutdown:
//		rkt_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0,
//		  NULL, NULL, NULL, NULL, NULL);
		break;
	case FastIo:
		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6);
		break;
	case AdapPrintfDone:
		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_5);
		break;
	default:
		BUG();
		break;
	}
}

/**
 *	aac_rkt_start_adapter		-	activate adapter
 *	@dev:	Adapter
 *
 *	Start up processing on an i960 based AAC adapter
 */

static void aac_rkt_start_adapter(struct aac_dev *dev)
{
	struct aac_init *init;

	init = dev->init;
	init->HostElapsedSeconds = cpu_to_le32(get_seconds());
	// We can only use a 32 bit address here
	rkt_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa,
	  0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
}

/**
 *	aac_rkt_check_health
 *	@dev: device to check if healthy
 *
 *	Will attempt to determine if the specified adapter is alive and
 *	capable of handling requests, returning 0 if alive.
 */
static int aac_rkt_check_health(struct aac_dev *dev)
{
	u32 status = rkt_readl(dev, MUnit.OMRx[0]);

	/*
	 *	Check to see if the board failed any self tests.
	 */
	if (status & SELF_TEST_FAILED)
		return -1;
	/*
	 *	Check to see if the board panic'd.
	 */
	if (status & KERNEL_PANIC) {
		char * buffer;
		struct POSTSTATUS {
			__le32 Post_Command;
			__le32 Post_Address;
		} * post;
		dma_addr_t paddr, baddr;
		int ret;

		if ((status & 0xFF000000L) == 0xBC000000L)
			return (status >> 16) & 0xFF;
		buffer = pci_alloc_consistent(dev->pdev, 512, &baddr);
		ret = -2;
		if (buffer == NULL)
			return ret;
		post = pci_alloc_consistent(dev->pdev,
		  sizeof(struct POSTSTATUS), &paddr);
		if (post == NULL) {
			pci_free_consistent(dev->pdev, 512, buffer, baddr);
			return ret;
		}
                memset(buffer, 0, 512);
		post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS);
                post->Post_Address = cpu_to_le32(baddr);
                rkt_writel(dev, MUnit.IMRx[0], paddr);
                rkt_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, 0, 0, 0, 0, 0,
		  NULL, NULL, NULL, NULL, NULL);
		pci_free_consistent(dev->pdev, sizeof(struct POSTSTATUS),
		  post, paddr);
                if ((buffer[0] == '0') && ((buffer[1] == 'x') || (buffer[1] == 'X'))) {
                        ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
                        ret <<= 4;
                        ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
                }
		pci_free_consistent(dev->pdev, 512, buffer, baddr);
                return ret;
        }
	/*
	 *	Wait for the adapter to be up and running.
	 */
	if (!(status & KERNEL_UP_AND_RUNNING))
		return -3;
	/*
	 *	Everything is OK
	 */
	return 0;
}

/**
 *	aac_rkt_send
 *	@fib: fib to issue
 *
 *	Will send a fib, returning 0 if successful.
 */
static int aac_rkt_send(struct fib * fib)
{
	u64 addr = fib->hw_fib_pa;
	struct aac_dev *dev = fib->dev;
	volatile void __iomem *device = dev->regs.rkt;
	u32 Index;

	dprintk((KERN_DEBUG "%p->aac_rkt_send(%p->%llx)\n", dev, fib, addr));
	Index = rkt_readl(dev, MUnit.InboundQueue);
	if (Index == 0xFFFFFFFFL)
		Index = rkt_readl(dev, MUnit.InboundQueue);
	dprintk((KERN_DEBUG "Index = 0x%x\n", Index));
	if (Index == 0xFFFFFFFFL)
		return Index;
	device += Index;
	dprintk((KERN_DEBUG "entry = %x %x %u\n", (u32)(addr & 0xffffffff),
	  (u32)(addr >> 32), (u32)le16_to_cpu(fib->hw_fib->header.Size)));
	writel((u32)(addr & 0xffffffff), device);
	device += sizeof(u32);
	writel((u32)(addr >> 32), device);
	device += sizeof(u32);
	writel(le16_to_cpu(fib->hw_fib->header.Size), device);
	rkt_writel(dev, MUnit.InboundQueue, Index);
	dprintk((KERN_DEBUG "aac_rkt_send - return 0\n"));
	return 0;
}

/**
 *	aac_rkt_init	-	initialize an i960 based AAC card
 *	@dev: device to configure
 *
 *	Allocate and set up resources for the i960 based AAC variants. The 
 *	device_interface in the commregion will be allocated and linked 
 *	to the comm region.
 */

int aac_rkt_init(struct aac_dev *dev)
{
	unsigned long start;
	unsigned long status;
	int instance;
	const char * name;

	instance = dev->id;
	name     = dev->name;

	/*
	 *	Check to see if the board panic'd while booting.
	 */
	/*
	 *	Check to see if the board failed any self tests.
	 */
	if (rkt_readl(dev, MUnit.OMRx[0]) & SELF_TEST_FAILED) {
		printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance);
		goto error_iounmap;
	}
	/*
	 *	Check to see if the monitor panic'd while booting.
	 */
	if (rkt_readl(dev, MUnit.OMRx[0]) & MONITOR_PANIC) {
		printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance);
		goto error_iounmap;
	}
	/*
	 *	Check to see if the board panic'd while booting.
	 */
	if (rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_PANIC) {
		printk(KERN_ERR "%s%d: adapter kernel panic'd.\n", dev->name, instance);
		goto error_iounmap;
	}
	start = jiffies;
	/*
	 *	Wait for the adapter to be up and running. Wait up to 3 minutes
	 */
	while (!(rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_UP_AND_RUNNING))
	{
		if(time_after(jiffies, start+startup_timeout*HZ))
		{
			status = rkt_readl(dev, MUnit.OMRx[0]);
			printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n", 
					dev->name, instance, status);
			goto error_iounmap;
		}
		msleep(1);
	}
	if (request_irq(dev->scsi_host_ptr->irq, aac_rkt_intr, IRQF_SHARED|IRQF_DISABLED, "aacraid", (void *)dev)<0)
	{
		printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance);
		goto error_iounmap;
	}
	/*
	 *	Fill in the function dispatch table.
	 */
	dev->a_ops.adapter_interrupt = aac_rkt_interrupt_adapter;
	dev->a_ops.adapter_disable_int = aac_rkt_disable_interrupt;
	dev->a_ops.adapter_notify = aac_rkt_notify_adapter;
	dev->a_ops.adapter_sync_cmd = rkt_sync_cmd;
	dev->a_ops.adapter_check_health = aac_rkt_check_health;
	dev->a_ops.adapter_send = aac_rkt_send;

	/*
	 *	First clear out all interrupts.  Then enable the one's that we
	 *	can handle.
	 */
	rkt_writeb(dev, MUnit.OIMR, 0xff);
	rkt_writel(dev, MUnit.ODR, 0xffffffff);
	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);

	if (aac_init_adapter(dev) == NULL)
		goto error_irq;
	if (dev->new_comm_interface) {
		/*
		 * FIB Setup has already been done, but we can minimize the
		 * damage by at least ensuring the OS never issues more
		 * commands than we can handle. The Rocket adapters currently
		 * can only handle 246 commands and 8 AIFs at the same time,
		 * and in fact do notify us accordingly if we negotiate the
		 * FIB size. The problem that causes us to add this check is
		 * to ensure that we do not overdo it with the adapter when a
		 * hard coded FIB override is being utilized. This special
		 * case warrants this half baked, but convenient, check here.
		 */
		if (dev->scsi_host_ptr->can_queue > (246 - AAC_NUM_MGT_FIB)) {
			dev->init->MaxIoCommands = cpu_to_le32(246);
			dev->scsi_host_ptr->can_queue = 246 - AAC_NUM_MGT_FIB;
		}
		rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
	}
	/*
	 *	Tell the adapter that all is configured, and it can start
	 *	accepting requests
	 */
	aac_rkt_start_adapter(dev);
	return 0;

error_irq:
	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
	free_irq(dev->scsi_host_ptr->irq, (void *)dev);

error_iounmap:

	return -1;
}
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	*
	8	* Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
	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	* rkt.c
	26	*
	27	* Abstract: Hardware miniport for Drawbridge specific hardware functions.
	28	*
	29	*/
	30
	31	#include <linux/kernel.h>
	32	#include <linux/init.h>
	33	#include <linux/types.h>
	34	#include <linux/sched.h>
	35	#include <linux/pci.h>
	36	#include <linux/spinlock.h>
	37	#include <linux/slab.h>
	38	#include <linux/blkdev.h>
	39	#include <linux/delay.h>
	40	#include <linux/completion.h>
	41	#include <linux/time.h>
	42	#include <linux/interrupt.h>
	43	#include <asm/semaphore.h>
	44
	45	#include <scsi/scsi_host.h>
	46
	47	#include "aacraid.h"
	48
	49	static irqreturn_t aac_rkt_intr(int irq, void dev_id, struct pt_regs regs)
	50	{
	51	struct aac_dev *dev = dev_id;
8e0c5ebd MH	52
	53	if (dev->new_comm_interface) {
	54	u32 Index = rkt_readl(dev, MUnit.OutboundQueue);
	55	if (Index == 0xFFFFFFFFL)
	56	Index = rkt_readl(dev, MUnit.OutboundQueue);
	57	if (Index != 0xFFFFFFFFL) {
	58	do {
	59	if (aac_intr_normal(dev, Index)) {
	60	rkt_writel(dev, MUnit.OutboundQueue, Index);
	61	rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
	62	}
	63	Index = rkt_readl(dev, MUnit.OutboundQueue);
	64	} while (Index != 0xFFFFFFFFL);
	65	return IRQ_HANDLED;
1da177e4	66	}
8e0c5ebd MH	67	} else {
	68	unsigned long bellbits;
	69	u8 intstat;
	70	intstat = rkt_readb(dev, MUnit.OISR);
	71	/*
	72	* Read mask and invert because drawbridge is reversed.
	73	* This allows us to only service interrupts that have
	74	* been enabled.
	75	* Check to see if this is our interrupt. If it isn't just return
	76	*/
	77	if (intstat & ~(dev->OIMR))
	78	{
	79	bellbits = rkt_readl(dev, OutboundDoorbellReg);
	80	if (bellbits & DoorBellPrintfReady) {
	81	aac_printf(dev, rkt_readl (dev, IndexRegs.Mailbox[5]));
	82	rkt_writel(dev, MUnit.ODR,DoorBellPrintfReady);
	83	rkt_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
	84	}
	85	else if (bellbits & DoorBellAdapterNormCmdReady) {
	86	rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
	87	aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
	88	// rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
	89	}
	90	else if (bellbits & DoorBellAdapterNormRespReady) {
	91	rkt_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
	92	aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
	93	}
	94	else if (bellbits & DoorBellAdapterNormCmdNotFull) {
	95	rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
	96	}
	97	else if (bellbits & DoorBellAdapterNormRespNotFull) {
	98	rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
	99	rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
	100	}
	101	return IRQ_HANDLED;
1da177e4	102	}
1da177e4 LT	103	}
	104	return IRQ_NONE;
	105	}
	106
bd1aac80 MH	107	/**
	108	* aac_rkt_disable_interrupt - Disable interrupts
	109	* @dev: Adapter
	110	*/
	111
	112	static void aac_rkt_disable_interrupt(struct aac_dev *dev)
	113	{
	114	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
	115	}
	116
1da177e4 LT	117	/**
	118	* rkt_sync_cmd - send a command and wait
	119	* @dev: Adapter
	120	* @command: Command to execute
	121	* @p1: first parameter
	122	* @ret: adapter status
	123	*
	124	* This routine will send a synchronous command to the adapter and wait
	125	* for its completion.
	126	*/
	127
7c00ffa3 MH	128	static int rkt_sync_cmd(struct aac_dev *dev, u32 command,
	129	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
	130	u32 status, u32 r1, u32 r2, u32 r3, u32 *r4)
1da177e4 LT	131	{
	132	unsigned long start;
	133	int ok;
	134	/*
	135	* Write the command into Mailbox 0
	136	*/
	137	rkt_writel(dev, InboundMailbox0, command);
	138	/*
7c00ffa3	139	* Write the parameters into Mailboxes 1 - 6
1da177e4 LT	140	*/
1da177e4 LT	141	rkt_writel(dev, InboundMailbox1, p1);
7c00ffa3 MH	142	rkt_writel(dev, InboundMailbox2, p2);
	143	rkt_writel(dev, InboundMailbox3, p3);
	144	rkt_writel(dev, InboundMailbox4, p4);
1da177e4 LT	145	/*
	146	* Clear the synch command doorbell to start on a clean slate.
	147	*/
	148	rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
	149	/*
	150	* Disable doorbell interrupts
	151	*/
	152	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
	153	/*
	154	* Force the completion of the mask register write before issuing
	155	* the interrupt.
	156	*/
	157	rkt_readb (dev, MUnit.OIMR);
	158	/*
	159	* Signal that there is a new synch command
	160	*/
	161	rkt_writel(dev, InboundDoorbellReg, INBOUNDDOORBELL_0);
	162
	163	ok = 0;
	164	start = jiffies;
	165
	166	/*
	167	* Wait up to 30 seconds
	168	*/
	169	while (time_before(jiffies, start+30*HZ))
	170	{
	171	udelay(5); /* Delay 5 microseconds to let Mon960 get info. */
	172	/*
	173	* Mon960 will set doorbell0 bit when it has completed the command.
	174	*/
	175	if (rkt_readl(dev, OutboundDoorbellReg) & OUTBOUNDDOORBELL_0) {
	176	/*
	177	* Clear the doorbell.
	178	*/
	179	rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
	180	ok = 1;
	181	break;
	182	}
	183	/*
	184	* Yield the processor in case we are slow
	185	*/
1241f359	186	msleep(1);
1da177e4 LT	187	}
	188	if (ok != 1) {
	189	/*
	190	* Restore interrupt mask even though we timed out
	191	*/
8e0c5ebd MH	192	if (dev->new_comm_interface)
	193	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
	194	else
	195	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
1da177e4 LT	196	return -ETIMEDOUT;
	197	}
	198	/*
	199	* Pull the synch status from Mailbox 0.
	200	*/
	201	if (status)
	202	*status = rkt_readl(dev, IndexRegs.Mailbox[0]);
7c00ffa3 MH	203	if (r1)
	204	*r1 = rkt_readl(dev, IndexRegs.Mailbox[1]);
	205	if (r2)
	206	*r2 = rkt_readl(dev, IndexRegs.Mailbox[2]);
	207	if (r3)
	208	*r3 = rkt_readl(dev, IndexRegs.Mailbox[3]);
	209	if (r4)
	210	*r4 = rkt_readl(dev, IndexRegs.Mailbox[4]);
1da177e4 LT	211	/*
	212	* Clear the synch command doorbell.
	213	*/
	214	rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
	215	/*
	216	* Restore interrupt mask
	217	*/
8e0c5ebd MH	218	if (dev->new_comm_interface)
	219	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
	220	else
	221	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
1da177e4 LT	222	return 0;
	223
	224	}
	225
	226	/**
	227	* aac_rkt_interrupt_adapter - interrupt adapter
	228	* @dev: Adapter
	229	*
	230	* Send an interrupt to the i960 and breakpoint it.
	231	*/
	232
	233	static void aac_rkt_interrupt_adapter(struct aac_dev *dev)
	234	{
7c00ffa3 MH	235	rkt_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0,
7c00ffa3 MH	236	NULL, NULL, NULL, NULL, NULL);
1da177e4 LT	237	}
	238
	239	/**
	240	* aac_rkt_notify_adapter - send an event to the adapter
	241	* @dev: Adapter
	242	* @event: Event to send
	243	*
	244	* Notify the i960 that something it probably cares about has
	245	* happened.
	246	*/
	247
	248	static void aac_rkt_notify_adapter(struct aac_dev *dev, u32 event)
	249	{
	250	switch (event) {
	251
	252	case AdapNormCmdQue:
	253	rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_1);
	254	break;
	255	case HostNormRespNotFull:
	256	rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_4);
	257	break;
	258	case AdapNormRespQue:
	259	rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_2);
	260	break;
	261	case HostNormCmdNotFull:
	262	rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3);
	263	break;
	264	case HostShutdown:
7c00ffa3 MH	265	// rkt_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0,
7c00ffa3 MH	266	// NULL, NULL, NULL, NULL, NULL);
1da177e4 LT	267	break;
	268	case FastIo:
	269	rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6);
	270	break;
	271	case AdapPrintfDone:
	272	rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_5);
	273	break;
	274	default:
	275	BUG();
	276	break;
	277	}
	278	}
	279
	280	/**
	281	* aac_rkt_start_adapter - activate adapter
	282	* @dev: Adapter
	283	*
	284	* Start up processing on an i960 based AAC adapter
	285	*/
	286
	287	static void aac_rkt_start_adapter(struct aac_dev *dev)
	288	{
1da177e4 LT	289	struct aac_init *init;
	290
	291	init = dev->init;
	292	init->HostElapsedSeconds = cpu_to_le32(get_seconds());
1da177e4	293	// We can only use a 32 bit address here
7c00ffa3 MH	294	rkt_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa,
7c00ffa3 MH	295	0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
1da177e4 LT	296	}
	297
	298	/**
	299	* aac_rkt_check_health
	300	* @dev: device to check if healthy
	301	*
	302	* Will attempt to determine if the specified adapter is alive and
	303	* capable of handling requests, returning 0 if alive.
	304	*/
	305	static int aac_rkt_check_health(struct aac_dev *dev)
	306	{
	307	u32 status = rkt_readl(dev, MUnit.OMRx[0]);
	308
	309	/*
	310	* Check to see if the board failed any self tests.
	311	*/
	312	if (status & SELF_TEST_FAILED)
	313	return -1;
	314	/*
	315	* Check to see if the board panic'd.
	316	*/
	317	if (status & KERNEL_PANIC) {
	318	char * buffer;
	319	struct POSTSTATUS {
56b58712 MH	320	__le32 Post_Command;
56b58712 MH	321	__le32 Post_Address;
1da177e4 LT	322	} * post;
	323	dma_addr_t paddr, baddr;
	324	int ret;
	325
	326	if ((status & 0xFF000000L) == 0xBC000000L)
	327	return (status >> 16) & 0xFF;
	328	buffer = pci_alloc_consistent(dev->pdev, 512, &baddr);
	329	ret = -2;
	330	if (buffer == NULL)
	331	return ret;
	332	post = pci_alloc_consistent(dev->pdev,
	333	sizeof(struct POSTSTATUS), &paddr);
	334	if (post == NULL) {
	335	pci_free_consistent(dev->pdev, 512, buffer, baddr);
	336	return ret;
	337	}
	338	memset(buffer, 0, 512);
	339	post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS);
	340	post->Post_Address = cpu_to_le32(baddr);
	341	rkt_writel(dev, MUnit.IMRx[0], paddr);
7c00ffa3 MH	342	rkt_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, 0, 0, 0, 0, 0,
7c00ffa3 MH	343	NULL, NULL, NULL, NULL, NULL);
1da177e4 LT	344	pci_free_consistent(dev->pdev, sizeof(struct POSTSTATUS),
1da177e4 LT	345	post, paddr);
1241f359	346	if ((buffer[0] == '0') && ((buffer[1] == 'x') \|\| (buffer[1] == 'X'))) {
1da177e4 LT	347	ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
	348	ret <<= 4;
	349	ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
	350	}
	351	pci_free_consistent(dev->pdev, 512, buffer, baddr);
	352	return ret;
	353	}
	354	/*
	355	* Wait for the adapter to be up and running.
	356	*/
	357	if (!(status & KERNEL_UP_AND_RUNNING))
	358	return -3;
	359	/*
	360	* Everything is OK
	361	*/
	362	return 0;
	363	}
	364
8e0c5ebd MH	365	/**
	366	* aac_rkt_send
	367	* @fib: fib to issue
	368	*
	369	* Will send a fib, returning 0 if successful.
	370	*/
	371	static int aac_rkt_send(struct fib * fib)
	372	{
	373	u64 addr = fib->hw_fib_pa;
	374	struct aac_dev *dev = fib->dev;
	375	volatile void __iomem *device = dev->regs.rkt;
	376	u32 Index;
	377
	378	dprintk((KERN_DEBUG "%p->aac_rkt_send(%p->%llx)\n", dev, fib, addr));
	379	Index = rkt_readl(dev, MUnit.InboundQueue);
	380	if (Index == 0xFFFFFFFFL)
	381	Index = rkt_readl(dev, MUnit.InboundQueue);
	382	dprintk((KERN_DEBUG "Index = 0x%x\n", Index));
	383	if (Index == 0xFFFFFFFFL)
	384	return Index;
	385	device += Index;
	386	dprintk((KERN_DEBUG "entry = %x %x %u\n", (u32)(addr & 0xffffffff),
	387	(u32)(addr >> 32), (u32)le16_to_cpu(fib->hw_fib->header.Size)));
	388	writel((u32)(addr & 0xffffffff), device);
	389	device += sizeof(u32);
	390	writel((u32)(addr >> 32), device);
	391	device += sizeof(u32);
	392	writel(le16_to_cpu(fib->hw_fib->header.Size), device);
	393	rkt_writel(dev, MUnit.InboundQueue, Index);
	394	dprintk((KERN_DEBUG "aac_rkt_send - return 0\n"));
	395	return 0;
	396	}
	397
1da177e4 LT	398	/**
	399	* aac_rkt_init - initialize an i960 based AAC card
	400	* @dev: device to configure
	401	*
	402	* Allocate and set up resources for the i960 based AAC variants. The
	403	* device_interface in the commregion will be allocated and linked
	404	* to the comm region.
	405	*/
	406
	407	int aac_rkt_init(struct aac_dev *dev)
	408	{
	409	unsigned long start;
	410	unsigned long status;
	411	int instance;
	412	const char * name;
	413
	414	instance = dev->id;
	415	name = dev->name;
	416
	417	/*
8e0c5ebd	418	* Check to see if the board panic'd while booting.
1da177e4	419	*/
1da177e4 LT	420	/*
	421	* Check to see if the board failed any self tests.
	422	*/
	423	if (rkt_readl(dev, MUnit.OMRx[0]) & SELF_TEST_FAILED) {
	424	printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance);
	425	goto error_iounmap;
	426	}
	427	/*
	428	* Check to see if the monitor panic'd while booting.
	429	*/
	430	if (rkt_readl(dev, MUnit.OMRx[0]) & MONITOR_PANIC) {
	431	printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance);
	432	goto error_iounmap;
	433	}
	434	/*
	435	* Check to see if the board panic'd while booting.
	436	*/
	437	if (rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_PANIC) {
	438	printk(KERN_ERR "%s%d: adapter kernel panic'd.\n", dev->name, instance);
	439	goto error_iounmap;
	440	}
	441	start = jiffies;
	442	/*
	443	* Wait for the adapter to be up and running. Wait up to 3 minutes
	444	*/
	445	while (!(rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_UP_AND_RUNNING))
	446	{
404d9a90	447	if(time_after(jiffies, start+startup_timeout*HZ))
1da177e4 LT	448	{
	449	status = rkt_readl(dev, MUnit.OMRx[0]);
	450	printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n",
	451	dev->name, instance, status);
	452	goto error_iounmap;
	453	}
404d9a90	454	msleep(1);
1da177e4	455	}
1d6f359a	456	if (request_irq(dev->scsi_host_ptr->irq, aac_rkt_intr, IRQF_SHARED\|IRQF_DISABLED, "aacraid", (void *)dev)<0)
1da177e4 LT	457	{
	458	printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance);
	459	goto error_iounmap;
	460	}
	461	/*
	462	* Fill in the function dispatch table.
	463	*/
	464	dev->a_ops.adapter_interrupt = aac_rkt_interrupt_adapter;
bd1aac80	465	dev->a_ops.adapter_disable_int = aac_rkt_disable_interrupt;
1da177e4 LT	466	dev->a_ops.adapter_notify = aac_rkt_notify_adapter;
	467	dev->a_ops.adapter_sync_cmd = rkt_sync_cmd;
	468	dev->a_ops.adapter_check_health = aac_rkt_check_health;
8e0c5ebd	469	dev->a_ops.adapter_send = aac_rkt_send;
1da177e4	470
bd1aac80 MH	471	/*
	472	* First clear out all interrupts. Then enable the one's that we
	473	* can handle.
	474	*/
	475	rkt_writeb(dev, MUnit.OIMR, 0xff);
	476	rkt_writel(dev, MUnit.ODR, 0xffffffff);
	477	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
	478
1da177e4 LT	479	if (aac_init_adapter(dev) == NULL)
1da177e4 LT	480	goto error_irq;
8e0c5ebd MH	481	if (dev->new_comm_interface) {
	482	/*
	483	* FIB Setup has already been done, but we can minimize the
	484	* damage by at least ensuring the OS never issues more
	485	* commands than we can handle. The Rocket adapters currently
	486	* can only handle 246 commands and 8 AIFs at the same time,
	487	* and in fact do notify us accordingly if we negotiate the
	488	* FIB size. The problem that causes us to add this check is
	489	* to ensure that we do not overdo it with the adapter when a
	490	* hard coded FIB override is being utilized. This special
	491	* case warrants this half baked, but convenient, check here.
	492	*/
	493	if (dev->scsi_host_ptr->can_queue > (246 - AAC_NUM_MGT_FIB)) {
	494	dev->init->MaxIoCommands = cpu_to_le32(246);
	495	dev->scsi_host_ptr->can_queue = 246 - AAC_NUM_MGT_FIB;
	496	}
	497	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
	498	}
1da177e4 LT	499	/*
	500	* Tell the adapter that all is configured, and it can start
	501	* accepting requests
	502	*/
	503	aac_rkt_start_adapter(dev);
	504	return 0;
	505
1da177e4	506	error_irq:
bd1aac80	507	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
1da177e4 LT	508	free_irq(dev->scsi_host_ptr->irq, (void *)dev);
	509
	510	error_iounmap:
1da177e4 LT	511
	512	return -1;
	513	}