![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps.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 / PS2_KERNEL / io.286|
Return to ps.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.286 |
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: ps.c,v $ ! 7: * Revision 1.10 91/11/11 12:29:03 hal ! 8: * Use n_atdr. ! 9: * ! 10: * Revision 1.9 91/10/30 10:47:46 hal ! 11: * Get psparms from tboot. ! 12: * ! 13: * Revision 1.8 91/10/24 12:36:25 hal ! 14: * Bump PSSECS from 4 to 6. ! 15: * Poll HF_REG (3F6) rather than CSR_REG (1F6). ! 16: * COH 3.2.03. ! 17: * ! 18: * Revision 1.7 91/09/11 14:45:38 hal ! 19: * Trial patch for Seagate 157A problems. ! 20: * ! 21: * Revision 1.6 91/09/11 13:23:12 hal ! 22: * Explicit sys in include paths. AT_MAJOR. ! 23: * ! 24: * Revision 1.5 91/05/22 15:06:59 hal ! 25: * Don't force 8's bit of control byte. ! 26: * ! 27: * Revision 1.4 91/03/14 14:22:32 hal ! 28: * ! 29: -lgl) */ ! 30: /* ! 31: * This is a driver for the ! 32: * hard disk on the PS. ! 33: * ! 34: * Reads drive characteristics from ROM (thru interrupt vector 0x41 and 0x46). ! 35: * Reads partition information from disk. ! 36: */ ! 37: #include <sys/coherent.h> ! 38: #include <sys/fdisk.h> ! 39: #include <sys/hdioctl.h> ! 40: #include <sys/buf.h> ! 41: #include <sys/con.h> ! 42: #include <sys/devices.h> ! 43: #include <sys/stat.h> ! 44: #include <sys/uproc.h> ! 45: #include <sys/typed.h> ! 46: #include <sys/timeout.h> /* TIM */ ! 47: #include <sys/sched.h> ! 48: #include <errno.h> ! 49: ! 50: extern saddr_t sds; /* System Data Selector */ ! 51: extern short n_atdr; /* Number of "ps" drives */ ! 52: int ATSREG = 0x3F6; ! 53: ! 54: /* ! 55: * Configurable parameters ! 56: */ ! 57: #define HDIRQ 14 /* Level 14 */ ! 58: #define NDRIVE 2 /* only two drives supported */ ! 59: #define SOFTLIM 6 /* (7) num of retrys before diag */ ! 60: #define HARDLIM 8 /* number of retrys before fail */ ! 61: #define BADLIM 100 /* num to stop recov if flagged bad */ ! 62: ! 63: #define BIT(n) (1 << (n)) ! 64: ! 65: #define CMOSA 0x70 /* write cmos address to this port */ ! 66: #define CMOSD 0x71 /* read cmos data through this port */ ! 67: ! 68: /* ! 69: * Driver configuration. ! 70: */ ! 71: void psload(); ! 72: void psunload(); ! 73: void psopen(); ! 74: void psread(); ! 75: void pswrite(); ! 76: int psioctl(); ! 77: void pstimer(); ! 78: void psblock(); ! 79: int nulldev(); ! 80: int nonedev(); ! 81: ! 82: CON pscon = { ! 83: DFBLK|DFCHR, /* Flags */ ! 84: AT_MAJOR, /* Major index */ ! 85: psopen, /* Open */ ! 86: nulldev, /* Close */ ! 87: psblock, /* Block */ ! 88: psread, /* Read */ ! 89: pswrite, /* Write */ ! 90: psioctl, /* Ioctl */ ! 91: nulldev, /* Powerfail */ ! 92: nulldev, /* Timeout */ ! 93: psload, /* Load */ ! 94: psunload /* Unload */ ! 95: }; ! 96: ! 97: /* ! 98: * Forward Referenced Functions. ! 99: */ ! 100: void psreset(); ! 101: int psdequeue(); ! 102: void psstart(); ! 103: void psintr(); ! 104: static void psstatus(); ! 105: void psdone(); ! 106: void disk_function(); ! 107: void disk_functionb(); ! 108: ! 109: /* ! 110: * Device States. ! 111: */ ! 112: #define SIDLE 0 /* controller idle */ ! 113: #define SRETRY 1 /* seeking */ ! 114: #define SREAD 2 /* reading */ ! 115: #define SWRITE 3 /* writing */ ! 116: #define SRESET 4 /* reseting */ ! 117: ! 118: char *smsg[] = { "SIDLE", "SRETRY", "SREAD", "SWRITE", "SRESET" }; ! 119: ! 120: /* ! 121: * Drive Parameters - copied from ROM. ! 122: * If patched, use the given values instead of reading from the ROM. ! 123: * NOTE: Exactly duplicates hdparm_s struct. ! 124: */ ! 125: struct dparm_s { ! 126: unsigned short d_ncyl; /* number of cylinders */ ! 127: unsigned char d_nhead; /* number of heads */ ! 128: unsigned short d_rwcc; /* reduced write current cyl */ ! 129: unsigned short d_wpcc; /* write pre-compensation cyl */ ! 130: unsigned char d_eccl; /* max ecc data length */ ! 131: unsigned char d_ctrl; /* control byte */ ! 132: unsigned char d_fill2[3]; ! 133: unsigned short d_landc; /* landing zone cylinder */ ! 134: unsigned char d_nspt; /* number of sectors per track */ ! 135: unsigned char d_fill3; ! 136: ! 137: } psparm[ NDRIVE ] = { ! 138: 0 /* Initialized to allow patching */ ! 139: }; ! 140: ! 141: /* ! 142: * Partition Parameters - copied from disk. ! 143: * ! 144: * There are NDRIVE * NPARTN positions for the user partitions, ! 145: * plus NDRIVE additional partitions to span each drive. ! 146: * ! 147: * Aligning partitions on cylinder boundaries: ! 148: * Optimal partition size: 2 * 3 * 4 * 5 * 7 * 17 = 14280 blocks ! 149: * Acceptable partition size: 3 * 4 * 5 * 7 * 17 = 7140 blocks ! 150: */ ! 151: static ! 152: struct fdisk_s pparm[NDRIVE*NPARTN + NDRIVE]; ! 153: ! 154: /* ! 155: * Per disk controller data. ! 156: * Only one controller; no more, no less. ! 157: */ ! 158: static ! 159: struct ps { ! 160: BUF *ps_actf; /* Link to first */ ! 161: BUF *ps_actl; /* Link to last */ ! 162: faddr_t ps_faddr; /* Source/Dest virtual address */ ! 163: daddr_t ps_bno; /* Block # on disk */ ! 164: unsigned ps_nsec; /* # of sectors on current transfer */ ! 165: unsigned ps_drv; ! 166: unsigned ps_head; ! 167: unsigned ps_cyl; ! 168: unsigned ps_sec; ! 169: unsigned ps_partn; ! 170: unsigned char ps_dtype[ NDRIVE ]; /* drive type, 0 if unused */ ! 171: unsigned char ps_tries; ! 172: unsigned char ps_state; ! 173: unsigned char ps_caching; /* caching in progress */ ! 174: unsigned ps_bad_drv; ! 175: unsigned ps_bad_head; ! 176: unsigned ps_bad_cyl; ! 177: } ps; ! 178: ! 179: static BUF dbuf; /* For raw I/O */ ! 180: ! 181: ! 182: #include <sys/abios.h> ! 183: #include <sys/mmu.h> ! 184: #include <sys/types.h> ! 185: #include <stdio.h> ! 186: ! 187: static request_block_hd rb; ! 188: ! 189: char killbuf[1024]; /* don't forget to fix bio.c */ ! 190: char l_com_data[0x80]; ! 191: paddr_t com_data_p, dev1p, fcn1p, dev2p, fcn2p; ! 192: a_sys_parm sp; ! 193: a_init_table it0, it1, it2, it15; ! 194: ! 195: char fcn0[0x10], fcn1[0x50], fcn2[0x40], fcn15[0x58]; ! 196: ! 197: extern int com_data,i0, i1, i2, i15, fcn_trn0, fcn_trn1, fcn_trn2, fcn_trn15; ! 198: ! 199: #define cscolon(d) ((faddr_t)(0x600000L + (unsigned) (d))) ! 200: #define init_tab_cp(s,r) fkcopy(cscolon(ffword(cscolon(s))), r, 24) ! 201: ! 202: /* ! 203: * Patchable variables. ! 204: * PSBSYW is a loop count for busy-waiting after issuing commands. ! 205: * PSSECS is number of seconds to wait for an expected interrupt. ! 206: */ ! 207: int PSBSYW = 50; /* patchable */ ! 208: int PSSECS = 6; /* patchable */ ! 209: ! 210: /** ! 211: * ! 212: * void ! 213: * psload() - load routine. ! 214: * ! 215: * Action: The controller is reset and the interrupt vector is grabbed. ! 216: * The drive characteristics are set up ps this time. ! 217: */ ! 218: static void ! 219: psload() ! 220: { ! 221: unsigned int u; ! 222: register int s; ! 223: struct dparm_s * dp; ! 224: ! 225: init_abios(); ! 226: ! 227: n_atdr = 1; ! 228: ! 229: if (n_atdr == 0) ! 230: return; ! 231: ! 232: ps.ps_actf = NULL; /* Start up with this Null to avoid phony calls */ ! 233: ! 234: /* ! 235: * Obtain (hardwire) Drive Types. ! 236: */ ! 237: ps.ps_dtype[0] = 1; /* This just means that it exists */ ! 238: ps.ps_dtype[1] = 0; /* This just means that it doesn't exist */ ! 239: ! 240: /* ! 241: * Obtain Drive Characteristics. ! 242: */ ! 243: ! 244: for (u = 0, dp = &psparm[0]; u < n_atdr; ++dp, ++u) ! 245: { ! 246: rb.length = 0x80; ! 247: rb.logical_id = 5; ! 248: rb.unit = 0; ! 249: rb.function = 3; ! 250: rb.reserved = 0L; ! 251: rb.ret_code = 0xffff; ! 252: rb.vars.f3.reserved = 0L; ! 253: d2_func(&rb, START_P); ! 254: if (rb.ret_code) ! 255: printf("\nhard disk function 3 returned = %d\n", ! 256: rb.ret_code); ! 257: dp->d_ncyl = rb.vars.f3.cylinders; ! 258: dp->d_nhead = rb.vars.f3.heads; ! 259: dp->d_nspt = rb.vars.f3.sectors_track; ! 260: dp->d_wpcc = 0xffff; ! 261: dp->d_landc = rb.vars.f3.cylinders; ! 262: if (dp->d_nhead > 8) ! 263: dp->d_ctrl |= 8; ! 264: ! 265: #if 0 ! 266: ! 267: printf(" drive %d parameters\n", u); ! 268: printf( ! 269: "ps%d: ncyl=%d nhead=%d wpcc=%d eccl=%d ctrl=%d landc=%d nspt=%d\n", ! 270: u, ! 271: dp->d_ncyl, ! 272: dp->d_nhead, ! 273: dp->d_wpcc, ! 274: dp->d_eccl, ! 275: dp->d_ctrl, ! 276: dp->d_landc, ! 277: dp->d_nspt); ! 278: printf("\nhard disk function 3 returned = %d\n", rb.ret_code); ! 279: printf("\nretries = %d", rb.vars.f3.retries); ! 280: printf("\nblock_addresses = %lu", rb.vars.f3.block_addresses); ! 281: printf("\nmax_blocks = %d\n", rb.vars.f3.max_blocks); ! 282: ! 283: #endif ! 284: } ! 285: ! 286: /* ! 287: * Initialize Drive Size. ! 288: */ ! 289: for (u = 0, dp = &psparm[0]; u < n_atdr; ++dp, ++u) { ! 290: ! 291: if (ps.ps_dtype[u] == 0) ! 292: continue; ! 293: ! 294: pparm[NDRIVE*NPARTN + u].p_size = ! 295: (long) dp->d_ncyl * dp->d_nhead * dp->d_nspt; ! 296: } ! 297: ! 298: ! 299: s = sphi(); ! 300: setivec(HDIRQ, psintr); ! 301: spl( s ); ! 302: ! 303: ps.ps_bad_drv = -1; ! 304: ! 305: /* ! 306: * Initialize Drive Controller. ! 307: */ ! 308: psreset(); ! 309: } ! 310: ! 311: paddr_t prot; ! 312: ! 313: /* This is the protected mode part of the abios initialization */ ! 314: init_abios() ! 315: { ! 316: unsigned int i, count, *tmp1; ! 317: paddr_t codeseg; ! 318: paddr_t *tmp, tmpp; ! 319: static short done = 0; ! 320: ! 321: if (done) /* Make sure we don't call this twice */ ! 322: return; ! 323: ! 324: done++; ! 325: ! 326: printf("init_abios_a() = %x\n", iresult()); ! 327: ! 328: /* First create the virtual pointer to the comm area */ ! 329: com_data_p = ptov(vtop(l_com_data, sds), 0x80L); ! 330: ! 331: /* Now copy the common data table into local space */ ! 332: fkcopy(cscolon((unsigned)(&com_data) & 0xfff0), l_com_data, 0x80); ! 333: ! 334: /* Now copy the initialization tables into local space */ ! 335: init_tab_cp(&i0, &it0); ! 336: init_tab_cp(&i1, &it1); ! 337: init_tab_cp(&i15, &it15); ! 338: init_tab_cp(&i2, &it2); ! 339: ! 340: /* Now convert each real mode device block pointer into a protected ! 341: * mode device block pointer . ! 342: */ ! 343: ! 344: tmp = tmp1 = l_com_data; /* Make thing easier on the compiler */ ! 345: ! 346: codeseg = ptov(0x0600L, 0xffffL); /* Set up an r/w alias to the cs */ ! 347: ! 348: /* Fix the segments in the CDA */ ! 349: /* the offsets are still ok */ ! 350: tmp1[9] = tmp1[13] = tmp1[17] = tmp1[21] = FP_SEL(codeseg); ! 351: ! 352: dev1p = tmp[6]; ! 353: dev2p = tmp[10]; /* Set this up so calls are easier later */ ! 354: ! 355: /* Now fix each function transfer table pointer in the cda so that ! 356: * it points to the proper spot in the ds ! 357: */ ! 358: ! 359: /* Fix the segments in the CDA */ ! 360: tmp1[11] = tmp1[15] = tmp1[19] = tmp1[23] = sds; ! 361: ! 362: tmp1[10] = (unsigned)fcn0; /* Now fix the offsets */ ! 363: tmp1[14] = (unsigned)fcn1; ! 364: tmp1[18] = (unsigned)fcn15; ! 365: tmp1[22] = (unsigned)fcn2; ! 366: ! 367: fcn1p = tmp[7]; ! 368: fcn2p = tmp[11]; /* Set this up so calls are easier later */ ! 369: ! 370: /* Now convert the pointers in the ftts to protected mode pointers */ ! 371: ! 372: /* This is the location of the Abios */ ! 373: fkcopy(cscolon(&fcn_trn0), &tmpp, 4); ! 374: tmpp = (tmpp & 0xffff0000L) >> 12; ! 375: prot = ptovx(tmpp); ! 376: ! 377: /* First do the system level functions */ ! 378: cnvt_ptrs(&fcn_trn0, fcn0, it0.ftt_length); ! 379: /* Now do the diskette functions */ ! 380: cnvt_ptrs(&fcn_trn1, fcn1, it1.ftt_length); ! 381: /* Now do the DMA functions */ ! 382: cnvt_ptrs(&fcn_trn15, fcn15, it15.ftt_length); ! 383: /* Finish up with the hard disk functions table */ ! 384: cnvt_ptrs(&fcn_trn2, fcn2, it2.ftt_length); ! 385: ! 386: /* Finally, Convert the data pointers */ ! 387: ! 388: i = *(int *)l_com_data; /* i is now a pointer to the first pointer */ ! 389: count = *(int *)(l_com_data+i+6);/* count is the # of data pointers*/ ! 390: while (count--) /* Any more data pointers? */ ! 391: { /* Redo the pointer using the saved size */ ! 392: tmp = l_com_data + i + 2; ! 393: *tmp = ptov(*tmp, (long)*(unsigned *)(tmp-2)); ! 394: i -= 6; /* Now point to the next pointer */ ! 395: } ! 396: } ! 397: ! 398: ! 399: cnvt_ptrs(cs_src, fcn_dest, length) ! 400: int cs_src, length; ! 401: char *fcn_dest; ! 402: { ! 403: paddr_t *tmp; ! 404: int count, i; ! 405: ! 406: /* First copy the tables into the data space */ ! 407: fkcopy(cscolon(cs_src), fcn_dest, length); ! 408: ! 409: /* First do the system level functions */ ! 410: ! 411: tmp = fcn_dest; ! 412: ! 413: FP_SEL(tmp[0]) = FP_SEL(prot); /* First the start routine */ ! 414: FP_SEL(tmp[1]) = FP_SEL(prot); /* Next the interrupt routine */ ! 415: FP_SEL(tmp[2]) = FP_SEL(prot); /* Next the time-out ruutine */ ! 416: ! 417: /* Then do the individual functions */ ! 418: ! 419: count = *((int *)(fcn_dest+0x0c)); /* how many functions */ ! 420: for (i=0; i < count; i++) /* convert each function */ ! 421: if (FP_OFF(tmp[i+4])) ! 422: FP_SEL(tmp[i+4]) = FP_SEL(prot); ! 423: } ! 424: ! 425: ! 426: /** ! 427: * ! 428: * void ! 429: * psunload() - unload routine. ! 430: */ ! 431: static void ! 432: psunload() ! 433: { ! 434: clrivec(HDIRQ); ! 435: } ! 436: ! 437: /** ! 438: * ! 439: * void ! 440: * psreset() -- reset hard disk controller, define drive characteristics. ! 441: */ ! 442: static void ! 443: psreset() ! 444: { ! 445: ps.ps_state = SRESET; ! 446: rb.length = 0x80; ! 447: rb.logical_id = 5; ! 448: rb.unit = 0; ! 449: rb.function = 5; ! 450: rb.reserved = 0L; ! 451: rb.ret_code = 0xffff; ! 452: rb.vars.f5.reserved = 0; ! 453: /* disk_function(START_P); */ ! 454: d2_func(&rb, START_P); ! 455: while (rb.ret_code == 2) /* Wait for time */ ! 456: { ! 457: unsigned long i; ! 458: ! 459: printf("PS: reset - %x\n", rb.ret_code); ! 460: for(i=0L; i < rb.vars.f8.wait_time; i+=4) ! 461: ; ! 462: ! 463: d2_func(&rb, INTERRUPT_P); ! 464: } ! 465: ps.ps_state = SIDLE; ! 466: if (rb.ret_code != 0) ! 467: printf("PS: reset failed - %x\n", rb.ret_code); ! 468: return; ! 469: } ! 470: ! 471: /** ! 472: * ! 473: * void ! 474: * psopen(dev, mode) ! 475: * dev_t dev; ! 476: * int mode; ! 477: * ! 478: * Input: dev = disk device to be opened. ! 479: * mode = access mode [IPR,IPW, IPR+IPW]. ! 480: * ! 481: * Action: Validate the minor device. ! 482: * Update the paritition table if necessary. ! 483: */ ! 484: static void ! 485: psopen(dev, mode) ! 486: register dev_t dev; ! 487: { ! 488: register int d; /* drive */ ! 489: register int p; /* partition */ ! 490: ! 491: p = minor(dev) % (NDRIVE*NPARTN); ! 492: ! 493: if (minor(dev) & SDEV) { ! 494: d = minor(dev) % NDRIVE; ! 495: p += NDRIVE * NPARTN; ! 496: } ! 497: else ! 498: d = minor(dev) / NPARTN; ! 499: ! 500: if ((d >= NDRIVE) || (ps.ps_dtype[d] == 0)) { ! 501: u.u_error = ENXIO; ! 502: return; ! 503: } ! 504: ! 505: if (minor(dev) & SDEV) ! 506: return; ! 507: ! 508: /* ! 509: * If partition not defined read partition characteristics. ! 510: */ ! 511: if (pparm[p].p_size == 0) ! 512: fdisk(makedev(major(dev), SDEV + d), &pparm[ d * NPARTN ]); ! 513: /* ! 514: * Ensure partition lies within drive boundaries and is non-zero size. ! 515: */ ! 516: if ((pparm[p].p_base+pparm[p].p_size) > pparm[d+NDRIVE*NPARTN].p_size) ! 517: u.u_error = EBADFMT; ! 518: else if (pparm[p].p_size == 0) ! 519: u.u_error = ENODEV; ! 520: } ! 521: ! 522: /** ! 523: * ! 524: * void ! 525: * psread(dev, iop) - read a block from the raw disk ! 526: * dev_t dev; ! 527: * IO * iop; ! 528: * ! 529: * Input: dev = disk device to be written to. ! 530: * iop = pointer to source I/O structure. ! 531: * ! 532: * Action: Invoke the common raw I/O processing code. ! 533: */ ! 534: static void ! 535: psread(dev, iop) ! 536: dev_t dev; ! 537: IO *iop; ! 538: { ! 539: ioreq(&dbuf, iop, dev, BREAD, BFRAW|BFBLK|BFIOC); ! 540: } ! 541: ! 542: /** ! 543: * ! 544: * void ! 545: * pswrite(dev, iop) - write a block to the raw disk ! 546: * dev_t dev; ! 547: * IO * iop; ! 548: * ! 549: * Input: dev = disk device to be written to. ! 550: * iop = pointer to source I/O structure. ! 551: * ! 552: * Action: Invoke the common raw I/O processing code. ! 553: */ ! 554: static void ! 555: pswrite(dev, iop) ! 556: dev_t dev; ! 557: IO *iop; ! 558: { ! 559: ioreq(&dbuf, iop, dev, BWRITE, BFRAW|BFBLK|BFIOC); ! 560: } ! 561: ! 562: /** ! 563: * ! 564: * int ! 565: * psioctl(dev, cmd, arg) ! 566: * dev_t dev; ! 567: * int cmd; ! 568: * char * vec; ! 569: * ! 570: * Input: dev = disk device to be operated on. ! 571: * cmd = input/output request to be performed. ! 572: * vec = (pointer to) optional argument. ! 573: * ! 574: * Action: Validate the minor device. ! 575: * Update the paritition table if necessary. ! 576: */ ! 577: static int ! 578: psioctl(dev, cmd, vec) ! 579: register dev_t dev; ! 580: int cmd; ! 581: char * vec; ! 582: { ! 583: int d; ! 584: ! 585: /* ! 586: * Identify drive number. ! 587: */ ! 588: if (minor(dev) & SDEV) ! 589: d = minor(dev) % NDRIVE; ! 590: else ! 591: d = minor(dev) / NPARTN; ! 592: ! 593: /* ! 594: * Identify input/output request. ! 595: */ ! 596: switch (cmd) { ! 597: ! 598: case HDGETA: ! 599: /* ! 600: * Get hard disk attributes. ! 601: */ ! 602: kucopy(&psparm[d], vec, sizeof(psparm[0])); ! 603: return(0); ! 604: ! 605: case HDSETA: ! 606: return 0; /* For now, do not allow this */ ! 607: /* Set hard disk pstributes. */ ! 608: ! 609: ukcopy(vec, &psparm[d], sizeof(psparm[0])); ! 610: ps.ps_dtype[d] = 1; /* set drive type nonzero */ ! 611: pparm[NDRIVE * NPARTN + d].p_size = (long) psparm[d].d_ncyl ! 612: * psparm[d].d_nhead * psparm[d].d_nspt; ! 613: psreset(); ! 614: return 0; ! 615: ! 616: default: ! 617: u.u_error = EINVAL; ! 618: return(-1); ! 619: } ! 620: } ! 621: ! 622: /** ! 623: * ! 624: * void ! 625: * pstimer() - wait for timeout ! 626: * ! 627: * Action: If drvl[AT_MAJOR] is greater than zero, decrement it. ! 628: * If it decrements to zero, call the abios again ! 629: */ ! 630: static void ! 631: pstimer() ! 632: { ! 633: register int s; ! 634: ! 635: s = sphi(); ! 636: if (--drvl[AT_MAJOR].d_time > 0) { ! 637: spl(s); ! 638: return; ! 639: } ! 640: disk_function(INTERRUPT_P); ! 641: spl(s); ! 642: } ! 643: ! 644: /** ! 645: * ! 646: * void ! 647: * psblock(bp) - queue a block to the disk ! 648: * ! 649: * Input: bp = pointer to block to be queued. ! 650: * ! 651: * Action: Queue a block to the disk. ! 652: * Make sure that the transfer is within the disk partition. ! 653: */ ! 654: static void ! 655: psblock(bp) ! 656: register BUF *bp; ! 657: { ! 658: register struct fdisk_s *pp; ! 659: int partn = minor(bp->b_dev) % (NDRIVE*NPARTN); ! 660: ! 661: if (minor(bp->b_dev) & SDEV) ! 662: partn += NDRIVE * NPARTN; ! 663: ! 664: pp = &pparm[ partn ]; ! 665: ! 666: /* ! 667: * Check for read at end of partition. ! 668: */ ! 669: if ((bp->b_req == BREAD) && (bp->b_bno == pp->p_size)) { ! 670: bdone(bp); ! 671: return; ! 672: } ! 673: ! 674: /* ! 675: * Range check disk region. ! 676: */ ! 677: if (((bp->b_bno + (bp->b_count/BSIZE)) > pp->p_size) ! 678: || (bp->b_count % BSIZE) || bp->b_count == 0) { ! 679: bp->b_flag |= BFERR; ! 680: bdone(bp); ! 681: return; ! 682: } ! 683: ! 684: bp->b_actf = NULL; ! 685: if (ps.ps_actf == NULL) ! 686: ps.ps_actf = bp; ! 687: else ! 688: ps.ps_actl->b_actf = bp; ! 689: ps.ps_actl = bp; ! 690: if (ps.ps_state == SIDLE) ! 691: if (psdequeue()) ! 692: psstart(); ! 693: } ! 694: ! 695: /** ! 696: * ! 697: * int ! 698: * psdequeue() - obtain next disk read/write operation ! 699: * ! 700: * Action: Pull some work from the disk queue. ! 701: * ! 702: * Return: 0 = no work. ! 703: * * = work to do. ! 704: */ ! 705: static int ! 706: psdequeue() ! 707: { ! 708: register BUF * bp = ps.ps_actf; ! 709: register struct fdisk_s * pp; ! 710: unsigned int nspt; ! 711: ! 712: ps.ps_caching = 0; ! 713: ps.ps_tries = 0; ! 714: ! 715: if (bp == NULL) ! 716: return (0); ! 717: ! 718: ps.ps_partn = minor(bp->b_dev) % (NDRIVE*NPARTN); ! 719: ! 720: if (minor(bp->b_dev) & SDEV) { ! 721: ps.ps_partn += (NDRIVE*NPARTN); ! 722: ps.ps_drv = minor(bp->b_dev) % NDRIVE; ! 723: } ! 724: else ! 725: ps.ps_drv = minor(bp->b_dev) / NPARTN; ! 726: nspt = psparm[ps.ps_drv].d_nspt; ! 727: ! 728: pp = &pparm[ ps.ps_partn ]; ! 729: ps.ps_bno = pp->p_base + bp->b_bno; ! 730: ps.ps_nsec = bp->b_count / BSIZE; ! 731: ps.ps_faddr = bp->b_faddr; ! 732: return (1); ! 733: } ! 734: ! 735: ! 736: /** ! 737: * ! 738: * void ! 739: * psstart() - start or restart next disk read/write operation. ! 740: * ! 741: * Action: Initiate disk read/write operation. ! 742: */ ! 743: static void ! 744: psstart() ! 745: { ! 746: register struct dparm_s *dp; ! 747: ! 748: dp = &psparm[ ps.ps_drv ]; ! 749: #if 0 ! 750: ps.ps_cyl = (ps.ps_bno / dp->d_nspt) / dp->d_nhead; ! 751: ps.ps_head = (ps.ps_bno / dp->d_nspt) % dp->d_nhead; ! 752: ps.ps_sec = (ps.ps_bno % dp->d_nspt) + 1; ! 753: ! 754: /* ! 755: * Check for repeated access to most recently identified bad track. ! 756: */ ! 757: if ((ps.ps_drv == ps.ps_bad_drv) ! 758: && (ps.ps_cyl == ps.ps_bad_cyl) ! 759: && (ps.ps_head == ps.ps_bad_head)) { ! 760: BUF * bp = ps.ps_actf; ! 761: printf("ps%d%c: bno=%U head=%u cyl=%u <Track Flagged Bad>\n", ! 762: ps.ps_drv, ! 763: (bp->b_dev & SDEV) ? 'x' : ps.ps_partn % NPARTN + 'a', ! 764: bp->b_bno, ! 765: ps.ps_head, ! 766: ps.ps_cyl); ! 767: bp->b_flag |= BFERR; ! 768: psdone(); ! 769: return; ! 770: } ! 771: #endif ! 772: rb.length = 0x80; ! 773: rb.logical_id = 5; ! 774: rb.unit = 0; ! 775: rb.reserved = 0L; ! 776: rb.ret_code = 0xffff; ! 777: ! 778: /* Note that the items below are set up the same way for a ! 779: * read or a write. */ ! 780: rb.vars.f8.reserved = 0; ! 781: rb.vars.f8.reserved1 = 0; ! 782: rb.vars.f8.dptr = vtop(ps.ps_faddr); ! 783: rb.vars.f8.reserved2 = 0; ! 784: rb.vars.f8.rb_address = ps.ps_bno; ! 785: rb.vars.f8.reserved3 = 0; ! 786: rb.vars.f8.blocks_read = ps.ps_nsec; ! 787: rb.vars.f8.caching = 0; ! 788: ! 789: if (ps.ps_actf->b_req == BWRITE) { ! 790: rb.function = 9; ! 791: ps.ps_state = SWRITE; ! 792: } ! 793: else { ! 794: rb.function = 8; ! 795: ps.ps_state = SREAD; ! 796: ! 797: } ! 798: disk_function(START_P); ! 799: } ! 800: ! 801: /** ! 802: * ! 803: * void ! 804: * psintr() - Interrupt routine. ! 805: * ! 806: */ ! 807: static void ! 808: psintr() ! 809: { ! 810: d2_func(&rb, INTERRUPT_P); ! 811: defer(disk_functionb, 0); ! 812: } ! 813: ! 814: /** ! 815: * ! 816: * static void ! 817: * psstatus() ! 818: * ! 819: * Print out appropiate error message ! 820: */ ! 821: static void ! 822: psstatus() ! 823: { ! 824: register BUF * bp = ps.ps_actf; ! 825: ! 826: printf("ps%d%c: bno=%U head=%u cyl=%u <", ! 827: ps.ps_drv, ! 828: (bp->b_dev & SDEV) ? 'x' : ps.ps_partn % NPARTN + 'a', ! 829: (bp->b_count/BSIZE) + bp->b_bno + ps.ps_caching ! 830: - ps.ps_nsec, ps.ps_head, ps.ps_cyl); ! 831: ! 832: switch (rb.ret_code | 0x00ff) { ! 833: case 0x00aa: ! 834: printf("Drive Not Ready>"); ! 835: break; ! 836: case 0x00cc: ! 837: printf("Write Fault>"); ! 838: break; ! 839: case 0x0002: ! 840: printf("No Data Addr Mark>"); ! 841: break; ! 842: case 0x0010: ! 843: printf("Bad Data Checksum>"); ! 844: break; ! 845: case 0x00a: ! 846: case 0x00b: ! 847: printf("Block Flagged Bad>"); ! 848: break; ! 849: default: ! 850: printf("Error 0x%x>", rb.ret_code); ! 851: } ! 852: printf("\n"); ! 853: ! 854: } ! 855: ! 856: /** ! 857: * ! 858: * void ! 859: * psdone() ! 860: * ! 861: * Action: Release current i/o buffer to the O/S. ! 862: */ ! 863: static void ! 864: psdone() ! 865: { ! 866: register BUF * bp = ps.ps_actf; ! 867: ! 868: drvl[AT_MAJOR].d_time = 0; ! 869: ps.ps_state = SIDLE; ! 870: bdone(bp); ! 871: ! 872: ps.ps_actf = bp->b_actf; ! 873: ! 874: if (psdequeue()) ! 875: psstart(); ! 876: } ! 877: ! 878: ! 879: void disk_function(type) ! 880: int type; ! 881: { ! 882: /* printf("disk function\n"); */ ! 883: d2_func(&rb, type); ! 884: printf("%s", ""); ! 885: disk_functionb(); ! 886: } ! 887: ! 888: static TIM pstim; ! 889: ! 890: void disk_functionb() ! 891: { ! 892: /* printf("rb.ret_code = %x\r", rb.ret_code); */ ! 893: while (rb.ret_code == 2) /* Wait for time */ ! 894: { ! 895: long i; ! 896: for(i=0L; i < rb.vars.f8.wait_time; i+=128) ! 897: ; ! 898: ! 899: d2_func(&rb, INTERRUPT_P); ! 900: } ! 901: ! 902: if (rb.ret_code == 0) /* Finished */ ! 903: { ! 904: ps.ps_actf->b_resid = 0; ! 905: psdone(); ! 906: } ! 907: else if (rb.ret_code == 1) /* Wat for int */ ! 908: { ! 909: /*ps.ps_state = SINT; */ ! 910: } ! 911: else ! 912: { ! 913: register BUF *bp = ps.ps_actf; ! 914: ! 915: psstatus(); ! 916: bp->b_flag |= BFERR; ! 917: psdone(); ! 918: } ! 919: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.