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