1/* 2** ----------------------------------------------------------------------------- 3** 4** Perle Specialix driver for Linux 5** Ported from existing RIO Driver for SCO sources. 6 * 7 * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK. 8 * 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. 13 * 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. 18 * 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. 22** 23** Module : rioboot.c 24** SID : 1.3 25** Last Modified : 11/6/98 10:33:36 26** Retrieved : 11/6/98 10:33:48 27** 28** ident @(#)rioboot.c 1.3 29** 30** ----------------------------------------------------------------------------- 31*/ 32 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> 42#include <asm/io.h> 43#include <asm/system.h> 44#include <asm/string.h> 45#include <asm/uaccess.h> 46 47 48#include "linux_compat.h" 49#include "rio_linux.h" 50#include "pkt.h" 51#include "daemon.h" 52#include "rio.h" 53#include "riospace.h" 54#include "cmdpkt.h" 55#include "map.h" 56#include "rup.h" 57#include "port.h" 58#include "riodrvr.h" 59#include "rioinfo.h" 60#include "func.h" 61#include "errors.h" 62#include "pci.h" 63 64#include "parmmap.h" 65#include "unixrup.h" 66#include "board.h" 67#include "host.h" 68#include "phb.h" 69#include "link.h" 70#include "cmdblk.h" 71#include "route.h" 72 73static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd __iomem *PktCmdP); 74 75static 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 92}; 93 94/** 95 * RIOBootCodeRTA - Load RTA boot code 96 * @p: RIO to load 97 * @rbp: Download descriptor 98 * 99 * Called when the user process initiates booting of the card firmware. 100 * Lads the firmware 101 */ 102 103int RIOBootCodeRTA(struct rio_info *p, struct DownLoad * rbp) 104{ 105 int offset; 106 107 func_enter(); 108 109 rio_dprintk(RIO_DEBUG_BOOT, "Data at user address %p\n", rbp->DataP); 110 111 /* 112 ** Check that we have set asside enough memory for this 113 */ 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; 117 func_exit(); 118 return -ENOMEM; 119 } 120 121 if (p->RIOBooting) { 122 rio_dprintk(RIO_DEBUG_BOOT, "RTA Boot Code : BUSY BUSY BUSY!\n"); 123 p->RIOError.Error = BOOT_IN_PROGRESS; 124 func_exit(); 125 return -EBUSY; 126 } 127 128 /* 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 131 ** to achieve this. 132 */ 133 offset = (RTA_BOOT_DATA_SIZE - (rbp->Count % RTA_BOOT_DATA_SIZE)) % RTA_BOOT_DATA_SIZE; 134 135 /* 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. 139 */ 140 memset(p->RIOBootPackets, 0, offset); 141 142 /* 143 ** Copy the data from user space into the array 144 */ 145 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; 149 func_exit(); 150 return -EFAULT; 151 } 152 153 /* 154 ** Make sure that our copy of the size includes that offset we discussed 155 ** earlier. 156 */ 157 p->RIONumBootPkts = (rbp->Count + offset) / RTA_BOOT_DATA_SIZE; 158 p->RIOBootCount = rbp->Count; 159 160 func_exit(); 161 return 0; 162} 163 164/** 165 * rio_start_card_running - host card start 166 * @HostP: The RIO to kick off 167 * 168 * Start a RIO processor unit running. Encapsulates the knowledge 169 * of the card type. 170 */ 171 172void rio_start_card_running(struct Host *HostP) 173{ 174 switch (HostP->Type) { 175 case RIO_AT: 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); 178 break; 179 case RIO_PCI: 180 /* 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 183 ** ports. 184 */ 185 rio_dprintk(RIO_DEBUG_BOOT, "Start PCI card running\n"); 186 writeb(PCITpBootFromRam | PCITpBusEnable | HostP->Mode, &HostP->Control); 187 break; 188 default: 189 rio_dprintk(RIO_DEBUG_BOOT, "Unknown host type %d\n", HostP->Type); 190 break; 191 } 192 return; 193} 194 195/* 196** Load in the host boot code - load it directly onto all halted hosts 197** of the correct type. 198** 199** Put your rubber pants on before messing with this code - even the magic 200** numbers have trouble understanding what they are doing here. 201*/ 202 203int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp) 204{ 205 struct Host *HostP; 206 u8 __iomem *Cad; 207 PARM_MAP __iomem *ParmMapP; 208 int RupN; 209 int PortN; 210 unsigned int host; 211 u8 __iomem *StartP; 212 u8 __iomem *DestP; 213 int wait_count; 214 u16 OldParmMap; 215 u16 offset; /* It is very important that this is a u16 */ 216 u8 *DownCode = NULL; 217 unsigned long flags; 218 219 HostP = NULL; /* Assure the compiler we've initialized it */ 220 221 222 /* Walk the hosts */ 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]; 226 227 rio_dprintk(RIO_DEBUG_BOOT, "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n", HostP->Type, HostP->Mode, HostP->Ivec); 228 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); 232 continue; 233 } 234 235 /* 236 ** Grab a pointer to the card (ioremapped) 237 */ 238 Cad = HostP->Caddr; 239 240 /* 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) 245 */ 246 StartP = &Cad[p->RIOConf.HostLoadBase - rbp->Count]; 247 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); 252 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; 257 func_exit(); 258 return -EFBIG; 259 } 260 /* 261 ** Ensure that the host really is stopped. 262 ** Disable it's external bus & twang its reset line. 263 */ 264 RIOHostReset(HostP->Type, HostP->CardP, HostP->Slot); 265 266 /* 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. 270 */ 271 rio_dprintk(RIO_DEBUG_BOOT, "Copy in code\n"); 272 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 */ 275 276 DownCode = vmalloc(rbp->Count); 277 if (!DownCode) { 278 p->RIOError.Error = NOT_ENOUGH_CORE_FOR_PCI_COPY; 279 func_exit(); 280 return -ENOMEM; 281 } 282 if (copy_from_user(DownCode, rbp->DataP, rbp->Count)) { 283 kfree(DownCode); 284 p->RIOError.Error = COPYIN_FAILED; 285 func_exit(); 286 return -EFAULT; 287 } 288 HostP->Copy(DownCode, StartP, rbp->Count); 289 vfree(DownCode); 290 291 rio_dprintk(RIO_DEBUG_BOOT, "Copy completed\n"); 292 293 /* 294 ** S T O P ! 295 ** 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. 304 ** 305 ** If I were you I wouldn't start from here. 306 */ 307 308 /* 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. 317 ** 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. 321 ** 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. 331 ** 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 341 ** download code). 342 ** 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)= 345 ** 0x7BFE. 346 ** This will be coded as four bytes: 347 ** 60 2C 20 02 348 ** being nfix .O+0 349 ** pfix .O+C 350 ** pfix .O+0 351 ** jump .O+2 352 ** 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). 356 ** 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'. 359 */ 360 361 362 /* 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. 366 */ 367 368 DestP = &Cad[0x7FF8]; /* <<<---- READ THE ABOVE COMMENTS */ 369 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 */ 373 374 /* 375 ** 0x7FFC is the address of the location following the last byte of 376 ** the four byte jump instruction. 377 ** READ THE ABOVE COMMENTS 378 ** 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). 382 */ 383 offset = (p->RIOConf.HostLoadBase - 2) - 0x7FFC; 384 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); 389 390 writeb(NFIX(0), DestP + 6); 391 writeb(JUMP(8), DestP + 7); 392 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); 395 396 /* 397 ** Flag what is going on 398 */ 399 HostP->Flags &= ~RUN_STATE; 400 HostP->Flags |= RC_STARTUP; 401 402 /* 403 ** Grab a copy of the current ParmMap pointer, so we 404 ** can tell when it has changed. 405 */ 406 OldParmMap = readw(&HostP->__ParmMapR); 407 408 rio_dprintk(RIO_DEBUG_BOOT, "Original parmmap is 0x%x\n", OldParmMap); 409 410 /* 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. 414 */ 415 rio_dprintk(RIO_DEBUG_BOOT, "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n", HostP->Type, HostP->Mode, HostP->Ivec); 416 417 rio_start_card_running(HostP); 418 419 rio_dprintk(RIO_DEBUG_BOOT, "Set control port\n"); 420 421 /* 422 ** Now, wait for upto five seconds for the Tp to setup the parmmap 423 ** pointer: 424 */ 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)); 427 mdelay(100); 428 429 } 430 431 /* 432 ** If the parmmap pointer is unchanged, then the host code 433 ** has crashed & burned in a really spectacular way 434 */ 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 ); 441 continue; 442 } 443 444 rio_dprintk(RIO_DEBUG_BOOT, "Running 0x%x\n", readw(&HostP->__ParmMapR)); 445 446 /* 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. 450 */ 451 452 /* 453 ** Grab a 32 bit pointer to the parmmap structure 454 */ 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); 459 460 /* 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. 464 */ 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 ); 471 continue; 472 } 473 474 writew(RIO_LINK_ENABLE, &ParmMapP->links); 475 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"); 480 mdelay(100); 481 } 482 rio_dprintk(RIO_DEBUG_BOOT, "OK! init_done!\n"); 483 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 ); 490 continue; 491 } 492 493 rio_dprintk(RIO_DEBUG_BOOT, "Got init_done\n"); 494 495 /* 496 ** It runs! It runs! 497 */ 498 rio_dprintk(RIO_DEBUG_BOOT, "Host ID %x Running\n", HostP->UniqueNum); 499 500 /* 501 ** set the time period between interrupts. 502 */ 503 writew(p->RIOConf.Timer, &ParmMapP->timer); 504 505 /* 506 ** Translate all the 16 bit pointers in the __ParmMapR into 507 ** 32 bit pointers for the driver in ioremap space. 508 */ 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)); 514 515 /* 516 ** point the UnixRups at the real Rups 517 */ 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); 523 } 524 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); 530 } 531 532 /* 533 ** point the PortP->Phbs at the real Phbs 534 */ 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; 539 /* int oldspl; */ 540 541 if (!PortP->Mapped) 542 continue; 543 544 PhbP = &HostP->PhbP[PortP->HostPort]; 545 rio_spin_lock_irqsave(&PortP->portSem, flags); 546 547 PortP->PhbP = PhbP; 548 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)); 555 556 rio_spin_unlock_irqrestore(&PortP->portSem, flags); 557 /* 558 ** point the UnixRup at the base SysPort 559 */ 560 if (!(PortN % PORTS_PER_RTA)) 561 HostP->UnixRups[PortP->RupNum].BaseSysPort = PortN; 562 } 563 } 564 565 rio_dprintk(RIO_DEBUG_BOOT, "Set the card running... \n"); 566 /* 567 ** last thing - show the world that everything is in place 568 */ 569 HostP->Flags &= ~RUN_STATE; 570 HostP->Flags |= RC_RUNNING; 571 } 572 /* 573 ** MPX always uses a poller. This is actually patched into the system 574 ** configuration and called directly from each clock tick. 575 ** 576 */ 577 p->RIOPolling = 1; 578 579 p->RIOSystemUp++; 580 581 rio_dprintk(RIO_DEBUG_BOOT, "Done everything %x\n", HostP->Ivec); 582 func_exit(); 583 return 0; 584} 585 586 587 588/** 589 * RIOBootRup - Boot an RTA 590 * @p: rio we are working with 591 * @Rup: Rup number 592 * @HostP: host object 593 * @PacketP: packet to use 594 * 595 * If we have successfully processed this boot, then 596 * return 1. If we havent, then return 0. 597 */ 598 599int RIOBootRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT __iomem *PacketP) 600{ 601 struct PktCmd __iomem *PktCmdP = (struct PktCmd __iomem *) PacketP->data; 602 struct PktCmd_M *PktReplyP; 603 struct CmdBlk *CmdBlkP; 604 unsigned int sequence; 605 606 /* 607 ** If we haven't been told what to boot, we can't boot it. 608 */ 609 if (p->RIONumBootPkts == 0) { 610 rio_dprintk(RIO_DEBUG_BOOT, "No RTA code to download yet\n"); 611 return 0; 612 } 613 614 /* 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! 619 */ 620 if ((readb(&PacketP->len) & PKT_CMD_BIT) && (readb(&PktCmdP->Command) == BOOT_COMPLETED)) 621 return RIOBootComplete(p, HostP, Rup, PktCmdP); 622 623 /* 624 ** Try to allocate a command block. This is in kernel space 625 */ 626 if (!(CmdBlkP = RIOGetCmdBlk())) { 627 rio_dprintk(RIO_DEBUG_BOOT, "No command blocks to boot RTA! come back later.\n"); 628 return 0; 629 } 630 631 /* 632 ** Fill in the default info on the command block 633 */ 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; 638 639 CmdBlkP->PreFuncP = CmdBlkP->PostFuncP = NULL; 640 PktReplyP = (struct PktCmd_M *) CmdBlkP->Packet.data; 641 642 /* 643 ** process COMMANDS on the boot rup! 644 */ 645 if (readb(&PacketP->len) & PKT_CMD_BIT) { 646 /* 647 ** We only expect one type of command - a BOOT_REQUEST! 648 */ 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); 652 return 1; 653 } 654 655 /* 656 ** Build a Boot Sequence command block 657 ** 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. 661 ** 662 ** We'll just (always) set the command field in packet reply 663 ** to allow an attempted boot sequence : 664 */ 665 PktReplyP->Command = BOOT_SEQUENCE; 666 667 PktReplyP->BootSequence.NumPackets = p->RIONumBootPkts; 668 PktReplyP->BootSequence.LoadBase = p->RIOConf.RtaLoadBase; 669 PktReplyP->BootSequence.CodeSize = p->RIOBootCount; 670 671 CmdBlkP->Packet.len = BOOT_SEQUENCE_LEN | PKT_CMD_BIT; 672 673 memcpy((void *) &CmdBlkP->Packet.data[BOOT_SEQUENCE_LEN], "BOOT", 4); 674 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); 676 677 /* 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. 683 */ 684 p->RIOBooting++; 685 RIOQueueCmdBlk(HostP, Rup, CmdBlkP); 686 return 1; 687 } 688 689 /* 690 ** It is a request for boot data. 691 */ 692 sequence = readw(&PktCmdP->Sequence); 693 694 rio_dprintk(RIO_DEBUG_BOOT, "Boot block %d on Host %Zd Rup%d\n", sequence, HostP - p->RIOHosts, Rup); 695 696 if (sequence >= p->RIONumBootPkts) { 697 rio_dprintk(RIO_DEBUG_BOOT, "Got a request for packet %d, max is %d\n", sequence, p->RIONumBootPkts); 698 } 699 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); 704 return 1; 705} 706 707/** 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 713 * 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. 718 */ 719 720static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd __iomem *PktCmdP) 721{ 722 struct Map *MapP = NULL; 723 struct Map *MapP2 = NULL; 724 int Flag; 725 int found; 726 int host, rta; 727 int EmptySlot = -1; 728 int entry, entry2; 729 char *MyType, *MyName; 730 unsigned int MyLink; 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); 733 734 p->RIOBooting = 0; 735 736 rio_dprintk(RIO_DEBUG_BOOT, "RTA Boot completed - BootInProgress now %d\n", p->RIOBooting); 737 738 /* 739 ** Determine type of unit (16/8 port RTA). 740 */ 741 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'); 745 else 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'); 747 748 rio_dprintk(RIO_DEBUG_BOOT, "UniqNum is 0x%x\n", RtaUniq); 749 750 if (RtaUniq == 0x00000000 || RtaUniq == 0xffffffff) { 751 rio_dprintk(RIO_DEBUG_BOOT, "Illegal RTA Uniq Number\n"); 752 return 1; 753 } 754 755 /* 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. 759 */ 760 761 if (!RIOBootOk(p, HostP, RtaUniq)) { 762 MyLink = readb(&PktCmdP->LinkNum); 763 if (Rup < (unsigned short) MAX_RUP) { 764 /* 765 ** RtaUniq was clone booted (by this RTA). Instruct this RTA 766 ** to hold off further attempts to boot on this link for 30 767 ** seconds. 768 */ 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); 771 } 772 } else 773 /* 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. 777 */ 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); 780 return 1; 781 } 782 783 /* 784 ** Check for a SLOT_IN_USE entry for this RTA attached to the 785 ** current host card in the driver table. 786 ** 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 792 ** unit. 793 */ 794 for (entry = 0; entry < MAX_RUP; entry++) { 795 unsigned int sysport; 796 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; 804 /* 805 ** For a 16 port RTA, check the second bank of 8 ports 806 */ 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; 815 } 816 } 817 if (RtaType == TYPE_RTA16) 818 rio_dprintk(RIO_DEBUG_BOOT, "RTA will be given IDs %d+%d\n", entry + 1, entry2 + 1); 819 else 820 rio_dprintk(RIO_DEBUG_BOOT, "RTA will be given ID %d\n", entry + 1); 821 return 1; 822 } 823 } 824 825 rio_dprintk(RIO_DEBUG_BOOT, "RTA not configured for this host\n"); 826 827 if (Rup >= (unsigned short) MAX_RUP) { 828 /* 829 ** It was a host that did the booting 830 */ 831 MyType = "Host"; 832 MyName = HostP->Name; 833 } else { 834 /* 835 ** It was an RTA that did the booting 836 */ 837 MyType = "RTA"; 838 MyName = HostP->Mapping[Rup].Name; 839 } 840 MyLink = readb(&PktCmdP->LinkNum); 841 842 /* 843 ** There is no SLOT_IN_USE entry for this RTA attached to the current 844 ** host card in the driver table. 845 ** 846 ** Check for a SLOT_TENTATIVE entry for this RTA attached to the 847 ** current host card in the driver table. 848 ** 849 ** If we find one, then we re-use that slot. 850 */ 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); 857 else 858 continue; 859 } else 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'); 863 return 1; 864 } 865 } 866 867 /* 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. 870 ** 871 ** Check if there is a SLOT_IN_USE or SLOT_TENTATIVE entry on another 872 ** host for this RTA in the driver table. 873 ** 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: 879 ** 880 ** + Plug 8 port RTA into host A. (This creates SLOT_TENTATIVE entry 881 ** in table) 882 ** + Unplug RTA and plug into host B. (We now have 2 SLOT_TENTATIVE 883 ** entries) 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. 888 */ 889 rio_dprintk(RIO_DEBUG_BOOT, "Have we seen RTA %x before?\n", RtaUniq); 890 found = 0; 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); 900 } else 901 rio_dprintk(RIO_DEBUG_BOOT, "This RTA is unit %d from host %s\n", rta + 1, p->RIOHosts[host].Name); 902 found = 1; 903 break; 904 } 905 } 906 } 907 908 /* 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. 911 ** 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... 914 ** 915 ** Check for a SLOT_IN_USE entry for this RTA in the config table. 916 */ 917 if (!MapP) { 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); 921 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) 928 break; 929 } 930 MapP2 = &p->RIOSavedTable[entry2]; 931 rio_dprintk(RIO_DEBUG_BOOT, "This RTA is from table entries %d+%d\n", rta, entry2); 932 } else 933 rio_dprintk(RIO_DEBUG_BOOT, "This RTA is from table entry %d\n", rta); 934 break; 935 } 936 } 937 } 938 939 /* 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. 942 ** 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. 946 ** 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. 951 */ 952 EmptySlot = 1; 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); 957 EmptySlot = 0; 958 } 959 } else { 960 if (RIOFindFreeID(p, HostP, &entry, NULL) == 0) { 961 RIODefaultName(p, HostP, entry); 962 rio_fill_host_slot(entry, 0, RtaUniq, HostP); 963 EmptySlot = 0; 964 } 965 } 966 967 /* 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. 970 ** 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. 977 */ 978 if (EmptySlot == 0) { 979 if (MapP) { 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); 991 } else { 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; 994 } 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; 999 /* 1000 ** Map second block of ttys for 16 port RTA 1001 */ 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); 1008 } else 1009 HostP->Mapping[entry2].Flags = SLOT_TENTATIVE | RTA_BOOTED | RTA_NEWBOOT | RTA16_SECOND_SLOT; 1010 memset(MapP2, 0, sizeof(struct Map)); 1011 } 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'); 1017 RIOSetChange(p); 1018 return 1; 1019 } 1020 1021 /* 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. 1025 */ 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) { 1030 /* 1031 ** already got it! 1032 */ 1033 return 1; 1034 } 1035 } 1036 /* 1037 ** If there is room, add the unit to the list of extras 1038 */ 1039 if (HostP->NumExtraBooted < MAX_EXTRA_UNITS) 1040 HostP->ExtraUnits[HostP->NumExtraBooted++] = RtaUniq; 1041 return 1; 1042} 1043 1044 1045/* 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. 1053*/ 1054int RIOBootOk(struct rio_info *p, struct Host *HostP, unsigned long RtaUniq) 1055{ 1056 int Entry; 1057 unsigned int HostUniq = HostP->UniqueNum; 1058 1059 /* 1060 ** Search bindings table for RTA or its parent. 1061 ** If it exists, return 0, else 1. 1062 */ 1063 for (Entry = 0; (Entry < MAX_RTA_BINDINGS) && (p->RIOBindTab[Entry] != 0); Entry++) { 1064 if ((p->RIOBindTab[Entry] == HostUniq) || (p->RIOBindTab[Entry] == RtaUniq)) 1065 return 0; 1066 } 1067 return 1; 1068} 1069 1070/* 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. 1073*/ 1074 1075void rio_fill_host_slot(int entry, int entry2, unsigned int rta_uniq, struct Host *host) 1076{ 1077 int link; 1078 1079 rio_dprintk(RIO_DEBUG_BOOT, "rio_fill_host_slot(%d, %d, 0x%x...)\n", entry, entry2, rta_uniq); 1080 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; 1087 if (entry2) { 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; 1096 } 1097 /* 1098 ** Must set these up, so that utilities show 1099 ** topology of 16 port RTAs correctly 1100 */ 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; 1104 if (entry2) { 1105 host->Mapping[entry2].Topology[link].Unit = ROUTE_DISCONNECT; 1106 host->Mapping[entry2].Topology[link].Link = NO_LINK; 1107 } 1108 } 1109} 1110