linux/drivers/char/rio/rioinit.c

/*
** -----------------------------------------------------------------------------
**
**  Perle Specialix driver for Linux
**  Ported from existing RIO Driver for SCO sources.
 *
 *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
 *
 *      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 of the License, 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; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**
**	Module		: rioinit.c
**	SID		: 1.3
**	Last Modified	: 11/6/98 10:33:43
**	Retrieved	: 11/6/98 10:33:49
**
**  ident @(#)rioinit.c	1.3
**
** -----------------------------------------------------------------------------
*/
#ifdef SCCS_LABELS
static char *_rioinit_c_sccs_ = "@(#)rioinit.c	1.3";
#endif

#include <linux/config.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/string.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>

#include <linux/termios.h>
#include <linux/serial.h>

#include <linux/generic_serial.h>


#include "linux_compat.h"
#include "typdef.h"
#include "pkt.h"
#include "daemon.h"
#include "rio.h"
#include "riospace.h"
#include "top.h"
#include "cmdpkt.h"
#include "map.h"
#include "riotypes.h"
#include "rup.h"
#include "port.h"
#include "riodrvr.h"
#include "rioinfo.h"
#include "func.h"
#include "errors.h"
#include "pci.h"

#include "parmmap.h"
#include "unixrup.h"
#include "board.h"
#include "host.h"
#include "error.h"
#include "phb.h"
#include "link.h"
#include "cmdblk.h"
#include "route.h"
#include "control.h"
#include "cirrus.h"
#include "rioioctl.h"
#include "rio_linux.h"

#undef bcopy
#define bcopy rio_pcicopy

int RIOPCIinit(struct rio_info *p, int Mode);

#if 0
static void RIOAllocateInterrupts(struct rio_info *);
static int RIOReport(struct rio_info *);
static void RIOStopInterrupts(struct rio_info *, int, int);
#endif

static int RIOScrub(int, BYTE *, int);

#if 0
extern int	rio_intr();

/*
**	Init time code.
*/
void
rioinit( p, info )
struct rio_info		* p;
struct RioHostInfo	* info;
{
	/*
	** Multi-Host card support - taking the easy way out - sorry !
	** We allocate and set up the Host and Port structs when the
	** driver is called to 'install' the first host.
	** We check for this first 'call' by testing the RIOPortp pointer.
	*/
	if ( !p->RIOPortp )
	{
		rio_dprintk (RIO_DEBUG_INIT,  "Allocating and setting up driver data structures\n");

		RIOAllocDataStructs(p);		/* allocate host/port structs */
		RIOSetupDataStructs(p);		/* setup topology structs */
	}

	RIOInitHosts( p, info );	/* hunt down the hardware */

	RIOAllocateInterrupts(p);	/* allocate interrupts */
	RIOReport(p);			/* show what we found */
}

/*
** Initialise the Cards 
*/ 
void
RIOInitHosts(p, info)
struct rio_info		* p;
struct RioHostInfo	* info;
{
/*
** 15.10.1998 ARG - ESIL 0762 part fix
** If there is no ISA card definition - we always look for PCI cards.
** As we currently only support one host card this lets an ISA card
** definition take precedence over PLUG and PLAY.
** No ISA card - we are PLUG and PLAY with PCI.
*/

	/*
	** Note - for PCI both these will be zero, that's okay because
	** RIOPCIInit() fills them in if a card is found.
	*/
	p->RIOHosts[p->RIONumHosts].Ivec	= info->vector;
	p->RIOHosts[p->RIONumHosts].PaddrP	= info->location;

	/*
	** Check that we are able to accommodate another host
	*/
	if ( p->RIONumHosts >= RIO_HOSTS )
	{
		p->RIOFailed++;
		return;
	}

	if ( info->bus & ISA_BUS )
	{
		rio_dprintk (RIO_DEBUG_INIT,  "initialising card %d (ISA)\n", p->RIONumHosts);
		RIOISAinit(p, p->mode);
	}
	else
	{
		rio_dprintk (RIO_DEBUG_INIT,  "initialising card %d (PCI)\n", p->RIONumHosts);
		RIOPCIinit(p, RIO_PCI_DEFAULT_MODE);
	}

	rio_dprintk (RIO_DEBUG_INIT,  "Total hosts initialised so far : %d\n", p->RIONumHosts);


#ifdef FUTURE_RELEASE
	if (p->bus & EISA_BUS)
		/* EISA card */
		RIOEISAinit(p, RIO_EISA_DEFAULT_MODE);

	if (p->bus & MCA_BUS)
		/* MCA card */
		RIOMCAinit(p, RIO_MCA_DEFAULT_MODE);
#endif
}

/*
** go through memory for an AT host that we pass in the device info
** structure and initialise
*/
void
RIOISAinit(p, mode)
struct rio_info *	p;
int					mode;
{

  /* XXX Need to implement this. */
#if 0
	p->intr_tid = iointset(p->RIOHosts[p->RIONumHosts].Ivec,
					(int (*)())rio_intr, (char*)p->RIONumHosts);

	rio_dprintk (RIO_DEBUG_INIT,  "Set interrupt handler, intr_tid = 0x%x\n", p->intr_tid );

	if (RIODoAT(p, p->RIOHosts[p->RIONumHosts].PaddrP, mode)) {
		return;
	}
	else {
		rio_dprintk (RIO_DEBUG_INIT, "RIODoAT failed\n");
		p->RIOFailed++;
	}
#endif

}

/*
** RIODoAT :
**
** Map in a boards physical address, check that the board is there,
** test the board and if everything is okay assign the board an entry
** in the Rio Hosts structure.
*/
int
RIODoAT(p, Base, mode)
struct rio_info *	p;
int		Base;
int		mode;
{
#define	FOUND		1
#define NOT_FOUND	0

	caddr_t		cardAddr;

	/*
	** Check to see if we actually have a board at this physical address.
	*/
	if ((cardAddr = RIOCheckForATCard(Base)) != 0) {
		/*
		** Now test the board to see if it is working.
		*/
		if (RIOBoardTest(Base, cardAddr, RIO_AT, 0) == RIO_SUCCESS) {
			/*
			** Fill out a slot in the Rio host structure.
			*/
			if (RIOAssignAT(p, Base, cardAddr, mode)) {
				return(FOUND);
			}
		}
		RIOMapout(Base, RIO_AT_MEM_SIZE, cardAddr);
	}
	return(NOT_FOUND);
}

caddr_t
RIOCheckForATCard(Base)
int		Base;
{
	int				off;
	struct DpRam	*cardp;		/* (Points at the host) */
	caddr_t			virtAddr;
	unsigned char			RIOSigTab[24];
/*
** Table of values to search for as prom signature of a host card
*/
	strcpy(RIOSigTab, "JBJGPGGHINSMJPJR");

	/*
	** Hey! Yes, You reading this code! Yo, grab a load a this:
	**
	** IF the card is using WORD MODE rather than BYTE MODE
	** then it will occupy 128K of PHYSICAL memory area. So,
	** you might think that the following Mapin is wrong. Well,
	** it isn't, because the SECOND 64K of occupied space is an
	** EXACT COPY of the FIRST 64K. (good?), so, we need only
	** map it in in one 64K block.
	*/
	if (RIOMapin(Base, RIO_AT_MEM_SIZE, &virtAddr) == -1) {
		rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Couldn't map the board in!\n");
		return((caddr_t)0);
	}

	/*
	** virtAddr points to the DP ram of the system.
	** We now cast this to a pointer to a RIO Host,
	** and have a rummage about in the PROM.
	*/
	cardp = (struct DpRam *)virtAddr;

	for (off=0; RIOSigTab[off]; off++) {
		if ((RBYTE(cardp->DpSignature[off]) & 0xFF) != RIOSigTab[off]) {
			/*
			** Signature mismatch - card not at this address
			*/
			RIOMapout(Base, RIO_AT_MEM_SIZE, virtAddr);
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Couldn't match the signature 0x%x 0x%x!\n",
						(int)cardp, off);
			return((caddr_t)0);
		}
	}

	/*
	** If we get here then we must have found a valid board so return
	** its virtual address.
	*/
	return(virtAddr);
}
#endif

/**
** RIOAssignAT :
**
** Fill out the fields in the p->RIOHosts structure now we know we know
** we have a board present.
**
** bits < 0 indicates 8 bit operation requested,
** bits > 0 indicates 16 bit operation.
*/
int
RIOAssignAT(p, Base, virtAddr, mode)
struct rio_info *	p;
int		Base;
caddr_t	virtAddr;
int		mode;
{
	int		bits;
	struct DpRam *cardp = (struct DpRam *)virtAddr;

	if ((Base < ONE_MEG) || (mode & BYTE_ACCESS_MODE))
		bits = BYTE_OPERATION;
	else
		bits = WORD_OPERATION;

	/*
	** Board has passed its scrub test. Fill in all the
	** transient stuff.
	*/
	p->RIOHosts[p->RIONumHosts].Caddr	= virtAddr;
	p->RIOHosts[p->RIONumHosts].CardP	= (struct DpRam *)virtAddr;

	/*
	** Revision 01 AT host cards don't support WORD operations,
	*/
	if ( RBYTE(cardp->DpRevision) == 01 )
		bits = BYTE_OPERATION;

	p->RIOHosts[p->RIONumHosts].Type = RIO_AT;
	p->RIOHosts[p->RIONumHosts].Copy = bcopy;
											/* set this later */
	p->RIOHosts[p->RIONumHosts].Slot = -1;
	p->RIOHosts[p->RIONumHosts].Mode = SLOW_LINKS | SLOW_AT_BUS | bits;
	WBYTE(p->RIOHosts[p->RIONumHosts].Control, 
			BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
			p->RIOHosts[p->RIONumHosts].Mode | 
			INTERRUPT_DISABLE );
	WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
	WBYTE(p->RIOHosts[p->RIONumHosts].Control,
			BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
			p->RIOHosts[p->RIONumHosts].Mode |
			INTERRUPT_DISABLE );
	WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
	p->RIOHosts[p->RIONumHosts].UniqueNum =
		((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
		((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
		((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
		((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);
	rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Uniquenum 0x%x\n",p->RIOHosts[p->RIONumHosts].UniqueNum);

	p->RIONumHosts++;
	rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Tests Passed at 0x%x\n", Base);
	return(1);
}
#if 0
#ifdef FUTURE_RELEASE
int RIOMCAinit(int Mode)
{
	uchar SlotNumber;
	caddr_t Caddr;
	uint	Paddr;
	uint	Ivec;
	int	 Handle;
	int	 ret = 0;

	/*
	** Valid mode information for MCA cards
	** is only FAST LINKS
	*/
	Mode = (Mode & FAST_LINKS) ? McaTpFastLinks : McaTpSlowLinks;
	rio_dprintk (RIO_DEBUG_INIT, "RIOMCAinit(%d)\n",Mode);


	/*
	** Check out each of the slots
	*/
	for (SlotNumber = 0; SlotNumber < McaMaxSlots; SlotNumber++) {
	/*
	** Enable the slot we want to talk to
	*/
	outb( McaSlotSelect, SlotNumber | McaSlotEnable );

	/*
	** Read the ID word from the slot
	*/
	if (((inb(McaIdHigh)<< 8)|inb(McaIdLow)) == McaRIOId)
	{
		rio_dprintk (RIO_DEBUG_INIT, "Potential MCA card in slot %d\n", SlotNumber);

		/*
		** Card appears to be a RIO MCA card!
		*/
		RIOMachineType |= (1<<RIO_MCA);

		/*
		** Just check we haven't found too many wonderful objects
		*/
		if ( RIONumHosts >= RIO_HOSTS )
		{
		Rprintf(RIOMesgTooManyCards);
		return(ret);
		}

		/*
		** McaIrqEnable contains the interrupt vector, and a card
		** enable bit.
		*/
		Ivec = inb(McaIrqEnable);

		rio_dprintk (RIO_DEBUG_INIT, "Ivec is %x\n", Ivec);

		switch ( Ivec & McaIrqMask )
		{
		case McaIrq9:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ9\n");
		break;
		case McaIrq3:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ3\n");
		break;
		case McaIrq4:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ4\n");
		break;
		case McaIrq7:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ7\n");
		break;
		case McaIrq10:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ10\n");
		break;
		case McaIrq11:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ11\n");
		break;
		case McaIrq12:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ12\n");
		break;
		case McaIrq15:
		rio_dprintk (RIO_DEBUG_INIT, "IRQ15\n");
		break;
		}

		/*
		** If the card enable bit isn't set, then set it!
		*/
		if ((Ivec & McaCardEnable) != McaCardEnable) {
			rio_dprintk (RIO_DEBUG_INIT, "McaCardEnable not set - setting!\n");
			outb(McaIrqEnable,Ivec|McaCardEnable);
		} else
			rio_dprintk (RIO_DEBUG_INIT, "McaCardEnable already set\n");

		/*
		** Convert the IRQ enable mask into something useful
		*/
		Ivec = RIOMcaToIvec[Ivec & McaIrqMask];

		/*
		** Find the physical address
		*/
		rio_dprintk (RIO_DEBUG_INIT, "inb(McaMemory) is %x\n", inb(McaMemory));
		Paddr = McaAddress(inb(McaMemory));

		rio_dprintk (RIO_DEBUG_INIT, "MCA card has Ivec %d Addr %x\n", Ivec, Paddr);

		if ( Paddr != 0 )
		{

		/*
		** Tell the memory mapper that we want to talk to it
		*/
		Handle = RIOMapin( Paddr, RIO_MCA_MEM_SIZE, &Caddr );

		if ( Handle == -1 ) {
			rio_dprintk (RIO_DEBUG_INIT, "Couldn't map %d bytes at %x\n", RIO_MCA_MEM_SIZE, Paddr;
			continue;
		}

		rio_dprintk (RIO_DEBUG_INIT, "Board mapped to vaddr 0x%x\n", Caddr);

		/*
		** And check that it is actually there!
		*/
		if ( RIOBoardTest( Paddr,Caddr,RIO_MCA,SlotNumber ) == RIO_SUCCESS )
		{
			rio_dprintk (RIO_DEBUG_INIT, "Board has passed test\n");
			rio_dprintk (RIO_DEBUG_INIT, "Slot %d. Type %d. Paddr 0x%x. Caddr 0x%x. Mode 0x%x.\n",
			                            SlotNumber, RIO_MCA, Paddr, Caddr, Mode);

			/*
			** Board has passed its scrub test. Fill in all the
			** transient stuff.
			*/
			p->RIOHosts[RIONumHosts].Slot	 = SlotNumber;
			p->RIOHosts[RIONumHosts].Ivec	 = Ivec;
			p->RIOHosts[RIONumHosts].Type	 = RIO_MCA;
			p->RIOHosts[RIONumHosts].Copy	 = bcopy;
			p->RIOHosts[RIONumHosts].PaddrP   = Paddr;
			p->RIOHosts[RIONumHosts].Caddr	= Caddr;
			p->RIOHosts[RIONumHosts].CardP	= (struct DpRam *)Caddr;
			p->RIOHosts[RIONumHosts].Mode	 = Mode;
			WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt , 0xff);
			p->RIOHosts[RIONumHosts].UniqueNum =
			((RBYTE(p->RIOHosts[RIONumHosts].Unique[0])&0xFF)<<0)|
						((RBYTE(p->RIOHosts[RIONumHosts].Unique[1])&0xFF)<<8)|
			((RBYTE(p->RIOHosts[RIONumHosts].Unique[2])&0xFF)<<16)|
			((RBYTE(p->RIOHosts[RIONumHosts].Unique[3])&0xFF)<<24);
			RIONumHosts++;
			ret++;
		}
		else
		{
			/*
			** It failed the test, so ignore it.
			*/
			rio_dprintk (RIO_DEBUG_INIT, "TEST FAILED\n");
			RIOMapout(Paddr, RIO_MCA_MEM_SIZE, Caddr );
		}
		}
		else
		{
		rio_dprintk (RIO_DEBUG_INIT, "Slot %d - Paddr zero!\n", SlotNumber);
		}
	}
	else
	{
		rio_dprintk (RIO_DEBUG_INIT, "Slot %d NOT RIO\n", SlotNumber);
	}
	}
	/*
	** Now we have checked all the slots, turn off the MCA slot selector
	*/
	outb(McaSlotSelect,0);
	rio_dprintk (RIO_DEBUG_INIT, "Slot %d NOT RIO\n", SlotNumber);
	return ret;
}

int RIOEISAinit( int Mode )
{
	static int EISADone = 0;
	uint Paddr;
	int PollIntMixMsgDone = 0;
	caddr_t Caddr;
	ushort Ident;
	uchar EisaSlot;
	uchar Ivec;
	int ret = 0;

	/*
	** The only valid mode information for EISA hosts is fast or slow
	** links.
	*/
	Mode = (Mode & FAST_LINKS) ? EISA_TP_FAST_LINKS : EISA_TP_SLOW_LINKS;

	if ( EISADone )
	{
		rio_dprintk (RIO_DEBUG_INIT, "RIOEISAinit() - already done, return.\n");
		return(0);
	}

	EISADone++;

	rio_dprintk (RIO_DEBUG_INIT, "RIOEISAinit()\n");


	/*
	** First check all cards to see if ANY are set for polled mode operation.
	** If so, set ALL to polled.
	*/

	for ( EisaSlot=1; EisaSlot<=RIO_MAX_EISA_SLOTS; EisaSlot++ )
	{
	Ident = (INBZ(EisaSlot,EISA_PRODUCT_IDENT_HI)<<8) |
		 INBZ(EisaSlot,EISA_PRODUCT_IDENT_LO);

	if ( Ident == RIO_EISA_IDENT )
	{
		rio_dprintk (RIO_DEBUG_INIT, "Found Specialix product\n");

		if ( INBZ(EisaSlot,EISA_PRODUCT_NUMBER) != RIO_EISA_PRODUCT_CODE )
		{
		rio_dprintk (RIO_DEBUG_INIT, "Not Specialix RIO - Product number %x\n",
						INBZ(EisaSlot, EISA_PRODUCT_NUMBER));
		continue;  /* next slot */
		}
		/*
		** Its a Specialix RIO!
		*/
		rio_dprintk (RIO_DEBUG_INIT, "RIO Revision %d\n",
					INBZ(EisaSlot, EISA_REVISION_NUMBER));
		
		RIOMachineType |= (1<<RIO_EISA);

		/*
		** Just check we haven't found too many wonderful objects
		*/
		if ( RIONumHosts >= RIO_HOSTS )
		{
		Rprintf(RIOMesgTooManyCards);
		return 0;
		}

		/*
		** Ensure that the enable bit is set!
		*/
		OUTBZ( EisaSlot, EISA_ENABLE, RIO_EISA_ENABLE_BIT );

		/*
		** EISA_INTERRUPT_VEC contains the interrupt vector.
		*/
		Ivec = INBZ(EisaSlot,EISA_INTERRUPT_VEC);

#ifdef RIODEBUG
		switch ( Ivec & EISA_INTERRUPT_MASK )
		{
		case EISA_IRQ_3:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 3\n");
		break;
		case EISA_IRQ_4:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 4\n");
		break;
		case EISA_IRQ_5:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 5\n");
		break;
		case EISA_IRQ_6:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 6\n");
		break;
		case EISA_IRQ_7:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 7\n");
		break;
		case EISA_IRQ_9:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 9\n");
		break;
		case EISA_IRQ_10:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 10\n");
		break;
		case EISA_IRQ_11:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 11\n");
		break;
		case EISA_IRQ_12:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 12\n");
		break;
		case EISA_IRQ_14:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 14\n");
		break;
		case EISA_IRQ_15:
			rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 15\n");
		break;
		case EISA_POLLED:
			rio_dprintk (RIO_DEBUG_INIT, "EISA POLLED\n");
		break;
		default:
			rio_dprintk (RIO_DEBUG_INIT, NULL,DBG_INIT|DBG_FAIL,"Shagged interrupt number!\n");
		Ivec &= EISA_CONTROL_MASK;
		}
#endif

		if ( (Ivec & EISA_INTERRUPT_MASK) ==
		 EISA_POLLED )
		{
		RIOWillPoll = 1;
		break;		/* From EisaSlot loop */
		}
	}
	}

	/*
	** Do it all again now we know whether to change all cards to polled
	** mode or not
	*/

	for ( EisaSlot=1; EisaSlot<=RIO_MAX_EISA_SLOTS; EisaSlot++ )
	{
	Ident = (INBZ(EisaSlot,EISA_PRODUCT_IDENT_HI)<<8) |
		 INBZ(EisaSlot,EISA_PRODUCT_IDENT_LO);

	if ( Ident == RIO_EISA_IDENT )
	{
		if ( INBZ(EisaSlot,EISA_PRODUCT_NUMBER) != RIO_EISA_PRODUCT_CODE )
		continue;  /* next slot */

		/*
		** Its a Specialix RIO!
		*/
		
		/*
		** Ensure that the enable bit is set!
		*/
		OUTBZ( EisaSlot, EISA_ENABLE, RIO_EISA_ENABLE_BIT );

		/*
		** EISA_INTERRUPT_VEC contains the interrupt vector.
		*/
		Ivec = INBZ(EisaSlot,EISA_INTERRUPT_VEC);

		if ( RIOWillPoll )
		{
			/*
			** If we are going to operate in polled mode, but this
			** board is configured to be interrupt driven, display
			** the message explaining the situation to the punter,
			** assuming we haven't already done so.
			*/

			if ( !PollIntMixMsgDone &&
			 (Ivec & EISA_INTERRUPT_MASK) != EISA_POLLED )
			{
			Rprintf(RIOMesgAllPolled);
			PollIntMixMsgDone = 1;
			}

			/*
			** Ungraciously ignore whatever the board reports as its
			** interrupt vector...
			*/

			Ivec &= ~EISA_INTERRUPT_MASK;

			/*
			** ...and force it to dance to the poll tune.
			*/

			Ivec |= EISA_POLLED;
		}

		/*
		** Convert the IRQ enable mask into something useful (0-15)
		*/
		Ivec = RIOEisaToIvec(Ivec);

		rio_dprintk (RIO_DEBUG_INIT, "EISA host in slot %d has Ivec 0x%x\n",
		 EisaSlot, Ivec);

		/*
		** Find the physical address
		*/
		Paddr = (INBZ(EisaSlot,EISA_MEMORY_BASE_HI)<<24) |
				(INBZ(EisaSlot,EISA_MEMORY_BASE_LO)<<16);

		rio_dprintk (RIO_DEBUG_INIT, "EISA card has Ivec %d Addr %x\n", Ivec, Paddr);

		if ( Paddr == 0 )
		{
		rio_dprintk (RIO_DEBUG_INIT,
		 "Board in slot %d configured for address zero!\n", EisaSlot);
		continue;
		}

		/*
		** Tell the memory mapper that we want to talk to it
		*/
		rio_dprintk (RIO_DEBUG_INIT, "About to map EISA card \n");

		if (RIOMapin( Paddr, RIO_EISA_MEM_SIZE, &Caddr) == -1) {
		rio_dprintk (RIO_DEBUG_INIT, "Couldn't map %d bytes at %x\n",
							RIO_EISA_MEM_SIZE,Paddr);
		continue;
		}

		rio_dprintk (RIO_DEBUG_INIT, "Board mapped to vaddr 0x%x\n", Caddr);

		/*
		** And check that it is actually there!
		*/
		if ( RIOBoardTest( Paddr,Caddr,RIO_EISA,EisaSlot) == RIO_SUCCESS )
			{
		rio_dprintk (RIO_DEBUG_INIT, "Board has passed test\n");
		rio_dprintk (RIO_DEBUG_INIT, 
		"Slot %d. Ivec %d. Type %d. Paddr 0x%x. Caddr 0x%x. Mode 0x%x.\n",
			EisaSlot,Ivec,RIO_EISA,Paddr,Caddr,Mode);

		/*
		** Board has passed its scrub test. Fill in all the
		** transient stuff.
		*/
		p->RIOHosts[RIONumHosts].Slot	 = EisaSlot;
		p->RIOHosts[RIONumHosts].Ivec	 = Ivec;
		p->RIOHosts[RIONumHosts].Type	 = RIO_EISA;
		p->RIOHosts[RIONumHosts].Copy	 = bcopy;
				p->RIOHosts[RIONumHosts].PaddrP   = Paddr;
				p->RIOHosts[RIONumHosts].Caddr	= Caddr;
		p->RIOHosts[RIONumHosts].CardP	= (struct DpRam *)Caddr;
				p->RIOHosts[RIONumHosts].Mode	 = Mode;
		/*
		** because the EISA prom is mapped into IO space, we
		** need to copy the unqiue number into the memory area
		** that it would have occupied, so that the download
		** code can determine its ID and card type.
		*/
	 WBYTE(p->RIOHosts[RIONumHosts].Unique[0],INBZ(EisaSlot,EISA_UNIQUE_NUM_0));
	 WBYTE(p->RIOHosts[RIONumHosts].Unique[1],INBZ(EisaSlot,EISA_UNIQUE_NUM_1));
	 WBYTE(p->RIOHosts[RIONumHosts].Unique[2],INBZ(EisaSlot,EISA_UNIQUE_NUM_2));
	 WBYTE(p->RIOHosts[RIONumHosts].Unique[3],INBZ(EisaSlot,EISA_UNIQUE_NUM_3));
		p->RIOHosts[RIONumHosts].UniqueNum =
			((RBYTE(p->RIOHosts[RIONumHosts].Unique[0])&0xFF)<<0)|
						((RBYTE(p->RIOHosts[RIONumHosts].Unique[1])&0xFF)<<8)|
			((RBYTE(p->RIOHosts[RIONumHosts].Unique[2])&0xFF)<<16)|
			((RBYTE(p->RIOHosts[RIONumHosts].Unique[3])&0xFF)<<24);
		INBZ(EisaSlot,EISA_INTERRUPT_RESET);
				RIONumHosts++;
		ret++;
			}
		else
		{
		/*
		** It failed the test, so ignore it.
		*/
		rio_dprintk (RIO_DEBUG_INIT, "TEST FAILED\n");

		RIOMapout(Paddr, RIO_EISA_MEM_SIZE, Caddr );
		}
	}
	}
	if (RIOMachineType & RIO_EISA)
	return ret+1;
	return ret;
}
#endif


#ifndef linux

#define CONFIG_ADDRESS	0xcf8
#define CONFIG_DATA		0xcfc
#define FORWARD_REG		0xcfa


static int
read_config(int bus_number, int device_num, int r_number) 
{
	unsigned int cav;
	unsigned int val;

/*
   Build config_address_value:

      31        24 23        16 15      11 10  8 7        0 
      ------------------------------------------------------
      |1| 0000000 | bus_number | device # | 000 | register |
      ------------------------------------------------------
*/

	cav = r_number & 0xff;
	cav |= ((device_num & 0x1f) << 11);
	cav |= ((bus_number & 0xff) << 16);
	cav |= 0x80000000; /* Enable bit */
	outpd(CONFIG_ADDRESS,cav);
	val = inpd(CONFIG_DATA);
	outpd(CONFIG_ADDRESS,0);
	return val;
}

static
write_config(bus_number,device_num,r_number,val) 
{
	unsigned int cav;

/*
   Build config_address_value:

      31        24 23        16 15      11 10  8 7        0 
      ------------------------------------------------------
      |1| 0000000 | bus_number | device # | 000 | register |
      ------------------------------------------------------
*/

	cav = r_number & 0xff;
	cav |= ((device_num & 0x1f) << 11);
	cav |= ((bus_number & 0xff) << 16);
	cav |= 0x80000000; /* Enable bit */
	outpd(CONFIG_ADDRESS, cav);
	outpd(CONFIG_DATA, val);
	outpd(CONFIG_ADDRESS, 0);
	return val;
}
#else
/* XXX Implement these... */
static int
read_config(int bus_number, int device_num, int r_number) 
{
  return 0;
}

static int
write_config(int bus_number, int device_num, int r_number) 
{
  return 0;
}

#endif

int
RIOPCIinit(p, Mode)
struct rio_info	*p;
int 		Mode;
{
	#define MAX_PCI_SLOT		32
	#define RIO_PCI_JET_CARD	0x200011CB

	static int	slot;	/* count of machine's PCI slots searched so far */
	caddr_t		Caddr;	/* Virtual address of the current PCI host card. */
	unsigned char	Ivec;	/* interrupt vector for the current PCI host */
	unsigned long	Paddr;	/* Physical address for the current PCI host */
	int		Handle;	/* Handle to Virtual memory allocated for current PCI host */


	rio_dprintk (RIO_DEBUG_INIT,  "Search for a RIO PCI card - start at slot %d\n", slot);

	/*
	** Initialise the search status
	*/
	p->RIOLastPCISearch	= RIO_FAIL;

	while ( (slot < MAX_PCI_SLOT) & (p->RIOLastPCISearch != RIO_SUCCESS) )
	{
		rio_dprintk (RIO_DEBUG_INIT,  "Currently testing slot %d\n", slot);

		if (read_config(0,slot,0) == RIO_PCI_JET_CARD) {
			p->RIOHosts[p->RIONumHosts].Ivec = 0;
			Paddr = read_config(0,slot,0x18);
			Paddr = Paddr - (Paddr & 0x1); /* Mask off the io bit */

			if ( (Paddr == 0) || ((Paddr & 0xffff0000) == 0xffff0000) ) {
				rio_dprintk (RIO_DEBUG_INIT,  "Goofed up slot\n");	/* what! */
				slot++;
				continue;
			}

			p->RIOHosts[p->RIONumHosts].PaddrP = Paddr;
			Ivec = (read_config(0,slot,0x3c) & 0xff);

			rio_dprintk (RIO_DEBUG_INIT,  "PCI Host at 0x%x, Intr %d\n", (int)Paddr, Ivec);

			Handle = RIOMapin( Paddr, RIO_PCI_MEM_SIZE, &Caddr );
			if (Handle == -1) {
				rio_dprintk (RIO_DEBUG_INIT,  "Couldn't map %d bytes at 0x%x\n", RIO_PCI_MEM_SIZE, (int)Paddr);
				slot++;
				continue;
			}
			p->RIOHosts[p->RIONumHosts].Ivec = Ivec + 32;
			p->intr_tid = iointset(p->RIOHosts[p->RIONumHosts].Ivec,
						(int (*)())rio_intr, (char *)p->RIONumHosts);
			if (RIOBoardTest( Paddr, Caddr, RIO_PCI, 0 ) == RIO_SUCCESS) {
				rio_dprintk (RIO_DEBUG_INIT, ("Board has passed test\n");
				rio_dprintk (RIO_DEBUG_INIT, ("Paddr 0x%x. Caddr 0x%x. Mode 0x%x.\n", Paddr, Caddr, Mode);

				/*
				** Board has passed its scrub test. Fill in all the
				** transient stuff.
				*/
				p->RIOHosts[p->RIONumHosts].Slot	   = 0;
				p->RIOHosts[p->RIONumHosts].Ivec	   = Ivec + 32;
				p->RIOHosts[p->RIONumHosts].Type	   = RIO_PCI;
				p->RIOHosts[p->RIONumHosts].Copy	   = rio_pcicopy; 
				p->RIOHosts[p->RIONumHosts].PaddrP	   = Paddr;
				p->RIOHosts[p->RIONumHosts].Caddr	   = Caddr;
				p->RIOHosts[p->RIONumHosts].CardP	   = (struct DpRam *)Caddr;
				p->RIOHosts[p->RIONumHosts].Mode	   = Mode;

#if 0
				WBYTE(p->RIOHosts[p->RIONumHosts].Control, 
						BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
						p->RIOHosts[p->RIONumHosts].Mode | 
						INTERRUPT_DISABLE );
				WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
				WBYTE(p->RIOHosts[p->RIONumHosts].Control,
						BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
						p->RIOHosts[p->RIONumHosts].Mode |
						INTERRUPT_DISABLE );
				WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
#else
				WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
#endif
				p->RIOHosts[p->RIONumHosts].UniqueNum  =
					((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
					((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
					((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
					((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);

				rio_dprintk (RIO_DEBUG_INIT, "Unique no 0x%x.\n", 
				    p->RIOHosts[p->RIONumHosts].UniqueNum);

				p->RIOLastPCISearch = RIO_SUCCESS;
				p->RIONumHosts++;
			}
		}
		slot++;
	}

	if ( slot >= MAX_PCI_SLOT ) {
		rio_dprintk (RIO_DEBUG_INIT,  "All %d PCI slots have tested for RIO cards !!!\n",
			     MAX_PCI_SLOT);
	}


	/*
	** I don't think we want to do this anymore
	**

	if (!p->RIOLastPCISearch == RIO_FAIL ) {
		p->RIOFailed++;
	}

	**
	*/
}

#ifdef FUTURE_RELEASE
void riohalt( void )
{
	int host;
	for ( host=0; host<p->RIONumHosts; host++ )
	{
		rio_dprintk (RIO_DEBUG_INIT, "Stop host %d\n", host);
		(void)RIOBoardTest( p->RIOHosts[host].PaddrP, p->RIOHosts[host].Caddr, p->RIOHosts[host].Type,p->RIOHosts[host].Slot );
	}
}
#endif
#endif

static	uchar	val[] = {
#ifdef VERY_LONG_TEST
	  0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
	  0xa5, 0xff, 0x5a, 0x00, 0xff, 0xc9, 0x36, 
#endif
	  0xff, 0x00, 0x00 };

#define	TEST_END sizeof(val)

/*
** RAM test a board. 
** Nothing too complicated, just enough to check it out.
*/
int
RIOBoardTest(paddr, caddr, type, slot)
paddr_t	paddr;
caddr_t	caddr;
uchar	type;
int		slot;
{
	struct DpRam *DpRam = (struct DpRam *)caddr;
	char *ram[4];
	int  size[4];
	int  op, bank;
	int  nbanks;

	rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Reset host type=%d, DpRam=0x%x, slot=%d\n",
			type,(int)DpRam, slot);

	RIOHostReset(type, DpRam, slot);

	/*
	** Scrub the memory. This comes in several banks:
	** DPsram1	- 7000h bytes
	** DPsram2	- 200h  bytes
	** DPsram3	- 7000h bytes
	** scratch	- 1000h bytes
	*/

	rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Setup ram/size arrays\n");

	size[0] = DP_SRAM1_SIZE;
	size[1] = DP_SRAM2_SIZE;
	size[2] = DP_SRAM3_SIZE;
	size[3] = DP_SCRATCH_SIZE;

	ram[0] = (char *)&DpRam->DpSram1[0];
	ram[1] = (char *)&DpRam->DpSram2[0];
	ram[2] = (char *)&DpRam->DpSram3[0];
	nbanks = (type == RIO_PCI) ? 3 : 4;
	if (nbanks == 4)
		ram[3] = (char *)&DpRam->DpScratch[0];


	if (nbanks == 3) {
		rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Memory: 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x)\n",
				(int)ram[0], size[0], (int)ram[1], size[1], (int)ram[2], size[2]);
	} else {
		rio_dprintk (RIO_DEBUG_INIT, "RIO-init: 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x)\n",
			(int)ram[0], size[0], (int)ram[1], size[1], (int)ram[2], size[2], (int)ram[3], 
					size[3]);
	}

	/*
	** This scrub operation will test for crosstalk between
	** banks. TEST_END is a magic number, and relates to the offset
	** within the 'val' array used by Scrub.
	*/
	for (op=0; op<TEST_END; op++) {
		for (bank=0; bank<nbanks; bank++) {
			if (RIOScrub(op, (BYTE *)ram[bank], size[bank]) == RIO_FAIL) {
				rio_dprintk (RIO_DEBUG_INIT, "RIO-init: RIOScrub band %d, op %d failed\n", 
							bank, op);
				return RIO_FAIL;
			}
		}
	}

	rio_dprintk (RIO_DEBUG_INIT, "Test completed\n");
	return RIO_SUCCESS;
}


/*
** Scrub an area of RAM.
** Define PRETEST and POSTTEST for a more thorough checking of the
** state of the memory.
** Call with op set to an index into the above 'val' array to determine
** which value will be written into memory.
** Call with op set to zero means that the RAM will not be read and checked
** before it is written.
** Call with op not zero, and the RAM will be read and compated with val[op-1]
** to check that the data from the previous phase was retained.
*/
static int
RIOScrub(op, ram, size)
int		op;
BYTE *	ram;
int		size; 
{
	int				off;
	unsigned char	oldbyte;
	unsigned char	newbyte;
	unsigned char	invbyte;
	unsigned short	oldword;
	unsigned short	newword;
	unsigned short	invword;
	unsigned short	swapword;

	if (op) {
		oldbyte = val[op-1];
		oldword = oldbyte | (oldbyte<<8);
	} else
	  oldbyte = oldword = 0; /* Tell the compiler we've initilalized them. */
	newbyte = val[op];
	newword = newbyte | (newbyte<<8);
	invbyte = ~newbyte;
	invword = invbyte | (invbyte<<8);

	/*
	** Check that the RAM contains the value that should have been left there
	** by the previous test (not applicable for pass zero)
	*/
	if (op) {
		for (off=0; off<size; off++) {
			if (RBYTE(ram[off]) != oldbyte) {
				rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Pre Check 1: BYTE at offset 0x%x should have been=%x, was=%x\n", off, oldbyte, RBYTE(ram[off]));
				return RIO_FAIL;
			}
		}
		for (off=0; off<size; off+=2) {
			if (*(ushort *)&ram[off] != oldword) {
				rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: WORD at offset 0x%x should have been=%x, was=%x\n",off,oldword,*(ushort *)&ram[off]);
				rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
				return RIO_FAIL;
			}
		}
	}

	/*
	** Now write the INVERSE of the test data into every location, using
	** BYTE write operations, first checking before each byte is written
	** that the location contains the old value still, and checking after
	** the write that the location contains the data specified - this is
	** the BYTE read/write test.
	*/
	for (off=0; off<size; off++) {
		if (op && (RBYTE(ram[off]) != oldbyte)) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Pre Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, oldbyte, RBYTE(ram[off]));
			return RIO_FAIL;
		}
		WBYTE(ram[off],invbyte);
		if (RBYTE(ram[off]) != invbyte) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Inv Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, invbyte, RBYTE(ram[off]));
			return RIO_FAIL;
		}
	}

	/*
	** now, use WORD operations to write the test value into every location,
	** check as before that the location contains the previous test value
	** before overwriting, and that it contains the data value written
	** afterwards.
	** This is the WORD operation test.
	*/
	for (off=0; off<size; off+=2) {
		if (*(ushort *)&ram[off] != invword) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: WORD at offset 0x%x should have been=%x, was=%x\n", off, invword, *(ushort *)&ram[off]);
		rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
			return RIO_FAIL;
		}

		*(ushort *)&ram[off] = newword;
		if ( *(ushort *)&ram[off] != newword ) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, newword, *(ushort *)&ram[off]);
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 1: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
			return RIO_FAIL;
		}
	}

	/*
	** now run through the block of memory again, first in byte mode
	** then in word mode, and check that all the locations contain the
	** required test data.
	*/
	for (off=0; off<size; off++) {
		if (RBYTE(ram[off]) != newbyte) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Byte Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, RBYTE(ram[off]));
			return RIO_FAIL;
		}
	}

	for (off=0; off<size; off+=2) {
		if ( *(ushort *)&ram[off] != newword ) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 2: WORD at offset 0x%x should have been=%x, was=%x\n", off, newword, *(ushort *)&ram[off]);
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 2: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
			return RIO_FAIL;
		}
	}

	/*
	** time to check out byte swapping errors
	*/
	swapword = invbyte | (newbyte << 8);

	for (off=0; off<size; off+=2) {
		WBYTE(ram[off],invbyte);
		WBYTE(ram[off+1],newbyte);
	}

	for ( off=0; off<size; off+=2 ) {
		if (*(ushort *)&ram[off] != swapword) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, swapword, *((ushort *)&ram[off]));
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
			return RIO_FAIL;
		}
		*((ushort *)&ram[off]) = ~swapword;
	}

	for (off=0; off<size; off+=2) {
		if (RBYTE(ram[off]) != newbyte) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, RBYTE(ram[off]));
			return RIO_FAIL;
		}
		if (RBYTE(ram[off+1]) != invbyte) {
			rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off+1, invbyte, RBYTE(ram[off+1]));
			return RIO_FAIL;
		}
		*((ushort *)&ram[off]) = newword;
	}
	return RIO_SUCCESS;
}

/*
** try to ensure that every host is either in polled mode
** or is in interrupt mode. Only allow interrupt mode if
** all hosts can interrupt (why?)
** and force into polled mode if told to. Patch up the
** interrupt vector & salute The Queen when you've done.
*/
#if 0
static void
RIOAllocateInterrupts(p)
struct rio_info *	p;
{
	int Host;

	/*
	** Easy case - if we have been told to poll, then we poll.
	*/
	if (p->mode & POLLED_MODE) {
		RIOStopInterrupts(p, 0, 0);
		return;
	}

	/*
	** check - if any host has been set to polled mode, then all must be.
	*/
	for (Host=0; Host<p->RIONumHosts; Host++) {
		if ( (p->RIOHosts[Host].Type != RIO_AT) &&
				(p->RIOHosts[Host].Ivec == POLLED) ) {
			RIOStopInterrupts(p, 1, Host );
			return;
		}
	}
	for (Host=0; Host<p->RIONumHosts; Host++) {
		if (p->RIOHosts[Host].Type == RIO_AT) {
			if ( (p->RIOHosts[Host].Ivec - 32) == 0) {
				RIOStopInterrupts(p, 2, Host );
				return;
			}
		}
	}
}

/*
** something has decided that we can't be doing with these
** new-fangled interrupt thingies. Set everything up to just
** poll.
*/
static void
RIOStopInterrupts(p, Reason, Host)
struct rio_info *	p;
int	Reason;
int	Host; 
{
#ifdef FUTURE_RELEASE
	switch (Reason) {
		case 0:	/* forced into polling by rio_polled */
			break;
		case 1:	/* SCU has set 'Host' into polled mode */
			break;
		case 2:	/* there aren't enough interrupt vectors for 'Host' */
			break;
	}
#endif

	for (Host=0; Host<p->RIONumHosts; Host++ ) {
		struct Host *HostP = &p->RIOHosts[Host];

		switch (HostP->Type) {
			case RIO_AT:
				/*
				** The AT host has it's interrupts disabled by clearing the
				** int_enable bit.
				*/
				HostP->Mode &= ~INTERRUPT_ENABLE;
				HostP->Ivec = POLLED;
				break;
#ifdef FUTURE_RELEASE
			case RIO_EISA:
				/*
				** The EISA host has it's interrupts disabled by setting the
				** Ivec to zero
				*/
				HostP->Ivec = POLLED;
				break;
#endif
			case RIO_PCI:
				/*
				** The PCI host has it's interrupts disabled by clearing the
				** int_enable bit, like a regular host card.
				*/
				HostP->Mode &= ~RIO_PCI_INT_ENABLE;
				HostP->Ivec = POLLED;
				break;
#ifdef FUTURE_RELEASE
			case RIO_MCA:
				/*
				** There's always one, isn't there?
				** The MCA host card cannot have it's interrupts disabled.
				*/
				RIOPatchVec(HostP);
				break;
#endif
		}
	}
}

/*
** This function is called at init time to setup the data structures.
*/
void
RIOAllocDataStructs(p)
struct rio_info *	p;
{
	int	port,
		host,
		tm;

	p->RIOPortp = (struct Port *)sysbrk(RIO_PORTS * sizeof(struct Port));
	if (!p->RIOPortp) {
		rio_dprintk (RIO_DEBUG_INIT, "RIO-init: No memory for port structures\n");
		p->RIOFailed++;
		return;
	} 
	bzero( p->RIOPortp, sizeof(struct Port) * RIO_PORTS );
	rio_dprintk (RIO_DEBUG_INIT,  "RIO-init: allocated and cleared memory for port structs\n");
	rio_dprintk (RIO_DEBUG_INIT,  "First RIO port struct @0x%x, size=0x%x bytes\n",
	    (int)p->RIOPortp, sizeof(struct Port));

	for( port=0; port<RIO_PORTS; port++ ) {
		p->RIOPortp[port].PortNum = port;
		p->RIOPortp[port].TtyP = &p->channel[port];
		sreset (p->RIOPortp[port].InUse);	/* Let the first guy uses it */
		p->RIOPortp[port].portSem = -1;	/* Let the first guy takes it */
		p->RIOPortp[port].ParamSem = -1;	/* Let the first guy takes it */
		p->RIOPortp[port].timeout_id = 0;	/* Let the first guy takes it */
	}

	p->RIOHosts = (struct Host *)sysbrk(RIO_HOSTS * sizeof(struct Host));
	if (!p->RIOHosts) {
		rio_dprintk (RIO_DEBUG_INIT, "RIO-init: No memory for host structures\n");
		p->RIOFailed++;
		return;
	}
	bzero(p->RIOHosts, sizeof(struct Host)*RIO_HOSTS);
	rio_dprintk (RIO_DEBUG_INIT,  "RIO-init: allocated and cleared memory for host structs\n");
	rio_dprintk (RIO_DEBUG_INIT,  "First RIO host struct @0x%x, size=0x%x bytes\n",
	    (int)p->RIOHosts, sizeof(struct Host));

	for( host=0; host<RIO_HOSTS; host++ ) {
		spin_lock_init (&p->RIOHosts[host].HostLock);
		p->RIOHosts[host].timeout_id = 0; /* Let the first guy takes it */
	}
	/*
	** check that the buffer size is valid, round down to the next power of
	** two if necessary; if the result is zero, then, hey, no double buffers.
	*/
	for ( tm = 1; tm && tm <= p->RIOConf.BufferSize; tm <<= 1 )
		;
	tm >>= 1;
	p->RIOBufferSize = tm;
	p->RIOBufferMask = tm ? tm - 1 : 0;
}

/*
** this function gets called whenever the data structures need to be
** re-setup, for example, after a riohalt (why did I ever invent it?)
*/
void
RIOSetupDataStructs(p)
struct rio_info	* p;
{
	int host, entry, rup;

	for ( host=0; host<RIO_HOSTS; host++ ) {
		struct Host *HostP = &p->RIOHosts[host];
		for ( entry=0; entry<LINKS_PER_UNIT; entry++ ) {
			HostP->Topology[entry].Unit = ROUTE_DISCONNECT;
			HostP->Topology[entry].Link = NO_LINK;
		}
		bcopy("HOST X", HostP->Name, 7);
		HostP->Name[5] = '1'+host;
		for (rup=0; rup<(MAX_RUP + LINKS_PER_UNIT); rup++) {
			if (rup < MAX_RUP) {
				for (entry=0; entry<LINKS_PER_UNIT; entry++ ) {
					HostP->Mapping[rup].Topology[entry].Unit = ROUTE_DISCONNECT;
					HostP->Mapping[rup].Topology[entry].Link = NO_LINK;
				}
				RIODefaultName(p, HostP, rup);
			}
			spin_lock_init(&HostP->UnixRups[rup].RupLock);
		}
	}
}
#endif

int
RIODefaultName(p, HostP, UnitId)
struct rio_info *	p;
struct Host *	HostP;
uint			UnitId;
{
#ifdef CHECK
	CheckHost( Host );
	CheckUnitId( UnitId );
#endif
	bcopy("UNKNOWN RTA X-XX",HostP->Mapping[UnitId].Name,17);
	HostP->Mapping[UnitId].Name[12]='1'+(HostP-p->RIOHosts);
	if ((UnitId+1) > 9) {
		HostP->Mapping[UnitId].Name[14]='0'+((UnitId+1)/10);
		HostP->Mapping[UnitId].Name[15]='0'+((UnitId+1)%10);
	}
	else {
		HostP->Mapping[UnitId].Name[14]='1'+UnitId;
		HostP->Mapping[UnitId].Name[15]=0;
	}
	return 0;
}

#define RIO_RELEASE	"Linux"
#define RELEASE_ID	"1.0"

#if 0
static int
RIOReport(p)
struct rio_info *	p;
{
	char *	RIORelease = RIO_RELEASE;
	char *	RIORelID = RELEASE_ID;
	int		host;

	rio_dprintk (RIO_DEBUG_INIT, "RIO : Release: %s ID: %s\n", RIORelease, RIORelID);

	if ( p->RIONumHosts==0 ) {
		rio_dprintk (RIO_DEBUG_INIT, "\nNo Hosts configured\n");
		return(0);
	}

	for ( host=0; host < p->RIONumHosts; host++ ) {
		struct Host *HostP = &p->RIOHosts[host];
		switch ( HostP->Type ) {
			case RIO_AT:
				rio_dprintk (RIO_DEBUG_INIT, "AT BUS : found the card at 0x%x\n", HostP->PaddrP);
		}
	}
	return 0;
}
#endif

static struct rioVersion	stVersion;

struct rioVersion *
RIOVersid(void)
{
    strlcpy(stVersion.version, "RIO driver for linux V1.0",
	    sizeof(stVersion.version));
    strlcpy(stVersion.buildDate, __DATE__,
	    sizeof(stVersion.buildDate));

    return &stVersion;
}

#if 0
int
RIOMapin(paddr, size, vaddr)
paddr_t		paddr;
int			size;
caddr_t *	vaddr;
{
	*vaddr = (caddr_t)permap( (long)paddr, size);
	return ((int)*vaddr);
}

void
RIOMapout(paddr, size, vaddr)
paddr_t		paddr;
long		size;
caddr_t 	vaddr;
{
}
#endif


void
RIOHostReset(Type, DpRamP, Slot)
uint Type;
volatile struct DpRam *DpRamP;
uint Slot; 
{
	/*
	** Reset the Tpu
	*/
	rio_dprintk (RIO_DEBUG_INIT,  "RIOHostReset: type 0x%x", Type);
	switch ( Type ) {
		case RIO_AT:
			rio_dprintk (RIO_DEBUG_INIT, " (RIO_AT)\n");
			WBYTE(DpRamP->DpControl,  BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
					  INTERRUPT_DISABLE | BYTE_OPERATION |
					  SLOW_LINKS | SLOW_AT_BUS);
			WBYTE(DpRamP->DpResetTpu, 0xFF);
			udelay(3);

			rio_dprintk (RIO_DEBUG_INIT,  "RIOHostReset: Don't know if it worked. Try reset again\n");
			WBYTE(DpRamP->DpControl,  BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
					  INTERRUPT_DISABLE | BYTE_OPERATION |
					  SLOW_LINKS | SLOW_AT_BUS);
			WBYTE(DpRamP->DpResetTpu, 0xFF);
			udelay(3);
			break;
#ifdef FUTURE_RELEASE
	case RIO_EISA:
	/*
	** Bet this doesn't work!
	*/
	OUTBZ( Slot, EISA_CONTROL_PORT,
		EISA_TP_RUN		| EISA_TP_BUS_DISABLE   |
		EISA_TP_SLOW_LINKS | EISA_TP_BOOT_FROM_RAM );
	OUTBZ( Slot, EISA_CONTROL_PORT,
		EISA_TP_RESET	  | EISA_TP_BUS_DISABLE   | 
		EISA_TP_SLOW_LINKS | EISA_TP_BOOT_FROM_RAM );
	suspend( 3 );
	OUTBZ( Slot, EISA_CONTROL_PORT,
		EISA_TP_RUN		| EISA_TP_BUS_DISABLE   | 
		EISA_TP_SLOW_LINKS | EISA_TP_BOOT_FROM_RAM );
	break;
	case RIO_MCA:
	WBYTE(DpRamP->DpControl  , McaTpBootFromRam | McaTpBusDisable );
	WBYTE(DpRamP->DpResetTpu , 0xFF );
	suspend( 3 );
	WBYTE(DpRamP->DpControl  , McaTpBootFromRam | McaTpBusDisable );
	WBYTE(DpRamP->DpResetTpu , 0xFF );
	suspend( 3 );
		break;
#endif
	case RIO_PCI:
		rio_dprintk (RIO_DEBUG_INIT, " (RIO_PCI)\n");
		DpRamP->DpControl  = RIO_PCI_BOOT_FROM_RAM;
		DpRamP->DpResetInt = 0xFF;
		DpRamP->DpResetTpu = 0xFF;
		udelay(100);
		/* for (i=0; i<6000; i++);  */
		/* suspend( 3 ); */
		break;
#ifdef FUTURE_RELEASE
	default:
	Rprintf(RIOMesgNoSupport,Type,DpRamP,Slot);
	return;
#endif

	default:
		rio_dprintk (RIO_DEBUG_INIT, " (UNKNOWN)\n");
		break;
	}
	return;
}