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