![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devata.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc|
Return to devata.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / pc |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "io.h"
7: #include "../port/error.h"
8:
9: #include "devtab.h"
10:
11: #define DPRINT if(0)print
12:
13: typedef struct Drive Drive;
14: typedef struct Ident Ident;
15: typedef struct Controller Controller;
16: typedef struct Partition Partition;
17: typedef struct Repl Repl;
18:
19: enum
20: {
21: /* ports */
22: Pbase0= 0x1F0,
23: Pbase1= 0x170,
24: Pdata= 0, /* data port (16 bits) */
25: Perror= 1, /* error port (read) */
26: Pprecomp= 1, /* buffer mode port (write) */
27: Pcount= 2, /* sector count port */
28: Psector= 3, /* sector number port */
29: Pcyllsb= 4, /* least significant byte cylinder # */
30: Pcylmsb= 5, /* most significant byte cylinder # */
31: Pdh= 6, /* drive/head port */
32: Pstatus= 7, /* status port (read) */
33: Sbusy= (1<<7),
34: Sready= (1<<6),
35: Sdrq= (1<<3),
36: Serr= (1<<0),
37: Pcmd= 7, /* cmd port (write) */
38:
39: /* commands */
40: Crecal= 0x10,
41: Cread= 0x20,
42: Cwrite= 0x30,
43: Cident= 0xEC,
44: Cident2= 0xFF, /* pseudo command for post Cident interrupt */
45: Csetbuf= 0xEF,
46: Cinitparam= 0x91,
47:
48: /* conner specific commands */
49: Cstandby= 0xE2,
50: Cidle= 0xE1,
51: Cpowerdown= 0xE3,
52:
53: /* disk states */
54: Sspinning,
55: Sstandby,
56: Sidle,
57: Spowerdown,
58:
59: /* something we have to or into the drive/head reg */
60: DHmagic= 0xA0,
61:
62: /* file types */
63: Qdir= 0,
64:
65: Maxxfer= BY2PG, /* maximum transfer size/cmd */
66: Npart= 8+2, /* 8 sub partitions, disk, and partition */
67: Nrepl= 64, /* maximum replacement blocks */
68:
69: Hardtimeout= 4000, /* disk access timeout */
70: };
71: #define PART(x) ((x)&0xF)
72: #define DRIVE(x) (((x)>>4)&0x7)
73: #define MKQID(d,p) (((d)<<4) | (p))
74:
75: struct Partition
76: {
77: ulong start;
78: ulong end;
79: char name[NAMELEN+1];
80: };
81:
82: struct Repl
83: {
84: Partition *p;
85: int nrepl;
86: ulong blk[Nrepl];
87: };
88:
89: #define PARTMAGIC "plan9 partitions"
90: #define REPLMAGIC "block replacements"
91:
92: /*
93: * an ata drive
94: */
95: struct Drive
96: {
97: QLock;
98:
99: Controller *cp;
100: int drive;
101: int confused; /* needs to be recalibrated (or worse) */
102: int online;
103: int npart; /* number of real partitions */
104: Partition p[Npart];
105: Repl repl;
106: ulong usetime;
107: int state;
108: char vol[NAMELEN];
109:
110: ulong cap; /* total bytes */
111: int bytes; /* bytes/sector */
112: int sectors; /* sectors/track */
113: int heads; /* heads/cyl */
114: long cyl; /* cylinders/drive */
115:
116: char lba; /* true if drive has logical block addressing */
117: char multi; /* non-zero if drive does multiple block xfers */
118: };
119:
120: /*
121: * a controller for 2 drives
122: */
123: struct Controller
124: {
125: QLock; /* exclusive access to the controller */
126:
127: Lock reglock; /* exclusive access to the registers */
128:
129: int confused; /* needs to be recalibrated (or worse) */
130: int pbase; /* base port */
131:
132: /*
133: * current operation
134: */
135: int cmd; /* current command */
136: int lastcmd; /* debugging info */
137: Rendez r; /* wait here for command termination */
138: char *buf; /* xfer buffer */
139: int nsecs; /* length of transfer (sectors) */
140: int sofar; /* sectors transferred so far */
141: int status;
142: int error;
143: Drive *dp; /* drive being accessed */
144: };
145:
146: Controller *atac;
147: Drive *ata;
148: static int spindowntime;
149:
150: static void ataintr(Ureg*, void*);
151: static long ataxfer(Drive*, Partition*, int, long, long, char*);
152: static void ataident(Drive*);
153: static void atasetbuf(Drive*, int);
154: static void ataparams(Drive*);
155: static void atapart(Drive*);
156: static int ataprobe(Drive*, int, int, int);
157:
158: static int
159: atagen(Chan *c, Dirtab *tab, long ntab, long s, Dir *dirp)
160: {
161: Qid qid;
162: int drive;
163: char name[NAMELEN+4];
164: Drive *dp;
165: Partition *pp;
166: ulong l;
167:
168: USED(tab, ntab);
169: qid.vers = 0;
170: drive = s/Npart;
171: s = s % Npart;
172: if(drive >= conf.nhard)
173: return -1;
174: dp = &ata[drive];
175:
176: if(dp->online == 0 || s >= dp->npart)
177: return 0;
178:
179: pp = &dp->p[s];
180: sprint(name, "%s%s", dp->vol, pp->name);
181: name[NAMELEN] = 0;
182: qid.path = MKQID(drive, s);
183: l = (pp->end - pp->start) * dp->bytes;
184: devdir(c, qid, name, l, eve, 0660, dirp);
185: return 1;
186: }
187:
188: void
189: atareset(void)
190: {
191: Drive *dp;
192: Controller *cp;
193: uchar equip;
194: char *p;
195:
196: equip = nvramread(0x12);
197: if(equip == 0)
198: equip = 0x10; /* the Globalyst 250 lies */
199:
200: ata = xalloc(2 * sizeof(Drive));
201: atac = xalloc(sizeof(Controller));
202:
203: cp = atac;
204: cp->buf = 0;
205: cp->lastcmd = cp->cmd;
206: cp->cmd = 0;
207: cp->pbase = Pbase0;
208: setvec(ATAvec0, ataintr, 0);
209:
210: dp = ata;
211: if(equip & 0xf0){
212: dp->drive = 0;
213: dp->online = 0;
214: dp->cp = cp;
215: dp++;
216: }
217: if((equip & 0x0f)){
218: dp->drive = 1;
219: dp->online = 0;
220: dp->cp = cp;
221: dp++;
222: }
223: conf.nhard = dp - ata;
224:
225: if(conf.nhard && (p = getconf("spindowntime")))
226: spindowntime = atoi(p);
227: }
228:
229: void
230: atainit(void)
231: {
232: }
233:
234: /*
235: * Get the characteristics of each drive. Mark unresponsive ones
236: * off line.
237: */
238: Chan*
239: ataattach(char *spec)
240: {
241: Drive *dp;
242:
243: for(dp = ata; dp < &ata[conf.nhard]; dp++){
244: if(waserror()){
245: dp->online = 0;
246: qunlock(dp);
247: continue;
248: }
249: qlock(dp);
250: if(!dp->online){
251: /*
252: * Make sure ataclock() doesn't
253: * interfere.
254: */
255: dp->usetime = m->ticks;
256: ataparams(dp);
257: dp->online = 1;
258: atasetbuf(dp, 1);
259: }
260:
261: /*
262: * read Plan 9 partition table
263: */
264: atapart(dp);
265: qunlock(dp);
266: poperror();
267: }
268: return devattach('H', spec);
269: }
270:
271: Chan*
272: ataclone(Chan *c, Chan *nc)
273: {
274: return devclone(c, nc);
275: }
276:
277: int
278: atawalk(Chan *c, char *name)
279: {
280: return devwalk(c, name, 0, 0, atagen);
281: }
282:
283: void
284: atastat(Chan *c, char *dp)
285: {
286: devstat(c, dp, 0, 0, atagen);
287: }
288:
289: Chan*
290: ataopen(Chan *c, int omode)
291: {
292: return devopen(c, omode, 0, 0, atagen);
293: }
294:
295: void
296: atacreate(Chan *c, char *name, int omode, ulong perm)
297: {
298: USED(c, name, omode, perm);
299: error(Eperm);
300: }
301:
302: void
303: ataclose(Chan *c)
304: {
305: Drive *d;
306: Partition *p;
307:
308: if(c->mode != OWRITE && c->mode != ORDWR)
309: return;
310:
311: d = &ata[DRIVE(c->qid.path)];
312: p = &d->p[PART(c->qid.path)];
313: if(strcmp(p->name, "partition") != 0)
314: return;
315:
316: if(waserror()){
317: qunlock(d);
318: nexterror();
319: }
320: qlock(d);
321: atapart(d);
322: qunlock(d);
323: poperror();
324: }
325:
326: void
327: ataremove(Chan *c)
328: {
329: USED(c);
330: error(Eperm);
331: }
332:
333: void
334: atawstat(Chan *c, char *dp)
335: {
336: USED(c, dp);
337: error(Eperm);
338: }
339:
340: long
341: ataread(Chan *c, void *a, long n, ulong offset)
342: {
343: Drive *dp;
344: long rv, i;
345: int skip;
346: uchar *aa = a;
347: Partition *pp;
348: char *buf;
349:
350: if(c->qid.path == CHDIR)
351: return devdirread(c, a, n, 0, 0, atagen);
352:
353: buf = smalloc(Maxxfer);
354: if(waserror()){
355: free(buf);
356: nexterror();
357: }
358:
359: dp = &ata[DRIVE(c->qid.path)];
360: pp = &dp->p[PART(c->qid.path)];
361:
362: skip = offset % dp->bytes;
363: for(rv = 0; rv < n; rv += i){
364: i = ataxfer(dp, pp, Cread, offset+rv-skip, n-rv+skip, buf);
365: if(i == 0)
366: break;
367: i -= skip;
368: if(i > n - rv)
369: i = n - rv;
370: memmove(aa+rv, buf + skip, i);
371: skip = 0;
372: }
373:
374: free(buf);
375: poperror();
376:
377: return rv;
378: }
379:
380: long
381: atawrite(Chan *c, void *a, long n, ulong offset)
382: {
383: Drive *dp;
384: long rv, i, partial;
385: uchar *aa = a;
386: Partition *pp;
387: char *buf;
388:
389: if(c->qid.path == CHDIR)
390: error(Eisdir);
391:
392: dp = &ata[DRIVE(c->qid.path)];
393: pp = &dp->p[PART(c->qid.path)];
394: buf = smalloc(Maxxfer);
395: if(waserror()){
396: free(buf);
397: nexterror();
398: }
399:
400: /*
401: * if not starting on a sector boundary,
402: * read in the first sector before writing
403: * it out.
404: */
405: partial = offset % dp->bytes;
406: if(partial){
407: ataxfer(dp, pp, Cread, offset-partial, dp->bytes, buf);
408: if(partial+n > dp->bytes)
409: rv = dp->bytes - partial;
410: else
411: rv = n;
412: memmove(buf+partial, aa, rv);
413: ataxfer(dp, pp, Cwrite, offset-partial, dp->bytes, buf);
414: } else
415: rv = 0;
416:
417: /*
418: * write out the full sectors
419: */
420: partial = (n - rv) % dp->bytes;
421: n -= partial;
422: for(; rv < n; rv += i){
423: i = n - rv;
424: if(i > Maxxfer)
425: i = Maxxfer;
426: memmove(buf, aa+rv, i);
427: i = ataxfer(dp, pp, Cwrite, offset+rv, i, buf);
428: if(i == 0)
429: break;
430: }
431:
432: /*
433: * if not ending on a sector boundary,
434: * read in the last sector before writing
435: * it out.
436: */
437: if(partial){
438: ataxfer(dp, pp, Cread, offset+rv, dp->bytes, buf);
439: memmove(buf, aa+rv, partial);
440: ataxfer(dp, pp, Cwrite, offset+rv, dp->bytes, buf);
441: rv += partial;
442: }
443:
444: free(buf);
445: poperror();
446:
447: return rv;
448: }
449:
450: /*
451: * did an interrupt happen?
452: */
453: static int
454: cmddone(void *a)
455: {
456: Controller *cp = a;
457:
458: return cp->cmd == 0;
459: }
460:
461: /*
462: * Wait for the controller to be ready to accept a command.
463: * This is protected from intereference by ataclock() by
464: * setting dp->usetime before it is called.
465: */
466: static void
467: cmdreadywait(Drive *dp)
468: {
469: long start;
470: int period;
471: Controller *cp = dp->cp;
472:
473: /* give it 2 seconds to spin down and up */
474: if(dp->state == Sspinning)
475: period = 10;
476: else
477: period = 2000;
478:
479: start = m->ticks;
480: while((inb(cp->pbase+Pstatus) & (Sready|Sbusy)) != Sready)
481: if(TK2MS(m->ticks - start) > period){
482: DPRINT("cmdreadywait failed\n");
483: error(Eio);
484: }
485: }
486:
487: static void
488: atarepl(Drive *dp, long bblk)
489: {
490: int i;
491:
492: if(dp->repl.p == 0)
493: return;
494: for(i = 0; i < dp->repl.nrepl; i++){
495: if(dp->repl.blk[i] == bblk)
496: DPRINT("found bblk %ld at offset %ld\n", bblk, i);
497: }
498: }
499:
500: static void
501: atasleep(Controller *cp)
502: {
503: tsleep(&cp->r, cmddone, cp, Hardtimeout);
504: if(cp->cmd && cp->cmd != Cident2){
505: DPRINT("hard drive timeout\n");
506: error("ata drive timeout");
507: }
508: }
509:
510:
511: /*
512: * transfer a number of sectors. ataintr will perform all the iterative
513: * parts.
514: */
515: static long
516: ataxfer(Drive *dp, Partition *pp, int cmd, long start, long len, char *buf)
517: {
518: Controller *cp;
519: long lblk;
520: int cyl, sec, head;
521: int loop, stat;
522:
523: if(dp->online == 0)
524: error(Eio);
525:
526: /*
527: * cut transfer size down to disk buffer size
528: */
529: start = start / dp->bytes;
530: if(len > Maxxfer)
531: len = Maxxfer;
532: len = (len + dp->bytes - 1) / dp->bytes;
533: if(len == 0)
534: return 0;
535:
536: /*
537: * calculate physical address
538: */
539: lblk = start + pp->start;
540: if(lblk >= pp->end)
541: return 0;
542: if(lblk+len > pp->end)
543: len = pp->end - lblk;
544: if(dp->lba){
545: sec = lblk & 0xff;
546: cyl = (lblk>>8) & 0xffff;
547: head = (lblk>>24) & 0xf;
548: } else {
549: cyl = lblk/(dp->sectors*dp->heads);
550: sec = (lblk % dp->sectors) + 1;
551: head = ((lblk/dp->sectors) % dp->heads);
552: }
553:
554: cp = dp->cp;
555: qlock(cp);
556: if(waserror()){
557: cp->buf = 0;
558: qunlock(cp);
559: nexterror();
560: }
561:
562: /*
563: * Make sure hardclock() doesn't
564: * interfere.
565: */
566: dp->usetime = m->ticks;
567: cmdreadywait(dp);
568:
569: ilock(&cp->reglock);
570: cp->sofar = 0;
571: cp->buf = buf;
572: cp->nsecs = len;
573: cp->cmd = cmd;
574: cp->dp = dp;
575: cp->status = 0;
576:
577: outb(cp->pbase+Pcount, cp->nsecs);
578: outb(cp->pbase+Psector, sec);
579: outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4) | (dp->lba<<6) | head);
580: outb(cp->pbase+Pcyllsb, cyl);
581: outb(cp->pbase+Pcylmsb, cyl>>8);
582: outb(cp->pbase+Pcmd, cmd);
583:
584: if(cmd == Cwrite){
585: loop = 0;
586: while((stat = inb(cp->pbase+Pstatus) & (Serr|Sdrq)) == 0)
587: if(++loop > 10000)
588: panic("ataxfer");
589: outss(cp->pbase+Pdata, cp->buf, dp->bytes/2);
590: } else
591: stat = 0;
592: iunlock(&cp->reglock);
593:
594: if(stat & Serr)
595: error(Eio);
596:
597: /*
598: * wait for command to complete. if we get a note,
599: * remember it but keep waiting to let the disk finish
600: * the current command.
601: */
602: loop = 0;
603: while(waserror()){
604: DPRINT("interrupted ataxfer\n");
605: if(loop++ > 10){
606: print("ata disk error\n");
607: nexterror();
608: }
609: }
610: atasleep(cp);
611: dp->state = Sspinning;
612: dp->usetime = m->ticks;
613: poperror();
614: if(loop)
615: nexterror();
616:
617: if(cp->status & Serr){
618: DPRINT("hd%d err: lblk %ld status %lux, err %lux\n",
619: dp-ata, lblk, cp->status, cp->error);
620: DPRINT("\tcyl %d, sec %d, head %d\n", cyl, sec, head);
621: DPRINT("\tnsecs %d, sofar %d\n", cp->nsecs, cp->sofar);
622: atarepl(dp, lblk+cp->sofar);
623: error(Eio);
624: }
625: cp->buf = 0;
626: len = cp->sofar*dp->bytes;
627: qunlock(cp);
628: poperror();
629:
630: return len;
631: }
632:
633: /*
634: * set read ahead mode
635: */
636: static void
637: atasetbuf(Drive *dp, int on)
638: {
639: Controller *cp = dp->cp;
640:
641: qlock(cp);
642: if(waserror()){
643: qunlock(cp);
644: nexterror();
645: }
646:
647: cmdreadywait(dp);
648:
649: ilock(&cp->reglock);
650: cp->cmd = Csetbuf;
651: outb(cp->pbase+Pprecomp, on ? 0xAA : 0x55); /* read look ahead */
652: outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4));
653: outb(cp->pbase+Pcmd, Csetbuf);
654: iunlock(&cp->reglock);
655:
656: atasleep(cp);
657:
658: /* if(cp->status & Serr)
659: DPRINT("hd%d setbuf err: status %lux, err %lux\n",
660: dp-ata, cp->status, cp->error);/**/
661:
662: poperror();
663: qunlock(cp);
664: }
665:
666: /*
667: * ident sector from drive. this is from ANSI X3.221-1994
668: */
669: struct Ident
670: {
671: ushort config; /* general configuration info */
672: ushort cyls; /* # of cylinders (default) */
673: ushort reserved0;
674: ushort heads; /* # of heads (default) */
675: ushort b2t; /* unformatted bytes/track */
676: ushort b2s; /* unformated bytes/sector */
677: ushort s2t; /* sectors/track (default) */
678: ushort reserved1[3];
679: /* 10 */
680: ushort serial[10]; /* serial number */
681: ushort type; /* buffer type */
682: ushort bsize; /* buffer size/512 */
683: ushort ecc; /* ecc bytes returned by read long */
684: ushort firm[4]; /* firmware revision */
685: ushort model[20]; /* model number */
686: /* 47 */
687: ushort s2i; /* number of sectors/interrupt */
688: ushort dwtf; /* double word transfer flag */
689: ushort capabilities;
690: ushort reserved2;
691: ushort piomode;
692: ushort dmamode;
693: ushort cvalid; /* (cvald&1) if next 4 words are valid */
694: ushort ccyls; /* current # cylinders */
695: ushort cheads; /* current # heads */
696: ushort cs2t; /* current sectors/track */
697: ushort ccap[2]; /* current capacity in sectors */
698: ushort cs2i; /* current number of sectors/interrupt */
699: /* 60 */
700: ushort lbasecs[2]; /* # LBA user addressable sectors */
701: ushort dmasingle;
702: ushort dmadouble;
703: /* 64 */
704: ushort reserved3[64];
705: ushort vendor[32]; /* vendor specific */
706: ushort reserved4[96];
707: };
708:
709: /*
710: * get parameters from the drive
711: */
712: static void
713: ataident(Drive *dp)
714: {
715: Controller *cp;
716: char *buf;
717: Ident *ip;
718: char id[21];
719:
720: cp = dp->cp;
721: buf = smalloc(Maxxfer);
722: qlock(cp);
723: if(waserror()){
724: qunlock(cp);
725: nexterror();
726: }
727:
728: cmdreadywait(dp);
729:
730: ilock(&cp->reglock);
731: cp->nsecs = 1;
732: cp->sofar = 0;
733: cp->cmd = Cident;
734: cp->dp = dp;
735: cp->buf = buf;
736: outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4));
737: outb(cp->pbase+Pcmd, Cident);
738: iunlock(&cp->reglock);
739:
740: atasleep(cp);
741:
742: if(cp->status & Serr){
743: DPRINT("bad disk ident status\n");
744: error(Eio);
745: }
746: ip = (Ident*)buf;
747:
748: /*
749: * this function appears to respond with an extra interrupt after
750: * the ident information is read, except on the safari. The following
751: * delay gives this extra interrupt a chance to happen while we are quiet.
752: * Otherwise, the interrupt may come during a subsequent read or write,
753: * causing a panic and much confusion.
754: */
755: if (cp->cmd == Cident2)
756: tsleep(&cp->r, return0, 0, Hardtimeout);
757:
758: memmove(id, ip->model, sizeof(id)-1);
759: id[sizeof(id)-1] = 0;
760:
761: if(ip->capabilities & (1<<9)){
762: dp->lba = 1;
763: dp->sectors = (ip->lbasecs[0]) | (ip->lbasecs[1]<<16);
764: dp->cap = dp->bytes * dp->sectors;
765: /*print("\nata%d model %s with %d lba sectors\n", dp->drive, id, dp->sectors);/**/
766: } else {
767: dp->lba = 0;
768:
769: /* use default (unformatted) settings */
770: dp->cyl = ip->cyls;
771: dp->heads = ip->heads;
772: dp->sectors = ip->s2t;
773: /*print("\nata%d model %s with default %d cyl %d head %d sec\n", dp->drive,
774: id, dp->cyl, dp->heads, dp->sectors);/**/
775:
776: if(ip->cvalid&(1<<0)){
777: /* use current settings */
778: dp->cyl = ip->ccyls;
779: dp->heads = ip->cheads;
780: dp->sectors = ip->cs2t;
781: /*print("\tchanged to %d cyl %d head %d sec\n", dp->cyl, dp->heads, dp->sectors);/**/
782: }
783: dp->cap = dp->bytes * dp->cyl * dp->heads * dp->sectors;
784: }
785: cp->lastcmd = cp->cmd;
786: cp->cmd = 0;
787: cp->buf = 0;
788: free(buf);
789: poperror();
790: qunlock(cp);
791: }
792:
793: /*
794: * probe the given sector to see if it exists
795: */
796: static int
797: ataprobe(Drive *dp, int cyl, int sec, int head)
798: {
799: Controller *cp;
800: char *buf;
801: int rv;
802:
803: cp = dp->cp;
804: buf = smalloc(Maxxfer);
805: qlock(cp);
806: if(waserror()){
807: free(buf);
808: qunlock(cp);
809: nexterror();
810: }
811:
812: cmdreadywait(dp);
813:
814: ilock(&cp->reglock);
815: cp->cmd = Cread;
816: cp->dp = dp;
817: cp->status = 0;
818: cp->nsecs = 1;
819: cp->sofar = 0;
820:
821: outb(cp->pbase+Pcount, 1);
822: outb(cp->pbase+Psector, sec+1);
823: outb(cp->pbase+Pdh, DHmagic | head | (dp->lba<<6) | (dp->drive<<4));
824: outb(cp->pbase+Pcyllsb, cyl);
825: outb(cp->pbase+Pcylmsb, cyl>>8);
826: outb(cp->pbase+Pcmd, Cread);
827: iunlock(&cp->reglock);
828:
829: atasleep(cp);
830:
831: if(cp->status & Serr)
832: rv = -1;
833: else
834: rv = 0;
835:
836: cp->buf = 0;
837: free(buf);
838: poperror();
839: qunlock(cp);
840: return rv;
841: }
842:
843: /*
844: * figure out the drive parameters
845: */
846: static void
847: ataparams(Drive *dp)
848: {
849: int i, hi, lo;
850:
851: /*
852: * first try the easy way, ask the drive and make sure it
853: * isn't lying.
854: */
855: dp->bytes = 512;
856: ataident(dp);
857: if(dp->lba){
858: i = dp->sectors - 1;
859: if(ataprobe(dp, (i>>8)&0xffff, (i&0xff)-1, (i>>24)&0xf) == 0)
860: return;
861: } else {
862: if(ataprobe(dp, dp->cyl-1, dp->sectors-1, dp->heads-1) == 0)
863: return;
864: }
865:
866: /*
867: * the drive lied, determine parameters by seeing which ones
868: * work to read sectors.
869: */
870: dp->lba = 0;
871: for(i = 0; i < 32; i++)
872: if(ataprobe(dp, 0, 0, i) < 0)
873: break;
874: dp->heads = i;
875: for(i = 0; i < 128; i++)
876: if(ataprobe(dp, 0, i, 0) < 0)
877: break;
878: dp->sectors = i;
879: for(i = 512; ; i += 512)
880: if(ataprobe(dp, i, dp->sectors-1, dp->heads-1) < 0)
881: break;
882: lo = i - 512;
883: hi = i;
884: for(; hi-lo > 1;){
885: i = lo + (hi - lo)/2;
886: if(ataprobe(dp, i, dp->sectors-1, dp->heads-1) < 0)
887: hi = i;
888: else
889: lo = i;
890: }
891: dp->cyl = lo + 1;
892: dp->cap = dp->bytes * dp->cyl * dp->heads * dp->sectors;
893: }
894:
895: /*
896: * Read block replacement table.
897: * The table is just ascii block numbers.
898: */
899: static void
900: atareplinit(Drive *dp)
901: {
902: char *line[Nrepl+1];
903: char *field[1];
904: ulong n;
905: int i;
906: char *buf;
907:
908: /*
909: * check the partition is big enough
910: */
911: if(dp->repl.p->end - dp->repl.p->start < Nrepl+1){
912: dp->repl.p = 0;
913: return;
914: }
915:
916: buf = smalloc(Maxxfer);
917: if(waserror()){
918: free(buf);
919: nexterror();
920: }
921:
922: /*
923: * read replacement table from disk, null terminate
924: */
925: ataxfer(dp, dp->repl.p, Cread, 0, dp->bytes, buf);
926: buf[dp->bytes-1] = 0;
927:
928: /*
929: * parse replacement table.
930: */
931: n = getfields(buf, line, Nrepl+1, "\n");
932: if(strncmp(line[0], REPLMAGIC, sizeof(REPLMAGIC)-1)){
933: dp->repl.p = 0;
934: } else {
935: for(dp->repl.nrepl = 0, i = 1; i < n; i++, dp->repl.nrepl++){
936: if(getfields(line[i], field, 1, " ") != 1)
937: break;
938: dp->repl.blk[dp->repl.nrepl] = strtoul(field[0], 0, 0);
939: if(dp->repl.blk[dp->repl.nrepl] <= 0)
940: break;
941: }
942: }
943: free(buf);
944: poperror();
945: }
946:
947: /*
948: * read partition table. The partition table is just ascii strings.
949: */
950: static void
951: atapart(Drive *dp)
952: {
953: Partition *pp;
954: char *line[Npart+1];
955: char *field[3];
956: ulong n;
957: int i;
958: char *buf;
959:
960: sprint(dp->vol, "hd%d", dp - ata);
961:
962: /*
963: * we always have a partition for the whole disk
964: * and one for the partition table
965: */
966: pp = &dp->p[0];
967: strcpy(pp->name, "disk");
968: pp->start = 0;
969: pp->end = dp->cap / dp->bytes;
970: pp++;
971: strcpy(pp->name, "partition");
972: pp->start = dp->p[0].end - 1;
973: pp->end = dp->p[0].end;
974: dp->npart = 2;
975:
976: /*
977: * initialise the bad-block replacement info
978: */
979: dp->repl.p = 0;
980:
981: buf = smalloc(Maxxfer);
982: if(waserror()){
983: free(buf);
984: nexterror();
985: }
986:
987: /*
988: * read last sector from disk, null terminate. This used
989: * to be the sector we used for the partition tables.
990: * However, this sector is special on some PC's so we've
991: * started to use the second last sector as the partition
992: * table instead. To avoid reconfiguring all our old systems
993: * we first look to see if there is a valid partition
994: * table in the last sector. If so, we use it. Otherwise
995: * we switch to the second last.
996: */
997: ataxfer(dp, pp, Cread, 0, dp->bytes, buf);
998: buf[dp->bytes-1] = 0;
999: n = getfields(buf, line, Npart+1, "\n");
1000: if(n == 0 || strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1)){
1001: dp->p[0].end--;
1002: dp->p[1].start--;
1003: dp->p[1].end--;
1004: ataxfer(dp, pp, Cread, 0, dp->bytes, buf);
1005: buf[dp->bytes-1] = 0;
1006: n = getfields(buf, line, Npart+1, "\n");
1007: }
1008:
1009: /*
1010: * parse partition table.
1011: */
1012: if(n && strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1) == 0){
1013: for(i = 1; i < n; i++){
1014: pp++;
1015: switch(getfields(line[i], field, 3, " ")) {
1016: case 2:
1017: if(strcmp(field[0], "unit") == 0)
1018: strncpy(dp->vol, field[1], NAMELEN);
1019: break;
1020: case 3:
1021: strncpy(pp->name, field[0], NAMELEN);
1022: if(strncmp(pp->name, "repl", NAMELEN) == 0)
1023: dp->repl.p = pp;
1024: pp->start = strtoul(field[1], 0, 0);
1025: pp->end = strtoul(field[2], 0, 0);
1026: if(pp->start > pp->end || pp->start >= dp->p[0].end)
1027: break;
1028: dp->npart++;
1029: }
1030: }
1031: }
1032: free(buf);
1033: poperror();
1034:
1035: if(dp->repl.p)
1036: atareplinit(dp);
1037: }
1038:
1039: enum
1040: {
1041: Maxloop= 10000,
1042: };
1043:
1044: /*
1045: * we get an interrupt for every sector transferred
1046: */
1047: static void
1048: ataintr(Ureg *ur, void *arg)
1049: {
1050: Controller *cp;
1051: Drive *dp;
1052: long loop;
1053: char *addr;
1054:
1055: USED(ur, arg);
1056:
1057: /*
1058: * BUG!! if there is ever more than one controller, we need a way to
1059: * distinguish which interrupted (use arg).
1060: */
1061: cp = &atac[0];
1062: dp = cp->dp;
1063:
1064: ilock(&cp->reglock);
1065:
1066: loop = 0;
1067: while((cp->status = inb(cp->pbase+Pstatus)) & Sbusy){
1068: if(++loop > Maxloop) {
1069: DPRINT("cmd=%lux status=%lux\n",
1070: cp->cmd, inb(cp->pbase+Pstatus));
1071: panic("ataintr: wait busy");
1072: }
1073: }
1074:
1075: switch(cp->cmd){
1076: case Cwrite:
1077: if(cp->status & Serr){
1078: cp->lastcmd = cp->cmd;
1079: cp->cmd = 0;
1080: cp->error = inb(cp->pbase+Perror);
1081: wakeup(&cp->r);
1082: break;
1083: }
1084: cp->sofar++;
1085: if(cp->sofar < cp->nsecs){
1086: loop = 0;
1087: while(((cp->status = inb(cp->pbase+Pstatus)) & Sdrq) == 0)
1088: if(++loop > Maxloop) {
1089: DPRINT("cmd=%lux status=%lux\n",
1090: cp->cmd, inb(cp->pbase+Pstatus));
1091: panic("ataintr: write");
1092: }
1093: addr = cp->buf;
1094: if(addr){
1095: addr += cp->sofar*dp->bytes;
1096: outss(cp->pbase+Pdata, addr, dp->bytes/2);
1097: }
1098: } else{
1099: cp->lastcmd = cp->cmd;
1100: cp->cmd = 0;
1101: wakeup(&cp->r);
1102: }
1103: break;
1104: case Cread:
1105: case Cident:
1106: loop = 0;
1107: while((cp->status & (Serr|Sdrq)) == 0){
1108: if(++loop > Maxloop) {
1109: DPRINT("cmd=%lux status=%lux\n",
1110: cp->cmd, inb(cp->pbase+Pstatus));
1111: panic("ataintr: read/ident");
1112: }
1113: cp->status = inb(cp->pbase+Pstatus);
1114: }
1115: if(cp->status & Serr){
1116: cp->lastcmd = cp->cmd;
1117: cp->cmd = 0;
1118: cp->error = inb(cp->pbase+Perror);
1119: wakeup(&cp->r);
1120: break;
1121: }
1122: addr = cp->buf;
1123: if(addr){
1124: addr += cp->sofar*dp->bytes;
1125: inss(cp->pbase+Pdata, addr, dp->bytes/2);
1126: }
1127: cp->sofar++;
1128: if(cp->sofar > cp->nsecs)
1129: print("ataintr %d %d\n", cp->sofar, cp->nsecs);
1130: if(cp->sofar >= cp->nsecs){
1131: cp->lastcmd = cp->cmd;
1132: if (cp->cmd == Cread)
1133: cp->cmd = 0;
1134: else
1135: cp->cmd = Cident2;
1136: wakeup(&cp->r);
1137: }
1138: break;
1139: case Cinitparam:
1140: case Csetbuf:
1141: case Cidle:
1142: case Cstandby:
1143: case Cpowerdown:
1144: cp->lastcmd = cp->cmd;
1145: cp->cmd = 0;
1146: wakeup(&cp->r);
1147: break;
1148: case Cident2:
1149: cp->lastcmd = cp->cmd;
1150: cp->cmd = 0;
1151: break;
1152: default:
1153: print("weird disk interrupt, cmd=%.2ux, lastcmd= %.2ux status=%.2ux\n",
1154: cp->cmd, cp->lastcmd, cp->status);
1155: break;
1156: }
1157:
1158: iunlock(&cp->reglock);
1159: }
1160:
1161: void
1162: hardclock(void)
1163: {
1164: int drive;
1165: Drive *dp;
1166: Controller *cp;
1167: int diff;
1168:
1169: if(spindowntime <= 0)
1170: return;
1171:
1172: for(drive = 0; drive < conf.nhard; drive++){
1173: dp = &ata[drive];
1174: cp = dp->cp;
1175:
1176: diff = TK2SEC(m->ticks - dp->usetime);
1177: if((dp->state == Sspinning) && (diff >= spindowntime)){
1178: ilock(&cp->reglock);
1179: cp->cmd = Cstandby;
1180: outb(cp->pbase+Pcount, 0);
1181: outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4) | 0);
1182: outb(cp->pbase+Pcmd, cp->cmd);
1183: iunlock(&cp->reglock);
1184: dp->state = Sstandby;
1185: }
1186: }
1187: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.