![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / boot / stand|
Return to sd.c CVS log | Up to [Research Unix] / researchv9 / sys / boot / stand |
1.1 root 1: /*
2: * @(#)sd.c 1.1 86/02/03 Copyright (c) 1985 by Sun Microsystems, Inc.
3: */
4: #include <sys/param.h>
5: #include <sys/inode.h>
6: #include <sun/dklabel.h>
7: #include <sun/dkio.h>
8: #include <sys/buf.h>
9: #include <sundev/screg.h>
10: #include <sundev/sireg.h>
11: #include <sundev/scsi.h>
12: #include <machine/sunromvec.h>
13: #include <machine/idprom.h>
14: #include "saio.h"
15: #include "param.h"
16:
17: /* For RAM-based code, print detailed error messages */
18: #if !defined(SDBOOT) && !defined(BOOTBLOCK)
19: #define SDERRORS
20: #endif
21:
22: /*
23: * Scsi disk parameter block
24: */
25: struct sdparam {
26: int sd_target;
27: int sd_unit;
28: int sd_boff;
29: #ifdef SUN3
30: int sd_ha_type;
31: #endif
32: struct saioreq subsip[1]; /* Sip for host adapter */
33: };
34:
35: /*
36: * Record an error message from scsi
37: */
38: #define DEBUG FIXME
39:
40: #if (!defined(SDBOOT)) & !defined(STBOOT) & !defined(DEBUG)
41:
42: #define sc_error(msg) scerrmsg = msg
43: #define DEFERRED_ERRORS
44: extern char *scerrmsg;
45:
46: #else
47:
48: extern sc_error(); /* It's in sc.c */
49: #undef DEFERRED_ERRORS
50:
51: #endif
52:
53: /*
54: * Our DMA space
55: */
56: struct sddma {
57: char buffer[MAXBSIZE];
58: struct dk_label xlabel[1];
59: };
60:
61: #define SDBUF (((struct sddma *)sip->si_dmaaddr)->buffer)
62: #define label (((struct sddma *)sip->si_dmaaddr)->xlabel)
63:
64: /*
65: * What resources we need to run
66: */
67: struct devinfo sdinfo = {
68: 0, /* No device to map in */
69: sizeof (struct sddma),
70: sizeof (struct sdparam),
71: 0, /* Dummy devices */
72: 0, /* Dummy devices */
73: MAP_MAINMEM,
74: MAXBSIZE, /* transfer size */
75: };
76:
77: /*
78: * The interfaces we export
79: */
80: extern int xxprobe(), xxboot();
81: int sdopen(), sdclose(), sdstrategy();
82:
83: struct boottab sddriver = {
84: "sd", xxprobe, xxboot,
85: sdopen, sdclose, sdstrategy,
86: "sd: Adaptec SCSI disk", &sdinfo
87: };
88:
89: #ifndef BOOTBLOCK
90:
91: /*
92: * Test routine for isspinning() to see if SCSI disk is running.
93: */
94: sdspin(sip, dummy)
95: struct saioreq *sip;
96: int dummy;
97: {
98:
99: #ifdef lint
100: dummy = dummy;
101: #endif lint
102: sip->si_bn = 0;
103: sip->si_cc = 0;
104: sip->si_ma = 0;
105: return (sdcmd (SC_TEST_UNIT_READY, sip, 0));
106: }
107: #endif
108:
109: #ifdef SUN3
110: /*
111: * Determine type of host adaptor interface, si or sc.
112: * Returns 1 if si host adaptor and 0 if sc host adaptor.
113: */
114: sd_probe(sip)
115: struct saioreq *sip;
116: {
117: if (siprobe(sip)) {
118: return (1);
119: } else {
120: return (0);
121: }
122: }
123: #endif
124:
125: /*
126: * Open the SCSI Disk controller
127: */
128: sdopen(sip)
129: register struct saioreq *sip;
130: {
131: register struct sdparam *sdp;
132: register short *sp, sum;
133: register int count, r;
134:
135: sdp = (struct sdparam *)sip->si_devdata;
136: bzero( (char *)sdp, (sizeof (struct sdparam)));
137:
138: /*
139: * Open the host adapter
140: */
141: *sdp->subsip = *sip; /* Initialize sub-sip */
142: #ifdef SUN3
143: {
144: extern struct boottab scdriver;
145: extern struct boottab sidriver;
146:
147: /* FIXME, find out which scsi interface to use */
148: if (sd_probe(sip)) {
149: sdp->sd_ha_type = 1;
150:
151: /* FIXME, must vector thru table */
152: sdp->subsip->si_boottab = &sidriver;
153: } else {
154: sdp->sd_ha_type = 0;
155:
156: /* FIXME, must vector thru table */
157: sdp->subsip->si_boottab = &scdriver;
158: }
159:
160: }
161: #endif
162: #ifdef SUN2
163: {
164: extern struct boottab scdriver;
165:
166: sdp->subsip->si_boottab = &scdriver;
167: }
168: #endif
169: sdp->subsip->si_unit = sip->si_unit >> 2; /* Target number */
170: r = devopen(sdp->subsip);
171: if (r < 0) return r;
172:
173: sdp->sd_unit = sip->si_unit & 0x03; /* Logical unit number */
174:
175: #ifndef BOOTBLOCK
176: /*
177: * Check that the disk is up and running...
178: */
179: switch (isspinning(sdspin, (char *)sip, 0)) {
180:
181: default: /* Error from sdspin */
182: case 0: /* Disk still not ready */
183: /* isspinning has already printed "Giving up..." */
184: return (-1);
185:
186: case 1:
187: break;
188:
189: case 2:
190: DELAY(1000000); /* one second delay after spinup */
191: break;
192: }
193: #endif
194:
195: /*
196: * Actually read the label
197: */
198: label->dkl_magic = 0;
199: sip->si_ma = (char *)label;
200: sip->si_cc = SECSIZE;
201: sip->si_bn = 0; /* Read block #0 */
202: if (sdcmd(SC_READ, sip, 1) <= 0) {
203: return (-1);
204: }
205: if (chklabel(label))
206: return -1;
207: sdp->sd_boff = (unsigned short)(label->dkl_map[sip->si_boff].dkl_cylno)
208: * (unsigned short)(label->dkl_nhead * label->dkl_nsect);
209: return (0);
210: }
211:
212: /*
213: * Execute reads or writes for the outside world.
214: */
215: sdstrategy(sip, rw)
216: struct saioreq *sip;
217: register int rw;
218: {
219: rw = sdcmd(rw == WRITE ? SC_WRITE : SC_READ, sip, 1);
220: if (rw < 0)
221: rw = 0;
222: return rw;
223: }
224:
225: /*
226: * Internal interface to the disk command set
227: *
228: * Returns the character count read (or 1 if count==0) for success,
229: * returns 0 for failure, or -1 for severe unretryable failure.
230: */
231: int
232: sdcmd(cmd, sip, errprint)
233: int cmd;
234: register struct saioreq *sip;
235: int errprint;
236: {
237: int blkno, acount;
238: register char *buf;
239: register struct sdparam *sdp;
240: struct scsi_cdb cdb, scdb;
241: struct scsi_scb scb, sscb;
242: register int retry, r, i, count;
243:
244: blkno = sip->si_bn;
245: acount = sip->si_cc;
246: buf = sip->si_ma;
247: sdp = (struct sdparam *)sip->si_devdata;
248:
249: if (cmd == SC_WRITE)
250: bcopy(buf, SDBUF, (unsigned)acount);
251:
252: /* set up cdb */
253: bzero((char *) &cdb, sizeof cdb);
254: cdb.cmd = cmd;
255: cdb.lun = sdp->sd_unit;
256: blkno += sdp->sd_boff;
257: cdbaddr(&cdb, blkno);
258: count = (acount + SECSIZE -1) & ~(SECSIZE-1);
259: cdb.count = count / SECSIZE;
260: retry = 0;
261: do {
262: sdp->subsip->si_cc = count;
263: sdp->subsip->si_ma = SDBUF;
264: #ifdef SUN3
265: if (sdp->sd_ha_type)
266: r = sidoit(&cdb, &scb, sdp->subsip);
267: else
268: #endif
269: r = scdoit(&cdb, &scb, sdp->subsip);
270: if (r < 0)
271: return -1; /* Major SCSI bus error, already printed */
272: if (scb.chk) {
273: bzero((char *) &scdb, sizeof scdb);
274: scdb.cmd = SC_REQUEST_SENSE;
275: scdb.lun = sdp->sd_unit;
276: scdb.count = sizeof (struct scsi_sense);
277: sdp->subsip->si_cc = scdb.count;
278: sdp->subsip->si_ma = SDBUF;
279: #ifdef SUN3
280: if (sdp->sd_ha_type)
281: i = sidoit(&scdb, &sscb, sdp->subsip);
282: else
283: #endif
284: i = scdoit(&scdb, &sscb, sdp->subsip);
285: if (i >= 4) { /* all the sense Adaptec gives us */
286: #ifndef DEFERRED_ERRORS
287: if (errprint) sd_pr_sense(SDBUF, i);
288: #endif
289: continue;
290: } else { /* can't get sense, give up */
291: if (errprint) {
292: printf("sd: scsi %s\n",
293: #ifdef DEFERRED_ERRORS
294: scerrmsg ? scerrmsg :
295: #endif
296: "sense failed");
297: }
298: return (0);
299: }
300: } else if (scb.busy) {
301: sc_error("disk busy");
302: DELAY(100000);
303: continue;
304: }
305: if (r != count) {
306: #ifndef DEFERRED_ERRORS
307: if (errprint)
308: printf("sd: dma count is %d wanted %d\n",
309: r, count);
310: #endif
311: continue;
312: }
313: if (cmd == SC_READ)
314: bcopy(SDBUF, buf, (unsigned)acount);
315: #ifdef DEFERRED_ERRORS
316: scerrmsg = 0;
317: #endif
318: return (count ? count : 1);
319: } while (retry++ < 16);
320: #ifdef DEFERRED_ERRORS
321: if (errprint) {
322: if (scb.chk) {
323: sd_pr_sense(SDBUF, i);
324: } else if (scerrmsg) {
325: printf("sd: scsi %s\n", scerrmsg);
326: } else if (r != count) {
327: printf("sd: dma count is %d wanted %d\n", r, count);
328: } else {
329: /* we should never get this far */
330: printf("sd: retry count exceeded\n");
331: }
332: }
333: #endif
334: return (0);
335: }
336:
337: #ifdef SDERRORS
338: char *class_00_errors[] = {
339: "No sense",
340: "No index signal",
341: "No seek complete",
342: "Write fault",
343: "Drive not ready",
344: "Drive not selected",
345: "No track 00",
346: "Multiple drives selected",
347: "No address acknowledged",
348: "Media not loaded",
349: "Insufficient capacity",
350: };
351:
352: char *class_01_errors[] = {
353: "I.D. CRC error",
354: "Unrecoverable data error",
355: "I.D. address mark not found",
356: "Data address mark not found",
357: "Record not found",
358: "Seek error",
359: "DMA timeout error",
360: "Write protected",
361: "Correctable data check",
362: "Bad block found",
363: "Interleave error",
364: "Data transfer incomplete",
365: "Unformatted or bad format on drive",
366: "Self test failed",
367: "Defective track (media errors)",
368: };
369:
370: char *class_02_errors[] = {
371: "Invalid command",
372: "Illegal block address",
373: "Aborted",
374: "Volume overflow",
375: };
376:
377: char **sc_errors[] = {
378: class_00_errors,
379: class_01_errors,
380: class_02_errors,
381: 0, 0, 0, 0,
382: };
383:
384: int sc_errct[] = {
385: sizeof class_00_errors / sizeof (char *),
386: sizeof class_01_errors / sizeof (char *),
387: sizeof class_02_errors / sizeof (char *),
388: 0, 0, 0, 0,
389: };
390:
391: char *sc_sense7_keys [] = {
392: "No sense",
393: "Recoverable error",
394: "Not ready",
395: "Media error",
396: "Hardware error",
397: "Illegal request",
398: "Media change",
399: "Write protect",
400: "Diagnostic unique",
401: "Vendor unique",
402: "Power up failed",
403: "Aborted command",
404: "Equal",
405: "Volume overflow",
406: };
407: #endif SDERRORS
408:
409: /*
410: * Print out sense info.
411: */
412: sd_pr_sense(sp, len)
413: register unsigned char *sp;
414: register int len;
415: {
416:
417: #ifndef SDERRORS
418: printf("sd: error");
419: while (--len >= 0) {
420: printf(" %x", *sp++);
421: }
422: printf("\n");
423: #else SDERRORS
424: #ifdef lint
425: len = len; /* Avoid spurious "len unused" messages */
426: #endif lint
427: printf("sd: ");
428: if (((struct scsi_sense *)sp)->class <= 6) {
429: register struct scsi_sense *sense;
430:
431: sense = (struct scsi_sense *) sp;
432: if (sense->code < sc_errct[sense->class]) {
433: printf("%s", sc_errors[sense->class][sense->code]);
434: } else {
435: printf("error %x", *sp);
436: }
437: if (sense->adr_val) {
438: printf("- block no. %d", (sense->high_addr << 16) |
439: (sense->mid_addr << 8) | sense->low_addr);
440: }
441: } else { /* Sense class 7: the standardized one */
442: register struct scsi_ext_sense *sense7;
443:
444: sense7 = (struct scsi_ext_sense *) sp;
445: if (sense7->fil_mk) {
446: printf("file mark ");
447: }
448: if (sense7->eom) {
449: printf("end of medium ");
450: }
451: if (sense7->key
452: < sizeof (sc_sense7_keys) / sizeof (sc_sense7_keys[0])) {
453: printf("%s", sc_sense7_keys[sense7->key]);
454: } else {
455: printf("sense key %x", sense7->key);
456: }
457: printf(" block no. %x", (sense7->info_1 << 24) |
458: (sense7->info_2 << 16) | (sense7->info_3 << 8) |
459: sense7->info_4);
460: }
461: printf("\n");
462: #endif SDERRORS
463: }
464:
465:
466: /*
467: * Close scsi disk
468: *
469: * We must close the host adapter too.
470: */
471: int
472: sdclose(sip)
473: struct saioreq *sip;
474: {
475: devclose(((struct sdparam *)sip->si_devdata)->subsip);
476: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.