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>
40 #include <linux/delay.h>
42 #include <asm/system.h>
43 #include <asm/string.h>
44 #include <asm/semaphore.h>
45 #include <asm/uaccess.h>
47 #include <linux/termios.h>
48 #include <linux/serial.h>
50 #include <linux/generic_serial.h>
53 #include "linux_compat.h"
83 #include "rio_linux.h"
85 int RIOPCIinit(struct rio_info *p, int Mode);
87 static int RIOScrub(int, BYTE *, int);
93 ** Fill out the fields in the p->RIOHosts structure now we know we know
94 ** we have a board present.
96 ** bits < 0 indicates 8 bit operation requested,
97 ** bits > 0 indicates 16 bit operation.
100 int RIOAssignAT(struct rio_info *p, int Base, caddr_t virtAddr, int mode)
103 struct DpRam *cardp = (struct DpRam *)virtAddr;
105 if ((Base < ONE_MEG) || (mode & BYTE_ACCESS_MODE))
106 bits = BYTE_OPERATION;
108 bits = WORD_OPERATION;
111 ** Board has passed its scrub test. Fill in all the
114 p->RIOHosts[p->RIONumHosts].Caddr = virtAddr;
115 p->RIOHosts[p->RIONumHosts].CardP = (struct DpRam *)virtAddr;
118 ** Revision 01 AT host cards don't support WORD operations,
120 if (readb(&cardp->DpRevision) == 01)
121 bits = BYTE_OPERATION;
123 p->RIOHosts[p->RIONumHosts].Type = RIO_AT;
124 p->RIOHosts[p->RIONumHosts].Copy = rio_copy_to_card;
126 p->RIOHosts[p->RIONumHosts].Slot = -1;
127 p->RIOHosts[p->RIONumHosts].Mode = SLOW_LINKS | SLOW_AT_BUS | bits;
128 writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | p->RIOHosts[p->RIONumHosts].Mode | INTERRUPT_DISABLE ,
129 &p->RIOHosts[p->RIONumHosts].Control);
130 writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
131 writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | p->RIOHosts[p->RIONumHosts].Mode | INTERRUPT_DISABLE,
132 &p->RIOHosts[p->RIONumHosts].Control);
133 writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
134 p->RIOHosts[p->RIONumHosts].UniqueNum =
135 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
136 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
137 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
138 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);
139 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Uniquenum 0x%x\n",p->RIOHosts[p->RIONumHosts].UniqueNum);
142 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Tests Passed at 0x%x\n", Base);
147 #ifdef VERY_LONG_TEST
148 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
149 0xa5, 0xff, 0x5a, 0x00, 0xff, 0xc9, 0x36,
153 #define TEST_END sizeof(val)
157 ** Nothing too complicated, just enough to check it out.
159 int RIOBoardTest(paddr_t paddr, caddr_t caddr, unsigned char type, int slot)
161 struct DpRam *DpRam = (struct DpRam *)caddr;
167 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Reset host type=%d, DpRam=0x%p, slot=%d\n",
170 RIOHostReset(type, DpRam, slot);
173 ** Scrub the memory. This comes in several banks:
174 ** DPsram1 - 7000h bytes
175 ** DPsram2 - 200h bytes
176 ** DPsram3 - 7000h bytes
177 ** scratch - 1000h bytes
180 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Setup ram/size arrays\n");
182 size[0] = DP_SRAM1_SIZE;
183 size[1] = DP_SRAM2_SIZE;
184 size[2] = DP_SRAM3_SIZE;
185 size[3] = DP_SCRATCH_SIZE;
187 ram[0] = (char *)&DpRam->DpSram1[0];
188 ram[1] = (char *)&DpRam->DpSram2[0];
189 ram[2] = (char *)&DpRam->DpSram3[0];
190 nbanks = (type == RIO_PCI) ? 3 : 4;
192 ram[3] = (char *)&DpRam->DpScratch[0];
196 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Memory: 0x%p(0x%x), 0x%p(0x%x), 0x%p(0x%x)\n",
197 ram[0], size[0], ram[1], size[1], ram[2], size[2]);
199 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: 0x%p(0x%x), 0x%p(0x%x), 0x%p(0x%x), 0x%p(0x%x)\n",
200 ram[0], size[0], ram[1], size[1], ram[2], size[2], ram[3], size[3]);
204 ** This scrub operation will test for crosstalk between
205 ** banks. TEST_END is a magic number, and relates to the offset
206 ** within the 'val' array used by Scrub.
208 for (op=0; op<TEST_END; op++) {
209 for (bank=0; bank<nbanks; bank++) {
210 if (RIOScrub(op, (BYTE *)ram[bank], size[bank]) == RIO_FAIL) {
211 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: RIOScrub band %d, op %d failed\n",
218 rio_dprintk (RIO_DEBUG_INIT, "Test completed\n");
224 ** Scrub an area of RAM.
225 ** Define PRETEST and POSTTEST for a more thorough checking of the
226 ** state of the memory.
227 ** Call with op set to an index into the above 'val' array to determine
228 ** which value will be written into memory.
229 ** Call with op set to zero means that the RAM will not be read and checked
230 ** before it is written.
231 ** Call with op not zero, and the RAM will be read and compated with val[op-1]
232 ** to check that the data from the previous phase was retained.
235 static int RIOScrub(int op, BYTE *ram, int size)
238 unsigned char oldbyte;
239 unsigned char newbyte;
240 unsigned char invbyte;
241 unsigned short oldword;
242 unsigned short newword;
243 unsigned short invword;
244 unsigned short swapword;
248 oldword = oldbyte | (oldbyte<<8);
250 oldbyte = oldword = 0; /* Tell the compiler we've initilalized them. */
252 newword = newbyte | (newbyte<<8);
254 invword = invbyte | (invbyte<<8);
257 ** Check that the RAM contains the value that should have been left there
258 ** by the previous test (not applicable for pass zero)
261 for (off=0; off<size; off++) {
262 if (readb(ram + off) != oldbyte) {
263 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, readb(ram + off));
267 for (off=0; off<size; off+=2) {
268 if (readw(ram + off) != oldword) {
269 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: WORD at offset 0x%x should have been=%x, was=%x\n",off,oldword, readw(ram + off));
270 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, readb(ram + off), off+1, readb(ram+off+1));
277 ** Now write the INVERSE of the test data into every location, using
278 ** BYTE write operations, first checking before each byte is written
279 ** that the location contains the old value still, and checking after
280 ** the write that the location contains the data specified - this is
281 ** the BYTE read/write test.
283 for (off=0; off<size; off++) {
284 if (op && (readb(ram + off) != oldbyte)) {
285 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, readb(ram + off));
288 writeb(invbyte, ram + off);
289 if (readb(ram + off) != invbyte) {
290 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Inv Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, invbyte, readb(ram + off));
296 ** now, use WORD operations to write the test value into every location,
297 ** check as before that the location contains the previous test value
298 ** before overwriting, and that it contains the data value written
300 ** This is the WORD operation test.
302 for (off=0; off<size; off+=2) {
303 if (readw(ram + off) != invword) {
304 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: WORD at offset 0x%x should have been=%x, was=%x\n", off, invword, readw(ram + off));
305 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, readb(ram + off), off+1, readb(ram+off+1));
309 writew(newword, ram + off);
310 if ( readw(ram + off) != newword ) {
311 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, readw(ram + off));
312 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, readb(ram + off), off+1, readb(ram + off + 1));
318 ** now run through the block of memory again, first in byte mode
319 ** then in word mode, and check that all the locations contain the
320 ** required test data.
322 for (off=0; off<size; off++) {
323 if (readb(ram + off) != newbyte) {
324 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Byte Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, readb(ram + off));
329 for (off=0; off<size; off+=2) {
330 if (readw(ram + off) != newword ) {
331 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, readw(ram + off));
332 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, readb(ram + off), off+1, readb(ram + off + 1));
338 ** time to check out byte swapping errors
340 swapword = invbyte | (newbyte << 8);
342 for (off=0; off<size; off+=2) {
343 writeb(invbyte, &ram[off]);
344 writeb(newbyte, &ram[off+1]);
347 for ( off=0; off<size; off+=2 ) {
348 if (readw(ram + off) != swapword) {
349 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, swapword, readw(ram + off));
350 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, readb(ram + off), off+1, readb(ram + off + 1));
353 writew(~swapword, ram + off);
356 for (off=0; off<size; off+=2) {
357 if (readb(ram + off) != newbyte) {
358 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, readb(ram + off));
361 if (readb(ram + off + 1) != invbyte) {
362 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, readb(ram + off + 1));
365 writew(newword, ram + off);
371 int RIODefaultName(struct rio_info *p, struct Host *HostP, unsigned int UnitId)
373 memcpy(HostP->Mapping[UnitId].Name, "UNKNOWN RTA X-XX", 17);
374 HostP->Mapping[UnitId].Name[12]='1'+(HostP-p->RIOHosts);
375 if ((UnitId+1) > 9) {
376 HostP->Mapping[UnitId].Name[14]='0'+((UnitId+1)/10);
377 HostP->Mapping[UnitId].Name[15]='0'+((UnitId+1)%10);
380 HostP->Mapping[UnitId].Name[14]='1'+UnitId;
381 HostP->Mapping[UnitId].Name[15]=0;
386 #define RIO_RELEASE "Linux"
387 #define RELEASE_ID "1.0"
389 static struct rioVersion stVersion;
391 struct rioVersion *RIOVersid(void)
393 strlcpy(stVersion.version, "RIO driver for linux V1.0",
394 sizeof(stVersion.version));
395 strlcpy(stVersion.buildDate, __DATE__,
396 sizeof(stVersion.buildDate));
401 void RIOHostReset(unsigned int Type, struct DpRam *DpRamP, unsigned int Slot)
406 rio_dprintk (RIO_DEBUG_INIT, "RIOHostReset: type 0x%x", Type);
409 rio_dprintk (RIO_DEBUG_INIT, " (RIO_AT)\n");
410 writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | INTERRUPT_DISABLE | BYTE_OPERATION |
411 SLOW_LINKS | SLOW_AT_BUS, &DpRamP->DpControl);
412 writeb(0xFF, &DpRamP->DpResetTpu);
414 rio_dprintk (RIO_DEBUG_INIT, "RIOHostReset: Don't know if it worked. Try reset again\n");
415 writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | INTERRUPT_DISABLE |
416 BYTE_OPERATION | SLOW_LINKS | SLOW_AT_BUS, &DpRamP->DpControl);
417 writeb(0xFF, &DpRamP->DpResetTpu);
421 rio_dprintk (RIO_DEBUG_INIT, " (RIO_PCI)\n");
422 writeb(RIO_PCI_BOOT_FROM_RAM, &DpRamP->DpControl);
423 writeb(0xFF, &DpRamP->DpResetInt);
424 writeb(0xFF, &DpRamP->DpResetTpu);
428 rio_dprintk (RIO_DEBUG_INIT, " (UNKNOWN)\n");