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