2 ** -----------------------------------------------------------------------------
4 ** Perle Specialix driver for Linux
5 ** Ported from existing RIO Driver for SCO sources.
7 * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 ** Last Modified : 11/6/98 10:33:43
26 ** Retrieved : 11/6/98 10:33:49
28 ** ident @(#)rioinit.c 1.3
30 ** -----------------------------------------------------------------------------
33 static char *_rioinit_c_sccs_ = "@(#)rioinit.c 1.3";
36 #include <linux/config.h>
37 #include <linux/module.h>
38 #include <linux/slab.h>
39 #include <linux/errno.h>
41 #include <asm/system.h>
42 #include <asm/string.h>
43 #include <asm/semaphore.h>
44 #include <asm/uaccess.h>
46 #include <linux/termios.h>
47 #include <linux/serial.h>
49 #include <linux/generic_serial.h>
52 #include "linux_compat.h"
82 #include "rio_linux.h"
85 #define bcopy rio_pcicopy
87 int RIOPCIinit(struct rio_info *p, int Mode);
90 static void RIOAllocateInterrupts(struct rio_info *);
91 static int RIOReport(struct rio_info *);
92 static void RIOStopInterrupts(struct rio_info *, int, int);
95 static int RIOScrub(int, BYTE *, int);
98 extern int rio_intr();
106 struct RioHostInfo * info;
109 ** Multi-Host card support - taking the easy way out - sorry !
110 ** We allocate and set up the Host and Port structs when the
111 ** driver is called to 'install' the first host.
112 ** We check for this first 'call' by testing the RIOPortp pointer.
116 rio_dprintk (RIO_DEBUG_INIT, "Allocating and setting up driver data structures\n");
118 RIOAllocDataStructs(p); /* allocate host/port structs */
119 RIOSetupDataStructs(p); /* setup topology structs */
122 RIOInitHosts( p, info ); /* hunt down the hardware */
124 RIOAllocateInterrupts(p); /* allocate interrupts */
125 RIOReport(p); /* show what we found */
129 ** Initialise the Cards
132 RIOInitHosts(p, info)
134 struct RioHostInfo * info;
137 ** 15.10.1998 ARG - ESIL 0762 part fix
138 ** If there is no ISA card definition - we always look for PCI cards.
139 ** As we currently only support one host card this lets an ISA card
140 ** definition take precedence over PLUG and PLAY.
141 ** No ISA card - we are PLUG and PLAY with PCI.
145 ** Note - for PCI both these will be zero, that's okay because
146 ** RIOPCIInit() fills them in if a card is found.
148 p->RIOHosts[p->RIONumHosts].Ivec = info->vector;
149 p->RIOHosts[p->RIONumHosts].PaddrP = info->location;
152 ** Check that we are able to accommodate another host
154 if ( p->RIONumHosts >= RIO_HOSTS )
160 if ( info->bus & ISA_BUS )
162 rio_dprintk (RIO_DEBUG_INIT, "initialising card %d (ISA)\n", p->RIONumHosts);
163 RIOISAinit(p, p->mode);
167 rio_dprintk (RIO_DEBUG_INIT, "initialising card %d (PCI)\n", p->RIONumHosts);
168 RIOPCIinit(p, RIO_PCI_DEFAULT_MODE);
171 rio_dprintk (RIO_DEBUG_INIT, "Total hosts initialised so far : %d\n", p->RIONumHosts);
174 #ifdef FUTURE_RELEASE
175 if (p->bus & EISA_BUS)
177 RIOEISAinit(p, RIO_EISA_DEFAULT_MODE);
179 if (p->bus & MCA_BUS)
181 RIOMCAinit(p, RIO_MCA_DEFAULT_MODE);
186 ** go through memory for an AT host that we pass in the device info
187 ** structure and initialise
195 /* XXX Need to implement this. */
197 p->intr_tid = iointset(p->RIOHosts[p->RIONumHosts].Ivec,
198 (int (*)())rio_intr, (char*)p->RIONumHosts);
200 rio_dprintk (RIO_DEBUG_INIT, "Set interrupt handler, intr_tid = 0x%x\n", p->intr_tid );
202 if (RIODoAT(p, p->RIOHosts[p->RIONumHosts].PaddrP, mode)) {
206 rio_dprintk (RIO_DEBUG_INIT, "RIODoAT failed\n");
216 ** Map in a boards physical address, check that the board is there,
217 ** test the board and if everything is okay assign the board an entry
218 ** in the Rio Hosts structure.
221 RIODoAT(p, Base, mode)
232 ** Check to see if we actually have a board at this physical address.
234 if ((cardAddr = RIOCheckForATCard(Base)) != 0) {
236 ** Now test the board to see if it is working.
238 if (RIOBoardTest(Base, cardAddr, RIO_AT, 0) == RIO_SUCCESS) {
240 ** Fill out a slot in the Rio host structure.
242 if (RIOAssignAT(p, Base, cardAddr, mode)) {
246 RIOMapout(Base, RIO_AT_MEM_SIZE, cardAddr);
252 RIOCheckForATCard(Base)
256 struct DpRam *cardp; /* (Points at the host) */
258 unsigned char RIOSigTab[24];
260 ** Table of values to search for as prom signature of a host card
262 strcpy(RIOSigTab, "JBJGPGGHINSMJPJR");
265 ** Hey! Yes, You reading this code! Yo, grab a load a this:
267 ** IF the card is using WORD MODE rather than BYTE MODE
268 ** then it will occupy 128K of PHYSICAL memory area. So,
269 ** you might think that the following Mapin is wrong. Well,
270 ** it isn't, because the SECOND 64K of occupied space is an
271 ** EXACT COPY of the FIRST 64K. (good?), so, we need only
272 ** map it in in one 64K block.
274 if (RIOMapin(Base, RIO_AT_MEM_SIZE, &virtAddr) == -1) {
275 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Couldn't map the board in!\n");
280 ** virtAddr points to the DP ram of the system.
281 ** We now cast this to a pointer to a RIO Host,
282 ** and have a rummage about in the PROM.
284 cardp = (struct DpRam *)virtAddr;
286 for (off=0; RIOSigTab[off]; off++) {
287 if ((RBYTE(cardp->DpSignature[off]) & 0xFF) != RIOSigTab[off]) {
289 ** Signature mismatch - card not at this address
291 RIOMapout(Base, RIO_AT_MEM_SIZE, virtAddr);
292 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Couldn't match the signature 0x%x 0x%x!\n",
299 ** If we get here then we must have found a valid board so return
300 ** its virtual address.
309 ** Fill out the fields in the p->RIOHosts structure now we know we know
310 ** we have a board present.
312 ** bits < 0 indicates 8 bit operation requested,
313 ** bits > 0 indicates 16 bit operation.
316 RIOAssignAT(p, Base, virtAddr, mode)
323 struct DpRam *cardp = (struct DpRam *)virtAddr;
325 if ((Base < ONE_MEG) || (mode & BYTE_ACCESS_MODE))
326 bits = BYTE_OPERATION;
328 bits = WORD_OPERATION;
331 ** Board has passed its scrub test. Fill in all the
334 p->RIOHosts[p->RIONumHosts].Caddr = virtAddr;
335 p->RIOHosts[p->RIONumHosts].CardP = (struct DpRam *)virtAddr;
338 ** Revision 01 AT host cards don't support WORD operations,
340 if ( RBYTE(cardp->DpRevision) == 01 )
341 bits = BYTE_OPERATION;
343 p->RIOHosts[p->RIONumHosts].Type = RIO_AT;
344 p->RIOHosts[p->RIONumHosts].Copy = bcopy;
346 p->RIOHosts[p->RIONumHosts].Slot = -1;
347 p->RIOHosts[p->RIONumHosts].Mode = SLOW_LINKS | SLOW_AT_BUS | bits;
348 WBYTE(p->RIOHosts[p->RIONumHosts].Control,
349 BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
350 p->RIOHosts[p->RIONumHosts].Mode |
352 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
353 WBYTE(p->RIOHosts[p->RIONumHosts].Control,
354 BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
355 p->RIOHosts[p->RIONumHosts].Mode |
357 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
358 p->RIOHosts[p->RIONumHosts].UniqueNum =
359 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
360 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
361 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
362 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);
363 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Uniquenum 0x%x\n",p->RIOHosts[p->RIONumHosts].UniqueNum);
366 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Tests Passed at 0x%x\n", Base);
370 #ifdef FUTURE_RELEASE
371 int RIOMCAinit(int Mode)
381 ** Valid mode information for MCA cards
382 ** is only FAST LINKS
384 Mode = (Mode & FAST_LINKS) ? McaTpFastLinks : McaTpSlowLinks;
385 rio_dprintk (RIO_DEBUG_INIT, "RIOMCAinit(%d)\n",Mode);
389 ** Check out each of the slots
391 for (SlotNumber = 0; SlotNumber < McaMaxSlots; SlotNumber++) {
393 ** Enable the slot we want to talk to
395 outb( McaSlotSelect, SlotNumber | McaSlotEnable );
398 ** Read the ID word from the slot
400 if (((inb(McaIdHigh)<< 8)|inb(McaIdLow)) == McaRIOId)
402 rio_dprintk (RIO_DEBUG_INIT, "Potential MCA card in slot %d\n", SlotNumber);
405 ** Card appears to be a RIO MCA card!
407 RIOMachineType |= (1<<RIO_MCA);
410 ** Just check we haven't found too many wonderful objects
412 if ( RIONumHosts >= RIO_HOSTS )
414 Rprintf(RIOMesgTooManyCards);
419 ** McaIrqEnable contains the interrupt vector, and a card
422 Ivec = inb(McaIrqEnable);
424 rio_dprintk (RIO_DEBUG_INIT, "Ivec is %x\n", Ivec);
426 switch ( Ivec & McaIrqMask )
429 rio_dprintk (RIO_DEBUG_INIT, "IRQ9\n");
432 rio_dprintk (RIO_DEBUG_INIT, "IRQ3\n");
435 rio_dprintk (RIO_DEBUG_INIT, "IRQ4\n");
438 rio_dprintk (RIO_DEBUG_INIT, "IRQ7\n");
441 rio_dprintk (RIO_DEBUG_INIT, "IRQ10\n");
444 rio_dprintk (RIO_DEBUG_INIT, "IRQ11\n");
447 rio_dprintk (RIO_DEBUG_INIT, "IRQ12\n");
450 rio_dprintk (RIO_DEBUG_INIT, "IRQ15\n");
455 ** If the card enable bit isn't set, then set it!
457 if ((Ivec & McaCardEnable) != McaCardEnable) {
458 rio_dprintk (RIO_DEBUG_INIT, "McaCardEnable not set - setting!\n");
459 outb(McaIrqEnable,Ivec|McaCardEnable);
461 rio_dprintk (RIO_DEBUG_INIT, "McaCardEnable already set\n");
464 ** Convert the IRQ enable mask into something useful
466 Ivec = RIOMcaToIvec[Ivec & McaIrqMask];
469 ** Find the physical address
471 rio_dprintk (RIO_DEBUG_INIT, "inb(McaMemory) is %x\n", inb(McaMemory));
472 Paddr = McaAddress(inb(McaMemory));
474 rio_dprintk (RIO_DEBUG_INIT, "MCA card has Ivec %d Addr %x\n", Ivec, Paddr);
480 ** Tell the memory mapper that we want to talk to it
482 Handle = RIOMapin( Paddr, RIO_MCA_MEM_SIZE, &Caddr );
484 if ( Handle == -1 ) {
485 rio_dprintk (RIO_DEBUG_INIT, "Couldn't map %d bytes at %x\n", RIO_MCA_MEM_SIZE, Paddr;
489 rio_dprintk (RIO_DEBUG_INIT, "Board mapped to vaddr 0x%x\n", Caddr);
492 ** And check that it is actually there!
494 if ( RIOBoardTest( Paddr,Caddr,RIO_MCA,SlotNumber ) == RIO_SUCCESS )
496 rio_dprintk (RIO_DEBUG_INIT, "Board has passed test\n");
497 rio_dprintk (RIO_DEBUG_INIT, "Slot %d. Type %d. Paddr 0x%x. Caddr 0x%x. Mode 0x%x.\n",
498 SlotNumber, RIO_MCA, Paddr, Caddr, Mode);
501 ** Board has passed its scrub test. Fill in all the
504 p->RIOHosts[RIONumHosts].Slot = SlotNumber;
505 p->RIOHosts[RIONumHosts].Ivec = Ivec;
506 p->RIOHosts[RIONumHosts].Type = RIO_MCA;
507 p->RIOHosts[RIONumHosts].Copy = bcopy;
508 p->RIOHosts[RIONumHosts].PaddrP = Paddr;
509 p->RIOHosts[RIONumHosts].Caddr = Caddr;
510 p->RIOHosts[RIONumHosts].CardP = (struct DpRam *)Caddr;
511 p->RIOHosts[RIONumHosts].Mode = Mode;
512 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt , 0xff);
513 p->RIOHosts[RIONumHosts].UniqueNum =
514 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[0])&0xFF)<<0)|
515 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[1])&0xFF)<<8)|
516 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[2])&0xFF)<<16)|
517 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[3])&0xFF)<<24);
524 ** It failed the test, so ignore it.
526 rio_dprintk (RIO_DEBUG_INIT, "TEST FAILED\n");
527 RIOMapout(Paddr, RIO_MCA_MEM_SIZE, Caddr );
532 rio_dprintk (RIO_DEBUG_INIT, "Slot %d - Paddr zero!\n", SlotNumber);
537 rio_dprintk (RIO_DEBUG_INIT, "Slot %d NOT RIO\n", SlotNumber);
541 ** Now we have checked all the slots, turn off the MCA slot selector
543 outb(McaSlotSelect,0);
544 rio_dprintk (RIO_DEBUG_INIT, "Slot %d NOT RIO\n", SlotNumber);
548 int RIOEISAinit( int Mode )
550 static int EISADone = 0;
552 int PollIntMixMsgDone = 0;
560 ** The only valid mode information for EISA hosts is fast or slow
563 Mode = (Mode & FAST_LINKS) ? EISA_TP_FAST_LINKS : EISA_TP_SLOW_LINKS;
567 rio_dprintk (RIO_DEBUG_INIT, "RIOEISAinit() - already done, return.\n");
573 rio_dprintk (RIO_DEBUG_INIT, "RIOEISAinit()\n");
577 ** First check all cards to see if ANY are set for polled mode operation.
578 ** If so, set ALL to polled.
581 for ( EisaSlot=1; EisaSlot<=RIO_MAX_EISA_SLOTS; EisaSlot++ )
583 Ident = (INBZ(EisaSlot,EISA_PRODUCT_IDENT_HI)<<8) |
584 INBZ(EisaSlot,EISA_PRODUCT_IDENT_LO);
586 if ( Ident == RIO_EISA_IDENT )
588 rio_dprintk (RIO_DEBUG_INIT, "Found Specialix product\n");
590 if ( INBZ(EisaSlot,EISA_PRODUCT_NUMBER) != RIO_EISA_PRODUCT_CODE )
592 rio_dprintk (RIO_DEBUG_INIT, "Not Specialix RIO - Product number %x\n",
593 INBZ(EisaSlot, EISA_PRODUCT_NUMBER));
594 continue; /* next slot */
597 ** Its a Specialix RIO!
599 rio_dprintk (RIO_DEBUG_INIT, "RIO Revision %d\n",
600 INBZ(EisaSlot, EISA_REVISION_NUMBER));
602 RIOMachineType |= (1<<RIO_EISA);
605 ** Just check we haven't found too many wonderful objects
607 if ( RIONumHosts >= RIO_HOSTS )
609 Rprintf(RIOMesgTooManyCards);
614 ** Ensure that the enable bit is set!
616 OUTBZ( EisaSlot, EISA_ENABLE, RIO_EISA_ENABLE_BIT );
619 ** EISA_INTERRUPT_VEC contains the interrupt vector.
621 Ivec = INBZ(EisaSlot,EISA_INTERRUPT_VEC);
624 switch ( Ivec & EISA_INTERRUPT_MASK )
627 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 3\n");
630 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 4\n");
633 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 5\n");
636 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 6\n");
639 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 7\n");
642 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 9\n");
645 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 10\n");
648 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 11\n");
651 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 12\n");
654 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 14\n");
657 rio_dprintk (RIO_DEBUG_INIT, "EISA IRQ 15\n");
660 rio_dprintk (RIO_DEBUG_INIT, "EISA POLLED\n");
663 rio_dprintk (RIO_DEBUG_INIT, NULL,DBG_INIT|DBG_FAIL,"Shagged interrupt number!\n");
664 Ivec &= EISA_CONTROL_MASK;
668 if ( (Ivec & EISA_INTERRUPT_MASK) ==
672 break; /* From EisaSlot loop */
678 ** Do it all again now we know whether to change all cards to polled
682 for ( EisaSlot=1; EisaSlot<=RIO_MAX_EISA_SLOTS; EisaSlot++ )
684 Ident = (INBZ(EisaSlot,EISA_PRODUCT_IDENT_HI)<<8) |
685 INBZ(EisaSlot,EISA_PRODUCT_IDENT_LO);
687 if ( Ident == RIO_EISA_IDENT )
689 if ( INBZ(EisaSlot,EISA_PRODUCT_NUMBER) != RIO_EISA_PRODUCT_CODE )
690 continue; /* next slot */
693 ** Its a Specialix RIO!
697 ** Ensure that the enable bit is set!
699 OUTBZ( EisaSlot, EISA_ENABLE, RIO_EISA_ENABLE_BIT );
702 ** EISA_INTERRUPT_VEC contains the interrupt vector.
704 Ivec = INBZ(EisaSlot,EISA_INTERRUPT_VEC);
709 ** If we are going to operate in polled mode, but this
710 ** board is configured to be interrupt driven, display
711 ** the message explaining the situation to the punter,
712 ** assuming we haven't already done so.
715 if ( !PollIntMixMsgDone &&
716 (Ivec & EISA_INTERRUPT_MASK) != EISA_POLLED )
718 Rprintf(RIOMesgAllPolled);
719 PollIntMixMsgDone = 1;
723 ** Ungraciously ignore whatever the board reports as its
724 ** interrupt vector...
727 Ivec &= ~EISA_INTERRUPT_MASK;
730 ** ...and force it to dance to the poll tune.
737 ** Convert the IRQ enable mask into something useful (0-15)
739 Ivec = RIOEisaToIvec(Ivec);
741 rio_dprintk (RIO_DEBUG_INIT, "EISA host in slot %d has Ivec 0x%x\n",
745 ** Find the physical address
747 Paddr = (INBZ(EisaSlot,EISA_MEMORY_BASE_HI)<<24) |
748 (INBZ(EisaSlot,EISA_MEMORY_BASE_LO)<<16);
750 rio_dprintk (RIO_DEBUG_INIT, "EISA card has Ivec %d Addr %x\n", Ivec, Paddr);
754 rio_dprintk (RIO_DEBUG_INIT,
755 "Board in slot %d configured for address zero!\n", EisaSlot);
760 ** Tell the memory mapper that we want to talk to it
762 rio_dprintk (RIO_DEBUG_INIT, "About to map EISA card \n");
764 if (RIOMapin( Paddr, RIO_EISA_MEM_SIZE, &Caddr) == -1) {
765 rio_dprintk (RIO_DEBUG_INIT, "Couldn't map %d bytes at %x\n",
766 RIO_EISA_MEM_SIZE,Paddr);
770 rio_dprintk (RIO_DEBUG_INIT, "Board mapped to vaddr 0x%x\n", Caddr);
773 ** And check that it is actually there!
775 if ( RIOBoardTest( Paddr,Caddr,RIO_EISA,EisaSlot) == RIO_SUCCESS )
777 rio_dprintk (RIO_DEBUG_INIT, "Board has passed test\n");
778 rio_dprintk (RIO_DEBUG_INIT,
779 "Slot %d. Ivec %d. Type %d. Paddr 0x%x. Caddr 0x%x. Mode 0x%x.\n",
780 EisaSlot,Ivec,RIO_EISA,Paddr,Caddr,Mode);
783 ** Board has passed its scrub test. Fill in all the
786 p->RIOHosts[RIONumHosts].Slot = EisaSlot;
787 p->RIOHosts[RIONumHosts].Ivec = Ivec;
788 p->RIOHosts[RIONumHosts].Type = RIO_EISA;
789 p->RIOHosts[RIONumHosts].Copy = bcopy;
790 p->RIOHosts[RIONumHosts].PaddrP = Paddr;
791 p->RIOHosts[RIONumHosts].Caddr = Caddr;
792 p->RIOHosts[RIONumHosts].CardP = (struct DpRam *)Caddr;
793 p->RIOHosts[RIONumHosts].Mode = Mode;
795 ** because the EISA prom is mapped into IO space, we
796 ** need to copy the unqiue number into the memory area
797 ** that it would have occupied, so that the download
798 ** code can determine its ID and card type.
800 WBYTE(p->RIOHosts[RIONumHosts].Unique[0],INBZ(EisaSlot,EISA_UNIQUE_NUM_0));
801 WBYTE(p->RIOHosts[RIONumHosts].Unique[1],INBZ(EisaSlot,EISA_UNIQUE_NUM_1));
802 WBYTE(p->RIOHosts[RIONumHosts].Unique[2],INBZ(EisaSlot,EISA_UNIQUE_NUM_2));
803 WBYTE(p->RIOHosts[RIONumHosts].Unique[3],INBZ(EisaSlot,EISA_UNIQUE_NUM_3));
804 p->RIOHosts[RIONumHosts].UniqueNum =
805 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[0])&0xFF)<<0)|
806 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[1])&0xFF)<<8)|
807 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[2])&0xFF)<<16)|
808 ((RBYTE(p->RIOHosts[RIONumHosts].Unique[3])&0xFF)<<24);
809 INBZ(EisaSlot,EISA_INTERRUPT_RESET);
816 ** It failed the test, so ignore it.
818 rio_dprintk (RIO_DEBUG_INIT, "TEST FAILED\n");
820 RIOMapout(Paddr, RIO_EISA_MEM_SIZE, Caddr );
824 if (RIOMachineType & RIO_EISA)
833 #define CONFIG_ADDRESS 0xcf8
834 #define CONFIG_DATA 0xcfc
835 #define FORWARD_REG 0xcfa
839 read_config(int bus_number, int device_num, int r_number)
845 Build config_address_value:
847 31 24 23 16 15 11 10 8 7 0
848 ------------------------------------------------------
849 |1| 0000000 | bus_number | device # | 000 | register |
850 ------------------------------------------------------
853 cav = r_number & 0xff;
854 cav |= ((device_num & 0x1f) << 11);
855 cav |= ((bus_number & 0xff) << 16);
856 cav |= 0x80000000; /* Enable bit */
857 outpd(CONFIG_ADDRESS,cav);
858 val = inpd(CONFIG_DATA);
859 outpd(CONFIG_ADDRESS,0);
864 write_config(bus_number,device_num,r_number,val)
869 Build config_address_value:
871 31 24 23 16 15 11 10 8 7 0
872 ------------------------------------------------------
873 |1| 0000000 | bus_number | device # | 000 | register |
874 ------------------------------------------------------
877 cav = r_number & 0xff;
878 cav |= ((device_num & 0x1f) << 11);
879 cav |= ((bus_number & 0xff) << 16);
880 cav |= 0x80000000; /* Enable bit */
881 outpd(CONFIG_ADDRESS, cav);
882 outpd(CONFIG_DATA, val);
883 outpd(CONFIG_ADDRESS, 0);
887 /* XXX Implement these... */
889 read_config(int bus_number, int device_num, int r_number)
895 write_config(int bus_number, int device_num, int r_number)
907 #define MAX_PCI_SLOT 32
908 #define RIO_PCI_JET_CARD 0x200011CB
910 static int slot; /* count of machine's PCI slots searched so far */
911 caddr_t Caddr; /* Virtual address of the current PCI host card. */
912 unsigned char Ivec; /* interrupt vector for the current PCI host */
913 unsigned long Paddr; /* Physical address for the current PCI host */
914 int Handle; /* Handle to Virtual memory allocated for current PCI host */
917 rio_dprintk (RIO_DEBUG_INIT, "Search for a RIO PCI card - start at slot %d\n", slot);
920 ** Initialise the search status
922 p->RIOLastPCISearch = RIO_FAIL;
924 while ( (slot < MAX_PCI_SLOT) & (p->RIOLastPCISearch != RIO_SUCCESS) )
926 rio_dprintk (RIO_DEBUG_INIT, "Currently testing slot %d\n", slot);
928 if (read_config(0,slot,0) == RIO_PCI_JET_CARD) {
929 p->RIOHosts[p->RIONumHosts].Ivec = 0;
930 Paddr = read_config(0,slot,0x18);
931 Paddr = Paddr - (Paddr & 0x1); /* Mask off the io bit */
933 if ( (Paddr == 0) || ((Paddr & 0xffff0000) == 0xffff0000) ) {
934 rio_dprintk (RIO_DEBUG_INIT, "Goofed up slot\n"); /* what! */
939 p->RIOHosts[p->RIONumHosts].PaddrP = Paddr;
940 Ivec = (read_config(0,slot,0x3c) & 0xff);
942 rio_dprintk (RIO_DEBUG_INIT, "PCI Host at 0x%x, Intr %d\n", (int)Paddr, Ivec);
944 Handle = RIOMapin( Paddr, RIO_PCI_MEM_SIZE, &Caddr );
946 rio_dprintk (RIO_DEBUG_INIT, "Couldn't map %d bytes at 0x%x\n", RIO_PCI_MEM_SIZE, (int)Paddr);
950 p->RIOHosts[p->RIONumHosts].Ivec = Ivec + 32;
951 p->intr_tid = iointset(p->RIOHosts[p->RIONumHosts].Ivec,
952 (int (*)())rio_intr, (char *)p->RIONumHosts);
953 if (RIOBoardTest( Paddr, Caddr, RIO_PCI, 0 ) == RIO_SUCCESS) {
954 rio_dprintk (RIO_DEBUG_INIT, ("Board has passed test\n");
955 rio_dprintk (RIO_DEBUG_INIT, ("Paddr 0x%x. Caddr 0x%x. Mode 0x%x.\n", Paddr, Caddr, Mode);
958 ** Board has passed its scrub test. Fill in all the
961 p->RIOHosts[p->RIONumHosts].Slot = 0;
962 p->RIOHosts[p->RIONumHosts].Ivec = Ivec + 32;
963 p->RIOHosts[p->RIONumHosts].Type = RIO_PCI;
964 p->RIOHosts[p->RIONumHosts].Copy = rio_pcicopy;
965 p->RIOHosts[p->RIONumHosts].PaddrP = Paddr;
966 p->RIOHosts[p->RIONumHosts].Caddr = Caddr;
967 p->RIOHosts[p->RIONumHosts].CardP = (struct DpRam *)Caddr;
968 p->RIOHosts[p->RIONumHosts].Mode = Mode;
971 WBYTE(p->RIOHosts[p->RIONumHosts].Control,
972 BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
973 p->RIOHosts[p->RIONumHosts].Mode |
975 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
976 WBYTE(p->RIOHosts[p->RIONumHosts].Control,
977 BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
978 p->RIOHosts[p->RIONumHosts].Mode |
980 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
982 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
984 p->RIOHosts[p->RIONumHosts].UniqueNum =
985 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
986 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
987 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
988 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);
990 rio_dprintk (RIO_DEBUG_INIT, "Unique no 0x%x.\n",
991 p->RIOHosts[p->RIONumHosts].UniqueNum);
993 p->RIOLastPCISearch = RIO_SUCCESS;
1000 if ( slot >= MAX_PCI_SLOT ) {
1001 rio_dprintk (RIO_DEBUG_INIT, "All %d PCI slots have tested for RIO cards !!!\n",
1007 ** I don't think we want to do this anymore
1010 if (!p->RIOLastPCISearch == RIO_FAIL ) {
1018 #ifdef FUTURE_RELEASE
1019 void riohalt( void )
1022 for ( host=0; host<p->RIONumHosts; host++ )
1024 rio_dprintk (RIO_DEBUG_INIT, "Stop host %d\n", host);
1025 (void)RIOBoardTest( p->RIOHosts[host].PaddrP, p->RIOHosts[host].Caddr, p->RIOHosts[host].Type,p->RIOHosts[host].Slot );
1031 static uchar val[] = {
1032 #ifdef VERY_LONG_TEST
1033 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
1034 0xa5, 0xff, 0x5a, 0x00, 0xff, 0xc9, 0x36,
1038 #define TEST_END sizeof(val)
1041 ** RAM test a board.
1042 ** Nothing too complicated, just enough to check it out.
1045 RIOBoardTest(paddr, caddr, type, slot)
1051 struct DpRam *DpRam = (struct DpRam *)caddr;
1057 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Reset host type=%d, DpRam=0x%x, slot=%d\n",
1058 type,(int)DpRam, slot);
1060 RIOHostReset(type, DpRam, slot);
1063 ** Scrub the memory. This comes in several banks:
1064 ** DPsram1 - 7000h bytes
1065 ** DPsram2 - 200h bytes
1066 ** DPsram3 - 7000h bytes
1067 ** scratch - 1000h bytes
1070 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Setup ram/size arrays\n");
1072 size[0] = DP_SRAM1_SIZE;
1073 size[1] = DP_SRAM2_SIZE;
1074 size[2] = DP_SRAM3_SIZE;
1075 size[3] = DP_SCRATCH_SIZE;
1077 ram[0] = (char *)&DpRam->DpSram1[0];
1078 ram[1] = (char *)&DpRam->DpSram2[0];
1079 ram[2] = (char *)&DpRam->DpSram3[0];
1080 nbanks = (type == RIO_PCI) ? 3 : 4;
1082 ram[3] = (char *)&DpRam->DpScratch[0];
1086 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Memory: 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x)\n",
1087 (int)ram[0], size[0], (int)ram[1], size[1], (int)ram[2], size[2]);
1089 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x)\n",
1090 (int)ram[0], size[0], (int)ram[1], size[1], (int)ram[2], size[2], (int)ram[3],
1095 ** This scrub operation will test for crosstalk between
1096 ** banks. TEST_END is a magic number, and relates to the offset
1097 ** within the 'val' array used by Scrub.
1099 for (op=0; op<TEST_END; op++) {
1100 for (bank=0; bank<nbanks; bank++) {
1101 if (RIOScrub(op, (BYTE *)ram[bank], size[bank]) == RIO_FAIL) {
1102 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: RIOScrub band %d, op %d failed\n",
1109 rio_dprintk (RIO_DEBUG_INIT, "Test completed\n");
1115 ** Scrub an area of RAM.
1116 ** Define PRETEST and POSTTEST for a more thorough checking of the
1117 ** state of the memory.
1118 ** Call with op set to an index into the above 'val' array to determine
1119 ** which value will be written into memory.
1120 ** Call with op set to zero means that the RAM will not be read and checked
1121 ** before it is written.
1122 ** Call with op not zero, and the RAM will be read and compated with val[op-1]
1123 ** to check that the data from the previous phase was retained.
1126 RIOScrub(op, ram, size)
1132 unsigned char oldbyte;
1133 unsigned char newbyte;
1134 unsigned char invbyte;
1135 unsigned short oldword;
1136 unsigned short newword;
1137 unsigned short invword;
1138 unsigned short swapword;
1141 oldbyte = val[op-1];
1142 oldword = oldbyte | (oldbyte<<8);
1144 oldbyte = oldword = 0; /* Tell the compiler we've initilalized them. */
1146 newword = newbyte | (newbyte<<8);
1148 invword = invbyte | (invbyte<<8);
1151 ** Check that the RAM contains the value that should have been left there
1152 ** by the previous test (not applicable for pass zero)
1155 for (off=0; off<size; off++) {
1156 if (RBYTE(ram[off]) != oldbyte) {
1157 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]));
1161 for (off=0; off<size; off+=2) {
1162 if (*(ushort *)&ram[off] != oldword) {
1163 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]);
1164 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]));
1171 ** Now write the INVERSE of the test data into every location, using
1172 ** BYTE write operations, first checking before each byte is written
1173 ** that the location contains the old value still, and checking after
1174 ** the write that the location contains the data specified - this is
1175 ** the BYTE read/write test.
1177 for (off=0; off<size; off++) {
1178 if (op && (RBYTE(ram[off]) != oldbyte)) {
1179 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]));
1182 WBYTE(ram[off],invbyte);
1183 if (RBYTE(ram[off]) != invbyte) {
1184 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]));
1190 ** now, use WORD operations to write the test value into every location,
1191 ** check as before that the location contains the previous test value
1192 ** before overwriting, and that it contains the data value written
1194 ** This is the WORD operation test.
1196 for (off=0; off<size; off+=2) {
1197 if (*(ushort *)&ram[off] != invword) {
1198 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]);
1199 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]));
1203 *(ushort *)&ram[off] = newword;
1204 if ( *(ushort *)&ram[off] != newword ) {
1205 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]);
1206 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]));
1212 ** now run through the block of memory again, first in byte mode
1213 ** then in word mode, and check that all the locations contain the
1214 ** required test data.
1216 for (off=0; off<size; off++) {
1217 if (RBYTE(ram[off]) != newbyte) {
1218 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]));
1223 for (off=0; off<size; off+=2) {
1224 if ( *(ushort *)&ram[off] != newword ) {
1225 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]);
1226 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]));
1232 ** time to check out byte swapping errors
1234 swapword = invbyte | (newbyte << 8);
1236 for (off=0; off<size; off+=2) {
1237 WBYTE(ram[off],invbyte);
1238 WBYTE(ram[off+1],newbyte);
1241 for ( off=0; off<size; off+=2 ) {
1242 if (*(ushort *)&ram[off] != swapword) {
1243 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]));
1244 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]));
1247 *((ushort *)&ram[off]) = ~swapword;
1250 for (off=0; off<size; off+=2) {
1251 if (RBYTE(ram[off]) != newbyte) {
1252 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]));
1255 if (RBYTE(ram[off+1]) != invbyte) {
1256 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]));
1259 *((ushort *)&ram[off]) = newword;
1265 ** try to ensure that every host is either in polled mode
1266 ** or is in interrupt mode. Only allow interrupt mode if
1267 ** all hosts can interrupt (why?)
1268 ** and force into polled mode if told to. Patch up the
1269 ** interrupt vector & salute The Queen when you've done.
1273 RIOAllocateInterrupts(p)
1274 struct rio_info * p;
1279 ** Easy case - if we have been told to poll, then we poll.
1281 if (p->mode & POLLED_MODE) {
1282 RIOStopInterrupts(p, 0, 0);
1287 ** check - if any host has been set to polled mode, then all must be.
1289 for (Host=0; Host<p->RIONumHosts; Host++) {
1290 if ( (p->RIOHosts[Host].Type != RIO_AT) &&
1291 (p->RIOHosts[Host].Ivec == POLLED) ) {
1292 RIOStopInterrupts(p, 1, Host );
1296 for (Host=0; Host<p->RIONumHosts; Host++) {
1297 if (p->RIOHosts[Host].Type == RIO_AT) {
1298 if ( (p->RIOHosts[Host].Ivec - 32) == 0) {
1299 RIOStopInterrupts(p, 2, Host );
1307 ** something has decided that we can't be doing with these
1308 ** new-fangled interrupt thingies. Set everything up to just
1312 RIOStopInterrupts(p, Reason, Host)
1313 struct rio_info * p;
1317 #ifdef FUTURE_RELEASE
1319 case 0: /* forced into polling by rio_polled */
1321 case 1: /* SCU has set 'Host' into polled mode */
1323 case 2: /* there aren't enough interrupt vectors for 'Host' */
1328 for (Host=0; Host<p->RIONumHosts; Host++ ) {
1329 struct Host *HostP = &p->RIOHosts[Host];
1331 switch (HostP->Type) {
1334 ** The AT host has it's interrupts disabled by clearing the
1337 HostP->Mode &= ~INTERRUPT_ENABLE;
1338 HostP->Ivec = POLLED;
1340 #ifdef FUTURE_RELEASE
1343 ** The EISA host has it's interrupts disabled by setting the
1346 HostP->Ivec = POLLED;
1351 ** The PCI host has it's interrupts disabled by clearing the
1352 ** int_enable bit, like a regular host card.
1354 HostP->Mode &= ~RIO_PCI_INT_ENABLE;
1355 HostP->Ivec = POLLED;
1357 #ifdef FUTURE_RELEASE
1360 ** There's always one, isn't there?
1361 ** The MCA host card cannot have it's interrupts disabled.
1371 ** This function is called at init time to setup the data structures.
1374 RIOAllocDataStructs(p)
1375 struct rio_info * p;
1381 p->RIOPortp = (struct Port *)sysbrk(RIO_PORTS * sizeof(struct Port));
1383 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: No memory for port structures\n");
1387 bzero( p->RIOPortp, sizeof(struct Port) * RIO_PORTS );
1388 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: allocated and cleared memory for port structs\n");
1389 rio_dprintk (RIO_DEBUG_INIT, "First RIO port struct @0x%x, size=0x%x bytes\n",
1390 (int)p->RIOPortp, sizeof(struct Port));
1392 for( port=0; port<RIO_PORTS; port++ ) {
1393 p->RIOPortp[port].PortNum = port;
1394 p->RIOPortp[port].TtyP = &p->channel[port];
1395 sreset (p->RIOPortp[port].InUse); /* Let the first guy uses it */
1396 p->RIOPortp[port].portSem = -1; /* Let the first guy takes it */
1397 p->RIOPortp[port].ParamSem = -1; /* Let the first guy takes it */
1398 p->RIOPortp[port].timeout_id = 0; /* Let the first guy takes it */
1401 p->RIOHosts = (struct Host *)sysbrk(RIO_HOSTS * sizeof(struct Host));
1403 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: No memory for host structures\n");
1407 bzero(p->RIOHosts, sizeof(struct Host)*RIO_HOSTS);
1408 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: allocated and cleared memory for host structs\n");
1409 rio_dprintk (RIO_DEBUG_INIT, "First RIO host struct @0x%x, size=0x%x bytes\n",
1410 (int)p->RIOHosts, sizeof(struct Host));
1412 for( host=0; host<RIO_HOSTS; host++ ) {
1413 spin_lock_init (&p->RIOHosts[host].HostLock);
1414 p->RIOHosts[host].timeout_id = 0; /* Let the first guy takes it */
1417 ** check that the buffer size is valid, round down to the next power of
1418 ** two if necessary; if the result is zero, then, hey, no double buffers.
1420 for ( tm = 1; tm && tm <= p->RIOConf.BufferSize; tm <<= 1 )
1423 p->RIOBufferSize = tm;
1424 p->RIOBufferMask = tm ? tm - 1 : 0;
1428 ** this function gets called whenever the data structures need to be
1429 ** re-setup, for example, after a riohalt (why did I ever invent it?)
1432 RIOSetupDataStructs(p)
1433 struct rio_info * p;
1435 int host, entry, rup;
1437 for ( host=0; host<RIO_HOSTS; host++ ) {
1438 struct Host *HostP = &p->RIOHosts[host];
1439 for ( entry=0; entry<LINKS_PER_UNIT; entry++ ) {
1440 HostP->Topology[entry].Unit = ROUTE_DISCONNECT;
1441 HostP->Topology[entry].Link = NO_LINK;
1443 bcopy("HOST X", HostP->Name, 7);
1444 HostP->Name[5] = '1'+host;
1445 for (rup=0; rup<(MAX_RUP + LINKS_PER_UNIT); rup++) {
1446 if (rup < MAX_RUP) {
1447 for (entry=0; entry<LINKS_PER_UNIT; entry++ ) {
1448 HostP->Mapping[rup].Topology[entry].Unit = ROUTE_DISCONNECT;
1449 HostP->Mapping[rup].Topology[entry].Link = NO_LINK;
1451 RIODefaultName(p, HostP, rup);
1453 spin_lock_init(&HostP->UnixRups[rup].RupLock);
1460 RIODefaultName(p, HostP, UnitId)
1461 struct rio_info * p;
1462 struct Host * HostP;
1467 CheckUnitId( UnitId );
1469 bcopy("UNKNOWN RTA X-XX",HostP->Mapping[UnitId].Name,17);
1470 HostP->Mapping[UnitId].Name[12]='1'+(HostP-p->RIOHosts);
1471 if ((UnitId+1) > 9) {
1472 HostP->Mapping[UnitId].Name[14]='0'+((UnitId+1)/10);
1473 HostP->Mapping[UnitId].Name[15]='0'+((UnitId+1)%10);
1476 HostP->Mapping[UnitId].Name[14]='1'+UnitId;
1477 HostP->Mapping[UnitId].Name[15]=0;
1482 #define RIO_RELEASE "Linux"
1483 #define RELEASE_ID "1.0"
1488 struct rio_info * p;
1490 char * RIORelease = RIO_RELEASE;
1491 char * RIORelID = RELEASE_ID;
1494 rio_dprintk (RIO_DEBUG_INIT, "RIO : Release: %s ID: %s\n", RIORelease, RIORelID);
1496 if ( p->RIONumHosts==0 ) {
1497 rio_dprintk (RIO_DEBUG_INIT, "\nNo Hosts configured\n");
1501 for ( host=0; host < p->RIONumHosts; host++ ) {
1502 struct Host *HostP = &p->RIOHosts[host];
1503 switch ( HostP->Type ) {
1505 rio_dprintk (RIO_DEBUG_INIT, "AT BUS : found the card at 0x%x\n", HostP->PaddrP);
1512 static struct rioVersion stVersion;
1517 strlcpy(stVersion.version, "RIO driver for linux V1.0",
1518 sizeof(stVersion.version));
1519 strlcpy(stVersion.buildDate, __DATE__,
1520 sizeof(stVersion.buildDate));
1527 RIOMapin(paddr, size, vaddr)
1532 *vaddr = (caddr_t)permap( (long)paddr, size);
1533 return ((int)*vaddr);
1537 RIOMapout(paddr, size, vaddr)
1547 RIOHostReset(Type, DpRamP, Slot)
1549 volatile struct DpRam *DpRamP;
1555 rio_dprintk (RIO_DEBUG_INIT, "RIOHostReset: type 0x%x", Type);
1558 rio_dprintk (RIO_DEBUG_INIT, " (RIO_AT)\n");
1559 WBYTE(DpRamP->DpControl, BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
1560 INTERRUPT_DISABLE | BYTE_OPERATION |
1561 SLOW_LINKS | SLOW_AT_BUS);
1562 WBYTE(DpRamP->DpResetTpu, 0xFF);
1565 rio_dprintk (RIO_DEBUG_INIT, "RIOHostReset: Don't know if it worked. Try reset again\n");
1566 WBYTE(DpRamP->DpControl, BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
1567 INTERRUPT_DISABLE | BYTE_OPERATION |
1568 SLOW_LINKS | SLOW_AT_BUS);
1569 WBYTE(DpRamP->DpResetTpu, 0xFF);
1572 #ifdef FUTURE_RELEASE
1575 ** Bet this doesn't work!
1577 OUTBZ( Slot, EISA_CONTROL_PORT,
1578 EISA_TP_RUN | EISA_TP_BUS_DISABLE |
1579 EISA_TP_SLOW_LINKS | EISA_TP_BOOT_FROM_RAM );
1580 OUTBZ( Slot, EISA_CONTROL_PORT,
1581 EISA_TP_RESET | EISA_TP_BUS_DISABLE |
1582 EISA_TP_SLOW_LINKS | EISA_TP_BOOT_FROM_RAM );
1584 OUTBZ( Slot, EISA_CONTROL_PORT,
1585 EISA_TP_RUN | EISA_TP_BUS_DISABLE |
1586 EISA_TP_SLOW_LINKS | EISA_TP_BOOT_FROM_RAM );
1589 WBYTE(DpRamP->DpControl , McaTpBootFromRam | McaTpBusDisable );
1590 WBYTE(DpRamP->DpResetTpu , 0xFF );
1592 WBYTE(DpRamP->DpControl , McaTpBootFromRam | McaTpBusDisable );
1593 WBYTE(DpRamP->DpResetTpu , 0xFF );
1598 rio_dprintk (RIO_DEBUG_INIT, " (RIO_PCI)\n");
1599 DpRamP->DpControl = RIO_PCI_BOOT_FROM_RAM;
1600 DpRamP->DpResetInt = 0xFF;
1601 DpRamP->DpResetTpu = 0xFF;
1603 /* for (i=0; i<6000; i++); */
1606 #ifdef FUTURE_RELEASE
1608 Rprintf(RIOMesgNoSupport,Type,DpRamP,Slot);
1613 rio_dprintk (RIO_DEBUG_INIT, " (UNKNOWN)\n");