![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / scsi|
Return to ch.c CVS log | Up to [Net/2] / Net2 / scsi |
1.1 root 1: /*
2: */
3: /*
4: * HISTORY
5: *
6: *
7: * PATCHES MAGIC LEVEL PATCH THAT GOT US HERE
8: * -------------------- ----- ----------------------
9: * CURRENT PATCH LEVEL: 1 00098
10: * -------------------- ----- ----------------------
11: *
12: * 16 Feb 93 Julian Elischer ADDED for SCSI system
13: *
14: */
15:
16: #include <sys/types.h>
17: #include <ch.h>
18:
19: #include <sys/param.h>
20: #include <sys/systm.h>
21:
22: #include <sys/errno.h>
23: #include <sys/ioctl.h>
24: #include <sys/buf.h>
25: #include <sys/proc.h>
26: #include <sys/user.h>
27: #include <sys/chio.h>
28:
29: #if defined(OSF)
30: #define SECSIZE 512
31: #endif /* defined(OSF) */
32:
33: #include <scsi/scsi_all.h>
34: #include <scsi/scsi_changer.h>
35: #include <scsi/scsiconf.h>
36:
37:
38: struct scsi_xfer ch_scsi_xfer[NCH];
39: int ch_xfer_block_wait[NCH];
40:
41:
42: #define PAGESIZ 4096
43: #define STQSIZE 4
44: #define CH_RETRIES 4
45:
46:
47: #define MODE(z) ( (minor(z) & 0x0F) )
48: #define UNIT(z) ( (minor(z) >> 4) )
49:
50: #ifndef MACH
51: #define ESUCCESS 0
52: #endif MACH
53:
54: int ch_info_valid[NCH]; /* the info about the device is valid */
55: int ch_initialized[NCH] ;
56: int ch_debug = 1;
57:
58: int chattach();
59: int ch_done();
60: struct ch_data
61: {
62: int flags;
63: struct scsi_switch *sc_sw; /* address of scsi low level switch */
64: int ctlr; /* so they know which one we want */
65: int targ; /* our scsi target ID */
66: int lu; /* out scsi lu */
67: short chmo; /* Offset of first CHM */
68: short chms; /* No. of CHM */
69: short slots; /* No. of Storage Elements */
70: short sloto; /* Offset of first SE */
71: short imexs; /* No. of Import/Export Slots */
72: short imexo; /* Offset of first IM/EX */
73: short drives; /* No. of CTS */
74: short driveo; /* Offset of first CTS */
75: short rot; /* CHM can rotate */
76: u_long op_matrix; /* possible opertaions */
77: u_short lsterr; /* details of lasterror */
78: u_char stor; /* posible Storage locations */
79: }ch_data[NCH];
80:
81: #define CH_OPEN 0x01
82: #define CH_KNOWN 0x02
83:
84: static int next_ch_unit = 0;
85: /***********************************************************************\
86: * The routine called by the low level scsi routine when it discovers *
87: * A device suitable for this driver *
88: \***********************************************************************/
89:
90: int chattach(ctlr,targ,lu,scsi_switch)
91: struct scsi_switch *scsi_switch;
92: {
93: int unit,i,stat;
94: unsigned char *tbl;
95:
96: if(scsi_debug & PRINTROUTINES) printf("chattach: ");
97: /*******************************************************\
98: * Check we have the resources for another drive *
99: \*******************************************************/
100: unit = next_ch_unit++;
101: if( unit >= NCH)
102: {
103: printf("Too many scsi changers..(%d > %d) reconfigure kernel",(unit + 1),NCH);
104: return(0);
105: }
106: /*******************************************************\
107: * Store information needed to contact our base driver *
108: \*******************************************************/
109: ch_data[unit].sc_sw = scsi_switch;
110: ch_data[unit].ctlr = ctlr;
111: ch_data[unit].targ = targ;
112: ch_data[unit].lu = lu;
113:
114: /*******************************************************\
115: * Use the subdriver to request information regarding *
116: * the drive. We cannot use interrupts yet, so the *
117: * request must specify this. *
118: \*******************************************************/
119: if((ch_mode_sense(unit, SCSI_NOSLEEP | SCSI_NOMASK /*| SCSI_SILENT*/)))
120: {
121: printf(" ch%d: scsi changer, %d slot(s) %d drive(s) %d arm(s) %d i/e-slot(s) \n",
122: unit, ch_data[unit].slots, ch_data[unit].drives, ch_data[unit].chms, ch_data[unit].imexs);
123: stat=CH_KNOWN;
124: }
125: else
126: {
127: printf(" ch%d: scsi changer :- offline\n", unit);
128: stat=CH_OPEN;
129: }
130: ch_initialized[unit] = stat;
131:
132: return;
133:
134: }
135:
136:
137:
138: /*******************************************************\
139: * open the device. *
140: \*******************************************************/
141: chopen(dev)
142: {
143: int errcode = 0;
144: int unit,mode;
145:
146: unit = UNIT(dev);
147: mode = MODE(dev);
148:
149: /*******************************************************\
150: * Check the unit is legal *
151: \*******************************************************/
152: if ( unit >= NCH )
153: {
154: printf("ch %d > %d\n",unit,NCH);
155: errcode = ENXIO;
156: return(errcode);
157: }
158: /*******************************************************\
159: * Only allow one at a time *
160: \*******************************************************/
161: if(ch_data[unit].flags & CH_OPEN)
162: {
163: printf("CH%d already open\n",unit);
164: errcode = ENXIO;
165: goto bad;
166: }
167:
168: if(ch_debug||(scsi_debug & (PRINTROUTINES | TRACEOPENS)))
169: printf("chopen: dev=0x%x (unit %d (of %d))\n"
170: , dev, unit, NCH);
171: /*******************************************************\
172: * Make sure the device has been initialised *
173: \*******************************************************/
174:
175: if (!ch_initialized[unit])
176: return(ENXIO);
177: if (ch_initialized[unit]!=CH_KNOWN) {
178: if((ch_mode_sense(unit, SCSI_NOSLEEP | SCSI_NOMASK /*| SCSI_SILENT*/)))
179: {
180: ch_initialized[unit]=CH_KNOWN;
181: }
182: else
183: {
184: printf(" ch%d: scsi changer :- offline\n", unit);
185: return(ENXIO);
186: }
187: }
188: /*******************************************************\
189: * Check that it is still responding and ok. *
190: \*******************************************************/
191:
192: if(ch_debug || (scsi_debug & TRACEOPENS))
193: printf("device is ");
194: if (!(ch_req_sense(unit, 0)))
195: {
196: errcode = ENXIO;
197: if(ch_debug || (scsi_debug & TRACEOPENS))
198: printf("not responding\n");
199: goto bad;
200: }
201: if(ch_debug || (scsi_debug & TRACEOPENS))
202: printf("ok\n");
203:
204: if(!(ch_test_ready(unit,0)))
205: {
206: printf("ch%d not ready\n",unit);
207: return(EIO);
208: }
209:
210: ch_info_valid[unit] = TRUE;
211:
212: /*******************************************************\
213: * Load the physical device parameters *
214: \*******************************************************/
215:
216: ch_data[unit].flags = CH_OPEN;
217: return(errcode);
218: bad:
219: return(errcode);
220: }
221:
222: /*******************************************************\
223: * close the device.. only called if we are the LAST *
224: * occurence of an open device *
225: \*******************************************************/
226: chclose(dev)
227: {
228: unsigned char unit,mode;
229:
230: unit = UNIT(dev);
231: mode = MODE(dev);
232:
233: if(scsi_debug & TRACEOPENS)
234: printf("Closing device");
235: ch_data[unit].flags = 0;
236: return(0);
237: }
238:
239:
240:
241: /***************************************************************\
242: * chstart *
243: * This routine is also called after other non-queued requests *
244: * have been made of the scsi driver, to ensure that the queue *
245: * continues to be drained. *
246: \***************************************************************/
247: /* chstart() is called at splbio */
248: chstart(unit)
249: {
250: int drivecount;
251: register struct buf *bp = 0;
252: register struct buf *dp;
253: struct scsi_xfer *xs;
254: int blkno, nblk;
255:
256:
257: if(scsi_debug & PRINTROUTINES) printf("chstart%d ",unit);
258: /*******************************************************\
259: * See if there is a buf to do and we are not already *
260: * doing one *
261: \*******************************************************/
262: xs=&ch_scsi_xfer[unit];
263: if(xs->flags & INUSE)
264: {
265: return; /* unit already underway */
266: }
267: if(ch_xfer_block_wait[unit]) /* a special awaits, let it proceed first */
268: {
269: wakeup(&ch_xfer_block_wait[unit]);
270: return;
271: }
272:
273: return;
274:
275: }
276:
277:
278: /*******************************************************\
279: * This routine is called by the scsi interrupt when *
280: * the transfer is complete.
281: \*******************************************************/
282: int ch_done(unit,xs)
283: int unit;
284: struct scsi_xfer *xs;
285: {
286: struct buf *bp;
287: int retval;
288:
289: if(ch_debug||(scsi_debug & PRINTROUTINES)) printf("ch_done%d ",unit);
290: if (! (xs->flags & INUSE))
291: panic("scsi_xfer not in use!");
292: wakeup(xs);
293: }
294: /*******************************************************\
295: * Perform special action on behalf of the user *
296: * Knows about the internals of this device *
297: \*******************************************************/
298: chioctl(dev, cmd, arg, mode)
299: dev_t dev;
300: int cmd;
301: caddr_t arg;
302: {
303: /* struct ch_cmd_buf *args;*/
304: union scsi_cmd *scsi_cmd;
305: register i,j;
306: unsigned int opri;
307: int errcode = 0;
308: unsigned char unit;
309: int number,flags,ret;
310:
311: /*******************************************************\
312: * Find the device that the user is talking about *
313: \*******************************************************/
314: flags = 0; /* give error messages, act on errors etc. */
315: unit = UNIT(dev);
316:
317: switch(cmd)
318: {
319: case CHIOOP: {
320: struct chop *ch=(struct chop *) arg;
321: if (ch_debug)
322: printf("[chtape_chop: %x]\n", ch->ch_op);
323:
324: switch ((short)(ch->ch_op)) {
325: case CHGETPARAM:
326: ch->u.getparam.chmo= ch_data[unit].chmo;
327: ch->u.getparam.chms= ch_data[unit].chms;
328: ch->u.getparam.sloto= ch_data[unit].sloto;
329: ch->u.getparam.slots= ch_data[unit].slots;
330: ch->u.getparam.imexo= ch_data[unit].imexo;
331: ch->u.getparam.imexs= ch_data[unit].imexs;
332: ch->u.getparam.driveo= ch_data[unit].driveo;
333: ch->u.getparam.drives= ch_data[unit].drives;
334: ch->u.getparam.rot= ch_data[unit].rot;
335: ch->result=0;
336: return 0;
337: break;
338: case CHPOSITION:
339: return ch_position(unit,&ch->result,ch->u.position.chm,
340: ch->u.position.to,
341: flags);
342: case CHMOVE:
343: return ch_move(unit,&ch->result, ch->u.position.chm,
344: ch->u.move.from, ch->u.move.to,
345: flags);
346: case CHGETELEM:
347: return ch_getelem(unit,&ch->result, ch->u.get_elem_stat.type,
348: ch->u.get_elem_stat.from, &ch->u.get_elem_stat.elem_data,
349: flags);
350: default:
351: return EINVAL;
352: }
353:
354: }
355: default:
356: return EINVAL;
357: }
358:
359: return(ret?ESUCCESS:EIO);
360: }
361:
362: ch_getelem(unit,stat,type,from,data,flags)
363: int unit,from,flags;
364: short *stat;
365: char *data;
366: {
367: struct scsi_read_element_status scsi_cmd;
368: char elbuf[32];
369: int ret;
370:
371: bzero(&scsi_cmd, sizeof(scsi_cmd));
372: scsi_cmd.op_code = READ_ELEMENT_STATUS;
373: scsi_cmd.element_type_code=type;
374: scsi_cmd.starting_element_addr[0]=(from>>8)&0xff;
375: scsi_cmd.starting_element_addr[1]=from&0xff;
376: scsi_cmd.number_of_elements[1]=1;
377: scsi_cmd.allocation_length[2]=32;
378:
379: if ((ret=ch_scsi_cmd(unit,
380: &scsi_cmd,
381: sizeof(scsi_cmd),
382: elbuf,
383: 32,
384: 100000,
385: flags) !=ESUCCESS)) {
386: *stat=ch_data[unit].lsterr;
387: bcopy(elbuf+16,data,16);
388: return ret;
389: }
390: bcopy(elbuf+16,data,16); /*Just a hack sh */
391: return ret;
392: }
393:
394: ch_move(unit,stat,chm,from,to,flags)
395: int unit,chm,from,to,flags;
396: short *stat;
397: {
398: struct scsi_move_medium scsi_cmd;
399: int ret;
400:
401: bzero(&scsi_cmd, sizeof(scsi_cmd));
402: scsi_cmd.op_code = MOVE_MEDIUM;
403: scsi_cmd.transport_element_address[0]=(chm>>8)&0xff;
404: scsi_cmd.transport_element_address[1]=chm&0xff;
405: scsi_cmd.source_address[0]=(from>>8)&0xff;
406: scsi_cmd.source_address[1]=from&0xff;
407: scsi_cmd.destination_address[0]=(to>>8)&0xff;
408: scsi_cmd.destination_address[1]=to&0xff;
409: scsi_cmd.invert=(chm&CH_INVERT)?1:0;
410: if ((ret=ch_scsi_cmd(unit,
411: &scsi_cmd,
412: sizeof(scsi_cmd),
413: NULL,
414: 0,
415: 100000,
416: flags) !=ESUCCESS)) {
417: *stat=ch_data[unit].lsterr;
418: return ret;
419: }
420: return ret;
421: }
422:
423: ch_position(unit,stat,chm,to,flags)
424: int unit,chm,to,flags;
425: short *stat;
426: {
427: struct scsi_position_to_element scsi_cmd;
428: int ret;
429:
430: bzero(&scsi_cmd, sizeof(scsi_cmd));
431: scsi_cmd.op_code = POSITION_TO_ELEMENT;
432: scsi_cmd.transport_element_address[0]=(chm>>8)&0xff;
433: scsi_cmd.transport_element_address[1]=chm&0xff;
434: scsi_cmd.source_address[0]=(to>>8)&0xff;
435: scsi_cmd.source_address[1]=to&0xff;
436: scsi_cmd.invert=(chm&CH_INVERT)?1:0;
437: if ((ret=ch_scsi_cmd(unit,
438: &scsi_cmd,
439: sizeof(scsi_cmd),
440: NULL,
441: 0,
442: 100000,
443: flags) !=ESUCCESS)) {
444: *stat=ch_data[unit].lsterr;
445: return ret;
446: }
447: return ret;
448: }
449:
450: /*******************************************************\
451: * Check with the device that it is ok, (via scsi driver)*
452: \*******************************************************/
453: ch_req_sense(unit, flags)
454: int flags;
455: {
456: struct scsi_sense_data sense;
457: struct scsi_sense scsi_cmd;
458:
459: bzero(&scsi_cmd, sizeof(scsi_cmd));
460: scsi_cmd.op_code = REQUEST_SENSE;
461: scsi_cmd.length = sizeof(sense);
462:
463: if (ch_scsi_cmd(unit,
464: &scsi_cmd,
465: sizeof(struct scsi_sense),
466: &sense,
467: sizeof(sense),
468: 100000,
469: flags | SCSI_DATA_IN) != 0)
470: {
471: return(FALSE);
472: }
473: else
474: return(TRUE);
475: }
476:
477: /*******************************************************\
478: * Get scsi driver to send a "are you ready" command *
479: \*******************************************************/
480: ch_test_ready(unit,flags)
481: int unit,flags;
482: {
483: struct scsi_test_unit_ready scsi_cmd;
484:
485: bzero(&scsi_cmd, sizeof(scsi_cmd));
486: scsi_cmd.op_code = TEST_UNIT_READY;
487:
488: if (ch_scsi_cmd(unit,
489: &scsi_cmd,
490: sizeof(struct scsi_test_unit_ready),
491: 0,
492: 0,
493: 100000,
494: flags) != 0) {
495: return(FALSE);
496: } else
497: return(TRUE);
498: }
499:
500:
501: #ifdef __STDC__
502: #define b2tol(a) (((unsigned)(a##_1) << 8) + (unsigned)a##_0 )
503: #else
504: #define b2tol(a) (((unsigned)(a/**/_1) << 8) + (unsigned)a/**/_0 )
505: #endif
506:
507: /*******************************************************\
508: * Get the scsi driver to send a full inquiry to the *
509: * device and use the results to fill out the global *
510: * parameter structure. *
511: \*******************************************************/
512: ch_mode_sense(unit, flags)
513: int unit,flags;
514: {
515: struct scsi_mode_sense scsi_cmd;
516: u_char scsi_sense[128]; /* Can't use scsi_mode_sense_data because of */
517: /* missing block descriptor */
518: u_char *b;
519: int i,l;
520:
521: /*******************************************************\
522: * First check if we have it all loaded *
523: \*******************************************************/
524: if (ch_info_valid[unit]==CH_KNOWN) return(TRUE);
525: /*******************************************************\
526: * First do a mode sense *
527: \*******************************************************/
528: ch_info_valid[unit] &= ~CH_KNOWN;
529: for(l=1;l>=0;l--) {
530: bzero(&scsi_cmd, sizeof(scsi_cmd));
531: scsi_cmd.op_code = MODE_SENSE;
532: scsi_cmd.dbd = l;
533: scsi_cmd.page_code = 0x3f; /* All Pages */
534: scsi_cmd.length = sizeof(scsi_sense);
535: /*******************************************************\
536: * do the command, but we don't need the results *
537: * just print them for our interest's sake *
538: \*******************************************************/
539: if (ch_scsi_cmd(unit,
540: &scsi_cmd,
541: sizeof(struct scsi_mode_sense),
542: &scsi_sense,
543: sizeof(scsi_sense),
544: 5000,
545: flags | SCSI_DATA_IN) == 0) {
546: ch_info_valid[unit] = CH_KNOWN;
547: break;
548: }
549: }
550: if (ch_info_valid[unit]!=CH_KNOWN) {
551: if(!(flags & SCSI_SILENT))
552: printf("could not mode sense for unit %d\n", unit);
553: return(FALSE);
554: }
555: l=scsi_sense[0]-3;
556: b=&scsi_sense[4];
557: /*****************************\
558: * To avoid alignment problems *
559: \*****************************/
560: /*FIX THIS FOR MSB */
561: #define p2copy(valp) (valp[1]+ (valp[0]<<8));valp+=2
562: #define p4copy(valp) (valp[3]+ (valp[2]<<8) + (valp[1]<<16) + (valp[0]<<24));valp+=4
563: #if 0
564: printf("\nmode_sense %d\n",l);
565: for(i=0;i<l+4;i++) {
566: printf("%x%c",scsi_sense[i],i%8==7?'\n':':');
567: }
568: printf("\n");
569: #endif
570: for(i=0;i<l;) {
571: int pc=(*b++)&0x3f;
572: int pl=*b++;
573: u_char *bb=b;
574: switch(pc) {
575: case 0x1d:
576: ch_data[unit].chmo =p2copy(bb);
577: ch_data[unit].chms =p2copy(bb);
578: ch_data[unit].sloto =p2copy(bb);
579: ch_data[unit].slots =p2copy(bb);
580: ch_data[unit].imexo =p2copy(bb);
581: ch_data[unit].imexs =p2copy(bb);
582: ch_data[unit].driveo =p2copy(bb);
583: ch_data[unit].drives =p2copy(bb);
584: break;
585: case 0x1e:
586: ch_data[unit].rot = (*b)&1;
587: break;
588: case 0x1f:
589: ch_data[unit].stor = *b&0xf;
590: bb+=2;
591: ch_data[unit].stor =p4copy(bb);
592: break;
593: default:
594: break;
595: }
596: b+=pl;
597: i+=pl+2;
598: }
599: if (ch_debug)
600: {
601: printf("unit %d: cht(%d-%d)slot(%d-%d)imex(%d-%d)cts(%d-%d) %s rotate\n",
602: unit,
603: ch_data[unit].chmo,
604: ch_data[unit].chms,
605: ch_data[unit].sloto,
606: ch_data[unit].slots,
607: ch_data[unit].imexo,
608: ch_data[unit].imexs,
609: ch_data[unit].driveo,
610: ch_data[unit].drives,
611: ch_data[unit].rot?"can":"can't");
612: }
613: return(TRUE);
614: }
615:
616: /*******************************************************\
617: * ask the scsi driver to perform a command for us. *
618: * Call it through the switch table, and tell it which *
619: * sub-unit we want, and what target and lu we wish to *
620: * talk to. Also tell it where to find the command *
621: * how long int is. *
622: * Also tell it where to read/write the data, and how *
623: * long the data is supposed to be *
624: \*******************************************************/
625: int ch_scsi_cmd(unit,scsi_cmd,cmdlen,data_addr,datalen,timeout,flags)
626:
627: int unit,flags;
628: struct scsi_generic *scsi_cmd;
629: int cmdlen;
630: int timeout;
631: u_char *data_addr;
632: int datalen;
633: {
634: struct scsi_xfer *xs;
635: int retval;
636: int s;
637:
638: if(ch_debug||(scsi_debug & PRINTROUTINES)) printf("\nch_scsi_cmd%d %x",
639: unit,scsi_cmd->opcode);
640: if(ch_data[unit].sc_sw) /* If we have a scsi driver */
641: {
642:
643: xs = &(ch_scsi_xfer[unit]);
644: if(!(flags & SCSI_NOMASK))
645: s = splbio();
646: ch_xfer_block_wait[unit]++; /* there is someone waiting */
647: while (xs->flags & INUSE)
648: {
649: sleep(&ch_xfer_block_wait[unit],PRIBIO+1);
650: }
651: ch_xfer_block_wait[unit]--;
652: xs->flags = INUSE;
653: if(!(flags & SCSI_NOMASK))
654: splx(s);
655:
656: /*******************************************************\
657: * Fill out the scsi_xfer structure *
658: \*******************************************************/
659: xs->flags |= flags;
660: xs->adapter = ch_data[unit].ctlr;
661: xs->targ = ch_data[unit].targ;
662: xs->lu = ch_data[unit].lu;
663: xs->retries = CH_RETRIES;
664: xs->timeout = timeout;
665: xs->cmd = scsi_cmd;
666: xs->cmdlen = cmdlen;
667: xs->data = data_addr;
668: xs->datalen = datalen;
669: xs->resid = datalen;
670: xs->when_done = (flags & SCSI_NOMASK)
671: ?(int (*)())0
672: :ch_done;
673: xs->done_arg = unit;
674: xs->done_arg2 = (int)xs;
675: retry: xs->error = XS_NOERROR;
676: xs->bp = 0;
677: ch_data[unit].lsterr=0;
678: retval = (*(ch_data[unit].sc_sw->scsi_cmd))(xs);
679: switch(retval)
680: {
681: case SUCCESSFULLY_QUEUED:
682: while(!(xs->flags & ITSDONE))
683: sleep(xs,PRIBIO+1);
684:
685: case HAD_ERROR:
686: case COMPLETE:
687: switch(xs->error)
688: {
689: case XS_NOERROR:
690: retval = ESUCCESS;
691: break;
692: case XS_SENSE:
693: retval = (ch_interpret_sense(unit,xs));
694: break;
695: case XS_DRIVER_STUFFUP:
696: retval = EIO;
697: break;
698: case XS_TIMEOUT:
699: if(xs->retries-- )
700: {
701: xs->flags &= ~ITSDONE;
702: goto retry;
703: }
704: retval = EIO;
705: break;
706: case XS_BUSY:
707: if(xs->retries-- )
708: {
709: xs->flags &= ~ITSDONE;
710: goto retry;
711: }
712: retval = EIO;
713: break;
714: default:
715: retval = EIO;
716: printf("st%d: unknown error category from scsi driver\n"
717: ,unit);
718: break;
719: }
720: break;
721: case TRY_AGAIN_LATER:
722: if(xs->retries-- )
723: {
724: xs->flags &= ~ITSDONE;
725: goto retry;
726: }
727: retval = EIO;
728: break;
729: default:
730: retval = EIO;
731: }
732: xs->flags = 0; /* it's free! */
733: chstart(unit);
734: }
735: else
736: {
737: printf("chd: not set up\n",unit);
738: return(EINVAL);
739: }
740: return(retval);
741: }
742: /***************************************************************\
743: * Look at the returned sense and act on the error and detirmine *
744: * The unix error number to pass back... (0 = report no error) *
745: \***************************************************************/
746:
747: int ch_interpret_sense(unit,xs)
748: int unit;
749: struct scsi_xfer *xs;
750: {
751: struct scsi_sense_data *sense;
752: int key;
753: int silent = xs->flags & SCSI_SILENT;
754:
755: /***************************************************************\
756: * If errors are ok, report a success *
757: \***************************************************************/
758: if(xs->flags & SCSI_ERR_OK) return(ESUCCESS);
759:
760: /***************************************************************\
761: * Get the sense fields and work out what CLASS *
762: \***************************************************************/
763: sense = &(xs->sense);
764: switch(sense->error_class)
765: {
766: /***************************************************************\
767: * If it's class 7, use the extended stuff and interpret the key *
768: \***************************************************************/
769: case 7:
770: {
771: key=sense->ext.extended.sense_key;
772: if(sense->ext.extended.ili)
773: if(!silent)
774: {
775: printf("length error ");
776: }
777: if(sense->valid)
778: xs->resid = ntohl(*((long *)sense->ext.extended.info));
779: if(xs->bp)
780: {
781: xs->bp->b_flags |= B_ERROR;
782: return(ESUCCESS);
783: }
784: if(sense->ext.extended.eom)
785: if(!silent) printf("end of medium ");
786: if(sense->ext.extended.filemark)
787: if(!silent) printf("filemark ");
788: if(ch_debug)
789: {
790: printf("code%x class%x valid%x\n"
791: ,sense->error_code
792: ,sense->error_class
793: ,sense->valid);
794: printf("seg%x key%x ili%x eom%x fmark%x\n"
795: ,sense->ext.extended.segment
796: ,sense->ext.extended.sense_key
797: ,sense->ext.extended.ili
798: ,sense->ext.extended.eom
799: ,sense->ext.extended.filemark);
800: printf("info: %x %x %x %x followed by %d extra bytes\n"
801: ,sense->ext.extended.info[0]
802: ,sense->ext.extended.info[1]
803: ,sense->ext.extended.info[2]
804: ,sense->ext.extended.info[3]
805: ,sense->ext.extended.extra_len);
806: printf("extra: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n"
807: ,sense->ext.extended.extra_bytes[0]
808: ,sense->ext.extended.extra_bytes[1]
809: ,sense->ext.extended.extra_bytes[2]
810: ,sense->ext.extended.extra_bytes[3]
811: ,sense->ext.extended.extra_bytes[4]
812: ,sense->ext.extended.extra_bytes[5]
813: ,sense->ext.extended.extra_bytes[6]
814: ,sense->ext.extended.extra_bytes[7]
815: ,sense->ext.extended.extra_bytes[8]
816: ,sense->ext.extended.extra_bytes[9]
817: ,sense->ext.extended.extra_bytes[10]
818: ,sense->ext.extended.extra_bytes[11]
819: ,sense->ext.extended.extra_bytes[12]
820: ,sense->ext.extended.extra_bytes[13]
821: ,sense->ext.extended.extra_bytes[14]
822: ,sense->ext.extended.extra_bytes[15]);
823:
824: }
825: switch(key)
826: {
827: case 0x0:
828: return(ESUCCESS);
829: case 0x1:
830: if(!silent)
831: {
832: printf("st%d: soft error(corrected) ", unit);
833: if(sense->valid)
834: {
835: printf("block no. %d (decimal)\n",
836: (sense->ext.extended.info[0] <<24)|
837: (sense->ext.extended.info[1] <<16)|
838: (sense->ext.extended.info[2] <<8)|
839: (sense->ext.extended.info[3] ));
840: }
841: else
842: {
843: printf("\n");
844: }
845: }
846: return(ESUCCESS);
847: case 0x2:
848: if(!silent) printf("st%d: not ready\n ", unit);
849: ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
850: sense->ext.extended.info[13] ;
851: return(ENODEV);
852: case 0x3:
853: if(!silent)
854: {
855: printf("st%d: medium error ", unit);
856: if(sense->valid)
857: {
858: printf("block no. %d (decimal)\n",
859: (sense->ext.extended.info[0] <<24)|
860: (sense->ext.extended.info[1] <<16)|
861: (sense->ext.extended.info[2] <<8)|
862: (sense->ext.extended.info[3] ));
863: }
864: else
865: {
866: printf("\n");
867: }
868: }
869: return(EIO);
870: case 0x4:
871: if(!silent) printf("st%d: non-media hardware failure\n ",
872: unit);
873: ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
874: sense->ext.extended.info[13] ;
875: return(EIO);
876: case 0x5:
877: if(!silent) printf("st%d: illegal request\n ", unit);
878: ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
879: sense->ext.extended.info[13] ;
880: return(EINVAL);
881: case 0x6:
882: if(!silent) printf("st%d: Unit attention.\n ", unit);
883: ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
884: sense->ext.extended.info[13] ;
885: ch_info_valid[unit] = FALSE;
886: if (ch_data[unit].flags & CH_OPEN) /* TEMP!!!! */
887: return(EIO);
888: else
889: return(ESUCCESS);
890: case 0x7:
891: if(!silent)
892: {
893: printf("st%d: attempted protection violation "
894: , unit);
895: if(sense->valid)
896: {
897: printf("block no. %d (decimal)\n",
898: (sense->ext.extended.info[0] <<24)|
899: (sense->ext.extended.info[1] <<16)|
900: (sense->ext.extended.info[2] <<8)|
901: (sense->ext.extended.info[3] ));
902: }
903: else
904: {
905: printf("\n");
906: }
907: }
908: return(EACCES);
909: case 0x8:
910: if(!silent)
911: {
912: printf("st%d: block wrong state (worm)\n "
913: , unit);
914: if(sense->valid)
915: {
916: printf("block no. %d (decimal)\n",
917: (sense->ext.extended.info[0] <<24)|
918: (sense->ext.extended.info[1] <<16)|
919: (sense->ext.extended.info[2] <<8)|
920: (sense->ext.extended.info[3] ));
921: }
922: else
923: {
924: printf("\n");
925: }
926: }
927: return(EIO);
928: case 0x9:
929: if(!silent) printf("st%d: vendor unique\n",
930: unit);
931: return(EIO);
932: case 0xa:
933: if(!silent) printf("st%d: copy aborted\n ",
934: unit);
935: return(EIO);
936: case 0xb:
937: if(!silent) printf("st%d: command aborted\n ",
938: unit);
939: ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
940: sense->ext.extended.info[13] ;
941: return(EIO);
942: case 0xc:
943: if(!silent)
944: {
945: printf("st%d: search returned\n ", unit);
946: if(sense->valid)
947: {
948: printf("block no. %d (decimal)\n",
949: (sense->ext.extended.info[0] <<24)|
950: (sense->ext.extended.info[1] <<16)|
951: (sense->ext.extended.info[2] <<8)|
952: (sense->ext.extended.info[3] ));
953: }
954: else
955: {
956: printf("\n");
957: }
958: }
959: return(ESUCCESS);
960: case 0xd:
961: if(!silent) printf("st%d: volume overflow\n ",
962: unit);
963: return(ENOSPC);
964: case 0xe:
965: if(!silent)
966: {
967: printf("st%d: verify miscompare\n ", unit);
968: if(sense->valid)
969: {
970: printf("block no. %d (decimal)\n",
971: (sense->ext.extended.info[0] <<24)|
972: (sense->ext.extended.info[1] <<16)|
973: (sense->ext.extended.info[2] <<8)|
974: (sense->ext.extended.info[3] ));
975: }
976: else
977: {
978: printf("\n");
979: }
980: }
981: return(EIO);
982: case 0xf:
983: if(!silent) printf("st%d: unknown error key\n ",
984: unit);
985: return(EIO);
986: }
987: break;
988: }
989: /***************************************************************\
990: * If it's NOT class 7, just report it. *
991: \***************************************************************/
992: case 0:
993: case 1:
994: case 2:
995: case 3:
996: case 4:
997: case 5:
998: case 6:
999: {
1000: if(!silent) printf("st%d: error class %d code %d\n",
1001: unit,
1002: sense->error_class,
1003: sense->error_code);
1004: if(sense->valid)
1005: if(!silent) printf("block no. %d (decimal)\n",
1006: (sense->ext.unextended.blockhi <<16),
1007: + (sense->ext.unextended.blockmed <<8),
1008: + (sense->ext.unextended.blocklow ));
1009: }
1010: return(EIO);
1011: }
1012: }
1013:
1014:
1015:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.