![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to at.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv|
Return to at.c CVS log | Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv |
1.1 ! root 1: /* (-lgl ! 2: * COHERENT Driver Kit Version 1.1.0 ! 3: * Copyright (c) 1982, 1990 by Mark Williams Company. ! 4: * All rights reserved. May not be copied without permission. ! 5: * ! 6: * $Log: at.c,v $ ! 7: * Revision 1.11 91/11/12 07:48:34 bin ! 8: * 3204 kernel source for use with piggy's tboot code ! 9: * ! 10: * Revision 1.10 91/11/11 12:29:03 hal ! 11: * Use n_atdr. ! 12: * ! 13: * Revision 1.9 91/10/30 10:47:46 hal ! 14: * Get atparms from tboot. ! 15: * ! 16: * Revision 1.8 91/10/24 12:36:25 hal ! 17: * Bump ATSECS from 4 to 6. ! 18: * Poll HF_REG (3F6) rather than CSR_REG (1F6). ! 19: * COH 3.2.03. ! 20: * ! 21: * Revision 1.7 91/09/11 14:45:38 hal ! 22: * Trial patch for Seagate 157A problems. ! 23: * ! 24: * Revision 1.6 91/09/11 13:23:12 hal ! 25: * Explicit sys in include paths. AT_MAJOR. ! 26: * ! 27: * Revision 1.5 91/05/22 15:06:59 hal ! 28: * Don't force 8's bit of control byte. ! 29: * ! 30: * Revision 1.4 91/03/14 14:22:32 hal ! 31: * ! 32: -lgl) */ ! 33: /* ! 34: * This is a driver for the ! 35: * hard disk on the AT. ! 36: * ! 37: * Reads drive characteristics from ROM (thru interrupt vector 0x41 and 0x46). ! 38: * Reads partition information from disk. ! 39: */ ! 40: #include <sys/coherent.h> ! 41: #include <sys/fdisk.h> ! 42: #include <sys/hdioctl.h> ! 43: #include <sys/buf.h> ! 44: #include <sys/con.h> ! 45: #include <sys/devices.h> ! 46: #include <sys/stat.h> ! 47: #include <sys/uproc.h> ! 48: #include <sys/typed.h> ! 49: #include <errno.h> ! 50: ! 51: extern saddr_t sds; /* System Data Selector */ ! 52: extern short n_atdr; /* Number of "at" drives */ ! 53: ! 54: /* ! 55: * Configurable parameters ! 56: */ ! 57: #define HDIRQ 14 /* Level 14 */ ! 58: #define HDBASE 0x01F0 /* Port base */ ! 59: #define NDRIVE 2 /* only two drives supported */ ! 60: #define SOFTLIM 6 /* (7) num of retrys before diag */ ! 61: #define HARDLIM 8 /* number of retrys before fail */ ! 62: #define BADLIM 100 /* num to stop recov if flagged bad */ ! 63: ! 64: #define BIT(n) (1 << (n)) ! 65: ! 66: #define CMOSA 0x70 /* write cmos address to this port */ ! 67: #define CMOSD 0x71 /* read cmos data through this port */ ! 68: ! 69: #ifndef ATCACHE ! 70: # if VERBOSE > 0 ! 71: # define ATCACHE 2 /* local cache size in blocks */ ! 72: # else ! 73: # define ATCACHE 0 /* no cache for small code */ ! 74: # endif ! 75: #endif ! 76: ! 77: /* ! 78: * Driver configuration. ! 79: */ ! 80: void atload(); ! 81: void atunload(); ! 82: void atopen(); ! 83: void atread(); ! 84: void atwrite(); ! 85: int atioctl(); ! 86: void atwatch(); ! 87: void atblock(); ! 88: int nulldev(); ! 89: int nonedev(); ! 90: ! 91: CON atcon = { ! 92: DFBLK|DFCHR, /* Flags */ ! 93: AT_MAJOR, /* Major index */ ! 94: atopen, /* Open */ ! 95: nulldev, /* Close */ ! 96: atblock, /* Block */ ! 97: atread, /* Read */ ! 98: atwrite, /* Write */ ! 99: atioctl, /* Ioctl */ ! 100: nulldev, /* Powerfail */ ! 101: atwatch, /* Timeout */ ! 102: atload, /* Load */ ! 103: atunload /* Unload */ ! 104: }; ! 105: ! 106: /* ! 107: * Forward Referenced Functions. ! 108: */ ! 109: void atreset(); ! 110: int atdequeue(); ! 111: void atstart(); ! 112: void atintr(); ! 113: void atdefer(); ! 114: int aterror(); ! 115: void atrecov(); ! 116: void atdone(); ! 117: ! 118: /* ! 119: * I/O Port Addresses ! 120: */ ! 121: #define DATA_REG (HDBASE+0) /* data (r/w) */ ! 122: #define AUX_REG (HDBASE+1) /* error(r), write precomp cyl/4 (w) */ ! 123: #define NSEC_REG (HDBASE+2) /* sector count (r/w) */ ! 124: #define SEC_REG (HDBASE+3) /* sector number (r/w) */ ! 125: #define LCYL_REG (HDBASE+4) /* low cylinder (r/w) */ ! 126: #define HCYL_REG (HDBASE+5) /* high cylinder (r/w) */ ! 127: #define HDRV_REG (HDBASE+6) /* drive/head (r/w) (D<<4)+(1<<H) */ ! 128: #define CSR_REG (HDBASE+7) /* status (r), command (w) */ ! 129: #define HF_REG (HDBASE+0x206) /* secondary status(r)/control byte(w)*/ ! 130: ! 131: /* ! 132: * Error from AUX_REG (r) ! 133: */ ! 134: #define DAM_ERR BIT(0) /* data address mark not found */ ! 135: #define TR0_ERR BIT(1) /* track 000 not found */ ! 136: #define ABT_ERR BIT(2) /* aborted command */ ! 137: #define ID_ERR BIT(4) /* id not found */ ! 138: #define ECC_ERR BIT(6) /* data ecc error */ ! 139: #define BAD_ERR BIT(7) /* bad block detect */ ! 140: ! 141: /* ! 142: * Status from CSR_REG (r) ! 143: */ ! 144: #define ERR_ST BIT(0) /* error occurred */ ! 145: #define INDEX_ST BIT(1) /* index pulse */ ! 146: #define SOFT_ST BIT(2) /* soft (corrected) ECC error */ ! 147: #define DRQ_ST BIT(3) /* data request */ ! 148: #define SKC_ST BIT(4) /* seek complete */ ! 149: #define WFLT_ST BIT(5) /* improper drive operation */ ! 150: #define RDY_ST BIT(6) /* drive is ready */ ! 151: #define BSY_ST BIT(7) /* controller is busy */ ! 152: ! 153: ! 154: /* ! 155: * Commands to CSR_REG (w) ! 156: */ ! 157: #define RESTORE(rate) (0x10+(rate)) /* X */ ! 158: #define SEEK(rate) (0x70+(rate)) /* X */ ! 159: #define READ_CMD (0x20) /* X */ ! 160: #define WRITE_CMD (0x30) /* X */ ! 161: #define FORMAT_CMD (0x50) /* X */ ! 162: #define VERIFY_CMD (0x40) /* X */ ! 163: #define DIAGNOSE_CMD (0x90) /* X */ ! 164: #define SETPARM_CMD (0x91) /* X */ ! 165: ! 166: /* ! 167: * Device States. ! 168: */ ! 169: #define SIDLE 0 /* controller idle */ ! 170: #define SRETRY 1 /* seeking */ ! 171: #define SREAD 2 /* reading */ ! 172: #define SWRITE 3 /* writing */ ! 173: ! 174: /* ! 175: * Drive Parameters - copied from ROM. ! 176: * If patched, use the given values instead of reading from the ROM. ! 177: * NOTE: Exactly duplicates hdparm_s struct. ! 178: */ ! 179: struct dparm_s { ! 180: unsigned short d_ncyl; /* number of cylinders */ ! 181: unsigned char d_nhead; /* number of heads */ ! 182: unsigned short d_rwcc; /* reduced write current cyl */ ! 183: unsigned short d_wpcc; /* write pre-compensation cyl */ ! 184: unsigned char d_eccl; /* max ecc data length */ ! 185: unsigned char d_ctrl; /* control byte */ ! 186: unsigned char d_fill2[3]; ! 187: unsigned short d_landc; /* landing zone cylinder */ ! 188: unsigned char d_nspt; /* number of sectors per track */ ! 189: unsigned char d_fill3; ! 190: ! 191: } atparm[ NDRIVE ] = { ! 192: 0 /* Initialized to allow patching */ ! 193: }; ! 194: ! 195: /* ! 196: * Partition Parameters - copied from disk. ! 197: * ! 198: * There are NDRIVE * NPARTN positions for the user partitions, ! 199: * plus NDRIVE additional partitions to span each drive. ! 200: * ! 201: * Aligning partitions on cylinder boundaries: ! 202: * Optimal partition size: 2 * 3 * 4 * 5 * 7 * 17 = 14280 blocks ! 203: * Acceptable partition size: 3 * 4 * 5 * 7 * 17 = 7140 blocks ! 204: */ ! 205: static ! 206: struct fdisk_s pparm[NDRIVE*NPARTN + NDRIVE]; ! 207: ! 208: /* ! 209: * Per disk controller data. ! 210: * Only one controller; no more, no less. ! 211: */ ! 212: static ! 213: struct at { ! 214: BUF *at_actf; /* Link to first */ ! 215: BUF *at_actl; /* Link to last */ ! 216: faddr_t at_faddr; /* Source/Dest virtual address */ ! 217: daddr_t at_bno; /* Block # on disk */ ! 218: unsigned at_nsec; /* # of sectors on current transfer */ ! 219: unsigned at_drv; ! 220: unsigned at_head; ! 221: unsigned at_cyl; ! 222: unsigned at_sec; ! 223: unsigned at_partn; ! 224: unsigned char at_dtype[ NDRIVE ]; /* drive type, 0 if unused */ ! 225: unsigned char at_tries; ! 226: unsigned char at_state; ! 227: unsigned char at_caching; /* caching in progress */ ! 228: #if ATCACHE > 0 ! 229: unsigned char at_cdrv[ ATCACHE ]; /* cached drive */ ! 230: daddr_t at_cbno[ ATCACHE ]; /* cached block number */ ! 231: unsigned char * at_cbuf[ ATCACHE ]; /* cached block */ ! 232: #endif ! 233: unsigned at_bad_drv; ! 234: unsigned at_bad_head; ! 235: unsigned at_bad_cyl; ! 236: } at; ! 237: ! 238: static BUF dbuf; /* For raw I/O */ ! 239: ! 240: /* ! 241: * Patchable variables. ! 242: * ATBSYW is a loop count for busy-waiting after issuing commands. ! 243: * ATSECS is number of seconds to wait for an expected interrupt. ! 244: */ ! 245: int ATBSYW = 50; /* patchable */ ! 246: int ATSECS = 6; /* patchable */ ! 247: static char timeout_msg[] = "at%d: TO\n"; ! 248: ! 249: /** ! 250: * ! 251: * void ! 252: * atload() - load routine. ! 253: * ! 254: * Action: The controller is reset and the interrupt vector is grabbed. ! 255: * The drive characteristics are set up at this time. ! 256: */ ! 257: static void ! 258: atload() ! 259: { ! 260: unsigned int u; ! 261: struct dparm_s * dp; ! 262: struct { unsigned off, seg; } p; ! 263: ! 264: if (n_atdr == 0) ! 265: return; ! 266: ! 267: /* ! 268: * Obtain Drive Types. ! 269: * ! 270: * High nibble of CMOS 0x12 is drive 0's type. ! 271: * Low nibble of CMOS 0x12 is drive 1's type. ! 272: */ ! 273: outb(CMOSA, 0x12); ! 274: /* delay */ ! 275: u = inb(CMOSD); ! 276: at.at_dtype[0] = u >> 4; ! 277: at.at_dtype[1] = u & 15; ! 278: ! 279: ! 280: /* ! 281: * Obtain Drive Characteristics. ! 282: */ ! 283: for (u = 0, dp = &atparm[0]; u < n_atdr; ++dp, ++u) { ! 284: struct dparm_s int_dp; ! 285: ! 286: if (dp->d_ncyl == 0) { ! 287: /* ! 288: * Not patched. ! 289: * ! 290: * If tertiary boot sent us parameters, ! 291: * Use "fifo" routines to fetch them. ! 292: * This only gives us ncyl, nhead, and nspt. ! 293: * Make educated guesses for other parameters: ! 294: * Set landc to ncyl, wpcc to -1. ! 295: * Set ctrl to 0 or 8 depending on head count. ! 296: * ! 297: * Follow INT 0x41/46 to get drive static BIOS drive ! 298: * parameters, if any. ! 299: * ! 300: * If there were no parameters from tertiary boot, ! 301: * or if INT 0x4? nhead and nspt match tboot parms, ! 302: * use "INT" parameters (will give better match on ! 303: * wpcc, landc, and ctrl fields, which tboot can't ! 304: * give us). ! 305: */ ! 306: ! 307: FIFO *ffp; ! 308: typed_space *tp; ! 309: int found, parm_int; ! 310: extern typed_space boot_gift; ! 311: ! 312: if (F_NULL != (ffp = fifo_open(&boot_gift, 0))) { ! 313: ! 314: for (found = 0; ! 315: !found && T_NULL != (tp = fifo_read(ffp)); ! 316: ) { ! 317: BIOS_DISK *bdp = (BIOS_DISK *)tp->ts_data; ! 318: if ((T_BIOS_DISK == tp->ts_type) && ! 319: (u == bdp->dp_drive) ) { ! 320: found = 1; ! 321: dp->d_ncyl = bdp->dp_cylinders; ! 322: dp->d_nhead = bdp->dp_heads; ! 323: dp->d_nspt = bdp->dp_sectors; ! 324: dp->d_wpcc = 0xffff; ! 325: dp->d_landc = dp->d_ncyl; ! 326: if (dp->d_nhead > 8) ! 327: dp->d_ctrl |= 8; ! 328: } ! 329: } ! 330: fifo_close(ffp); ! 331: } ! 332: ! 333: if (u == 0) ! 334: parm_int = 0x41; ! 335: else /* (u == 1) */ ! 336: parm_int = 0x46; ! 337: pkcopy((paddr_t)(parm_int*4), &p, sizeof p); ! 338: pkcopy((paddr_t) (p.seg << 4L) + p.off, ! 339: &int_dp, sizeof(int_dp)); ! 340: if (!found || ! 341: (dp->d_nhead == int_dp.d_nhead ! 342: && dp->d_nspt == int_dp.d_nspt)) { ! 343: *dp = int_dp; ! 344: printf("Using INT 0x%x",parm_int); ! 345: } else ! 346: printf("Using INT 0x13(08)"); ! 347: } else { ! 348: printf("Using patched"); ! 349: /* ! 350: * Avoid incomplete patching. ! 351: */ ! 352: if (at.at_dtype[u] == 0) ! 353: at.at_dtype[u] = 1; ! 354: if (dp->d_nspt == 0) ! 355: dp->d_nspt = 17; ! 356: #if FORCE_CTRL_8 ! 357: if (dp->d_nhead > 8) ! 358: dp->d_ctrl |= 8; ! 359: #endif ! 360: ! 361: } ! 362: #if VERBOSE > 0 ! 363: printf(" drive %d parameters\n", u); ! 364: printf( ! 365: "at%d: ncyl=%d nhead=%d wpcc=%d eccl=%d ctrl=%d landc=%d nspt=%d\n", ! 366: u, ! 367: dp->d_ncyl, ! 368: dp->d_nhead, ! 369: dp->d_wpcc, ! 370: dp->d_eccl, ! 371: dp->d_ctrl, ! 372: dp->d_landc, ! 373: dp->d_nspt); ! 374: #endif ! 375: } ! 376: ! 377: /* ! 378: * Initialize Drive Size. ! 379: */ ! 380: for (u = 0, dp = &atparm[0]; u < n_atdr; ++dp, ++u) { ! 381: ! 382: if (at.at_dtype[u] == 0) ! 383: continue; ! 384: ! 385: pparm[NDRIVE*NPARTN + u].p_size = ! 386: (long) dp->d_ncyl * dp->d_nhead * dp->d_nspt; ! 387: } ! 388: ! 389: /* ! 390: * Initialize Drive Controller. ! 391: */ ! 392: atreset(); ! 393: ! 394: setivec(HDIRQ, atintr); ! 395: ! 396: #if ATCACHE > 0 ! 397: at.at_cdrv[0] = -1; ! 398: at.at_cbuf[0] = kalloc(BSIZE); ! 399: #endif ! 400: ! 401: #if ATCACHE > 1 ! 402: at.at_cdrv[1] = -1; ! 403: at.at_cbuf[1] = kalloc(BSIZE); ! 404: #endif ! 405: ! 406: at.at_bad_drv = -1; ! 407: } ! 408: ! 409: /** ! 410: * ! 411: * void ! 412: * atunload() - unload routine. ! 413: */ ! 414: static void ! 415: atunload() ! 416: { ! 417: clrivec(HDIRQ); ! 418: } ! 419: ! 420: /** ! 421: * ! 422: * void ! 423: * atreset() -- reset hard disk controller, define drive characteristics. ! 424: */ ! 425: static void ! 426: atreset() ! 427: { ! 428: register int u; ! 429: register struct dparm_s * dp; ! 430: ! 431: /* ! 432: * Reset controller for a minimum of 4.8 microseconds. ! 433: */ ! 434: outb(HF_REG, 4); ! 435: for (u = 100; --u != 0;) ! 436: ; ! 437: outb(HF_REG, atparm[0].d_ctrl & 0x0F); ! 438: myatbsyw(0); ! 439: if (inb(AUX_REG) != 0x01) ! 440: printf("at: AT disk controller not present (reset)\n"); ! 441: ! 442: /* ! 443: * Initialize drive parameters. ! 444: */ ! 445: for (u = 0, dp = &atparm[0]; u < n_atdr; ++dp, ++u) { ! 446: ! 447: if (at.at_dtype[u] == 0) ! 448: continue; ! 449: ! 450: myatbsyw(u); ! 451: ! 452: /* ! 453: * Set drive characteristics. ! 454: * 0x1F1 - AUX_REG ! 455: * 0x1F2 - NSEC_REG ! 456: * 0x1F3 - SEC_REG ! 457: * 0x1F4 - LCYL_REG ! 458: * 0x1F5 - HCYL_REG ! 459: * 0x1F6 - HDRV_REG ! 460: * 0x1F7 - CSR_REG ! 461: */ ! 462: outb(HF_REG, dp->d_ctrl); ! 463: outb(AUX_REG, dp->d_wpcc / 4); ! 464: outb(NSEC_REG, dp->d_nspt); ! 465: outb(SEC_REG, 0x01); ! 466: outb(LCYL_REG, (char)(dp->d_ncyl)); ! 467: outb(HCYL_REG, (char)(dp->d_ncyl >> 8)); ! 468: outb(HDRV_REG, 0xA0 + (u<<4) + dp->d_nhead - 1); ! 469: outb(CSR_REG, SETPARM_CMD); ! 470: myatbsyw(u); ! 471: ! 472: /* ! 473: * Restore heads. ! 474: */ ! 475: outb(CSR_REG, RESTORE(0)); ! 476: myatbsyw(u); ! 477: } ! 478: } ! 479: ! 480: /** ! 481: * ! 482: * void ! 483: * atopen(dev, mode) ! 484: * dev_t dev; ! 485: * int mode; ! 486: * ! 487: * Input: dev = disk device to be opened. ! 488: * mode = access mode [IPR,IPW, IPR+IPW]. ! 489: * ! 490: * Action: Validate the minor device. ! 491: * Update the paritition table if necessary. ! 492: */ ! 493: static void ! 494: atopen(dev, mode) ! 495: register dev_t dev; ! 496: { ! 497: register int d; /* drive */ ! 498: register int p; /* partition */ ! 499: ! 500: p = minor(dev) % (NDRIVE*NPARTN); ! 501: ! 502: if (minor(dev) & SDEV) { ! 503: d = minor(dev) % NDRIVE; ! 504: p += NDRIVE * NPARTN; ! 505: } ! 506: else ! 507: d = minor(dev) / NPARTN; ! 508: ! 509: if ((d >= NDRIVE) || (at.at_dtype[d] == 0)) { ! 510: u.u_error = ENXIO; ! 511: return; ! 512: } ! 513: ! 514: if (minor(dev) & SDEV) ! 515: return; ! 516: ! 517: /* ! 518: * If partition not defined read partition characteristics. ! 519: */ ! 520: if (pparm[p].p_size == 0) ! 521: fdisk(makedev(major(dev), SDEV + d), &pparm[ d * NPARTN ]); ! 522: ! 523: /* ! 524: * Ensure partition lies within drive boundaries and is non-zero size. ! 525: */ ! 526: if ((pparm[p].p_base+pparm[p].p_size) > pparm[d+NDRIVE*NPARTN].p_size) ! 527: u.u_error = EBADFMT; ! 528: else if (pparm[p].p_size == 0) ! 529: u.u_error = ENODEV; ! 530: } ! 531: ! 532: /** ! 533: * ! 534: * void ! 535: * atread(dev, iop) - write a block to the raw disk ! 536: * dev_t dev; ! 537: * IO * iop; ! 538: * ! 539: * Input: dev = disk device to be written to. ! 540: * iop = pointer to source I/O structure. ! 541: * ! 542: * Action: Invoke the common raw I/O processing code. ! 543: */ ! 544: static void ! 545: atread(dev, iop) ! 546: dev_t dev; ! 547: IO *iop; ! 548: { ! 549: ioreq(&dbuf, iop, dev, BREAD, BFRAW|BFBLK|BFIOC); ! 550: } ! 551: ! 552: /** ! 553: * ! 554: * void ! 555: * atwrite(dev, iop) - write a block to the raw disk ! 556: * dev_t dev; ! 557: * IO * iop; ! 558: * ! 559: * Input: dev = disk device to be written to. ! 560: * iop = pointer to source I/O structure. ! 561: * ! 562: * Action: Invoke the common raw I/O processing code. ! 563: */ ! 564: static void ! 565: atwrite(dev, iop) ! 566: dev_t dev; ! 567: IO *iop; ! 568: { ! 569: ioreq(&dbuf, iop, dev, BWRITE, BFRAW|BFBLK|BFIOC); ! 570: } ! 571: ! 572: /** ! 573: * ! 574: * int ! 575: * atioctl(dev, cmd, arg) ! 576: * dev_t dev; ! 577: * int cmd; ! 578: * char * vec; ! 579: * ! 580: * Input: dev = disk device to be operated on. ! 581: * cmd = input/output request to be performed. ! 582: * vec = (pointer to) optional argument. ! 583: * ! 584: * Action: Validate the minor device. ! 585: * Update the paritition table if necessary. ! 586: */ ! 587: static int ! 588: atioctl(dev, cmd, vec) ! 589: register dev_t dev; ! 590: int cmd; ! 591: char * vec; ! 592: { ! 593: int d; ! 594: ! 595: /* ! 596: * Identify drive number. ! 597: */ ! 598: if (minor(dev) & SDEV) ! 599: d = minor(dev) % NDRIVE; ! 600: else ! 601: d = minor(dev) / NPARTN; ! 602: ! 603: /* ! 604: * Identify input/output request. ! 605: */ ! 606: switch (cmd) { ! 607: ! 608: case HDGETA: ! 609: /* ! 610: * Get hard disk attributes. ! 611: */ ! 612: kucopy(&atparm[d], vec, sizeof(atparm[0])); ! 613: return(0); ! 614: ! 615: case HDSETA: ! 616: /* Set hard disk attributes. */ ! 617: ukcopy(vec, &atparm[d], sizeof(atparm[0])); ! 618: at.at_dtype[d] = 1; /* set drive type nonzero */ ! 619: pparm[NDRIVE * NPARTN + d].p_size = ! 620: (long) atparm[d].d_ncyl * atparm[d].d_nhead * atparm[d].d_nspt; ! 621: atreset(); ! 622: return 0; ! 623: ! 624: default: ! 625: u.u_error = EINVAL; ! 626: return(-1); ! 627: } ! 628: } ! 629: ! 630: /** ! 631: * ! 632: * void ! 633: * atwatch() - guard against lost interrupt ! 634: * ! 635: * Action: If drvl[AT_MAJOR] is greater than zero, decrement it. ! 636: * If it decrements to zero, simulate a hardware interrupt. ! 637: */ ! 638: static void ! 639: atwatch() ! 640: { ! 641: register BUF * bp = at.at_actf; ! 642: register int s; ! 643: ! 644: s = sphi(); ! 645: if (--drvl[AT_MAJOR].d_time > 0) { ! 646: spl(s); ! 647: return; ! 648: } ! 649: printf("at%d%c: bno=%U head=%u cyl=%u <Watchdog Timeout>\n", ! 650: at.at_drv, ! 651: (bp->b_dev & SDEV) ? 'x' : at.at_partn % NPARTN + 'a', ! 652: bp->b_bno, at.at_head, at.at_cyl); ! 653: ! 654: /* ! 655: * Reset hard disk controller. ! 656: * ! 657: * Mark current cylinder as bad so atstart() will fail. ! 658: * Otherwise would lock up if this track NEVER gives enough IRQ's. ! 659: */ ! 660: at.at_bad_drv = at.at_drv; ! 661: at.at_bad_head = at.at_head; ! 662: at.at_bad_cyl = at.at_cyl; ! 663: atreset(); ! 664: atstart(); ! 665: spl(s); ! 666: } ! 667: ! 668: /** ! 669: * ! 670: * void ! 671: * atblock(bp) - queue a block to the disk ! 672: * ! 673: * Input: bp = pointer to block to be queued. ! 674: * ! 675: * Action: Queue a block to the disk. ! 676: * Make sure that the transfer is within the disk partition. ! 677: */ ! 678: static void ! 679: atblock(bp) ! 680: register BUF *bp; ! 681: { ! 682: register struct fdisk_s *pp; ! 683: int partn = minor(bp->b_dev) % (NDRIVE*NPARTN); ! 684: ! 685: bp->b_resid = bp->b_count; ! 686: ! 687: if (minor(bp->b_dev) & SDEV) ! 688: partn += NDRIVE * NPARTN; ! 689: ! 690: pp = &pparm[ partn ]; ! 691: ! 692: /* ! 693: * Check for read at end of partition. ! 694: */ ! 695: if ((bp->b_req == BREAD) && (bp->b_bno == pp->p_size)) { ! 696: bdone(bp); ! 697: return; ! 698: } ! 699: ! 700: /* ! 701: * Range check disk region. ! 702: */ ! 703: if (((bp->b_bno + (bp->b_count/BSIZE)) > pp->p_size) ! 704: || (bp->b_count % BSIZE) || bp->b_count == 0) { ! 705: bp->b_flag |= BFERR; ! 706: bdone(bp); ! 707: return; ! 708: } ! 709: ! 710: bp->b_actf = NULL; ! 711: if (at.at_actf == NULL) ! 712: at.at_actf = bp; ! 713: else ! 714: at.at_actl->b_actf = bp; ! 715: at.at_actl = bp; ! 716: ! 717: if (at.at_state == SIDLE) ! 718: if (atdequeue()) ! 719: atstart(); ! 720: } ! 721: ! 722: /** ! 723: * ! 724: * int ! 725: * atdequeue() - obtain next disk read/write operation ! 726: * ! 727: * Action: Pull some work from the disk queue. ! 728: * ! 729: * Return: 0 = no work. ! 730: * * = work to do. ! 731: */ ! 732: static int ! 733: atdequeue() ! 734: { ! 735: register BUF * bp; ! 736: register struct fdisk_s * pp; ! 737: unsigned int nspt; ! 738: ! 739: for (;;) { ! 740: at.at_caching = 0; ! 741: at.at_tries = 0; ! 742: ! 743: if ((bp = at.at_actf) == NULL) ! 744: return (0); ! 745: ! 746: at.at_partn = minor(bp->b_dev) % (NDRIVE*NPARTN); ! 747: ! 748: if (minor(bp->b_dev) & SDEV) { ! 749: at.at_partn += (NDRIVE*NPARTN); ! 750: at.at_drv = minor(bp->b_dev) % NDRIVE; ! 751: } ! 752: else ! 753: at.at_drv = minor(bp->b_dev) / NPARTN; ! 754: nspt = atparm[at.at_drv].d_nspt; ! 755: ! 756: pp = &pparm[ at.at_partn ]; ! 757: at.at_bno = pp->p_base + bp->b_bno; ! 758: at.at_nsec = bp->b_count / BSIZE; ! 759: at.at_faddr = bp->b_faddr; ! 760: ! 761: #if ATCACHE > 0 ! 762: if (bp->b_req == BWRITE) { ! 763: ! 764: /* ! 765: * Invalidate cache if write might overlap. ! 766: */ ! 767: if (at.at_nsec > 1) { ! 768: at.at_cdrv[0] = -1; ! 769: #if ATCACHE > 1 ! 770: at.at_cdrv[1] = -1; ! 771: #endif ! 772: } ! 773: else if (at.at_bno == at.at_cbno[0]) ! 774: at.at_cdrv[0] = -1; ! 775: #if ATCACHE > 1 ! 776: else if (at.at_bno == at.at_cbno[1]) ! 777: at.at_cdrv[1] = -1; ! 778: #endif ! 779: } ! 780: else if (at.at_nsec == 1) { ! 781: ! 782: /* ! 783: * Test for cache hit on block 0. ! 784: */ ! 785: if ((at.at_drv == at.at_cdrv[0]) ! 786: && (at.at_bno == at.at_cbno[0])) { ! 787: ! 788: kpcopy(at.at_cbuf[0], ! 789: bp->b_paddr, BSIZE); ! 790: at.at_actf = bp->b_actf; ! 791: bp->b_resid = 0; ! 792: bdone(bp); ! 793: continue; ! 794: } ! 795: ! 796: #if ATCACHE > 1 ! 797: /* ! 798: * Test for cache hit on block 1. ! 799: */ ! 800: if ((at.at_drv == at.at_cdrv[1]) ! 801: && (at.at_bno == at.at_cbno[1])) { ! 802: ! 803: kpcopy(at.at_cbuf[1], ! 804: bp->b_paddr, BSIZE); ! 805: at.at_actf = bp->b_actf; ! 806: bp->b_resid = 0; ! 807: bdone(bp); ! 808: continue; ! 809: } ! 810: #endif ! 811: ! 812: /* ! 813: * Enable caching if no backlog for disk i/o. ! 814: */ ! 815: if (bp->b_actf == NULL) { ! 816: /* ! 817: * Enable caching on single block reads ! 818: * when at least one block left on same track. ! 819: */ ! 820: at.at_caching = nspt - 1 - (at.at_bno % nspt); ! 821: #if ATCACHE > 1 ! 822: if (at.at_caching >= 2) { ! 823: at.at_caching = 2; ! 824: at.at_cdrv[2-1] = -1; ! 825: } ! 826: #endif ! 827: ! 828: if (at.at_caching) { ! 829: at.at_nsec += at.at_caching; ! 830: at.at_cdrv[1-1] = -1; ! 831: } ! 832: } ! 833: } ! 834: #endif ! 835: ! 836: return (1); ! 837: } ! 838: } ! 839: ! 840: /** ! 841: * ! 842: * void ! 843: * atstart() - start or restart next disk read/write operation. ! 844: * ! 845: * Action: Initiate disk read/write operation. ! 846: */ ! 847: static void ! 848: atstart() ! 849: { ! 850: register struct dparm_s *dp; ! 851: ! 852: dp = &atparm[ at.at_drv ]; ! 853: ! 854: at.at_cyl = (at.at_bno / dp->d_nspt) / dp->d_nhead; ! 855: at.at_head = (at.at_bno / dp->d_nspt) % dp->d_nhead; ! 856: at.at_sec = (at.at_bno % dp->d_nspt) + 1; ! 857: ! 858: /* ! 859: * Check for repeated access to most recently identified bad track. ! 860: */ ! 861: if ((at.at_drv == at.at_bad_drv) ! 862: && (at.at_cyl == at.at_bad_cyl) ! 863: && (at.at_head == at.at_bad_head)) { ! 864: BUF * bp = at.at_actf; ! 865: printf("at%d%c: bno=%U head=%u cyl=%u <Track Flagged Bad>\n", ! 866: at.at_drv, ! 867: (bp->b_dev & SDEV) ? 'x' : at.at_partn % NPARTN + 'a', ! 868: bp->b_bno, ! 869: at.at_head, ! 870: at.at_cyl); ! 871: bp->b_flag |= BFERR; ! 872: atdone(bp); ! 873: return; ! 874: } ! 875: ! 876: myatbsyw(at.at_drv); ! 877: ! 878: outb(HF_REG, dp->d_ctrl); ! 879: outb(AUX_REG, dp->d_wpcc / 4); ! 880: outb(NSEC_REG, at.at_nsec); ! 881: outb(SEC_REG, at.at_sec); ! 882: outb(LCYL_REG, at.at_cyl); ! 883: outb(HCYL_REG, at.at_cyl >> 8); ! 884: outb(HDRV_REG, (at.at_drv << 4) + at.at_head + 0xA0); ! 885: ! 886: if (at.at_actf->b_req == BWRITE) { ! 887: ! 888: outb(CSR_REG, WRITE_CMD); ! 889: ! 890: while (atdrqw() == 0) ! 891: printf(timeout_msg, at.at_drv); ! 892: ! 893: atsend(at.at_faddr); ! 894: at.at_state = SWRITE; ! 895: } ! 896: else { ! 897: outb(CSR_REG, READ_CMD); ! 898: at.at_state = SREAD; ! 899: } ! 900: drvl[AT_MAJOR].d_time = ATSECS; ! 901: } ! 902: ! 903: /** ! 904: * ! 905: * void ! 906: * atintr() - Interrupt routine. ! 907: * ! 908: * Clear interrupt then defer actual processing. ! 909: */ ! 910: static void ! 911: atintr() ! 912: { ! 913: inb(CSR_REG); /* clears controller interrupt */ ! 914: defer(atdefer, 0); ! 915: } ! 916: ! 917: /** ! 918: * ! 919: * void ! 920: * atdefer() - Deferred service of hard disk interrupt. ! 921: * ! 922: * Action: Service disk interrupt. ! 923: * Transfer required data. ! 924: * Update state. ! 925: */ ! 926: static void ! 927: atdefer() ! 928: { ! 929: register BUF * bp = at.at_actf; ! 930: ! 931: switch (at.at_state) { ! 932: ! 933: case SRETRY: ! 934: atstart(); ! 935: break; ! 936: ! 937: case SREAD: ! 938: /* ! 939: * Check for I/O error before waiting for data. ! 940: */ ! 941: if (aterror()) { ! 942: atrecov(); ! 943: break; ! 944: } ! 945: ! 946: /* ! 947: * Wait for data, or forever. ! 948: */ ! 949: if (atdrqw() == 0) ! 950: printf(timeout_msg, at.at_drv); ! 951: ! 952: #if ATCACHE > 0 ! 953: /* ! 954: * Cache data block. ! 955: */ ! 956: if (at.at_caching == at.at_nsec) ! 957: atrecv(at.at_cbuf[ at.at_nsec - 1 ], sds); ! 958: else ! 959: #endif ! 960: ! 961: /* ! 962: * Read data block. ! 963: */ ! 964: atrecv(at.at_faddr); ! 965: ! 966: /* ! 967: * Check for I/O error after reading data. ! 968: */ ! 969: if (aterror()) { ! 970: atrecov(); ! 971: break; ! 972: } ! 973: ! 974: #if ATCACHE > 0 ! 975: /* ! 976: * Validate cached blocks. ! 977: */ ! 978: if (at.at_caching == at.at_nsec) { ! 979: at.at_cbno[ at.at_nsec - 1 ] = at.at_bno; ! 980: at.at_cdrv[ at.at_nsec - 1 ] = at.at_drv; ! 981: at.at_caching--; ! 982: } ! 983: else ! 984: #endif ! 985: { ! 986: FP_OFF(at.at_faddr) += BSIZE; ! 987: bp->b_resid -= BSIZE; ! 988: } ! 989: ! 990: at.at_tries = 0; ! 991: at.at_bno++; ! 992: ! 993: /* ! 994: * Check for end of transfer. ! 995: */ ! 996: if (--at.at_nsec == 0) ! 997: atdone(bp); ! 998: break; ! 999: ! 1000: case SWRITE: ! 1001: /* ! 1002: * Check for I/O error. ! 1003: */ ! 1004: if (aterror()) { ! 1005: atrecov(); ! 1006: break; ! 1007: } ! 1008: ! 1009: FP_OFF(at.at_faddr) += BSIZE; ! 1010: bp->b_resid -= BSIZE; ! 1011: at.at_tries = 0; ! 1012: at.at_bno++; ! 1013: ! 1014: /* ! 1015: * Check for end of transfer. ! 1016: */ ! 1017: if (--at.at_nsec == 0) { ! 1018: atdone(bp); ! 1019: break; ! 1020: } ! 1021: ! 1022: /* ! 1023: * Wait for ability to send data, or forever. ! 1024: */ ! 1025: while (atdrqw() == 0) ! 1026: printf(timeout_msg, at.at_drv); ! 1027: ! 1028: /* ! 1029: * Send data block. ! 1030: */ ! 1031: atsend(at.at_faddr); ! 1032: } ! 1033: } ! 1034: ! 1035: /** ! 1036: * ! 1037: * int ! 1038: * aterror() ! 1039: * ! 1040: * Action: Check for drive error. ! 1041: * If found, increment error count and report it. ! 1042: * ! 1043: * Return: 0 = No error found. ! 1044: * 1 = Error occurred. ! 1045: */ ! 1046: static int ! 1047: aterror() ! 1048: { ! 1049: register BUF * bp = at.at_actf; ! 1050: register int csr; ! 1051: register int aux; ! 1052: ! 1053: if ((csr = inb(HF_REG)) & (ERR_ST|WFLT_ST)) { ! 1054: ! 1055: aux = inb(AUX_REG); ! 1056: ! 1057: /* ! 1058: * Don't retry or report failures on cache reads. ! 1059: */ ! 1060: #if ATCACHE > 0 ! 1061: if ((at.at_state == SREAD) && (at.at_caching == at.at_nsec)) { ! 1062: at.at_tries = BADLIM; ! 1063: return 1; ! 1064: } ! 1065: #endif ! 1066: ! 1067: if (aux & BAD_ERR) { ! 1068: at.at_tries = BADLIM; ! 1069: at.at_bad_drv = at.at_drv; ! 1070: at.at_bad_head = at.at_head; ! 1071: at.at_bad_cyl = at.at_cyl; ! 1072: } ! 1073: else if (++at.at_tries < SOFTLIM) ! 1074: return 1; ! 1075: ! 1076: printf("at%d%c: bno=%U head=%u cyl=%u", ! 1077: at.at_drv, ! 1078: (bp->b_dev & SDEV) ? 'x' : at.at_partn % NPARTN + 'a', ! 1079: (bp->b_count/BSIZE) + bp->b_bno ! 1080: + at.at_caching - at.at_nsec, ! 1081: at.at_head, at.at_cyl); ! 1082: ! 1083: #if VERBOSE > 0 ! 1084: if ((csr & RDY_ST) == 0) ! 1085: printf(" <Drive Not Ready>"); ! 1086: if (csr & WFLT_ST) ! 1087: printf(" <Write Fault>"); ! 1088: ! 1089: if (aux & DAM_ERR) ! 1090: printf(" <No Data Addr Mark>"); ! 1091: if (aux & TR0_ERR) ! 1092: printf(" <Track 0 Not Found>"); ! 1093: if (aux & ID_ERR) ! 1094: printf(" <ID Not Found>"); ! 1095: if (aux & ECC_ERR) ! 1096: printf(" <Bad Data Checksum>"); ! 1097: if (aux & ABT_ERR) ! 1098: printf(" <Command Aborted>"); ! 1099: #else ! 1100: if ((csr & (RDY_ST|WFLT_ST)) != RDY_ST) ! 1101: printf(" csr=%x", csr); ! 1102: if (aux & (DAM_ERR|TR0_ERR|ID_ERR|ECC_ERR|ABT_ERR)) ! 1103: printf(" aux=%x", aux); ! 1104: #endif ! 1105: if (aux & BAD_ERR) ! 1106: printf(" <Block Flagged Bad>"); ! 1107: ! 1108: if (at.at_tries < HARDLIM) ! 1109: printf(" retrying..."); ! 1110: printf("\n"); ! 1111: return 1; ! 1112: } ! 1113: return 0; ! 1114: } ! 1115: ! 1116: /** ! 1117: * ! 1118: * void ! 1119: * atrecov() ! 1120: * ! 1121: * Action: Attempt recovery. ! 1122: */ ! 1123: static void ! 1124: atrecov() ! 1125: { ! 1126: register BUF *bp = at.at_actf; ! 1127: register int cmd = SEEK(0); ! 1128: register int cyl = at.at_cyl; ! 1129: ! 1130: switch (at.at_tries) { ! 1131: ! 1132: case 1: ! 1133: case 2: ! 1134: /* ! 1135: * Move in 1 cylinder, then retry operation ! 1136: */ ! 1137: if (--cyl < 0) ! 1138: cyl += 2; ! 1139: break; ! 1140: ! 1141: case 3: ! 1142: case 4: ! 1143: /* ! 1144: * Move out 1 cylinder, then retry operation ! 1145: */ ! 1146: if (++cyl >= atparm[ at.at_drv ].d_ncyl) ! 1147: cyl -= 2; ! 1148: break; ! 1149: ! 1150: case 5: ! 1151: case 6: ! 1152: /* ! 1153: * Seek to cylinder 0, then retry operation ! 1154: */ ! 1155: cyl = 0; ! 1156: break; ! 1157: ! 1158: default: ! 1159: /* ! 1160: * Restore drive, then retry operation ! 1161: */ ! 1162: cmd = RESTORE(0); ! 1163: cyl = 0; ! 1164: break; ! 1165: } ! 1166: ! 1167: /* ! 1168: * Retry operation [after repositioning head] ! 1169: */ ! 1170: if (at.at_tries < HARDLIM) { ! 1171: drvl[AT_MAJOR].d_time = (cmd == RESTORE(0)) ! 1172: ? (ATSECS * 2) : ATSECS; ! 1173: outb(LCYL_REG, cyl); ! 1174: outb(HCYL_REG, cyl >> 8); ! 1175: outb(HDRV_REG, (at.at_drv << 4) + 0xA0); ! 1176: outb(CSR_REG, cmd); ! 1177: at.at_state = SRETRY; ! 1178: } ! 1179: ! 1180: /* ! 1181: * Give up on block. ! 1182: */ ! 1183: else { ! 1184: /* ! 1185: * Not a cache-read error. ! 1186: */ ! 1187: #if ATCACHE > 0 ! 1188: if ((at.at_state != SREAD) || (at.at_caching != at.at_nsec)) ! 1189: #endif ! 1190: bp->b_flag |= BFERR; ! 1191: ! 1192: atdone(bp); ! 1193: } ! 1194: } ! 1195: ! 1196: /** ! 1197: * ! 1198: * void ! 1199: * atdone(bp) ! 1200: * BUF * bp; ! 1201: * ! 1202: * Action: Release current i/o buffer to the O/S. ! 1203: */ ! 1204: static void ! 1205: atdone(bp) ! 1206: register BUF * bp; ! 1207: { ! 1208: drvl[AT_MAJOR].d_time = 0; ! 1209: at.at_state = SIDLE; ! 1210: at.at_actf = bp->b_actf; ! 1211: bdone(bp); ! 1212: ! 1213: if (atdequeue()) ! 1214: atstart(); ! 1215: } ! 1216: ! 1217: int ! 1218: myatbsyw(unit) int unit; ! 1219: { ! 1220: register int n, status; ! 1221: ! 1222: for (n = ATBSYW; n > 0; --n) ! 1223: if ((status = atbsyw()) != 0) ! 1224: return status; ! 1225: printf(timeout_msg, unit); ! 1226: return 0; ! 1227: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.