![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src / scg-linux-sg|
Return to scsi.c CVS log | Up to [UNIX Amiga Emulator] / uae / src / scg-linux-sg |
1.1 root 1: /* @(#)scsi-linux-sg.c 1.30 98/11/06 Copyright 1997 J. Schilling */
2: #ifndef lint
3: static char __sccsid[] =
4: "@(#)scsi-linux-sg.c 1.30 98/11/06 Copyright 1997 J. Schilling";
5: #endif
6: /*
7: * Interface for Linux generic SCSI implementation (sg).
8: *
9: * This is the interface for the broken Linux SCSI generic driver.
10: * This is a hack, that tries to emulate the functionality
11: * of the scg driver.
12: *
13: * Design flaws of the sg driver:
14: * - cannot see if SCSI command could not be send
15: * - cannot get SCSI status byte
16: * - cannot get real dma count of tranfer
17: * - cannot get number of bytes valid in auto sense data
18: * - to few data in auto sense (CCS/SCSI-2/SCSI-3 needs >= 18)
19: *
20: * This code contains support for the sg driver version 2
21: *
22: * Copyright (c) 1997 J. Schilling
23: */
24: /*
25: * This program is free software; you can redistribute it and/or modify
26: * it under the terms of the GNU General Public License as published by
27: * the Free Software Foundation; either version 2, or (at your option)
28: * any later version.
29: *
30: * This program is distributed in the hope that it will be useful,
31: * but WITHOUT ANY WARRANTY; without even the implied warranty of
32: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33: * GNU General Public License for more details.
34: *
35: * You should have received a copy of the GNU General Public License
36: * along with this program; see the file COPYING. If not, write to
37: * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
38: */
39:
40: #include <linux/version.h>
41:
42: #define DEBUG
43:
44: #ifndef LINUX_VERSION_CODE /* Very old kernel? */
45: # define LINUX_VERSION_CODE 0
46: #endif
47:
48: #if LINUX_VERSION_CODE >= 0x01031a /* <linux/scsi.h> introduced in 1.3.26 */
49: #if LINUX_VERSION_CODE >= 0x020000 /* <scsi/scsi.h> introduced somewhere. */
50: /* Need to fine tune the ifdef so we get the transition point right. */
51: #include <scsi/scsi.h>
52: #else
53: #include <linux/scsi.h>
54: #endif
55: #else
56: #define __KERNEL__
57: #include <linux/fs.h>
58: #undef __KERNEL__
59: #include "block/blk.h"
60: #include "scsi/scsi.h"
61: #endif
62:
63: #include <stdlib.h>
64: #include <stdio.h>
65: #include <errno.h>
66: #include <unistd.h>
67: #include <sys/types.h>
68: #include <sys/stat.h>
69: #include <sys/ioctl.h>
70: #include <sys/time.h>
71: #include <fcntl.h>
72: #include <scsi/sg.h>
73: #include <asm/param.h>
74:
75: #include "scg/defs.h"
76: #include "scg/scsitransp.h"
77: #include "scg/scgcmd.h"
78:
79: #ifndef SCSI_IOCTL_GET_BUS_NUMBER
80: #define SCSI_IOCTL_GET_BUS_NUMBER 0x5386
81: #endif
82:
83: /*
84: * XXX There must be a better way than duplicating things from system include
85: * XXX files. This is stolen from /usr/src/linux/drivers/scsi/scsi.h
86: */
87: #ifndef DID_OK
88: #define DID_OK 0x00 /* NO error */
89: #define DID_NO_CONNECT 0x01 /* Couldn't connect before timeout period */
90: #define DID_BUS_BUSY 0x02 /* BUS stayed busy through time out period */
91: #define DID_TIME_OUT 0x03 /* TIMED OUT for other reason */
92: #define DID_BAD_TARGET 0x04 /* BAD target. */
93: #define DID_ABORT 0x05 /* Told to abort for some other reason */
94: #define DID_PARITY 0x06 /* Parity error */
95: #define DID_ERROR 0x07 /* Internal error */
96: #define DID_RESET 0x08 /* Reset by somebody. */
97: #define DID_BAD_INTR 0x09 /* Got an interrupt we weren't expecting. */
98: #endif
99:
100: #define MAX_SCG 4 /* Max # of SCSI controllers */
101: #define MAX_TGT 16
102: #define MAX_LUN 8
103:
104: typedef struct SCSIPrivate {
105: int scgfile; /* Used for SG_GET_BUFSIZE ioctl() */
106: short scgfiles[MAX_SCG][MAX_TGT][MAX_LUN];
107: short buscookies[MAX_SCG];
108: int pack_id; /* Should be a random number */
109: char *SCSIbuf;
110: long scg_maxdma;
111: } SCSIPrivate;
112:
113: #ifdef SG_BIG_BUFF
114: #define MAX_DMA_LINUX SG_BIG_BUFF /* Defined in include/scsi/sg.h */
115: #else
116: #define MAX_DMA_LINUX (4*1024) /* Old Linux versions */
117: #endif
118:
119: #ifndef SG_MAX_SENSE
120: # define SG_MAX_SENSE 16 /* Too small for CCS / SCSI-2 */
121: #endif /* But cannot be changed */
122:
123:
124: #if !defined(__i386) && !defined(i386) && !defined(mc68000)
125: #define MISALIGN
126: #endif
127: /*#define MISALIGN*/
128: /*#undef SG_GET_BUFSIZE*/
129:
130: #if defined(USE_PG) && !defined(USE_PG_ONLY)
131: #include "scsi-linux-pg.c"
132: #endif
133:
134: #ifdef MISALIGN
135: LOCAL int scsi_getint __PR((int *ip));
136: #endif
137: LOCAL int scsi_send __PR((SCSI *scgp, int f, struct scg_cmd *sp));
138: LOCAL BOOL sg_setup __PR((SCSI *scgp, int f, int busno, int tgt, int tlun));
139: LOCAL void sg_initdev __PR((SCSI *scgp, int f));
140: LOCAL int sg_mapbus __PR((SCSI *scgp, int ino));
141: LOCAL BOOL sg_mapdev __PR((SCSI *scgp, int f, int *busp, int *tgtp, int *lunp,
142: int *chanp, int *inop));
143: LOCAL void sg_settimeout __PR((int f, int timeout));
144: LOCAL long scsi_maxdma __PR((SCSI *scgp));
145: LOCAL void scsitimes __PR((SCSI *scgp));
146:
147: EXPORT
148: int scsi_open(scgp, device, busno, tgt, tlun)
149: SCSI *scgp;
150: char *device;
151: int busno;
152: int tgt;
153: int tlun;
154: {
155: register int f;
156: register int i;
157: register int b;
158: register int t;
159: register int l;
160: register int nopen = 0;
161: char devname[64];
162:
163: if (!(scgp->private = calloc(1, sizeof(*scgp->private)))) {
164: return -1;
165: }
166: scgp->private->pack_id = rand(); /* now is a random number */
167: scgp->private->scgfile = -1;
168: scgp->private->SCSIbuf = (void *)-1;
169:
170: for (b=0; b < MAX_SCG; b++) {
171: scgp->private->buscookies[b] = (short)-1;
172: for (t=0; t < MAX_TGT; t++) {
173: for (l=0; l < MAX_LUN ; l++)
174: scgp->private->scgfiles[b][t][l] = (short)-1;
175: }
176: }
177: if ((device != NULL && *device != '\0') || (busno == -2 && tgt == -2))
178: goto openbydev;
179:
180: if (busno >= 0 && tgt >= 0 && tlun >= 0) {
181: if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN)
182: return (-1);
183: }
184:
185: for (i=0; i < 32; i++) {
186: sprintf(devname, "/dev/sg%d", i);
187: f = open(devname, 2);
188: if (f < 0) {
189: if (errno != ENOENT && errno != ENXIO && errno != ENODEV)
190: fprintf(stderr, "Cannot open '%s'.\n", devname);
191: } else {
192: if (sg_setup(scgp, f, busno, tgt, tlun))
193: return (++nopen);
194: if (busno < 0 && tgt < 0 && tlun < 0)
195: nopen++;
196: }
197: }
198: if (nopen == 0) for (i=0; i <= 25; i++) {
199: sprintf(devname, "/dev/sg%c", i+'a');
200: f = open(devname, 2);
201: if (f < 0) {
202: if (errno != ENOENT && errno != ENXIO && errno != ENODEV)
203: fprintf(stderr, "Cannot open '%s'.\n", devname);
204: } else {
205: if (sg_setup(scgp, f, busno, tgt, tlun))
206: return (++nopen);
207: if (busno < 0 && tgt < 0 && tlun < 0)
208: nopen++;
209: }
210: }
211: openbydev:
212: if (device != NULL && *device != '\0') {
213: f = open(device, 2);
214: if (f < 0 && errno == ENOENT)
215: goto openpg;
216:
217: if (!sg_mapdev(scgp, f, &busno, &tgt, &tlun, 0, 0)) {
218: close(f);
219: goto openpg;
220: }
221:
222: if (scgp->scsibus < 0)
223: scgp->scsibus = busno;
224: if (scgp->target < 0)
225: scgp->target = tgt;
226: if (scgp->lun < 0)
227: scgp->lun = tlun;
228:
229: if (sg_setup(scgp, f, busno, tgt, tlun))
230: return (++nopen);
231: }
232: openpg:
233: #ifdef USE_PG
234: nopen += pg_open(scgp, device, busno, tgt, tlun);
235: #endif
236: return (nopen);
237: }
238:
239: LOCAL BOOL
240: sg_setup(scgp, f, busno, tgt, tlun)
241: SCSI *scgp;
242: int f;
243: int busno;
244: int tgt;
245: int tlun;
246: {
247: int n;
248: int Chan;
249: int Ino;
250: int Bus;
251: int Target;
252: int Lun;
253: BOOL onetarget = FALSE;
254:
255:
256: if (scgp->scsibus >= 0 && scgp->target >= 0 && scgp->lun >= 0)
257: onetarget = TRUE;
258:
259: sg_mapdev(scgp, f, &Bus, &Target, &Lun, &Chan, &Ino);
260:
261: /*
262: * For old kernels try to make the best guess.
263: */
264: Ino |= Chan << 8;
265: n = sg_mapbus(scgp, Ino);
266: if (Bus == -1) {
267: Bus = n;
268: if (scgp->debug)
269: printf("SCSI Bus: %d (mapped from %d)\n", Bus, Ino);
270: }
271:
272: /* if (scgp->private->scgfiles[Bus][Target][Lun] == (short)-1) */
273: scgp->private->scgfiles[Bus][Target][Lun] = (short)f;
274:
275: if (onetarget) {
276: if (Bus == busno && Target == tgt && Lun == tlun) {
277: sg_initdev(scgp, f);
278: scgp->private->scgfile = f; /* remember file for ioctl's */
279: return (TRUE);
280: } else {
281: scgp->private->scgfiles[Bus][Target][Lun] = (short)-1;
282: close(f);
283: }
284: } else {
285: sg_initdev(scgp, f);
286: if (scgp->private->scgfile < 0)
287: scgp->private->scgfile = f; /* remember file for ioctl's */
288: }
289: return (FALSE);
290: }
291:
292: LOCAL void
293: sg_initdev(scgp, f)
294: SCSI *scgp;
295: int f;
296: {
297: struct sg_rep {
298: struct sg_header hd;
299: unsigned char rbuf[100];
300: } sg_rep;
301: int n;
302:
303: /* Eat any unwanted garbage from prior use of this device */
304:
305: n = fcntl(f, F_GETFL); /* Be very proper about this */
306: fcntl(f, F_SETFL, n|O_NONBLOCK);
307:
308: fillbytes((caddr_t)&sg_rep, sizeof(struct sg_header), '\0');
309: sg_rep.hd.reply_len = sizeof(struct sg_header);
310:
311: while (read(f, &sg_rep, sizeof(sg_rep)) >= 0 || errno != EAGAIN)
312: ;
313:
314: fcntl(f, F_SETFL, n);
315:
316: sg_settimeout(f, scgp->deftimeout);
317: }
318:
319: LOCAL int
320: sg_mapbus(scgp, ino)
321: SCSI *scgp;
322: int ino;
323: {
324: register int i;
325:
326: for (i=0; i < MAX_SCG; i++) {
327: if (scgp->private->buscookies[i] == (short)-1) {
328: scgp->private->buscookies[i] = ino;
329: return (i);
330: }
331:
332: if (scgp->private->buscookies[i] == ino)
333: return (i);
334: }
335: return (0);
336: }
337:
338: LOCAL BOOL
339: sg_mapdev(scgp, f, busp, tgtp, lunp, chanp, inop)
340: SCSI *scgp;
341: int f;
342: int *busp;
343: int *tgtp;
344: int *lunp;
345: int *chanp;
346: int *inop;
347: {
348: struct sg_id {
349: long l1; /* target | lun << 8 | channel << 16 | low_ino << 24 */
350: long l2; /* Unique id */
351: } sg_id;
352: int Chan;
353: int Ino;
354: int Bus;
355: int Target;
356: int Lun;
357:
358: if (ioctl(f, SCSI_IOCTL_GET_IDLUN, &sg_id))
359: return (FALSE);
360: if (scgp->debug)
361: printf("l1: 0x%lX l2: 0x%lX\n", sg_id.l1, sg_id.l2);
362: if (ioctl(f, SCSI_IOCTL_GET_BUS_NUMBER, &Bus) < 0) {
363: Bus = -1;
364: }
365:
366: Target = sg_id.l1 & 0xFF;
367: Lun = (sg_id.l1 >> 8) & 0xFF;
368: Chan = (sg_id.l1 >> 16) & 0xFF;
369: Ino = (sg_id.l1 >> 24) & 0xFF;
370: if (scgp->debug) {
371: printf("Bus: %d Target: %d Lun: %d Chan: %d Ino: %d\n",
372: Bus, Target, Lun, Chan, Ino);
373: }
374: *busp = Bus;
375: *tgtp = Target;
376: *lunp = Lun;
377: if (chanp)
378: *chanp = Chan;
379: if (inop)
380: *inop = Ino;
381: return (TRUE);
382: }
383:
384: LOCAL long
385: scsi_maxdma(scgp)
386: SCSI *scgp;
387: {
388: long maxdma = MAX_DMA_LINUX;
389:
390: #ifdef SG_GET_BUFSIZE
391: /*
392: * We assume that all /dev/sg instances use the same
393: * maximum buffer size.
394: */
395: if ((maxdma = ioctl(scgp->private->scgfile, SG_GET_BUFSIZE, 0)) < 0) {
396: if (scgp->private->scgfile >= 0) {
397: maxdma = MAX_DMA_LINUX;
398: }
399: }
400: #endif
401: #ifdef USE_PG
402: if (scgp->scsibus == pgbus)
403: return (pg_maxdma(scgp));
404: if ((scgp->scsibus < 0) && (pg_maxdma(scgp) < maxdma))
405: return (pg_maxdma(scgp));
406: #endif
407: return (maxdma);
408: }
409:
410: EXPORT void *
411: scsi_getbuf(scgp, amt)
412: SCSI *scgp;
413: long amt;
414: {
415: char *ret;
416:
417: if (scgp->private->scg_maxdma == 0)
418: scgp->private->scg_maxdma = scsi_maxdma(scgp);
419:
420: if (amt <= 0 || amt > scgp->private->scg_maxdma)
421: return ((void *)0);
422: if (scgp->debug)
423: printf("scsi_getbuf: %ld bytes\n", amt);
424: /*
425: * For performance reason, we allocate pagesize()
426: * bytes before the SCSI buffer to avoid
427: * copying the whole buffer contents when
428: * setting up the /dev/sg data structures.
429: */
430: ret = valloc((size_t)(amt+getpagesize()));
431: if (ret == NULL)
432: return (ret);
433: ret += getpagesize();
434: scgp->private->SCSIbuf = ret;
435: return ((void *)ret);
436: }
437:
438: EXPORT
439: BOOL scsi_havebus(scgp, busno)
440: SCSI *scgp;
441: int busno;
442: {
443: register int t;
444: register int l;
445:
446: if (busno < 0 || busno >= MAX_SCG)
447: return (FALSE);
448:
449: for (t=0; t < MAX_TGT; t++) {
450: for (l=0; l < MAX_LUN ; l++)
451: if (scgp->private->scgfiles[busno][t][l] >= 0)
452: return (TRUE);
453: }
454: return (FALSE);
455: }
456:
457: EXPORT
458: int scsi_fileno(scgp, busno, tgt, tlun)
459: SCSI *scgp;
460: int busno;
461: int tgt;
462: int tlun;
463: {
464: if (busno < 0 || busno >= MAX_SCG ||
465: tgt < 0 || tgt >= MAX_TGT ||
466: tlun < 0 || tlun >= MAX_LUN)
467: return (-1);
468:
469: return ((int)scgp->private->scgfiles[busno][tgt][tlun]);
470: }
471:
472: EXPORT
473: int scsi_isatapi(scgp)
474: SCSI *scgp;
475: {
476: #ifdef USE_PG
477: if (scgp->scsibus == pgbus)
478: return (pg_isatapi(scgp));
479: #endif
480:
481: #ifdef SG_EMULATED_HOST
482: {
483: int emulated = FALSE;
484: int f = scsi_fileno(scgp, scgp->scsibus, scgp->target, scgp->lun);
485:
486: if (ioctl(f, SG_EMULATED_HOST, &emulated) >= 0)
487: return (emulated != 0);
488: }
489: #endif
490: return (-1);
491: }
492:
493: EXPORT
494: int scsireset(scgp)
495: SCSI *scgp;
496: {
497: #ifdef USE_PG
498: if (scgp->scsibus == pgbus)
499: return (pg_reset(scgp));
500: #endif
501: /*
502: * Do we have a SCSI reset in the Linux sg driver?
503: */
504: return (-1);
505: }
506:
507: LOCAL void
508: sg_settimeout(f, tmo)
509: int f;
510: int tmo;
511: {
512: tmo *= HZ;
513: if (tmo)
514: tmo += HZ/2;
515:
516: if (ioctl(f, SG_SET_TIMEOUT, &tmo) < 0)
517: fprintf(stderr, "Cannot set SG_SET_TIMEOUT.\n");
518: }
519:
520: /*
521: * Get misaligned int.
522: * Needed for all recent processors (sparc/ppc/alpha)
523: * because the /dev/sg design forces us to do misaligned
524: * reads of integers.
525: */
526: #ifdef MISALIGN
527: LOCAL int
528: scsi_getint(ip)
529: int *ip;
530: {
531: int ret;
532: register char *cp = (char *)ip;
533: register char *tp = (char *)&ret;
534: register int i;
535:
536: for (i = sizeof(int); --i >= 0; )
537: *tp++ = *cp++;
538:
539: return (ret);
540: }
541: #define GETINT(a) scsi_getint(&(a))
542: #else
543: #define GETINT(a) (a)
544: #endif
545:
546: LOCAL int
547: scsi_send(scgp, f, sp)
548: SCSI *scgp;
549: int f;
550: struct scg_cmd *sp;
551: {
552: struct sg_rq *sgp;
553: struct sg_rq *sgp2;
554: int i;
555: int pack_len;
556: int reply_len;
557: int amt = sp->cdb_len;
558: struct sg_rq {
559: struct sg_header hd;
560: unsigned char buf[MAX_DMA_LINUX+SCG_MAX_CMD];
561: } sg_rq;
562: #ifdef SG_GET_BUFSIZE /* We may use a 'sg' version 2 driver */
563: char driver_byte;
564: char host_byte;
565: char msg_byte;
566: char status_byte;
567: #endif
568:
569: if (f < 0) {
570: sp->error = SCG_FATAL;
571: return (0);
572: }
573: #ifdef USE_PG
574: if (scgp->scsibus == pgbus)
575: return (pg_send(scgp, f, sp));
576: #endif
577: if (sp->timeout != scgp->deftimeout)
578: sg_settimeout(f, sp->timeout);
579:
580:
581: sgp2 = sgp = &sg_rq;
582: if (sp->addr == scgp->private->SCSIbuf) {
583: sgp = (struct sg_rq *)
584: (scgp->private->SCSIbuf - (sizeof(struct sg_header) + amt));
585: sgp2 = (struct sg_rq *)
586: (scgp->private->SCSIbuf - (sizeof(struct sg_header)));
587: } else {
588: if (scgp->debug) {
589: printf("DMA addr: 0x%8.8lX size: %d - using copy buffer\n",
590: (long)sp->addr, sp->size);
591: }
592: if (sp->size > (int)(sizeof(sg_rq.buf) - SCG_MAX_CMD)) {
593: errno = ENOMEM;
594: return (-1);
595: }
596: }
597:
598: /*
599: * This is done to avoid misaligned access of sgp->some_int
600: */
601: pack_len = sizeof(struct sg_header) + amt;
602: reply_len = sizeof(struct sg_header);
603: if (sp->flags & SCG_RECV_DATA) {
604: reply_len += sp->size;
605: } else {
606: pack_len += sp->size;
607: }
608:
609: #ifdef MISALIGN
610: /*
611: * sgp->some_int may be misaligned if (sp->addr == SCSIbuf)
612: * This is no problem on Intel porocessors, however
613: * all other processors don't like it.
614: * sizeof(struct sg_header) + amt is usually not a multiple of
615: * sizeof(int). For this reason, we fill in the values into sg_rq
616: * which is always corectly aligned and then copy it to the real
617: * location if this location differs from sg_rq.
618: * Never read/write directly to sgp->some_int !!!!!
619: */
620: fillbytes((caddr_t)&sg_rq, sizeof(struct sg_header), '\0');
621:
622: sg_rq.hd.pack_len = pack_len;
623: sg_rq.hd.reply_len = reply_len;
624: sg_rq.hd.pack_id = scgp->private->pack_id++;
625: /* sg_rq.hd.result = 0; not needed because of fillbytes() */
626:
627: if ((caddr_t)&sg_rq != (caddr_t)sgp)
628: movebytes((caddr_t)&sg_rq, (caddr_t)sgp, sizeof(struct sg_header));
629: #else
630: fillbytes((caddr_t)sgp, sizeof(struct sg_header), '\0');
631:
632: sgp->hd.pack_len = pack_len;
633: sgp->hd.reply_len = reply_len;
634: sgp->hd.pack_id = scgp->private->pack_id++;
635: /* sgp->hd.result = 0; not needed because of fillbytes() */
636: #endif
637: if (amt == 12)
638: sgp->hd.twelve_byte = 1;
639:
640:
641: for (i = 0; i < amt; i++ ) {
642: sgp->buf[i] = sp->cdb.cmd_cdb[i];;
643: }
644: if (!(sp->flags & SCG_RECV_DATA)) {
645: if ((void *)sp->addr != (void *)&sgp->buf[amt])
646: movebytes(sp->addr, &sgp->buf[amt], sp->size);
647: amt += sp->size;
648: }
649: #ifdef SG_GET_BUFSIZE
650: sgp->hd.want_new = 1; /* Order new behaviour */
651: sgp->hd.cdb_len = sp->cdb_len; /* Set CDB length */
652: if (sp->sense_len > SG_MAX_SENSE)
653: sgp->hd.sense_len = SG_MAX_SENSE;
654: else
655: sgp->hd.sense_len = sp->sense_len;
656: #endif
657: i = sizeof(struct sg_header) + amt;
658: if ((amt = write(f, sgp, i)) < 0) { /* write */
659: sg_settimeout(f, scgp->deftimeout);
660: return (-1);
661: } else if (amt != i) {
662: /* errmsg("scsi_send(%s) wrote %d bytes (expected %d).\n",
663: scsi_command, amt, i);*/
664: }
665:
666: if (sp->addr == scgp->private->SCSIbuf) {
667: movebytes(sgp, sgp2, sizeof(struct sg_header));
668: sgp = sgp2;
669: }
670: sgp->hd.sense_buffer[0] = 0;
671: if ((amt = read(f, sgp, reply_len)) < 0) { /* read */
672: sg_settimeout(f, scgp->deftimeout);
673: return (-1);
674: }
675:
676: if (sp->flags & SCG_RECV_DATA && ((void *)sgp->buf != (void *)sp->addr)) {
677: movebytes(sgp->buf, sp->addr, sp->size);
678: }
679: sp->ux_errno = GETINT(sgp->hd.result); /* Unaligned read */
680: sp->error = SCG_NO_ERROR;
681:
682: #ifdef SG_GET_BUFSIZE
683: if (sgp->hd.grant_new) {
684: sp->sense_count = sgp->hd.sense_len;
685: pack_len = GETINT(sgp->hd.sg_cmd_status); /* Unaligned read */
686: driver_byte = (pack_len >> 24) & 0xFF;
687: host_byte = (pack_len >> 16) & 0xFF;
688: msg_byte = (pack_len >> 8) & 0xFF;
689: status_byte = pack_len & 0xFF;
690:
691: switch (host_byte) {
692:
693: case DID_OK:
694: if (sgp->hd.sense_buffer[0] != 0) {
695: /*
696: * The Linux SCSI system up to 2.1.xx
697: * trashes the status byte in the
698: * kernel. Until this gets fixed, we
699: * need this hack.
700: */
701: sp->error = SCG_RETRYABLE;
702: status_byte = 2;
703: sgp->hd.sense_len = SG_MAX_SENSE;
704: }
705: break;
706:
707: case DID_NO_CONNECT: /* Arbitration won, retry NO_CONNECT? */
708: case DID_BAD_TARGET:
709: sp->error = SCG_FATAL;
710: break;
711:
712: case DID_TIME_OUT:
713: sp->error = SCG_TIMEOUT;
714: break;
715:
716: default:
717: sp->error = SCG_RETRYABLE;
718: break;
719:
720: }
721: if ((host_byte != DID_OK || status_byte != 0) && sp->ux_errno == 0)
722: sp->ux_errno = EIO;
723: sp->u_scb.cmd_scb[0] = status_byte;
724: if (status_byte & 2) {
725: sp->sense_count = sgp->hd.sense_len;
726: movebytes(sgp->hd.sense_buffer, sp->u_sense.cmd_sense, sp->sense_count);
727: }
728: } else
729: #endif
730: {
731: if (GETINT(sgp->hd.result) == EBUSY) { /* Unaligned read */
732: struct timeval to;
733:
734: to.tv_sec = sp->timeout;
735: to.tv_usec = 500000;
736: scsitimes(scgp);
737:
738: if (scgp->cmdstop->tv_sec < to.tv_sec ||
739: (scgp->cmdstop->tv_sec == to.tv_sec &&
740: scgp->cmdstop->tv_usec < to.tv_usec)) {
741:
742: sp->ux_errno = 0;
743: sp->error = SCG_TIMEOUT; /* a timeout */
744: } else {
745: sp->error = SCG_RETRYABLE; /* may be BUS_BUSY */
746: }
747: }
748:
749: if (sp->flags & SCG_RECV_DATA)
750: sp->resid = (sp->size + sizeof(struct sg_header)) - amt;
751: else
752: sp->resid = 0; /* sg version1 cannot return DMA resid count */
753:
754: if (sgp->hd.sense_buffer[0] != 0) {
755: sp->error = SCG_RETRYABLE;
756: sp->scb.chk = 1;
757: sp->sense_count = SG_MAX_SENSE;
758: movebytes(sgp->hd.sense_buffer, sp->u_sense.cmd_sense, sp->sense_count);
759: if (sp->ux_errno == 0)
760: sp->ux_errno = EIO;
761: }
762: }
763:
764: if (scgp->verbose > 0 && scgp->debug) {
765: #ifdef SG_GET_BUFSIZE
766: printf("status: %X pack_len: %d, reply_len: %d pack_id: %d result: %d wn: %d gn: %d cdb_len: %d sense_len: %d sense[0]: %02X\n",
767: GETINT(sgp->hd.sg_cmd_status),
768: GETINT(sgp->hd.pack_len),
769: GETINT(sgp->hd.reply_len),
770: GETINT(sgp->hd.pack_id),
771: GETINT(sgp->hd.result),
772: sgp->hd.want_new,
773: sgp->hd.grant_new,
774: sgp->hd.cdb_len,
775: sgp->hd.sense_len,
776: sgp->hd.sense_buffer[0]);
777: #else
778: printf("pack_len: %d, reply_len: %d pack_id: %d result: %d sense[0]: %02X\n",
779: GETINT(sgp->hd.pack_len),
780: GETINT(sgp->hd.reply_len),
781: GETINT(sgp->hd.pack_id),
782: GETINT(sgp->hd.result),
783: sgp->hd.sense_buffer[0]);
784: #endif
785: #ifdef DEBUG
786: printf("sense: ");
787: for (i=0; i < 16; i++)
788: printf("%02X ", sgp->hd.sense_buffer[i]);
789: printf("\n");
790: #endif
791: }
792:
793: if (sp->timeout != scgp->deftimeout)
794: sg_settimeout(f, scgp->deftimeout);
795: return 0;
796: }
797:
798: LOCAL
799: void scsitimes(scgp)
800: SCSI *scgp;
801: {
802: struct timeval *stp = scgp->cmdstop;
803:
804: gettimeofday(stp, (struct timezone *)0);
805: stp->tv_sec -= scgp->cmdstart->tv_sec;
806: stp->tv_usec -= scgp->cmdstart->tv_usec;
807: while (stp->tv_usec < 0) {
808: stp->tv_sec -= 1;
809: stp->tv_usec += 1000000;
810: }
811: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.