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:36
26 ** Retrieved : 11/6/98 10:33:48
28 ** ident @(#)rioboot.c 1.3
30 ** -----------------------------------------------------------------------------
33 #include <linux/module.h>
34 #include <linux/slab.h>
35 #include <linux/termios.h>
36 #include <linux/serial.h>
37 #include <linux/vmalloc.h>
38 #include <linux/generic_serial.h>
39 #include <linux/errno.h>
40 #include <linux/interrupt.h>
41 #include <linux/delay.h>
43 #include <asm/system.h>
44 #include <asm/string.h>
45 #include <asm/uaccess.h>
48 #include "linux_compat.h"
49 #include "rio_linux.h"
73 static int RIOBootComplete(struct rio_info
*p
, struct Host
*HostP
, unsigned int Rup
, struct PktCmd __iomem
*PktCmdP
);
75 static const unsigned char RIOAtVec2Ctrl
[] = {
76 /* 0 */ INTERRUPT_DISABLE
,
77 /* 1 */ INTERRUPT_DISABLE
,
78 /* 2 */ INTERRUPT_DISABLE
,
79 /* 3 */ INTERRUPT_DISABLE
,
80 /* 4 */ INTERRUPT_DISABLE
,
81 /* 5 */ INTERRUPT_DISABLE
,
82 /* 6 */ INTERRUPT_DISABLE
,
83 /* 7 */ INTERRUPT_DISABLE
,
84 /* 8 */ INTERRUPT_DISABLE
,
85 /* 9 */ IRQ_9
| INTERRUPT_ENABLE
,
86 /* 10 */ INTERRUPT_DISABLE
,
87 /* 11 */ IRQ_11
| INTERRUPT_ENABLE
,
88 /* 12 */ IRQ_12
| INTERRUPT_ENABLE
,
89 /* 13 */ INTERRUPT_DISABLE
,
90 /* 14 */ INTERRUPT_DISABLE
,
91 /* 15 */ IRQ_15
| INTERRUPT_ENABLE
95 * RIOBootCodeRTA - Load RTA boot code
97 * @rbp: Download descriptor
99 * Called when the user process initiates booting of the card firmware.
103 int RIOBootCodeRTA(struct rio_info
*p
, struct DownLoad
* rbp
)
109 rio_dprintk(RIO_DEBUG_BOOT
, "Data at user address %p\n", rbp
->DataP
);
112 ** Check that we have set asside enough memory for this
114 if (rbp
->Count
> SIXTY_FOUR_K
) {
115 rio_dprintk(RIO_DEBUG_BOOT
, "RTA Boot Code Too Large!\n");
116 p
->RIOError
.Error
= HOST_FILE_TOO_LARGE
;
122 rio_dprintk(RIO_DEBUG_BOOT
, "RTA Boot Code : BUSY BUSY BUSY!\n");
123 p
->RIOError
.Error
= BOOT_IN_PROGRESS
;
129 ** The data we load in must end on a (RTA_BOOT_DATA_SIZE) byte boundary,
130 ** so calculate how far we have to move the data up the buffer
133 offset
= (RTA_BOOT_DATA_SIZE
- (rbp
->Count
% RTA_BOOT_DATA_SIZE
)) % RTA_BOOT_DATA_SIZE
;
136 ** Be clean, and clear the 'unused' portion of the boot buffer,
137 ** because it will (eventually) be part of the Rta run time environment
138 ** and so should be zeroed.
140 memset(p
->RIOBootPackets
, 0, offset
);
143 ** Copy the data from user space into the array
146 if (copy_from_user(((u8
*)p
->RIOBootPackets
) + offset
, rbp
->DataP
, rbp
->Count
)) {
147 rio_dprintk(RIO_DEBUG_BOOT
, "Bad data copy from user space\n");
148 p
->RIOError
.Error
= COPYIN_FAILED
;
154 ** Make sure that our copy of the size includes that offset we discussed
157 p
->RIONumBootPkts
= (rbp
->Count
+ offset
) / RTA_BOOT_DATA_SIZE
;
158 p
->RIOBootCount
= rbp
->Count
;
165 * rio_start_card_running - host card start
166 * @HostP: The RIO to kick off
168 * Start a RIO processor unit running. Encapsulates the knowledge
172 void rio_start_card_running(struct Host
*HostP
)
174 switch (HostP
->Type
) {
176 rio_dprintk(RIO_DEBUG_BOOT
, "Start ISA card running\n");
177 writeb(BOOT_FROM_RAM
| EXTERNAL_BUS_ON
| HostP
->Mode
| RIOAtVec2Ctrl
[HostP
->Ivec
& 0xF], &HostP
->Control
);
181 ** PCI is much the same as MCA. Everything is once again memory
182 ** mapped, so we are writing to memory registers instead of io
185 rio_dprintk(RIO_DEBUG_BOOT
, "Start PCI card running\n");
186 writeb(PCITpBootFromRam
| PCITpBusEnable
| HostP
->Mode
, &HostP
->Control
);
189 rio_dprintk(RIO_DEBUG_BOOT
, "Unknown host type %d\n", HostP
->Type
);
196 ** Load in the host boot code - load it directly onto all halted hosts
197 ** of the correct type.
199 ** Put your rubber pants on before messing with this code - even the magic
200 ** numbers have trouble understanding what they are doing here.
203 int RIOBootCodeHOST(struct rio_info
*p
, struct DownLoad
*rbp
)
207 PARM_MAP __iomem
*ParmMapP
;
215 u16 offset
; /* It is very important that this is a u16 */
219 HostP
= NULL
; /* Assure the compiler we've initialized it */
223 for (host
= 0; host
< p
->RIONumHosts
; host
++) {
224 rio_dprintk(RIO_DEBUG_BOOT
, "Attempt to boot host %d\n", host
);
225 HostP
= &p
->RIOHosts
[host
];
227 rio_dprintk(RIO_DEBUG_BOOT
, "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n", HostP
->Type
, HostP
->Mode
, HostP
->Ivec
);
229 /* Don't boot hosts already running */
230 if ((HostP
->Flags
& RUN_STATE
) != RC_WAITING
) {
231 rio_dprintk(RIO_DEBUG_BOOT
, "%s %d already running\n", "Host", host
);
236 ** Grab a pointer to the card (ioremapped)
241 ** We are going to (try) and load in rbp->Count bytes.
242 ** The last byte will reside at p->RIOConf.HostLoadBase-1;
243 ** Therefore, we need to start copying at address
244 ** (caddr+p->RIOConf.HostLoadBase-rbp->Count)
246 StartP
= &Cad
[p
->RIOConf
.HostLoadBase
- rbp
->Count
];
248 rio_dprintk(RIO_DEBUG_BOOT
, "kernel virtual address for host is %p\n", Cad
);
249 rio_dprintk(RIO_DEBUG_BOOT
, "kernel virtual address for download is %p\n", StartP
);
250 rio_dprintk(RIO_DEBUG_BOOT
, "host loadbase is 0x%x\n", p
->RIOConf
.HostLoadBase
);
251 rio_dprintk(RIO_DEBUG_BOOT
, "size of download is 0x%x\n", rbp
->Count
);
253 /* Make sure it fits */
254 if (p
->RIOConf
.HostLoadBase
< rbp
->Count
) {
255 rio_dprintk(RIO_DEBUG_BOOT
, "Bin too large\n");
256 p
->RIOError
.Error
= HOST_FILE_TOO_LARGE
;
261 ** Ensure that the host really is stopped.
262 ** Disable it's external bus & twang its reset line.
264 RIOHostReset(HostP
->Type
, HostP
->CardP
, HostP
->Slot
);
267 ** Copy the data directly from user space to the SRAM.
268 ** This ain't going to be none too clever if the download
269 ** code is bigger than this segment.
271 rio_dprintk(RIO_DEBUG_BOOT
, "Copy in code\n");
273 /* Buffer to local memory as we want to use I/O space and
274 some cards only do 8 or 16 bit I/O */
276 DownCode
= vmalloc(rbp
->Count
);
278 p
->RIOError
.Error
= NOT_ENOUGH_CORE_FOR_PCI_COPY
;
282 if (copy_from_user(DownCode
, rbp
->DataP
, rbp
->Count
)) {
284 p
->RIOError
.Error
= COPYIN_FAILED
;
288 HostP
->Copy(DownCode
, StartP
, rbp
->Count
);
291 rio_dprintk(RIO_DEBUG_BOOT
, "Copy completed\n");
296 ** Upto this point the code has been fairly rational, and possibly
297 ** even straight forward. What follows is a pile of crud that will
298 ** magically turn into six bytes of transputer assembler. Normally
299 ** you would expect an array or something, but, being me, I have
300 ** chosen [been told] to use a technique whereby the startup code
301 ** will be correct if we change the loadbase for the code. Which
302 ** brings us onto another issue - the loadbase is the *end* of the
303 ** code, not the start.
305 ** If I were you I wouldn't start from here.
309 ** We now need to insert a short boot section into
310 ** the memory at the end of Sram2. This is normally (de)composed
311 ** of the last eight bytes of the download code. The
312 ** download has been assembled/compiled to expect to be
313 ** loaded from 0x7FFF downwards. We have loaded it
314 ** at some other address. The startup code goes into the small
315 ** ram window at Sram2, in the last 8 bytes, which are really
316 ** at addresses 0x7FF8-0x7FFF.
318 ** If the loadbase is, say, 0x7C00, then we need to branch to
319 ** address 0x7BFE to run the host.bin startup code. We assemble
320 ** this jump manually.
322 ** The two byte sequence 60 08 is loaded into memory at address
323 ** 0x7FFE,F. This is a local branch to location 0x7FF8 (60 is nfix 0,
324 ** which adds '0' to the .O register, complements .O, and then shifts
325 ** it left by 4 bit positions, 08 is a jump .O+8 instruction. This will
326 ** add 8 to .O (which was 0xFFF0), and will branch RELATIVE to the new
327 ** location. Now, the branch starts from the value of .PC (or .IP or
328 ** whatever the bloody register is called on this chip), and the .PC
329 ** will be pointing to the location AFTER the branch, in this case
330 ** .PC == 0x8000, so the branch will be to 0x8000+0xFFF8 = 0x7FF8.
332 ** A long branch is coded at 0x7FF8. This consists of loading a four
333 ** byte offset into .O using nfix (as above) and pfix operators. The
334 ** pfix operates in exactly the same way as the nfix operator, but
335 ** without the complement operation. The offset, of course, must be
336 ** relative to the address of the byte AFTER the branch instruction,
337 ** which will be (urm) 0x7FFC, so, our final destination of the branch
338 ** (loadbase-2), has to be reached from here. Imagine that the loadbase
339 ** is 0x7C00 (which it is), then we will need to branch to 0x7BFE (which
340 ** is the first byte of the initial two byte short local branch of the
343 ** To code a jump from 0x7FFC (which is where the branch will start
344 ** from) to 0x7BFE, we will need to branch 0xFC02 bytes (0x7FFC+0xFC02)=
346 ** This will be coded as four bytes:
353 ** The nfix operator is used, so that the startup code will be
354 ** compatible with the whole Tp family. (lies, damn lies, it'll never
355 ** work in a month of Sundays).
357 ** The nfix nyble is the 1s complement of the nyble value you
358 ** want to load - in this case we wanted 'F' so we nfix loaded '0'.
363 ** Dest points to the top 8 bytes of Sram2. The Tp jumps
364 ** to 0x7FFE at reset time, and starts executing. This is
365 ** a short branch to 0x7FF8, where a long branch is coded.
368 DestP
= &Cad
[0x7FF8]; /* <<<---- READ THE ABOVE COMMENTS */
370 #define NFIX(N) (0x60 | (N)) /* .O = (~(.O + N))<<4 */
371 #define PFIX(N) (0x20 | (N)) /* .O = (.O + N)<<4 */
372 #define JUMP(N) (0x00 | (N)) /* .PC = .PC + .O */
375 ** 0x7FFC is the address of the location following the last byte of
376 ** the four byte jump instruction.
377 ** READ THE ABOVE COMMENTS
379 ** offset is (TO-FROM) % MEMSIZE, but with compound buggering about.
380 ** Memsize is 64K for this range of Tp, so offset is a short (unsigned,
381 ** cos I don't understand 2's complement).
383 offset
= (p
->RIOConf
.HostLoadBase
- 2) - 0x7FFC;
385 writeb(NFIX(((unsigned short) (~offset
) >> (unsigned short) 12) & 0xF), DestP
);
386 writeb(PFIX((offset
>> 8) & 0xF), DestP
+ 1);
387 writeb(PFIX((offset
>> 4) & 0xF), DestP
+ 2);
388 writeb(JUMP(offset
& 0xF), DestP
+ 3);
390 writeb(NFIX(0), DestP
+ 6);
391 writeb(JUMP(8), DestP
+ 7);
393 rio_dprintk(RIO_DEBUG_BOOT
, "host loadbase is 0x%x\n", p
->RIOConf
.HostLoadBase
);
394 rio_dprintk(RIO_DEBUG_BOOT
, "startup offset is 0x%x\n", offset
);
397 ** Flag what is going on
399 HostP
->Flags
&= ~RUN_STATE
;
400 HostP
->Flags
|= RC_STARTUP
;
403 ** Grab a copy of the current ParmMap pointer, so we
404 ** can tell when it has changed.
406 OldParmMap
= readw(&HostP
->__ParmMapR
);
408 rio_dprintk(RIO_DEBUG_BOOT
, "Original parmmap is 0x%x\n", OldParmMap
);
411 ** And start it running (I hope).
412 ** As there is nothing dodgy or obscure about the
413 ** above code, this is guaranteed to work every time.
415 rio_dprintk(RIO_DEBUG_BOOT
, "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n", HostP
->Type
, HostP
->Mode
, HostP
->Ivec
);
417 rio_start_card_running(HostP
);
419 rio_dprintk(RIO_DEBUG_BOOT
, "Set control port\n");
422 ** Now, wait for upto five seconds for the Tp to setup the parmmap
425 for (wait_count
= 0; (wait_count
< p
->RIOConf
.StartupTime
) && (readw(&HostP
->__ParmMapR
) == OldParmMap
); wait_count
++) {
426 rio_dprintk(RIO_DEBUG_BOOT
, "Checkout %d, 0x%x\n", wait_count
, readw(&HostP
->__ParmMapR
));
432 ** If the parmmap pointer is unchanged, then the host code
433 ** has crashed & burned in a really spectacular way
435 if (readw(&HostP
->__ParmMapR
) == OldParmMap
) {
436 rio_dprintk(RIO_DEBUG_BOOT
, "parmmap 0x%x\n", readw(&HostP
->__ParmMapR
));
437 rio_dprintk(RIO_DEBUG_BOOT
, "RIO Mesg Run Fail\n");
438 HostP
->Flags
&= ~RUN_STATE
;
439 HostP
->Flags
|= RC_STUFFED
;
440 RIOHostReset( HostP
->Type
, HostP
->CardP
, HostP
->Slot
);
444 rio_dprintk(RIO_DEBUG_BOOT
, "Running 0x%x\n", readw(&HostP
->__ParmMapR
));
447 ** Well, the board thought it was OK, and setup its parmmap
448 ** pointer. For the time being, we will pretend that this
449 ** board is running, and check out what the error flag says.
453 ** Grab a 32 bit pointer to the parmmap structure
455 ParmMapP
= (PARM_MAP __iomem
*) RIO_PTR(Cad
, readw(&HostP
->__ParmMapR
));
456 rio_dprintk(RIO_DEBUG_BOOT
, "ParmMapP : %p\n", ParmMapP
);
457 ParmMapP
= (PARM_MAP __iomem
*)(Cad
+ readw(&HostP
->__ParmMapR
));
458 rio_dprintk(RIO_DEBUG_BOOT
, "ParmMapP : %p\n", ParmMapP
);
461 ** The links entry should be 0xFFFF; we set it up
462 ** with a mask to say how many PHBs to use, and
463 ** which links to use.
465 if (readw(&ParmMapP
->links
) != 0xFFFF) {
466 rio_dprintk(RIO_DEBUG_BOOT
, "RIO Mesg Run Fail %s\n", HostP
->Name
);
467 rio_dprintk(RIO_DEBUG_BOOT
, "Links = 0x%x\n", readw(&ParmMapP
->links
));
468 HostP
->Flags
&= ~RUN_STATE
;
469 HostP
->Flags
|= RC_STUFFED
;
470 RIOHostReset( HostP
->Type
, HostP
->CardP
, HostP
->Slot
);
474 writew(RIO_LINK_ENABLE
, &ParmMapP
->links
);
476 rio_dprintk(RIO_DEBUG_BOOT
, "Looking for init_done - %d ticks\n", p
->RIOConf
.StartupTime
);
477 HostP
->timeout_id
= 0;
478 for (wait_count
= 0; (wait_count
< p
->RIOConf
.StartupTime
) && !readw(&ParmMapP
->init_done
); wait_count
++) {
479 rio_dprintk(RIO_DEBUG_BOOT
, "Waiting for init_done\n");
482 rio_dprintk(RIO_DEBUG_BOOT
, "OK! init_done!\n");
484 if (readw(&ParmMapP
->error
) != E_NO_ERROR
|| !readw(&ParmMapP
->init_done
)) {
485 rio_dprintk(RIO_DEBUG_BOOT
, "RIO Mesg Run Fail %s\n", HostP
->Name
);
486 rio_dprintk(RIO_DEBUG_BOOT
, "Timedout waiting for init_done\n");
487 HostP
->Flags
&= ~RUN_STATE
;
488 HostP
->Flags
|= RC_STUFFED
;
489 RIOHostReset( HostP
->Type
, HostP
->CardP
, HostP
->Slot
);
493 rio_dprintk(RIO_DEBUG_BOOT
, "Got init_done\n");
498 rio_dprintk(RIO_DEBUG_BOOT
, "Host ID %x Running\n", HostP
->UniqueNum
);
501 ** set the time period between interrupts.
503 writew(p
->RIOConf
.Timer
, &ParmMapP
->timer
);
506 ** Translate all the 16 bit pointers in the __ParmMapR into
507 ** 32 bit pointers for the driver in ioremap space.
509 HostP
->ParmMapP
= ParmMapP
;
510 HostP
->PhbP
= (struct PHB __iomem
*) RIO_PTR(Cad
, readw(&ParmMapP
->phb_ptr
));
511 HostP
->RupP
= (struct RUP __iomem
*) RIO_PTR(Cad
, readw(&ParmMapP
->rups
));
512 HostP
->PhbNumP
= (unsigned short __iomem
*) RIO_PTR(Cad
, readw(&ParmMapP
->phb_num_ptr
));
513 HostP
->LinkStrP
= (struct LPB __iomem
*) RIO_PTR(Cad
, readw(&ParmMapP
->link_str_ptr
));
516 ** point the UnixRups at the real Rups
518 for (RupN
= 0; RupN
< MAX_RUP
; RupN
++) {
519 HostP
->UnixRups
[RupN
].RupP
= &HostP
->RupP
[RupN
];
520 HostP
->UnixRups
[RupN
].Id
= RupN
+ 1;
521 HostP
->UnixRups
[RupN
].BaseSysPort
= NO_PORT
;
522 spin_lock_init(&HostP
->UnixRups
[RupN
].RupLock
);
525 for (RupN
= 0; RupN
< LINKS_PER_UNIT
; RupN
++) {
526 HostP
->UnixRups
[RupN
+ MAX_RUP
].RupP
= &HostP
->LinkStrP
[RupN
].rup
;
527 HostP
->UnixRups
[RupN
+ MAX_RUP
].Id
= 0;
528 HostP
->UnixRups
[RupN
+ MAX_RUP
].BaseSysPort
= NO_PORT
;
529 spin_lock_init(&HostP
->UnixRups
[RupN
+ MAX_RUP
].RupLock
);
533 ** point the PortP->Phbs at the real Phbs
535 for (PortN
= p
->RIOFirstPortsMapped
; PortN
< p
->RIOLastPortsMapped
+ PORTS_PER_RTA
; PortN
++) {
536 if (p
->RIOPortp
[PortN
]->HostP
== HostP
) {
537 struct Port
*PortP
= p
->RIOPortp
[PortN
];
538 struct PHB __iomem
*PhbP
;
544 PhbP
= &HostP
->PhbP
[PortP
->HostPort
];
545 rio_spin_lock_irqsave(&PortP
->portSem
, flags
);
549 PortP
->TxAdd
= (u16 __iomem
*) RIO_PTR(Cad
, readw(&PhbP
->tx_add
));
550 PortP
->TxStart
= (u16 __iomem
*) RIO_PTR(Cad
, readw(&PhbP
->tx_start
));
551 PortP
->TxEnd
= (u16 __iomem
*) RIO_PTR(Cad
, readw(&PhbP
->tx_end
));
552 PortP
->RxRemove
= (u16 __iomem
*) RIO_PTR(Cad
, readw(&PhbP
->rx_remove
));
553 PortP
->RxStart
= (u16 __iomem
*) RIO_PTR(Cad
, readw(&PhbP
->rx_start
));
554 PortP
->RxEnd
= (u16 __iomem
*) RIO_PTR(Cad
, readw(&PhbP
->rx_end
));
556 rio_spin_unlock_irqrestore(&PortP
->portSem
, flags
);
558 ** point the UnixRup at the base SysPort
560 if (!(PortN
% PORTS_PER_RTA
))
561 HostP
->UnixRups
[PortP
->RupNum
].BaseSysPort
= PortN
;
565 rio_dprintk(RIO_DEBUG_BOOT
, "Set the card running... \n");
567 ** last thing - show the world that everything is in place
569 HostP
->Flags
&= ~RUN_STATE
;
570 HostP
->Flags
|= RC_RUNNING
;
573 ** MPX always uses a poller. This is actually patched into the system
574 ** configuration and called directly from each clock tick.
581 rio_dprintk(RIO_DEBUG_BOOT
, "Done everything %x\n", HostP
->Ivec
);
589 * RIOBootRup - Boot an RTA
590 * @p: rio we are working with
592 * @HostP: host object
593 * @PacketP: packet to use
595 * If we have successfully processed this boot, then
596 * return 1. If we havent, then return 0.
599 int RIOBootRup(struct rio_info
*p
, unsigned int Rup
, struct Host
*HostP
, struct PKT __iomem
*PacketP
)
601 struct PktCmd __iomem
*PktCmdP
= (struct PktCmd __iomem
*) PacketP
->data
;
602 struct PktCmd_M
*PktReplyP
;
603 struct CmdBlk
*CmdBlkP
;
604 unsigned int sequence
;
607 ** If we haven't been told what to boot, we can't boot it.
609 if (p
->RIONumBootPkts
== 0) {
610 rio_dprintk(RIO_DEBUG_BOOT
, "No RTA code to download yet\n");
615 ** Special case of boot completed - if we get one of these then we
616 ** don't need a command block. For all other cases we do, so handle
617 ** this first and then get a command block, then handle every other
618 ** case, relinquishing the command block if disaster strikes!
620 if ((readb(&PacketP
->len
) & PKT_CMD_BIT
) && (readb(&PktCmdP
->Command
) == BOOT_COMPLETED
))
621 return RIOBootComplete(p
, HostP
, Rup
, PktCmdP
);
624 ** Try to allocate a command block. This is in kernel space
626 if (!(CmdBlkP
= RIOGetCmdBlk())) {
627 rio_dprintk(RIO_DEBUG_BOOT
, "No command blocks to boot RTA! come back later.\n");
632 ** Fill in the default info on the command block
634 CmdBlkP
->Packet
.dest_unit
= Rup
< (unsigned short) MAX_RUP
? Rup
: 0;
635 CmdBlkP
->Packet
.dest_port
= BOOT_RUP
;
636 CmdBlkP
->Packet
.src_unit
= 0;
637 CmdBlkP
->Packet
.src_port
= BOOT_RUP
;
639 CmdBlkP
->PreFuncP
= CmdBlkP
->PostFuncP
= NULL
;
640 PktReplyP
= (struct PktCmd_M
*) CmdBlkP
->Packet
.data
;
643 ** process COMMANDS on the boot rup!
645 if (readb(&PacketP
->len
) & PKT_CMD_BIT
) {
647 ** We only expect one type of command - a BOOT_REQUEST!
649 if (readb(&PktCmdP
->Command
) != BOOT_REQUEST
) {
650 rio_dprintk(RIO_DEBUG_BOOT
, "Unexpected command %d on BOOT RUP %d of host %Zd\n", readb(&PktCmdP
->Command
), Rup
, HostP
- p
->RIOHosts
);
651 RIOFreeCmdBlk(CmdBlkP
);
656 ** Build a Boot Sequence command block
658 ** We no longer need to use "Boot Mode", we'll always allow
659 ** boot requests - the boot will not complete if the device
660 ** appears in the bindings table.
662 ** We'll just (always) set the command field in packet reply
663 ** to allow an attempted boot sequence :
665 PktReplyP
->Command
= BOOT_SEQUENCE
;
667 PktReplyP
->BootSequence
.NumPackets
= p
->RIONumBootPkts
;
668 PktReplyP
->BootSequence
.LoadBase
= p
->RIOConf
.RtaLoadBase
;
669 PktReplyP
->BootSequence
.CodeSize
= p
->RIOBootCount
;
671 CmdBlkP
->Packet
.len
= BOOT_SEQUENCE_LEN
| PKT_CMD_BIT
;
673 memcpy((void *) &CmdBlkP
->Packet
.data
[BOOT_SEQUENCE_LEN
], "BOOT", 4);
675 rio_dprintk(RIO_DEBUG_BOOT
, "Boot RTA on Host %Zd Rup %d - %d (0x%x) packets to 0x%x\n", HostP
- p
->RIOHosts
, Rup
, p
->RIONumBootPkts
, p
->RIONumBootPkts
, p
->RIOConf
.RtaLoadBase
);
678 ** If this host is in slave mode, send the RTA an invalid boot
679 ** sequence command block to force it to kill the boot. We wait
680 ** for half a second before sending this packet to prevent the RTA
681 ** attempting to boot too often. The master host should then grab
682 ** the RTA and make it its own.
685 RIOQueueCmdBlk(HostP
, Rup
, CmdBlkP
);
690 ** It is a request for boot data.
692 sequence
= readw(&PktCmdP
->Sequence
);
694 rio_dprintk(RIO_DEBUG_BOOT
, "Boot block %d on Host %Zd Rup%d\n", sequence
, HostP
- p
->RIOHosts
, Rup
);
696 if (sequence
>= p
->RIONumBootPkts
) {
697 rio_dprintk(RIO_DEBUG_BOOT
, "Got a request for packet %d, max is %d\n", sequence
, p
->RIONumBootPkts
);
700 PktReplyP
->Sequence
= sequence
;
701 memcpy(PktReplyP
->BootData
, p
->RIOBootPackets
[p
->RIONumBootPkts
- sequence
- 1], RTA_BOOT_DATA_SIZE
);
702 CmdBlkP
->Packet
.len
= PKT_MAX_DATA_LEN
;
703 RIOQueueCmdBlk(HostP
, Rup
, CmdBlkP
);
708 * RIOBootComplete - RTA boot is done
709 * @p: RIO we are working with
710 * @HostP: Host structure
711 * @Rup: RUP being used
712 * @PktCmdP: Packet command that was used
714 * This function is called when an RTA been booted.
715 * If booted by a host, HostP->HostUniqueNum is the booting host.
716 * If booted by an RTA, HostP->Mapping[Rup].RtaUniqueNum is the booting RTA.
717 * RtaUniq is the booted RTA.
720 static int RIOBootComplete(struct rio_info
*p
, struct Host
*HostP
, unsigned int Rup
, struct PktCmd __iomem
*PktCmdP
)
722 struct Map
*MapP
= NULL
;
723 struct Map
*MapP2
= NULL
;
729 char *MyType
, *MyName
;
731 unsigned short RtaType
;
732 u32 RtaUniq
= (readb(&PktCmdP
->UniqNum
[0])) + (readb(&PktCmdP
->UniqNum
[1]) << 8) + (readb(&PktCmdP
->UniqNum
[2]) << 16) + (readb(&PktCmdP
->UniqNum
[3]) << 24);
736 rio_dprintk(RIO_DEBUG_BOOT
, "RTA Boot completed - BootInProgress now %d\n", p
->RIOBooting
);
739 ** Determine type of unit (16/8 port RTA).
742 RtaType
= GetUnitType(RtaUniq
);
743 if (Rup
>= (unsigned short) MAX_RUP
)
744 rio_dprintk(RIO_DEBUG_BOOT
, "RIO: Host %s has booted an RTA(%d) on link %c\n", HostP
->Name
, 8 * RtaType
, readb(&PktCmdP
->LinkNum
) + 'A');
746 rio_dprintk(RIO_DEBUG_BOOT
, "RIO: RTA %s has booted an RTA(%d) on link %c\n", HostP
->Mapping
[Rup
].Name
, 8 * RtaType
, readb(&PktCmdP
->LinkNum
) + 'A');
748 rio_dprintk(RIO_DEBUG_BOOT
, "UniqNum is 0x%x\n", RtaUniq
);
750 if (RtaUniq
== 0x00000000 || RtaUniq
== 0xffffffff) {
751 rio_dprintk(RIO_DEBUG_BOOT
, "Illegal RTA Uniq Number\n");
756 ** If this RTA has just booted an RTA which doesn't belong to this
757 ** system, or the system is in slave mode, do not attempt to create
758 ** a new table entry for it.
761 if (!RIOBootOk(p
, HostP
, RtaUniq
)) {
762 MyLink
= readb(&PktCmdP
->LinkNum
);
763 if (Rup
< (unsigned short) MAX_RUP
) {
765 ** RtaUniq was clone booted (by this RTA). Instruct this RTA
766 ** to hold off further attempts to boot on this link for 30
769 if (RIOSuspendBootRta(HostP
, HostP
->Mapping
[Rup
].ID
, MyLink
)) {
770 rio_dprintk(RIO_DEBUG_BOOT
, "RTA failed to suspend booting on link %c\n", 'A' + MyLink
);
774 ** RtaUniq was booted by this host. Set the booting link
775 ** to hold off for 30 seconds to give another unit a
776 ** chance to boot it.
778 writew(30, &HostP
->LinkStrP
[MyLink
].WaitNoBoot
);
779 rio_dprintk(RIO_DEBUG_BOOT
, "RTA %x not owned - suspend booting down link %c on unit %x\n", RtaUniq
, 'A' + MyLink
, HostP
->Mapping
[Rup
].RtaUniqueNum
);
784 ** Check for a SLOT_IN_USE entry for this RTA attached to the
785 ** current host card in the driver table.
787 ** If it exists, make a note that we have booted it. Other parts of
788 ** the driver are interested in this information at a later date,
789 ** in particular when the booting RTA asks for an ID for this unit,
790 ** we must have set the BOOTED flag, and the NEWBOOT flag is used
791 ** to force an open on any ports that where previously open on this
794 for (entry
= 0; entry
< MAX_RUP
; entry
++) {
795 unsigned int sysport
;
797 if ((HostP
->Mapping
[entry
].Flags
& SLOT_IN_USE
) && (HostP
->Mapping
[entry
].RtaUniqueNum
== RtaUniq
)) {
798 HostP
->Mapping
[entry
].Flags
|= RTA_BOOTED
| RTA_NEWBOOT
;
799 if ((sysport
= HostP
->Mapping
[entry
].SysPort
) != NO_PORT
) {
800 if (sysport
< p
->RIOFirstPortsBooted
)
801 p
->RIOFirstPortsBooted
= sysport
;
802 if (sysport
> p
->RIOLastPortsBooted
)
803 p
->RIOLastPortsBooted
= sysport
;
805 ** For a 16 port RTA, check the second bank of 8 ports
807 if (RtaType
== TYPE_RTA16
) {
808 entry2
= HostP
->Mapping
[entry
].ID2
- 1;
809 HostP
->Mapping
[entry2
].Flags
|= RTA_BOOTED
| RTA_NEWBOOT
;
810 sysport
= HostP
->Mapping
[entry2
].SysPort
;
811 if (sysport
< p
->RIOFirstPortsBooted
)
812 p
->RIOFirstPortsBooted
= sysport
;
813 if (sysport
> p
->RIOLastPortsBooted
)
814 p
->RIOLastPortsBooted
= sysport
;
817 if (RtaType
== TYPE_RTA16
)
818 rio_dprintk(RIO_DEBUG_BOOT
, "RTA will be given IDs %d+%d\n", entry
+ 1, entry2
+ 1);
820 rio_dprintk(RIO_DEBUG_BOOT
, "RTA will be given ID %d\n", entry
+ 1);
825 rio_dprintk(RIO_DEBUG_BOOT
, "RTA not configured for this host\n");
827 if (Rup
>= (unsigned short) MAX_RUP
) {
829 ** It was a host that did the booting
832 MyName
= HostP
->Name
;
835 ** It was an RTA that did the booting
838 MyName
= HostP
->Mapping
[Rup
].Name
;
840 MyLink
= readb(&PktCmdP
->LinkNum
);
843 ** There is no SLOT_IN_USE entry for this RTA attached to the current
844 ** host card in the driver table.
846 ** Check for a SLOT_TENTATIVE entry for this RTA attached to the
847 ** current host card in the driver table.
849 ** If we find one, then we re-use that slot.
851 for (entry
= 0; entry
< MAX_RUP
; entry
++) {
852 if ((HostP
->Mapping
[entry
].Flags
& SLOT_TENTATIVE
) && (HostP
->Mapping
[entry
].RtaUniqueNum
== RtaUniq
)) {
853 if (RtaType
== TYPE_RTA16
) {
854 entry2
= HostP
->Mapping
[entry
].ID2
- 1;
855 if ((HostP
->Mapping
[entry2
].Flags
& SLOT_TENTATIVE
) && (HostP
->Mapping
[entry2
].RtaUniqueNum
== RtaUniq
))
856 rio_dprintk(RIO_DEBUG_BOOT
, "Found previous tentative slots (%d+%d)\n", entry
, entry2
);
860 rio_dprintk(RIO_DEBUG_BOOT
, "Found previous tentative slot (%d)\n", entry
);
861 if (!p
->RIONoMessage
)
862 printk("RTA connected to %s '%s' (%c) not configured.\n", MyType
, MyName
, MyLink
+ 'A');
868 ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
869 ** attached to the current host card in the driver table.
871 ** Check if there is a SLOT_IN_USE or SLOT_TENTATIVE entry on another
872 ** host for this RTA in the driver table.
874 ** For a SLOT_IN_USE entry on another host, we need to delete the RTA
875 ** entry from the other host and add it to this host (using some of
876 ** the functions from table.c which do this).
877 ** For a SLOT_TENTATIVE entry on another host, we must cope with the
878 ** following scenario:
880 ** + Plug 8 port RTA into host A. (This creates SLOT_TENTATIVE entry
882 ** + Unplug RTA and plug into host B. (We now have 2 SLOT_TENTATIVE
884 ** + Configure RTA on host B. (This slot now becomes SLOT_IN_USE)
885 ** + Unplug RTA and plug back into host A.
886 ** + Configure RTA on host A. We now have the same RTA configured
887 ** with different ports on two different hosts.
889 rio_dprintk(RIO_DEBUG_BOOT
, "Have we seen RTA %x before?\n", RtaUniq
);
891 Flag
= 0; /* Convince the compiler this variable is initialized */
892 for (host
= 0; !found
&& (host
< p
->RIONumHosts
); host
++) {
893 for (rta
= 0; rta
< MAX_RUP
; rta
++) {
894 if ((p
->RIOHosts
[host
].Mapping
[rta
].Flags
& (SLOT_IN_USE
| SLOT_TENTATIVE
)) && (p
->RIOHosts
[host
].Mapping
[rta
].RtaUniqueNum
== RtaUniq
)) {
895 Flag
= p
->RIOHosts
[host
].Mapping
[rta
].Flags
;
896 MapP
= &p
->RIOHosts
[host
].Mapping
[rta
];
897 if (RtaType
== TYPE_RTA16
) {
898 MapP2
= &p
->RIOHosts
[host
].Mapping
[MapP
->ID2
- 1];
899 rio_dprintk(RIO_DEBUG_BOOT
, "This RTA is units %d+%d from host %s\n", rta
+ 1, MapP
->ID2
, p
->RIOHosts
[host
].Name
);
901 rio_dprintk(RIO_DEBUG_BOOT
, "This RTA is unit %d from host %s\n", rta
+ 1, p
->RIOHosts
[host
].Name
);
909 ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
910 ** attached to the current host card in the driver table.
912 ** If we have not found a SLOT_IN_USE or SLOT_TENTATIVE entry on
913 ** another host for this RTA in the driver table...
915 ** Check for a SLOT_IN_USE entry for this RTA in the config table.
918 rio_dprintk(RIO_DEBUG_BOOT
, "Look for RTA %x in RIOSavedTable\n", RtaUniq
);
919 for (rta
= 0; rta
< TOTAL_MAP_ENTRIES
; rta
++) {
920 rio_dprintk(RIO_DEBUG_BOOT
, "Check table entry %d (%x)", rta
, p
->RIOSavedTable
[rta
].RtaUniqueNum
);
922 if ((p
->RIOSavedTable
[rta
].Flags
& SLOT_IN_USE
) && (p
->RIOSavedTable
[rta
].RtaUniqueNum
== RtaUniq
)) {
923 MapP
= &p
->RIOSavedTable
[rta
];
924 Flag
= p
->RIOSavedTable
[rta
].Flags
;
925 if (RtaType
== TYPE_RTA16
) {
926 for (entry2
= rta
+ 1; entry2
< TOTAL_MAP_ENTRIES
; entry2
++) {
927 if (p
->RIOSavedTable
[entry2
].RtaUniqueNum
== RtaUniq
)
930 MapP2
= &p
->RIOSavedTable
[entry2
];
931 rio_dprintk(RIO_DEBUG_BOOT
, "This RTA is from table entries %d+%d\n", rta
, entry2
);
933 rio_dprintk(RIO_DEBUG_BOOT
, "This RTA is from table entry %d\n", rta
);
940 ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
941 ** attached to the current host card in the driver table.
943 ** We may have found a SLOT_IN_USE entry on another host for this
944 ** RTA in the config table, or a SLOT_IN_USE or SLOT_TENTATIVE entry
945 ** on another host for this RTA in the driver table.
947 ** Check the driver table for room to fit this newly discovered RTA.
948 ** RIOFindFreeID() first looks for free slots and if it does not
949 ** find any free slots it will then attempt to oust any
950 ** tentative entry in the table.
953 if (RtaType
== TYPE_RTA16
) {
954 if (RIOFindFreeID(p
, HostP
, &entry
, &entry2
) == 0) {
955 RIODefaultName(p
, HostP
, entry
);
956 rio_fill_host_slot(entry
, entry2
, RtaUniq
, HostP
);
960 if (RIOFindFreeID(p
, HostP
, &entry
, NULL
) == 0) {
961 RIODefaultName(p
, HostP
, entry
);
962 rio_fill_host_slot(entry
, 0, RtaUniq
, HostP
);
968 ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
969 ** attached to the current host card in the driver table.
971 ** If we found a SLOT_IN_USE entry on another host for this
972 ** RTA in the config or driver table, and there are enough free
973 ** slots in the driver table, then we need to move it over and
974 ** delete it from the other host.
975 ** If we found a SLOT_TENTATIVE entry on another host for this
976 ** RTA in the driver table, just delete the other host entry.
978 if (EmptySlot
== 0) {
980 if (Flag
& SLOT_IN_USE
) {
981 rio_dprintk(RIO_DEBUG_BOOT
, "This RTA configured on another host - move entry to current host (1)\n");
982 HostP
->Mapping
[entry
].SysPort
= MapP
->SysPort
;
983 memcpy(HostP
->Mapping
[entry
].Name
, MapP
->Name
, MAX_NAME_LEN
);
984 HostP
->Mapping
[entry
].Flags
= SLOT_IN_USE
| RTA_BOOTED
| RTA_NEWBOOT
;
985 RIOReMapPorts(p
, HostP
, &HostP
->Mapping
[entry
]);
986 if (HostP
->Mapping
[entry
].SysPort
< p
->RIOFirstPortsBooted
)
987 p
->RIOFirstPortsBooted
= HostP
->Mapping
[entry
].SysPort
;
988 if (HostP
->Mapping
[entry
].SysPort
> p
->RIOLastPortsBooted
)
989 p
->RIOLastPortsBooted
= HostP
->Mapping
[entry
].SysPort
;
990 rio_dprintk(RIO_DEBUG_BOOT
, "SysPort %d, Name %s\n", (int) MapP
->SysPort
, MapP
->Name
);
992 rio_dprintk(RIO_DEBUG_BOOT
, "This RTA has a tentative entry on another host - delete that entry (1)\n");
993 HostP
->Mapping
[entry
].Flags
= SLOT_TENTATIVE
| RTA_BOOTED
| RTA_NEWBOOT
;
995 if (RtaType
== TYPE_RTA16
) {
996 if (Flag
& SLOT_IN_USE
) {
997 HostP
->Mapping
[entry2
].Flags
= SLOT_IN_USE
| RTA_BOOTED
| RTA_NEWBOOT
| RTA16_SECOND_SLOT
;
998 HostP
->Mapping
[entry2
].SysPort
= MapP2
->SysPort
;
1000 ** Map second block of ttys for 16 port RTA
1002 RIOReMapPorts(p
, HostP
, &HostP
->Mapping
[entry2
]);
1003 if (HostP
->Mapping
[entry2
].SysPort
< p
->RIOFirstPortsBooted
)
1004 p
->RIOFirstPortsBooted
= HostP
->Mapping
[entry2
].SysPort
;
1005 if (HostP
->Mapping
[entry2
].SysPort
> p
->RIOLastPortsBooted
)
1006 p
->RIOLastPortsBooted
= HostP
->Mapping
[entry2
].SysPort
;
1007 rio_dprintk(RIO_DEBUG_BOOT
, "SysPort %d, Name %s\n", (int) HostP
->Mapping
[entry2
].SysPort
, HostP
->Mapping
[entry
].Name
);
1009 HostP
->Mapping
[entry2
].Flags
= SLOT_TENTATIVE
| RTA_BOOTED
| RTA_NEWBOOT
| RTA16_SECOND_SLOT
;
1010 memset(MapP2
, 0, sizeof(struct Map
));
1012 memset(MapP
, 0, sizeof(struct Map
));
1013 if (!p
->RIONoMessage
)
1014 printk("An orphaned RTA has been adopted by %s '%s' (%c).\n", MyType
, MyName
, MyLink
+ 'A');
1015 } else if (!p
->RIONoMessage
)
1016 printk("RTA connected to %s '%s' (%c) not configured.\n", MyType
, MyName
, MyLink
+ 'A');
1022 ** There is no room in the driver table to make an entry for the
1023 ** booted RTA. Keep a note of its Uniq Num in the overflow table,
1024 ** so we can ignore it's ID requests.
1026 if (!p
->RIONoMessage
)
1027 printk("The RTA connected to %s '%s' (%c) cannot be configured. You cannot configure more than 128 ports to one host card.\n", MyType
, MyName
, MyLink
+ 'A');
1028 for (entry
= 0; entry
< HostP
->NumExtraBooted
; entry
++) {
1029 if (HostP
->ExtraUnits
[entry
] == RtaUniq
) {
1037 ** If there is room, add the unit to the list of extras
1039 if (HostP
->NumExtraBooted
< MAX_EXTRA_UNITS
)
1040 HostP
->ExtraUnits
[HostP
->NumExtraBooted
++] = RtaUniq
;
1046 ** If the RTA or its host appears in the RIOBindTab[] structure then
1047 ** we mustn't boot the RTA and should return 0.
1048 ** This operation is slightly different from the other drivers for RIO
1049 ** in that this is designed to work with the new utilities
1050 ** not config.rio and is FAR SIMPLER.
1051 ** We no longer support the RIOBootMode variable. It is all done from the
1052 ** "boot/noboot" field in the rio.cf file.
1054 int RIOBootOk(struct rio_info
*p
, struct Host
*HostP
, unsigned long RtaUniq
)
1057 unsigned int HostUniq
= HostP
->UniqueNum
;
1060 ** Search bindings table for RTA or its parent.
1061 ** If it exists, return 0, else 1.
1063 for (Entry
= 0; (Entry
< MAX_RTA_BINDINGS
) && (p
->RIOBindTab
[Entry
] != 0); Entry
++) {
1064 if ((p
->RIOBindTab
[Entry
] == HostUniq
) || (p
->RIOBindTab
[Entry
] == RtaUniq
))
1071 ** Make an empty slot tentative. If this is a 16 port RTA, make both
1072 ** slots tentative, and the second one RTA_SECOND_SLOT as well.
1075 void rio_fill_host_slot(int entry
, int entry2
, unsigned int rta_uniq
, struct Host
*host
)
1079 rio_dprintk(RIO_DEBUG_BOOT
, "rio_fill_host_slot(%d, %d, 0x%x...)\n", entry
, entry2
, rta_uniq
);
1081 host
->Mapping
[entry
].Flags
= (RTA_BOOTED
| RTA_NEWBOOT
| SLOT_TENTATIVE
);
1082 host
->Mapping
[entry
].SysPort
= NO_PORT
;
1083 host
->Mapping
[entry
].RtaUniqueNum
= rta_uniq
;
1084 host
->Mapping
[entry
].HostUniqueNum
= host
->UniqueNum
;
1085 host
->Mapping
[entry
].ID
= entry
+ 1;
1086 host
->Mapping
[entry
].ID2
= 0;
1088 host
->Mapping
[entry2
].Flags
= (RTA_BOOTED
| RTA_NEWBOOT
| SLOT_TENTATIVE
| RTA16_SECOND_SLOT
);
1089 host
->Mapping
[entry2
].SysPort
= NO_PORT
;
1090 host
->Mapping
[entry2
].RtaUniqueNum
= rta_uniq
;
1091 host
->Mapping
[entry2
].HostUniqueNum
= host
->UniqueNum
;
1092 host
->Mapping
[entry2
].Name
[0] = '\0';
1093 host
->Mapping
[entry2
].ID
= entry2
+ 1;
1094 host
->Mapping
[entry2
].ID2
= entry
+ 1;
1095 host
->Mapping
[entry
].ID2
= entry2
+ 1;
1098 ** Must set these up, so that utilities show
1099 ** topology of 16 port RTAs correctly
1101 for (link
= 0; link
< LINKS_PER_UNIT
; link
++) {
1102 host
->Mapping
[entry
].Topology
[link
].Unit
= ROUTE_DISCONNECT
;
1103 host
->Mapping
[entry
].Topology
[link
].Link
= NO_LINK
;
1105 host
->Mapping
[entry2
].Topology
[link
].Unit
= ROUTE_DISCONNECT
;
1106 host
->Mapping
[entry2
].Topology
[link
].Link
= NO_LINK
;