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