![[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 [Early Linux] / linux / kernel / blk_drv / scsi|
Return to scsi.c CVS log | Up to [Early Linux] / linux / kernel / blk_drv / scsi |
1.1 root 1: /*
2: * scsi.c Copyright (C) 1992 Drew Eckhardt
3: * generic mid-level SCSI driver by
4: * Drew Eckhardt
5: *
6: * <[email protected]>
7: */
8: #include <linux/config.h>
9:
10: #ifdef CONFIG_SCSI
11: #include <asm/system.h>
12: #include <linux/sched.h>
13: #include <linux/timer.h>
14: #include <linux/string.h>
15:
16: #include "scsi.h"
17: #include "hosts.h"
18:
19: #ifdef CONFIG_BLK_DEV_SD
20: #include "sd.h"
21: #endif
22:
23: #ifdef CONFIG_BLK_DEV_ST
24: #include "st.h"
25: #endif
26:
27: /*
28: static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/scsi.c,v 1.1 1992/04/24 18:01:50 root Exp root $";
29: */
30:
31: #define INTERNAL_ERROR (printk ("Internal error in file %s, line %s.\n", __FILE__, __LINE__), panic(""))
32:
33: static void scsi_done (int host, int result);
34: static void update_timeout (void);
35:
36: static int time_start;
37: static int time_elapsed;
38:
39: /*
40: global variables :
41: NR_SCSI_DEVICES is the number of SCSI devices we have detected,
42: scsi_devices an array of these specifing the address for each
43: (host, id, LUN)
44: */
45:
46: int NR_SCSI_DEVICES=0;
47: Scsi_Device scsi_devices[MAX_SCSI_DEVICE];
48:
49: #define SENSE_LENGTH 255
50: /*
51: As the scsi do command functions are inteligent, and may need to
52: redo a command, we need to keep track of the last command
53: executed on each one.
54: */
55:
56: #define WAS_RESET 0x01
57: #define WAS_TIMEDOUT 0x02
58: #define WAS_SENSE 0x04
59: #define IS_RESETTING 0x08
60:
61: static Scsi_Cmnd last_cmnd[MAX_SCSI_HOSTS];
62: static int last_reset[MAX_SCSI_HOSTS];
63:
64: /*
65: This is the number of clock ticks we should wait before we time out
66: and abort the command. This is for where the scsi.c module generates
67: the command, not where it originates from a higher level, in which
68: case the timeout is specified there.
69:
70:
71: ABORT_TIMEOUT and RESET_TIMEOUT are the timeouts for RESET and ABORT
72: respectively.
73: */
74: #ifdef DEBUG
75: #define SCSI_TIMEOUT 500
76: #else
77: #define SCSI_TIMEOUT 100
78: #endif
79: #ifdef DEBUG
80: #define SENSE_TIMEOUT SCSI_TIMEOUT
81: #define ABORT_TIMEOUT SCSI_TIMEOUT
82: #define RESET_TIMEOUT SCSI_TIMEOUT
83: #else
84:
85: #define SENSE_TIMEOUT 50
86: #define RESET_TIMEOUT 50
87: #define ABORT_TIMEOUT 50
88: #define MIN_RESET_DELAY 25
89:
90: #endif
91: /*
92: As the actual SCSI command runs in the background, we must set up a
93: flag that tells scan_scsis() when the result it has is valid.
94: scan_scsis can set the_result to -1, and watch for it to become the
95: actual return code for that call. the scan_scsis_done function() is
96: our user specified completion function that is passed on to the
97: scsi_do_cmd() function.
98: */
99:
100: static int the_result;
101: static unsigned char sense_buffer[SENSE_LENGTH];
102: static void scan_scsis_done (int host, int result)
103: {
104:
105: #ifdef DEBUG
106: printk ("scan_scsis_done(%d, %06x\n\r", host, result);
107: #endif
108: the_result = result;
109: }
110: /*
111: Detecting SCSI devices :
112: We scan all present host adapter's busses, from ID 0 to ID 6.
113: We use the INQUIRY command, determine device type, and pass the ID /
114: lun address of all sequential devices to the tape driver, all random
115: devices to the disk driver.
116: */
117:
118: static void scan_scsis (void)
119: {
120: int host_nr , dev, lun, type, maxed;
121: static unsigned char scsi_cmd [12];
122: static unsigned char scsi_result [256];
123:
124: for (host_nr = 0; host_nr < MAX_SCSI_HOSTS; ++host_nr)
125: if (scsi_hosts[host_nr].present)
126: {
127: for (dev = 0; dev < 7; ++dev)
128: if (scsi_hosts[host_nr].this_id != dev)
129: #ifdef MULTI_LUN
130: for (lun = 0; lun < 8; ++lun)
131: {
132: #else
133: {
134: lun = 0;
135: #endif
136: /* Build an INQUIRY command block. */
137:
138: scsi_cmd[0] = INQUIRY;
139: scsi_cmd[1] = (lun << 5) & 0xe0;
140: scsi_cmd[2] = 0;
141: scsi_cmd[3] = 0;
142: scsi_cmd[4] = 255;
143: scsi_cmd[5] = 0;
144: the_result = -1;
145: #ifdef DEBUG
146: memset ((void *) scsi_result , 0, 255);
147: #endif
148: scsi_do_cmd (host_nr, dev, (void *) scsi_cmd, (void *)
149: scsi_result, 256, scan_scsis_done,
150: SCSI_TIMEOUT, sense_buffer, 3);
151:
152: /* Wait for valid result */
153:
154: while (the_result < 0);
155:
156:
157: if (!the_result)
158: {
159: scsi_devices[NR_SCSI_DEVICES].
160: host_no = host_nr;
161: scsi_devices[NR_SCSI_DEVICES].
162: id = dev;
163: scsi_devices[NR_SCSI_DEVICES].
164: lun = lun;
165: scsi_devices[NR_SCSI_DEVICES].
166: removable = (0x80 &
167: scsi_result[1]) >> 7;
168:
169:
170:
171: /*
172: Currently, all sequential devices are assumed to be tapes,
173: all random devices disk, with the appropriate read only
174: flags set for ROM / WORM treated as RO.
175: */
176:
177: switch (type = scsi_result[0])
178: {
179: case TYPE_TAPE:
180: case TYPE_DISK:
181: scsi_devices[NR_SCSI_DEVICES].writeable = 1;
182: break;
183: case TYPE_WORM:
184: case TYPE_ROM:
185: scsi_devices[NR_SCSI_DEVICES].writeable = 0;
186: break;
187: default:
188: type = -1;
189: }
190:
191: scsi_devices[NR_SCSI_DEVICES].random = (type == TYPE_TAPE) ? 0 : 1;
192:
193: maxed = 0;
194: switch (type)
195: {
196: case -1:
197: break;
198: case TYPE_TAPE:
199: printk("Detected scsi tape at host %d, ID %d, lun %d \n", host_nr, dev, lun);
200: #ifdef CONFIG_BLK_DEV_ST
201: if (!(maxed = (NR_ST == MAX_ST)))
202: scsi_tapes[NR_ST].device = &scsi_devices[NR_SCSI_DEVICES];
203: #endif
204: default:
205: printk("Detected scsi disk at host %d, ID %d, lun %d \n", host_nr, dev, lun);
206: #ifdef CONFIG_BLK_DEV_SD
207: if (!(maxed = (NR_SD >= MAX_SD)))
208: rscsi_disks[NR_SD].device = &scsi_devices[NR_SCSI_DEVICES];
209: #endif
210: }
211:
212: if (maxed)
213: {
214: printk ("Already have detected maximum number of SCSI %ss Unable to \n"
215: "add drive at SCSI host %s, ID %d, LUN %d\n\r", (type == TYPE_TAPE) ?
216: "tape" : "disk", scsi_hosts[host_nr].name,
217: dev, lun);
218: type = -1;
219: break;
220: }
221:
222: else if (type != -1)
223: {
224: if (type == TYPE_TAPE)
225: #ifdef CONFIG_BLK_DEV_ST
226: ++NR_ST;
227: #else
228: ;
229: #endif
230:
231: else
232: #ifdef CONFIG_BLK_DEV_SD
233: ++NR_SD;
234: #else
235: ;
236: #endif
237: }
238: ++NR_SCSI_DEVICES;
239: } /* if result == DID_OK ends */
240: } /* for lun ends */
241: } /* if present */
242:
243: printk("Detected "
244: #ifdef CONFIG_BLK_DEV_SD
245: "%d disk%s "
246: #endif
247:
248: #ifdef CONFIG_BLK_DEV_ST
249: "%d tape%s "
250: #endif
251:
252: "total.\n",
253:
254: #ifdef CONFIG_BLK_DEV_SD
255: NR_SD, (NR_SD != 1) ? "s" : ""
256: #ifdef CONFIG_BLK_DEV_ST
257: ,
258: #endif
259: #endif
260:
261: #ifdef CONFIG_BLK_DEV_ST
262: NR_ST, (NR_ST != 1) ? "s" : ""
263: #endif
264: );
265: } /* scan_scsis ends */
266:
267: /*
268: We handle the timeout differently if it happens when a reset,
269: abort, etc are in process.
270: */
271:
272: static unsigned char internal_timeout[MAX_SCSI_HOSTS];
273:
274: /* Flag bits for the internal_timeout array */
275:
276: #define NORMAL_TIMEOUT 0
277: #define IN_ABORT 1
278: #define IN_RESET 2
279: /*
280: This is our time out function, called when the timer expires for a
281: given host adapter. It will attempt to abort the currently executing
282: command, that failing perform a kernel panic.
283: */
284:
285: static void scsi_times_out (int host)
286: {
287:
288: switch (internal_timeout[host] & (IN_ABORT | IN_RESET))
289: {
290: case NORMAL_TIMEOUT:
291: printk("SCSI host %d timed out - aborting command \r\n",
292: host);
293:
294: if (!scsi_abort (host, DID_TIME_OUT))
295: return;
296: case IN_ABORT:
297: printk("SCSI host %d abort() timed out - reseting \r\n",
298: host);
299: if (!scsi_reset (host))
300: return;
301: case IN_RESET:
302: case (IN_ABORT | IN_RESET):
303: printk("Unable to reset scsi host %d\r\n",host);
304: panic("");
305: default:
306: INTERNAL_ERROR;
307: }
308:
309: }
310:
311: /*
312: This is inline because we have stack problemes if we recurse to deeply.
313: */
314:
315: static void internal_cmnd (int host, unsigned char target, const void *cmnd ,
316: void *buffer, unsigned bufflen, void (*done)(int,int))
317: {
318: int temp;
319:
320: #ifdef DEBUG_DELAY
321: int clock;
322: #endif
323:
324: if ((host < 0) || (host > MAX_SCSI_HOSTS))
325: panic ("Host number in internal_cmnd() is out of range.\n");
326:
327:
328: /*
329: We will wait MIN_RESET_DELAY clock ticks after the last reset so
330: we can avoid the drive not being ready.
331: */
332: temp = last_reset[host];
333: while (jiffies < temp);
334:
335: host_timeout[host] = last_cmnd[host].timeout_per_command;
336: update_timeout();
337:
338: /*
339: We will use a queued command if possible, otherwise we will emulate the
340: queing and calling of completion function ourselves.
341: */
342: #ifdef DEBUG
343: printk("internal_cmnd (host = %d, target = %d, command = %08x, buffer = %08x, \n"
344: "bufflen = %d, done = %08x)\n", host, target, cmnd, buffer, bufflen, done);
345: #endif
346:
347:
348: if (scsi_hosts[host].can_queue)
349: {
350: #ifdef DEBUG
351: printk("queuecommand : routine at %08x\n",
352: scsi_hosts[host].queuecommand);
353: #endif
354: scsi_hosts[host].queuecommand (target, cmnd, buffer, bufflen,
355: done);
356: }
357: else
358: {
359:
360: #ifdef DEBUG
361: printk("command() : routine at %08x\n", scsi_hosts[host].command);
362: #endif
363: temp=scsi_hosts[host].command (target, cmnd, buffer, bufflen);
364:
365: #ifdef DEBUG_DELAY
366: clock = jiffies + 400;
367: while (jiffies < clock);
368: printk("done(host = %d, result = %04x) : routine at %08x\n", host, temp, done);
369: #endif
370: done(host, temp);
371: }
372: #ifdef DEBUG
373: printk("leaving internal_cmnd()\n");
374: #endif
375: }
376:
377: static void scsi_request_sense (int host, unsigned char target,
378: unsigned char lun)
379: {
380: cli();
381: host_timeout[host] = SENSE_TIMEOUT;
382: update_timeout();
383: last_cmnd[host].flags |= WAS_SENSE;
384: sti();
385:
386: last_cmnd[host].sense_cmnd[1] = lun << 5;
387:
388: internal_cmnd (host, target, (void *) last_cmnd[host].sense_cmnd,
389: (void *) last_cmnd[host].sense_buffer, SENSE_LENGTH,
390: scsi_done);
391: }
392:
393:
394:
395:
396:
397: /*
398: scsi_do_cmd sends all the commands out to the low-level driver. It
399: handles the specifics required for each low level driver - ie queued
400: or non queud. It also prevents conflicts when different high level
401: drivers go for the same host at the same time.
402: */
403:
404: void scsi_do_cmd (int host, unsigned char target, const void *cmnd ,
405: void *buffer, unsigned bufflen, void (*done)(int,int),
406: int timeout, unsigned char *sense_buffer, int retries
407: )
408: {
409: int ok = 0;
410:
411: #ifdef DEBUG
412: int i;
413: printk ("scsi_do_cmd (host = %d, target = %d, buffer =%08x, "
414: "bufflen = %d, done = %08x, timeout = %d, retries = %d)\n"
415: "command : " , host, target, buffer, bufflen, done, timeout, retries);
416: for (i = 0; i < 10; ++i)
417: printk ("%02x ", ((unsigned char *) cmnd)[i]);
418: printk("\n");
419: #endif
420:
421: if ((host >= MAX_SCSI_HOSTS) || !scsi_hosts[host].present)
422: {
423: printk ("Invalid or not present host number. %d\n", host);
424: panic("");
425: }
426:
427:
428: /*
429: We must prevent reentrancy to the lowlevel host driver. This prevents
430: it - we enter a loop until the host we want to talk to is not busy.
431: Race conditions are prevented, as interrupts are disabled inbetween the
432: time we check for the host being not busy, and the time we mark it busy
433: ourselves.
434: */
435:
436: do {
437: cli();
438: if (host_busy[host])
439: {
440: sti();
441: #ifdef DEBUG
442: printk("Host %d is busy.\n" );
443: #endif
444: while (host_busy[host]);
445: #ifdef DEBUG
446: printk("Host %d is no longer busy.");
447: #endif
448: }
449: else
450: {
451: host_busy[host] = 1;
452: ok = 1;
453: sti();
454: }
455: } while (!ok);
456:
457:
458: /*
459: Our own function scsi_done (which marks the host as not busy, disables
460: the timeout counter, etc) will be called by us or by the
461: scsi_hosts[host].queuecommand() function needs to also call
462: the completion function for the high level driver.
463:
464: */
465:
466: memcpy ((void *) last_cmnd[host].cmnd , (void *) cmnd, 10);
467: last_cmnd[host].host = host;
468: last_cmnd[host].target = target;
469: last_cmnd[host].lun = (last_cmnd[host].cmnd[1] >> 5);
470: last_cmnd[host].bufflen = bufflen;
471: last_cmnd[host].buffer = buffer;
472: last_cmnd[host].sense_buffer = sense_buffer;
473: last_cmnd[host].flags=0;
474: last_cmnd[host].retries=0;
475: last_cmnd[host].allowed=retries;
476: last_cmnd[host].done = done;
477: last_cmnd[host].timeout_per_command = timeout;
478:
479: /* Start the timer ticking. */
480:
481: internal_timeout[host] = 0;
482: internal_cmnd (host, target, cmnd , buffer, bufflen, scsi_done);
483:
484: #ifdef DEBUG
485: printk ("Leaving scsi_do_cmd()\n");
486: #endif
487: }
488:
489:
490: /*
491: The scsi_done() function disables the timeout timer for the scsi host,
492: marks the host as not busy, and calls the user specified completion
493: function for that host's current command.
494: */
495:
496: static void reset (int host)
497: {
498: #ifdef DEBUG
499: printk("reset(%d)\n", host);
500: #endif
501:
502: last_cmnd[host].flags |= (WAS_RESET | IS_RESETTING);
503: scsi_reset(host);
504:
505: #ifdef DEBUG
506: printk("performing request sense\n");
507: #endif
508:
509: scsi_request_sense (host, last_cmnd[host].target, last_cmnd[host].lun);
510: }
511:
512:
513:
514: static int check_sense (int host)
515: {
516: if (((sense_buffer[0] & 0x70) >> 4) == 7)
517: switch (sense_buffer[2] & 0xf)
518: {
519: case NO_SENSE:
520: case RECOVERED_ERROR:
521: return 0;
522:
523: case ABORTED_COMMAND:
524: case NOT_READY:
525: case UNIT_ATTENTION:
526: return SUGGEST_RETRY;
527:
528: /* these three are not supported */
529: case COPY_ABORTED:
530: case VOLUME_OVERFLOW:
531: case MISCOMPARE:
532:
533: case MEDIUM_ERROR:
534: return SUGGEST_REMAP;
535: case BLANK_CHECK:
536: case DATA_PROTECT:
537: case HARDWARE_ERROR:
538: case ILLEGAL_REQUEST:
539: default:
540: return SUGGEST_ABORT;
541: }
542: else
543: return SUGGEST_RETRY;
544: }
545:
546: static void scsi_done (int host, int result)
547: {
548: int status=0;
549: int exit=0;
550: int checked;
551: int oldto;
552: oldto = host_timeout[host];
553: host_timeout[host] = 0;
554: update_timeout();
555:
556: #define FINISHED 0
557: #define MAYREDO 1
558: #define REDO 3
559:
560: #ifdef DEBUG
561: printk("In scsi_done(host = %d, result = %06x)\n", host, result);
562: #endif
563: if (host > MAX_SCSI_HOSTS || host < 0)
564: {
565: host_timeout[host] = 0;
566: update_timeout();
567: panic("scsi_done() called with invalid host number.\n");
568: }
569:
570: switch (host_byte(result))
571: {
572: case DID_OK:
573: if (last_cmnd[host].flags & IS_RESETTING)
574: {
575: last_cmnd[host].flags &= ~IS_RESETTING;
576: status = REDO;
577: break;
578: }
579:
580: if (status_byte(result) && (last_cmnd[host].flags &
581: WAS_SENSE))
582: {
583: last_cmnd[host].flags &= ~WAS_SENSE;
584: cli();
585: internal_timeout[host] &= ~SENSE_TIMEOUT;
586: sti();
587:
588: if (!(last_cmnd[host].flags & WAS_RESET))
589: reset(host);
590: else
591: {
592: exit = (DRIVER_HARD | SUGGEST_ABORT);
593: status = FINISHED;
594: }
595: }
596: else switch(msg_byte(result))
597: {
598: case COMMAND_COMPLETE:
599: switch (status_byte(result))
600: {
601: case GOOD:
602: if (last_cmnd[host].flags & WAS_SENSE)
603: {
604: #ifdef DEBUG
605: printk ("In scsi_done, GOOD status, COMMAND COMPLETE, parsing sense information.\n");
606: #endif
607:
608: last_cmnd[host].flags &= ~WAS_SENSE;
609: cli();
610: internal_timeout[host] &= ~SENSE_TIMEOUT;
611: sti();
612:
613: switch (checked = check_sense(host))
614: {
615: case 0:
616: #ifdef DEBUG
617: printk("NO SENSE. status = REDO\n");
618: #endif
619:
620: host_timeout[host] = oldto;
621: update_timeout();
622: status = REDO;
623: break;
624: case SUGGEST_REMAP:
625: case SUGGEST_RETRY:
626: #ifdef DEBUG
627: printk("SENSE SUGGEST REMAP or SUGGEST RETRY - status = MAYREDO\n");
628: #endif
629:
630: status = MAYREDO;
631: exit = SUGGEST_RETRY;
632: break;
633: case SUGGEST_ABORT:
634: #ifdef DEBUG
635: printk("SENSE SUGGEST ABORT - status = FINISHED");
636: #endif
637:
638: status = FINISHED;
639: exit = DRIVER_SENSE;
640: break;
641: default:
642: printk ("Internal error %s %s \n", __FILE__,
643: __LINE__);
644: }
645: }
646: else
647: {
648: #ifdef DEBUG
649: printk("COMMAND COMPLETE message returned, status = FINISHED. \n");
650: #endif
651:
652: exit = DRIVER_OK;
653: status = FINISHED;
654: }
655: break;
656:
657: case CHECK_CONDITION:
658:
659: #ifdef DEBUG
660: printk("CHECK CONDITION message returned, performing request sense.\n");
661: #endif
662:
663: scsi_request_sense (host, last_cmnd[host].target, last_cmnd[host].lun);
664: break;
665:
666: case CONDITION_GOOD:
667: case INTERMEDIATE_GOOD:
668: case INTERMEDIATE_C_GOOD:
669: #ifdef DEBUG
670: printk("CONDITION GOOD, INTERMEDIATE GOOD, or INTERMEDIATE CONDITION GOOD recieved and ignored. \n");
671: #endif
672: break;
673:
674: case BUSY:
675: #ifdef DEBUG
676: printk("BUSY message returned, performing REDO");
677: #endif
678: host_timeout[host] = oldto;
679: update_timeout();
680: status = REDO;
681: break;
682:
683: case RESERVATION_CONFLICT:
684: reset(host);
685: exit = DRIVER_SOFT | SUGGEST_ABORT;
686: status = MAYREDO;
687: break;
688: default:
689: printk ("Internal error %s %s \n"
690: "status byte = %d \n", __FILE__,
691: __LINE__, status_byte(result));
692:
693: }
694: break;
695: default:
696: panic ("unsupported message byte recieved.");
697: }
698: break;
699: case DID_TIME_OUT:
700: #ifdef DEBUG
701: printk("Host returned DID_TIME_OUT - ");
702: #endif
703:
704: if (last_cmnd[host].flags & WAS_TIMEDOUT)
705: {
706: #ifdef DEBUG
707: printk("Aborting\n");
708: #endif
709: exit = (DRIVER_TIMEOUT | SUGGEST_ABORT);
710: }
711: else
712: {
713: #ifdef DEBUG
714: printk ("Retrying.\n");
715: #endif
716: last_cmnd[host].flags |= WAS_TIMEDOUT;
717: status = REDO;
718: }
719: break;
720: case DID_BUS_BUSY:
721: case DID_PARITY:
722: status = REDO;
723: break;
724: case DID_NO_CONNECT:
725: #ifdef DEBUG
726: printk("Couldn't connect.\n");
727: #endif
728: exit = (DRIVER_HARD | SUGGEST_ABORT);
729: break;
730: case DID_ERROR:
731: status = MAYREDO;
732: exit = (DRIVER_HARD | SUGGEST_ABORT);
733: break;
734: case DID_BAD_TARGET:
735: case DID_ABORT:
736: exit = (DRIVER_INVALID | SUGGEST_ABORT);
737: break;
738: default :
739: exit = (DRIVER_ERROR | SUGGEST_DIE);
740: }
741:
742: switch (status)
743: {
744: case FINISHED:
745: break;
746: case MAYREDO:
747:
748: #ifdef DEBUG
749: printk("In MAYREDO, allowing %d retries, have %d\n\r",
750: last_cmnd[host].allowed, last_cmnd[host].retries);
751: #endif
752:
753: if ((++last_cmnd[host].retries) < last_cmnd[host].allowed)
754: {
755: if ((last_cmnd[host].retries >= (last_cmnd[host].allowed >> 1))
756: && !(last_cmnd[host].flags & WAS_RESET))
757: reset(host);
758: break;
759:
760: }
761: else
762: {
763: status = FINISHED;
764: break;
765: }
766: /* fall through to REDO */
767:
768: case REDO:
769: if (last_cmnd[host].flags & WAS_SENSE)
770: scsi_request_sense (host, last_cmnd[host].target,
771: last_cmnd[host].lun);
772: else
773: internal_cmnd (host, last_cmnd[host].target,
774: last_cmnd[host].cmnd,
775: last_cmnd[host].buffer,
776: last_cmnd[host].bufflen, scsi_done);
777: break;
778: default:
779: INTERNAL_ERROR;
780: }
781:
782: if (status == FINISHED)
783: {
784: #ifdef DEBUG
785: printk("Calling done function - at address %08x\n", last_cmnd[host].done);
786: #endif
787: last_cmnd[host].done (host, (result | ((exit & 0xff) << 24)));
788: host_busy[host] = 0;
789: }
790:
791:
792: #undef FINISHED
793: #undef REDO
794: #undef MAYREDO
795:
796: }
797:
798: /*
799: The scsi_abort function interfaces with the abort() function of the host
800: we are aborting, and causes the current command to not complete. The
801: caller should deal with any error messages or status returned on the
802: next call.
803:
804: This will not be called rentrantly for a given host.
805: */
806:
807: /*
808: Since we're nice guys and specified that abort() and reset()
809: can be non-reentrant. The internal_timeout flags are used for
810: this.
811: */
812:
813:
814: int scsi_abort (int host, int why)
815: {
816: int temp, oldto;
817:
818: while(1)
819: {
820: cli();
821: if (internal_timeout[host] & IN_ABORT)
822: {
823: sti();
824: while (internal_timeout[host] & IN_ABORT);
825: }
826: else
827: {
828: internal_timeout[host] |= IN_ABORT;
829: host_timeout[host] = ABORT_TIMEOUT;
830: update_timeout();
831:
832: oldto = host_timeout[host];
833:
834: sti();
835: if (!host_busy[host] || !scsi_hosts[host].abort(why))
836: temp = 0;
837: else
838: temp = 1;
839:
840: cli();
841: internal_timeout[host] &= ~IN_ABORT;
842: host_timeout[host]=oldto;
843: update_timeout();
844: sti();
845: return temp;
846: }
847: }
848: }
849:
850: int scsi_reset (int host)
851: {
852: int temp, oldto;
853:
854: while (1) {
855: cli();
856: if (internal_timeout[host] & IN_RESET)
857: {
858: sti();
859: while (internal_timeout[host] & IN_RESET);
860: }
861: else
862: {
863: oldto = host_timeout[host];
864: host_timeout[host] = RESET_TIMEOUT;
865: update_timeout();
866: internal_timeout[host] |= IN_RESET;
867:
868: if (host_busy[host])
869: {
870: sti();
871: if (!(last_cmnd[host].flags & IS_RESETTING) && !(internal_timeout[host] & IN_ABORT))
872: scsi_abort(host, DID_RESET);
873:
874: temp = scsi_hosts[host].reset();
875: }
876: else
877: {
878: host_busy[host]=1;
879:
880: sti();
881: temp = scsi_hosts[host].reset();
882: last_reset[host] = jiffies;
883: host_busy[host]=0;
884: }
885:
886: cli();
887: host_timeout[host] = oldto;
888: update_timeout();
889: internal_timeout[host] &= ~IN_RESET;
890: sti();
891: return temp;
892: }
893: }
894: }
895:
896:
897: static void scsi_main_timeout(void)
898: {
899: /*
900: We must not enter update_timeout with a timeout condition still pending.
901: */
902:
903: int i, timed_out;
904:
905: do {
906: cli();
907:
908: /*
909: Find all timers such that they have 0 or negative (shouldn't happen)
910: time remaining on them.
911: */
912:
913: for (i = timed_out = 0; i < MAX_SCSI_HOSTS; ++i)
914: if (host_timeout[i] != 0 && host_timeout[i] <= time_elapsed)
915: {
916: sti();
917: host_timeout[i] = 0;
918: scsi_times_out(i);
919: ++timed_out;
920: }
921:
922: update_timeout();
923: } while (timed_out);
924: sti();
925: }
926:
927: /*
928: These are used to keep track of things.
929: */
930:
931: static int time_start, time_elapsed;
932:
933: /*
934: The strategy is to cause the timer code to call scsi_times_out()
935: when the soonest timeout is pending.
936: */
937:
938: static void update_timeout(void)
939: {
940: int i, least, used;
941:
942: cli();
943:
944: /*
945: Figure out how much time has passed since the last time the timeouts
946: were updated
947: */
948: used = (time_start) ? (jiffies - time_start) : 0;
949:
950: /*
951: Find out what is due to timeout soonest, and adjust all timeouts for
952: the amount of time that has passed since the last time we called
953: update_timeout.
954: */
955:
956: for (i = 0, least = 0xffffffff; i < MAX_SCSI_HOSTS; ++i)
957: if (host_timeout[i] > 0 && (host_timeout[i] -= used) < least)
958: least = host_timeout[i];
959:
960: /*
961: If something is due to timeout again, then we will set the next timeout
962: interrupt to occur. Otherwise, timeouts are disabled.
963: */
964:
965: if (least != 0xffffffff)
966: {
967: time_start = jiffies;
968: timer_table[SCSI_TIMER].expires = (time_elapsed = least) + jiffies;
969: timer_active |= 1 << SCSI_TIMER;
970: }
971: else
972: {
973: timer_table[SCSI_TIMER].expires = time_start = time_elapsed = 0;
974: timer_active &= ~(1 << SCSI_TIMER);
975: }
976: sti();
977: }
978: /*
979: scsi_dev_init() is our initialization routine, which inturn calls host
980: initialization, bus scanning, and sd/st initialization routines. It
981: should be called from main().
982: */
983:
984: static unsigned char generic_sense[6] = {REQUEST_SENSE, 0,0,0, 255, 0};
985: void scsi_dev_init (void)
986: {
987: int i;
988: #ifdef FOO_ON_YOU
989: return;
990: #endif
991: timer_table[SCSI_TIMER].fn = scsi_main_timeout;
992: timer_table[SCSI_TIMER].expires = 0;
993:
994: scsi_init(); /* initialize all hosts */
995: /*
996: Set up sense command in each host structure.
997: */
998:
999: for (i = 0; i < MAX_SCSI_HOSTS; ++i)
1000: {
1001: memcpy ((void *) last_cmnd[i].sense_cmnd, (void *) generic_sense,
1002: 6);
1003: last_reset[i] = 0;
1004: }
1005:
1006: scan_scsis(); /* scan for scsi devices */
1007:
1008: #ifdef CONFIG_BLK_DEV_SD
1009: sd_init(); /* init scsi disks */
1010: #endif
1011:
1012: #ifdef CONFIG_BLK_DEV_ST
1013: st_init(); /* init scsi tapes */
1014: #endif
1015: }
1016: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.