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