/* ** ----------------------------------------------------------------------------- ** ** 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; }