![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386|
Return to scsi.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386 |
1.1 ! root 1: /* ! 2: * This is the generic SCSI part of the ! 3: * Adaptec AHA154x host adapter driver for the AT. ! 4: */ ! 5: ! 6: #include <sys/debug.h> ! 7: ! 8: #include <sys/coherent.h> ! 9: #include <sys/fdisk.h> ! 10: #include <sys/hdioctl.h> ! 11: #include <sys/sdioctl.h> ! 12: #include <sys/buf.h> ! 13: #include <sys/con.h> ! 14: #include <sys/stat.h> ! 15: #if _I386 ! 16: #include <sys/uproc.h> ! 17: #endif /* _I386 */ ! 18: #include <sys/errno.h> ! 19: #include <sys/scsiwork.h> ! 20: #include <kernel/typed.h> ! 21: #if _I386 ! 22: #include <sys/mmu.h> ! 23: #endif /* _I386 */ ! 24: ! 25: #ifndef _I386 ! 26: extern saddr_t sds; ! 27: #endif /* _I386 */ ! 28: extern short at_drive_ct; ! 29: ! 30: /* ! 31: * Configurable parameters ! 32: */ ! 33: #define DEF_AHA_HDS 64 ! 34: #define DEF_AHA_SPT 32 ! 35: ! 36: #define NDRIVE (8 * 4) /* 8 SCSI ids and 4 LUNs */ ! 37: #define SDMAJOR 13 /* Major Device Number */ ! 38: ! 39: /* ! 40: * Configurable variables - see /etc/conf/aha/Space.c ! 41: */ ! 42: extern int SDIRQ; /* Interrupt */ ! 43: extern int SDBASE; /* Port base */ ! 44: extern int SDDMA; /* Used for first party DMA */ ! 45: ! 46: extern int AHA_SD_HDS; ! 47: extern int AHA_SD_SPT; ! 48: ! 49: /* ! 50: * LUN --------++ ! 51: * device macros Special-+ || ! 52: * minor device bits are of the form: 76543210 ! 53: * ||| || ! 54: * SCSI ID--+++ || ! 55: * Partition ----++ ! 56: * Partition mapping: ! 57: * ! 58: * Description Special Bit Partition # Device Type ! 59: * ----------- ----------- ----------- ------ ---- ! 60: * partition a 0 00 /dev/sd??a disk ! 61: * partition b 0 01 /dev/sd??b disk ! 62: * partition c 0 10 /dev/sd??c disk ! 63: * partition d 0 11 /dev/sd??d disk ! 64: * partition table 1 00 /dev/sd??x disk ! 65: * no rewind tape 1 01 /dev/sd??n tape ! 66: * UNALLOCATED 1 10 --- ???? ! 67: * rewind tape device 1 11 /dev/sd?? tape ! 68: */ ! 69: #define DRIVENO(minor) (((minor) >> 2) & 0x1F) /* SCSI ID + LUN */ ! 70: #define SCSIID(minor) (((minor) >> 4) & 0x7) /* SCSI ID */ ! 71: #define LUN(minor) (((minor) >> 2) & 0x3) /* Logical Unit Number */ ! 72: #define PARTITION(minor) ((minor) & 0x3) /* Partition */ ! 73: #define sdmkdev(maj, s, drv) makedev((maj), ((s)|((drv)<<2))) ! 74: ! 75: /* ! 76: * Driver configuration. ! 77: */ ! 78: void sdload(); ! 79: void sdunload(); ! 80: void sdopen(); ! 81: void sdclose(); ! 82: void sdread(); ! 83: void sdwrite(); ! 84: int sdioctl(); ! 85: void sdblock(); ! 86: int sdwatch(); ! 87: int nulldev(); ! 88: int nonedev(); ! 89: ! 90: CON sdcon = { ! 91: DFBLK|DFCHR, /* Flags */ ! 92: SDMAJOR, /* Major index */ ! 93: sdopen, /* Open */ ! 94: sdclose, /* Close */ ! 95: sdblock, /* Block */ ! 96: sdread, /* Read */ ! 97: sdwrite, /* Write */ ! 98: sdioctl, /* Ioctl */ ! 99: nulldev, /* Powerfail */ ! 100: sdwatch, /* Timeout */ ! 101: sdload, /* Load */ ! 102: sdunload /* Unload */ ! 103: }; ! 104: ! 105: /* ! 106: * host adapter routines ! 107: */ ! 108: int aha_load(); /* initialize host adapter, DMA */ ! 109: void aha_unload(); /* shutdown the host adapter */ ! 110: int aha_start(); /* see if there's work */ ! 111: int aha_command(); ! 112: ! 113: /* ! 114: * Partition Parameters - copied from disk. ! 115: * ! 116: * There are NPARTN positions for the user partitions in array PPARM, ! 117: * plus 1 additional position to span the entire drive. ! 118: * Array pparmp[] contains a pointer to a kalloc()'ed PPARM ! 119: * entry if the drive actually exists, is a disk drive and if someone ! 120: * has attmpted to read a partition table from the drive. ! 121: */ ! 122: typedef struct fdisk_s PPARM[NPARTN + 1]; /* 4 partitions + whole drive */ ! 123: static PPARM *pparmp[NDRIVE]; /* one per possible drive */ ! 124: #define WHOLE_DRIVE NPARTN /* index for whole drive */ ! 125: #define PNULL ((PPARM *)0) ! 126: ! 127: /* ! 128: * Per disk controller data. ! 129: * Only one host adapter; no more, no less. ! 130: */ ! 131: static ! 132: scsi_work_t sd; ! 133: ! 134: static BUF dbuf; /* For raw I/O */ ! 135: static int sw_active; ! 136: ! 137: /** ! 138: * ! 139: * void ! 140: * sdload() - load routine. ! 141: * ! 142: * Action: The controller is reset and the interrupt vector is grabbed. ! 143: * The drive characteristics are set up at this time. ! 144: */ ! 145: static void ! 146: sdload() ! 147: { ! 148: FIFO *ffp; ! 149: typed_space *tp; ! 150: extern typed_space boot_gift; ! 151: ! 152: /* ! 153: * Initialize Drive Controller. ! 154: */ ! 155: sw_active = 0; ! 156: if (aha_load(SDDMA, SDIRQ, SDBASE, &sd) < 0) { ! 157: SET_U_ERROR(ENXIO, "aha_load() failed."); ! 158: return; ! 159: } ! 160: ! 161: /* ! 162: * Set values for # of heads and # of sectors per track. ! 163: * ! 164: * AHA translation mode uses the same # of heads ! 165: * and the same # of sectors per track for all drives. ! 166: * ! 167: * If these values are already patched, leave them alone. ! 168: * Otherwise, look in the data area written by tboot. ! 169: * If nothing from tboot, use default values. ! 170: */ ! 171: if (AHA_SD_HDS == 0 || AHA_SD_SPT == 0) { ! 172: /* heads & spt not both patched */ ! 173: AHA_SD_HDS = DEF_AHA_HDS; ! 174: AHA_SD_SPT = DEF_AHA_SPT; ! 175: if (F_NULL != (ffp = fifo_open(&boot_gift, 0))) { ! 176: if (tp = fifo_read(ffp)) { ! 177: BIOS_DISK *bdp = (BIOS_DISK *)tp->ts_data; ! 178: if ((T_BIOS_DISK == tp->ts_type) && ! 179: (at_drive_ct == bdp->dp_drive) ) { ! 180: /* got values from tboot */ ! 181: AHA_SD_HDS = bdp->dp_heads; ! 182: AHA_SD_SPT = bdp->dp_sectors; ! 183: } ! 184: } ! 185: fifo_close(ffp); ! 186: } ! 187: } ! 188: printf(" AHA_SD_HDS=%d AHA_SD_SPT=%d\n", AHA_SD_HDS, AHA_SD_SPT); ! 189: ! 190: /* aha_device_info(); */ /* enable after this gets fixed */ ! 191: } ! 192: ! 193: /** ! 194: * ! 195: * void ! 196: * sdunload() - unload routine. ! 197: */ ! 198: static void ! 199: sdunload() ! 200: { ! 201: register int i; ! 202: ! 203: if (sw_active > 0) ! 204: printf("aha154x: sdunload() athough %d active\n", sw_active); ! 205: aha_unload(SDIRQ); ! 206: for (i = 0; i < NDRIVE; ++i) ! 207: if (pparmp[i] != PNULL) ! 208: kfree(pparmp[i]); /* free any partition tables */ ! 209: } ! 210: ! 211: /* ! 212: * int ! 213: * sdgetpartitions(dev) - load partition table for specified drive ! 214: * ! 215: * - return 1 on success and 0 on failure ! 216: */ ! 217: int sdgetpartitions(dev) ! 218: dev_t dev; ! 219: { ! 220: register int i; ! 221: scsi_cmd_t sc; ! 222: unsigned char *buffer; ! 223: struct fdisk_s *fdp; ! 224: int d = DRIVENO(minor(dev)); ! 225: ! 226: pparmp[d] = kalloc(sizeof *pparmp[0]); ! 227: fdp = (struct fdisk_s *) pparmp[d]; /* point to first entry */ ! 228: #ifdef _I386 ! 229: buffer = palloc(36+1); ! 230: #else /* _I386 */ ! 231: buffer = kalloc(36+1); ! 232: #endif /* _I386 */ ! 233: ! 234: if (buffer == NULL || pparmp[d] == PNULL) { ! 235: printf("aha154x: out of kernel memory\n"); ! 236: #ifdef _I386 ! 237: SET_U_ERROR(ENOMEM, "aha154x: out of kernel memory"); ! 238: #else /* _I386 */ ! 239: u.u_error = EKSPACE; ! 240: #endif /* _I386 */ ! 241: return 0; ! 242: } ! 243: kclear(pparmp[d], sizeof *pparmp[0]); ! 244: sc.unit = d; ! 245: sc.block = 0L; ! 246: sc.blklen = 0; ! 247: ! 248: #ifdef _I386 ! 249: /* sc.buffer is a virtual-physical address (Ciaran Space.) */ ! 250: sc.buffer = vtovp(buffer); ! 251: #else /* _I386 */ ! 252: sc.buffer = VTOP2(buffer, sds); ! 253: #endif /* _I386 */ ! 254: ++drvl[SDMAJOR].d_time; ! 255: ! 256: sc.cmd = ScmdREADCAPACITY; ! 257: sc.buflen = 8; ! 258: ! 259: for(i = 0; i < sc.buflen; ++i) ! 260: buffer[i] = 0; ! 261: ! 262: /* ! 263: * If we call aha_command() only once we get a capacity of ! 264: * 0. All ScmdREADCAPACITY calls after the first return a ! 265: * correct answer. ! 266: * ! 267: * This may be a bug in the aha154x. ! 268: */ ! 269: aha_command(&sc); ! 270: aha_command(&sc); ! 271: ! 272: T_PIGGY( 0x20000, { ! 273: printf("buffer ="); ! 274: for(i = 0; i < sc.buflen; ++i) ! 275: printf(" %x", buffer[i]); ! 276: printf("\n"); ! 277: }); ! 278: ! 279: sc.block = (buffer[0]<<8) | buffer[1]; ! 280: sc.block <<= 16; ! 281: sc.block |= (buffer[2]<<8) | buffer[3]; ! 282: ! 283: sc.blklen = (buffer[6]<<8) | buffer[7]; ! 284: ! 285: T_PIGGY( 0x20000, { ! 286: printf("SCSI %ld. blocks of size %d\n", sc.block, sc.blklen); ! 287: } ); ! 288: ! 289: #ifdef _I386 ! 290: pfree(buffer); ! 291: #else /* _I386 */ ! 292: kfree(buffer); ! 293: #endif /* _I386 */ ! 294: fdp[WHOLE_DRIVE].p_size = sc.block; ! 295: if (0 == fdp[WHOLE_DRIVE].p_size) { ! 296: /* ! 297: * If we are just opening this drive, make it so we can ! 298: * read the first block without an error. ! 299: */ ! 300: fdp[WHOLE_DRIVE].p_size = 1; ! 301: } ! 302: ! 303: --drvl[SDMAJOR].d_time; ! 304: return fdisk(sdmkdev(major(dev), SDEV, d), pparmp[d]); ! 305: } ! 306: ! 307: /** ! 308: * ! 309: * void ! 310: * sdopen(dev, mode) ! 311: * dev_t dev; ! 312: * int mode; ! 313: * ! 314: * Input: dev = disk device to be opened. ! 315: * mode = access mode [IPR,IPW, IPR+IPW]. ! 316: * ! 317: * Action: Validate the minor device. ! 318: * Update the paritition table if necessary. ! 319: */ ! 320: static void ! 321: sdopen(dev, mode) ! 322: register dev_t dev; ! 323: { ! 324: register int p; /* partition */ ! 325: register int d; /* drive (SCSI ID + LUN) */ ! 326: struct fdisk_s *fdp; /* one partition entry */ ! 327: ! 328: if (minor(dev) & SDEV) { ! 329: if (PARTITION(minor(dev)) != 0) { /* tape device ? */ ! 330: /* not yet! */ ! 331: SET_U_ERROR(ENXIO, "No tape yet"); ! 332: devmsg(dev, "No tape yet"); ! 333: } else { ! 334: ++drvl[SDMAJOR].d_time; ! 335: ++sw_active; ! 336: } ! 337: return; ! 338: } ! 339: ! 340: d = DRIVENO(minor(dev)); ! 341: p = PARTITION(minor(dev)); ! 342: ! 343: /* ! 344: * If partition not defined read partition characteristics. ! 345: */ ! 346: if (pparmp[d] == PNULL) /* no entry yet for this drive ? */ ! 347: if (!sdgetpartitions(dev)) { ! 348: SET_U_ERROR(ENXIO, "sdgetpartitions() failed."); ! 349: return; ! 350: } ! 351: /* ! 352: * Ensure partition lies within drive boundaries and is non-zero size. ! 353: */ ! 354: fdp = (struct fdisk_s *) pparmp[d]; ! 355: if ((fdp[p].p_base+fdp[p].p_size) > fdp[WHOLE_DRIVE].p_size) { ! 356: #ifdef _I386 ! 357: SET_U_ERROR(EINVAL, "Partition exceeds drive size."); ! 358: #else /* _I386 */ ! 359: u.u_error = EBADFMT; ! 360: #endif /* _I386 */ ! 361: } else if (fdp[p].p_size == 0) { ! 362: SET_U_ERROR(ENODEV, "No such partition."); ! 363: } else { ! 364: ++drvl[SDMAJOR].d_time; ! 365: ++sw_active; ! 366: } ! 367: } ! 368: ! 369: void sdclose(dev) ! 370: { ! 371: --drvl[SDMAJOR].d_time; ! 372: --sw_active; ! 373: } ! 374: ! 375: /** ! 376: * ! 377: * void ! 378: * sdread(dev, iop) - write a block to the raw disk ! 379: * dev_t dev; ! 380: * IO * iop; ! 381: * ! 382: * Input: dev = disk device to be written to. ! 383: * iop = pointer to source I/O structure. ! 384: * ! 385: * Action: Invoke the common raw I/O processing code. ! 386: */ ! 387: static void ! 388: sdread(dev, iop) ! 389: dev_t dev; ! 390: IO *iop; ! 391: { ! 392: ioreq(&dbuf, iop, dev, BREAD, BFRAW|BFBLK|BFIOC); ! 393: } ! 394: ! 395: /** ! 396: * ! 397: * void ! 398: * sdwrite(dev, iop) - write a block to the raw disk ! 399: * dev_t dev; ! 400: * IO * iop; ! 401: * ! 402: * Input: dev = disk device to be written to. ! 403: * iop = pointer to source I/O structure. ! 404: * ! 405: * Action: Invoke the common raw I/O processing code. ! 406: */ ! 407: static void ! 408: sdwrite(dev, iop) ! 409: dev_t dev; ! 410: IO *iop; ! 411: { ! 412: ioreq(&dbuf, iop, dev, BWRITE, BFRAW|BFBLK|BFIOC); ! 413: } ! 414: ! 415: /** ! 416: * ! 417: * int ! 418: * sdioctl(dev, cmd, arg) ! 419: * dev_t dev; ! 420: * int cmd; ! 421: * char * vec; ! 422: * ! 423: * Input: dev = disk device to be operated on. ! 424: * cmd = input/output request to be performed. ! 425: * vec = (pointer to) optional argument. ! 426: * ! 427: * Action: Validate the minor device. ! 428: * Update the paritition table if necessary. ! 429: */ ! 430: static int ! 431: sdioctl(dev, cmd, vec) ! 432: register dev_t dev; ! 433: int cmd; ! 434: char * vec; ! 435: { ! 436: int i; /* Integer for abusing. */ ! 437: int d; /* Drive number. */ ! 438: hdparm_t hdparm; ! 439: struct fdisk_s *fdp; ! 440: int do_getpt = 0; /* 1 if need to call sdgetpartitions() */ ! 441: ! 442: d = DRIVENO(minor(dev)); ! 443: ! 444: /* ! 445: * Identify input/output request. ! 446: */ ! 447: switch (cmd) { ! 448: ! 449: case HDGETA: ! 450: /* ! 451: * If haven't loaded partition table yet for this drive, ! 452: * try to do it now. Note sdgetpartitions() will fail ! 453: * if there is a new drive (e.g. no signature). But all ! 454: * we need is allocation of pparmp[d] and capacity read ! 455: * properly from the drive. ! 456: */ ! 457: if (pparmp[d] == PNULL) { ! 458: do_getpt = 1; /* REALLY just want Read Capacity */ ! 459: ! 460: i = sdgetpartitions(dev); ! 461: ! 462: if (pparmp[d] == NULL) { ! 463: SET_U_ERROR(ENXIO, "sdgetparitions() failed."); ! 464: return -1; ! 465: } ! 466: } ! 467: fdp = (struct fdisk_s *) pparmp[d]; ! 468: *(short *)&hdparm.landc[0] = ! 469: *(short *)&hdparm.ncyl[0] = fdp[WHOLE_DRIVE].p_size ! 470: / (AHA_SD_HDS * AHA_SD_SPT); ! 471: hdparm.nhead = AHA_SD_HDS; ! 472: hdparm.nspt = AHA_SD_SPT; ! 473: kucopy(&hdparm, vec, sizeof hdparm); ! 474: /* ! 475: * I know it's ugly. But it gets around startup Catch-22. ! 476: * ! 477: * The fdisk command needs HDGETA. HDGETA invokes ! 478: * sdgetpartitions(), but we want to call it again ! 479: * after the partition table has been created by the fdisk ! 480: * command. ! 481: */ ! 482: if (do_getpt) { ! 483: kfree(pparmp[d]); ! 484: pparmp[d] = PNULL; /* force re-read of p. table */ ! 485: } ! 486: return 0; ! 487: case HDSETA: ! 488: /* ! 489: * Set hard disk attributes. ! 490: */ ! 491: fdp = (struct fdisk_s *) pparmp[d]; ! 492: ukcopy(vec, &hdparm, sizeof hdparm); ! 493: AHA_SD_HDS = hdparm.nhead; ! 494: AHA_SD_SPT = hdparm.nspt; ! 495: fdp[WHOLE_DRIVE].p_size = ! 496: (long)(*(short *)&hdparm.ncyl[0]) ! 497: * (long)AHA_SD_HDS * (long)AHA_SD_SPT; ! 498: ! 499: return 0; ! 500: case SCSI_HA_CMD: ! 501: return aha_ioctl(cmd, vec); ! 502: case SCSI_CMD: ! 503: return 0; ! 504: case SCSI_CMD_IN: ! 505: return 0; ! 506: case SCSI_CMD_OUT: ! 507: return 0; ! 508: ! 509: default: ! 510: SET_U_ERROR( EINVAL, "Illegal SCSI ioctl command." ); ! 511: return -1; ! 512: } ! 513: } ! 514: ! 515: /** ! 516: * ! 517: * void ! 518: * sdblock(bp) - queue a block to the disk ! 519: * ! 520: * Input: bp = pointer to block to be queued. ! 521: * ! 522: * Action: Queue a block to the disk. ! 523: * Make sure that the transfer is within the disk partition. ! 524: */ ! 525: static void ! 526: sdblock(bp) ! 527: register BUF *bp; ! 528: { ! 529: register scsi_work_t *sw; ! 530: register int s; ! 531: struct fdisk_s *fdp; ! 532: ! 533: int p = PARTITION(minor(bp->b_dev)); ! 534: int drv = DRIVENO(minor(bp->b_dev)); ! 535: ! 536: if (minor(bp->b_dev) & SDEV) ! 537: p = WHOLE_DRIVE; ! 538: bp->b_resid = bp->b_count; ! 539: ! 540: fdp = (struct fdisk_s *) pparmp[drv]; ! 541: ! 542: /* ! 543: * Range check disk region. ! 544: */ ! 545: if (pparmp[drv] == PNULL) { ! 546: if (p == WHOLE_DRIVE) { ! 547: #if 0 ! 548: /* Why did we only allow people to access the first block of WHOLE_DRIVE? ! 549: in cases where there was not a valid partition table? */ ! 550: if ((bp->b_bno != 0) || (bp->b_count != BSIZE)) { ! 551: bp->b_flag |= BFERR; ! 552: bdone(bp); ! 553: return; ! 554: } ! 555: #endif ! 556: } else { ! 557: printf("aha154x: no partition table\n"); ! 558: bp->b_flag |= BFERR; ! 559: bdone(bp); ! 560: return; ! 561: } ! 562: } else if ((bp->b_bno + (bp->b_count/BSIZE)) > fdp[p].p_size) { ! 563: ! 564: T_PIGGY( 0x20000 , { ! 565: printf("\n(bp->b_bno: %x + (bp->b_count: %x /BSIZE): %x): %x > ", ! 566: bp->b_bno, bp->b_count, (bp->b_count/BSIZE), ! 567: (bp->b_bno + (bp->b_count/BSIZE))); ! 568: printf(" fdp[p].p_size: %x\n", fdp[p].p_size); ! 569: } ); ! 570: ! 571: bp->b_flag |= BFERR; ! 572: bdone(bp); ! 573: return; ! 574: } ! 575: ! 576: bp->b_actf = NULL; ! 577: #ifdef _I386 ! 578: sw = (scsi_work_t *)palloc(sizeof(*sw)); ! 579: T_PIGGY(0x100000, printf("sw(%x)", sw); ); ! 580: #else /* _I386 */ ! 581: sw = (scsi_work_t *)kalloc(sizeof(*sw)); ! 582: #endif /* _I386 */ ! 583: if (sw == (scsi_work_t *)0) { ! 584: printf("aha154x: out of kernel memory\n"); ! 585: bp->b_flag |= BFERR; ! 586: bdone(bp); ! 587: return; ! 588: } ! 589: sw->sw_bp = bp; ! 590: sw->sw_drv = drv; ! 591: sw->sw_type = 0; ! 592: if (p != WHOLE_DRIVE) ! 593: sw->sw_bno = fdp[p].p_base + bp->b_bno; ! 594: else ! 595: sw->sw_bno = bp->b_bno; ! 596: sw->sw_retry = 1; ! 597: ! 598: T_PIGGY( 0x20000, ! 599: printf("sdblock: drv %x bno %lx bp=%x, flag = %x\n", ! 600: drv, (long) sw->sw_bno, bp, bp->b_flag); ! 601: ); ! 602: ! 603: /* ! 604: * NIGEL: These fields were never filled in before, now that kalloc () ! 605: * does as it is supposed to we have to do it properly. ! 606: */ ! 607: ! 608: sw->sw_actl = sw->sw_actf = NULL; ! 609: ! 610: s = sphi(); ! 611: if (sd.sw_actf == NULL) { ! 612: ASSERT (sd.sw_actl == NULL); ! 613: sd.sw_actf = sw; ! 614: } else { ! 615: ASSERT (sd.sw_actl != NULL); ! 616: sd.sw_actl->sw_actf = sw; ! 617: } ! 618: sd.sw_actl = sw; ! 619: spl(s); ! 620: ! 621: #ifdef TRACER ! 622: begin_count (0); ! 623: #endif ! 624: aha_start(); ! 625: } ! 626: ! 627: sdwatch() ! 628: { ! 629: register int i; ! 630: ! 631: if (0 != (i = aha_start())) { ! 632: T_PIGGY( 0x20000, printf("sdwatch: started %d actions\n", i); ); ! 633: } ! 634: ! 635: if ( 0!= (i = aha_completed())) { ! 636: T_PIGGY( 0x20000, printf("sdwatch: completed %d actions\n", i); ); ! 637: } ! 638: ! 639: T_PIGGY (0x20000, aha_mbox_status ()); ! 640: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.