![[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 [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to scsi.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /*
2: * scsi.c Copyright (C) 1992 Drew Eckhardt
3: * Copyright (C) 1993, 1994, 1995 Eric Youngdale
4: *
5: * generic mid-level SCSI driver
6: * Initial versions: Drew Eckhardt
7: * Subsequent revisions: Eric Youngdale
8: *
9: * <[email protected]>
10: *
11: * Bug correction thanks go to :
12: * Rik Faith <[email protected]>
13: * Tommy Thorn <tthorn>
14: * Thomas Wuensche <[email protected]>
15: *
16: * Modified by Eric Youngdale [email protected] to
17: * add scatter-gather, multiple outstanding request, and other
18: * enhancements.
19: *
20: * Native multichannel and wide scsi support added
21: * by Michael Neuffer [email protected]
22: */
23:
24: /*
25: * Don't import our own symbols, as this would severely mess up our
26: * symbol tables.
27: */
28: #define _SCSI_SYMS_VER_
29: #include <linux/module.h>
30:
31: #include <asm/system.h>
32: #include <linux/sched.h>
33: #include <linux/timer.h>
34: #include <linux/string.h>
35: #include <linux/malloc.h>
36: #include <asm/irq.h>
37: #include <asm/dma.h>
38: #include <linux/ioport.h>
39: #include <linux/kernel.h>
40: #include<linux/stat.h>
41:
42: #include <linux/blk.h>
43: #include "scsi.h"
44: #include "hosts.h"
45: #include "constants.h"
46:
47: #include <linux/config.h>
48:
49: #undef USE_STATIC_SCSI_MEMORY
50:
51: /*
52: static const char RCSid[] = "$Header: /gd4/gnu/cvsroot/gnumach/i386/i386at/gpl/linux/scsi/scsi.c,v 1.2 1997/03/24 21:51:33 thomas Exp $";
53: */
54:
55:
56: /* Command groups 3 and 4 are reserved and should never be used. */
57: const unsigned char scsi_command_size[8] = { 6, 10, 10, 12, 12, 12, 10, 10 };
58:
59: #define INTERNAL_ERROR (panic ("Internal error in file %s, line %d.\n", __FILE__, __LINE__))
60:
61: /*
62: * PAGE_SIZE must be a multiple of the sector size (512). True
63: * for all reasonably recent architectures (even the VAX...).
64: */
65: #define SECTOR_SIZE 512
66: #define SECTORS_PER_PAGE (PAGE_SIZE/SECTOR_SIZE)
67:
68: #if SECTORS_PER_PAGE <= 8
69: typedef unsigned char FreeSectorBitmap;
70: #elif SECTORS_PER_PAGE <= 32
71: typedef unsigned int FreeSectorBitmap;
72: #else
73: # error You lose.
74: #endif
75:
76: static void scsi_done (Scsi_Cmnd *SCpnt);
77: static int update_timeout (Scsi_Cmnd *, int);
78: static void print_inquiry(unsigned char *data);
79: static void scsi_times_out (Scsi_Cmnd * SCpnt, int pid);
80: static int scan_scsis_single (int channel,int dev,int lun,int * max_scsi_dev ,
81: Scsi_Device ** SDpnt, Scsi_Cmnd * SCpnt,
82: struct Scsi_Host *shpnt, char * scsi_result);
83: void scsi_build_commandblocks(Scsi_Device * SDpnt);
84:
85: #ifdef CONFIG_MODULES
86: extern struct symbol_table scsi_symbol_table;
87: #endif
88:
89: static FreeSectorBitmap * dma_malloc_freelist = NULL;
90: static int scsi_need_isa_bounce_buffers;
91: static unsigned int dma_sectors = 0;
92: unsigned int dma_free_sectors = 0;
93: unsigned int need_isa_buffer = 0;
94: static unsigned char ** dma_malloc_pages = NULL;
95:
96: static int time_start;
97: static int time_elapsed;
98: static volatile struct Scsi_Host * host_active = NULL;
99: #define SCSI_BLOCK(HOST) ((HOST->block && host_active && HOST != host_active) \
100: || (HOST->can_queue && HOST->host_busy >= HOST->can_queue))
101:
102: #define MAX_SCSI_DEVICE_CODE 10
103: const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE] =
104: {
105: "Direct-Access ",
106: "Sequential-Access",
107: "Printer ",
108: "Processor ",
109: "WORM ",
110: "CD-ROM ",
111: "Scanner ",
112: "Optical Device ",
113: "Medium Changer ",
114: "Communications "
115: };
116:
117:
118: /*
119: * global variables :
120: * scsi_devices an array of these specifying the address for each
121: * (host, id, LUN)
122: */
123:
124: Scsi_Device * scsi_devices = NULL;
125:
126: /* Process ID of SCSI commands */
127: unsigned long scsi_pid = 0;
128:
129: static unsigned char generic_sense[6] = {REQUEST_SENSE, 0,0,0, 255, 0};
130: static void resize_dma_pool(void);
131:
132: /* This variable is merely a hook so that we can debug the kernel with gdb. */
133: Scsi_Cmnd * last_cmnd = NULL;
134:
135: /* This is the pointer to the /proc/scsi code.
136: * It is only initialized to !=0 if the scsi code is present
137: */
138: extern int (* dispatch_scsi_info_ptr)(int ino, char *buffer, char **start,
139: off_t offset, int length, int inout);
140: extern int dispatch_scsi_info(int ino, char *buffer, char **start,
141: off_t offset, int length, int inout);
142:
143: struct proc_dir_entry proc_scsi_scsi = {
144: PROC_SCSI_SCSI, 4, "scsi",
145: S_IFREG | S_IRUGO | S_IWUSR, 2, 0, 0, 0,
146: NULL,
147: NULL, NULL,
148: NULL, NULL, NULL
149: };
150:
151:
152: /*
153: * As the scsi do command functions are intelligent, and may need to
154: * redo a command, we need to keep track of the last command
155: * executed on each one.
156: */
157:
158: #define WAS_RESET 0x01
159: #define WAS_TIMEDOUT 0x02
160: #define WAS_SENSE 0x04
161: #define IS_RESETTING 0x08
162: #define IS_ABORTING 0x10
163: #define ASKED_FOR_SENSE 0x20
164:
165: /*
166: * This is the number of clock ticks we should wait before we time out
167: * and abort the command. This is for where the scsi.c module generates
168: * the command, not where it originates from a higher level, in which
169: * case the timeout is specified there.
170: *
171: * ABORT_TIMEOUT and RESET_TIMEOUT are the timeouts for RESET and ABORT
172: * respectively.
173: */
174:
175: #ifdef DEBUG_TIMEOUT
176: static void scsi_dump_status(void);
177: #endif
178:
179:
180: #ifdef DEBUG
181: #define SCSI_TIMEOUT (5*HZ)
182: #else
183: #define SCSI_TIMEOUT (1*HZ)
184: #endif
185:
186: #ifdef DEBUG
187: #define SENSE_TIMEOUT SCSI_TIMEOUT
188: #define ABORT_TIMEOUT SCSI_TIMEOUT
189: #define RESET_TIMEOUT SCSI_TIMEOUT
190: #else
191: #define SENSE_TIMEOUT (5*HZ/10)
192: #define RESET_TIMEOUT (5*HZ/10)
193: #define ABORT_TIMEOUT (5*HZ/10)
194: #endif
195:
196: #define MIN_RESET_DELAY (1*HZ)
197:
198: /* Do not call reset on error if we just did a reset within 10 sec. */
199: #define MIN_RESET_PERIOD (10*HZ)
200:
201: /* The following devices are known not to tolerate a lun != 0 scan for
202: * one reason or another. Some will respond to all luns, others will
203: * lock up.
204: */
205:
206: #define BLIST_NOLUN 0x01
207: #define BLIST_FORCELUN 0x02
208: #define BLIST_BORKEN 0x04
209: #define BLIST_KEY 0x08
210: #define BLIST_SINGLELUN 0x10
211:
212: struct dev_info{
213: const char * vendor;
214: const char * model;
215: const char * revision; /* Latest revision known to be bad. Not used yet */
216: unsigned flags;
217: };
218:
219: /*
220: * This is what was previously known as the blacklist. The concept
221: * has been expanded so that we can specify other types of things we
222: * need to be aware of.
223: */
224: static struct dev_info device_list[] =
225: {
226: {"CHINON","CD-ROM CDS-431","H42", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
227: {"CHINON","CD-ROM CDS-535","Q14", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
228: {"DENON","DRD-25X","V", BLIST_NOLUN}, /* Locks up if probed for lun != 0 */
229: {"HITACHI","DK312C","CM81", BLIST_NOLUN}, /* Responds to all lun - dtg */
230: {"HITACHI","DK314C","CR21" , BLIST_NOLUN}, /* responds to all lun */
231: {"IMS", "CDD521/10","2.06", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
232: {"MAXTOR","XT-3280","PR02", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
233: {"MAXTOR","XT-4380S","B3C", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
234: {"MAXTOR","MXT-1240S","I1.2", BLIST_NOLUN}, /* Locks up when LUN>0 polled */
235: {"MAXTOR","XT-4170S","B5A", BLIST_NOLUN}, /* Locks-up sometimes when LUN>0 polled. */
236: {"MAXTOR","XT-8760S","B7B", BLIST_NOLUN}, /* guess what? */
237: {"MEDIAVIS","RENO CD-ROMX2A","2.03",BLIST_NOLUN},/*Responds to all lun */
238: {"NEC","CD-ROM DRIVE:841","1.0", BLIST_NOLUN}, /* Locks-up when LUN>0 polled. */
239: {"RODIME","RO3000S","2.33", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
240: {"SEAGATE", "ST157N", "\004|j", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
241: * for aha152x controller, which causes
242: * SCSI code to reset bus.*/
243: {"SEAGATE", "ST296","921", BLIST_NOLUN}, /* Responds to all lun */
244: {"SEAGATE","ST1581","6538",BLIST_NOLUN}, /* Responds to all lun */
245: {"SONY","CD-ROM CDU-541","4.3d", BLIST_NOLUN},
246: {"SONY","CD-ROM CDU-55S","1.0i", BLIST_NOLUN},
247: {"SONY","CD-ROM CDU-561","1.7x", BLIST_NOLUN},
248: {"TANDBERG","TDC 3600","U07", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
249: {"TEAC","CD-ROM","1.06", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
250: * for seagate controller, which causes
251: * SCSI code to reset bus.*/
252: {"TEXEL","CD-ROM","1.06", BLIST_NOLUN}, /* causes failed REQUEST SENSE on lun 1
253: * for seagate controller, which causes
254: * SCSI code to reset bus.*/
255: {"QUANTUM","LPS525S","3110", BLIST_NOLUN}, /* Locks sometimes if polled for lun != 0 */
256: {"QUANTUM","PD1225S","3110", BLIST_NOLUN}, /* Locks sometimes if polled for lun != 0 */
257: {"MEDIAVIS","CDR-H93MV","1.31", BLIST_NOLUN}, /* Locks up if polled for lun != 0 */
258: {"SANKYO", "CP525","6.64", BLIST_NOLUN}, /* causes failed REQ SENSE, extra reset */
259: {"HP", "C1750A", "3226", BLIST_NOLUN}, /* scanjet iic */
260: {"HP", "C1790A", "", BLIST_NOLUN}, /* scanjet iip */
261: {"HP", "C2500A", "", BLIST_NOLUN}, /* scanjet iicx */
262:
263: /*
264: * Other types of devices that have special flags.
265: */
266: {"SONY","CD-ROM CDU-8001","*", BLIST_BORKEN},
267: {"TEXEL","CD-ROM","1.06", BLIST_BORKEN},
268: {"INSITE","Floptical F*8I","*", BLIST_KEY},
269: {"INSITE","I325VM","*", BLIST_KEY},
270: {"PIONEER","CD-ROMDRM-602X","*", BLIST_FORCELUN | BLIST_SINGLELUN},
271: {"PIONEER","CD-ROMDRM-604X","*", BLIST_FORCELUN | BLIST_SINGLELUN},
272: /*
273: * Must be at end of list...
274: */
275: {NULL, NULL, NULL}
276: };
277:
278: static int get_device_flags(unsigned char * response_data){
279: int i = 0;
280: unsigned char * pnt;
281: for(i=0; 1; i++){
282: if(device_list[i].vendor == NULL) return 0;
283: pnt = &response_data[8];
284: while(*pnt && *pnt == ' ') pnt++;
285: if(memcmp(device_list[i].vendor, pnt,
286: strlen(device_list[i].vendor))) continue;
287: pnt = &response_data[16];
288: while(*pnt && *pnt == ' ') pnt++;
289: if(memcmp(device_list[i].model, pnt,
290: strlen(device_list[i].model))) continue;
291: return device_list[i].flags;
292: }
293: return 0;
294: }
295:
296: void scsi_make_blocked_list(void) {
297: int block_count = 0, index;
298: unsigned int flags;
299: struct Scsi_Host * sh[128], * shpnt;
300:
301: /*
302: * Create a circular linked list from the scsi hosts which have
303: * the "wish_block" field in the Scsi_Host structure set.
304: * The blocked list should include all the scsi hosts using ISA DMA.
305: * In some systems, using two dma channels simultaneously causes
306: * unpredictable results.
307: * Among the scsi hosts in the blocked list, only one host at a time
308: * is allowed to have active commands queued. The transition from
309: * one active host to the next one is allowed only when host_busy == 0
310: * for the active host (which implies host_busy == 0 for all the hosts
311: * in the list). Moreover for block devices the transition to a new
312: * active host is allowed only when a request is completed, since a
313: * block device request can be divided into multiple scsi commands
314: * (when there are few sg lists or clustering is disabled).
315: *
316: * (DB, 4 Feb 1995)
317: */
318:
319: save_flags(flags);
320: cli();
321: host_active = NULL;
322:
323: for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next) {
324:
325: #if 0
326: /*
327: * Is this is a candidate for the blocked list?
328: * Useful to put into the blocked list all the hosts whose driver
329: * does not know about the host->block feature.
330: */
331: if (shpnt->unchecked_isa_dma) shpnt->wish_block = 1;
332: #endif
333:
334: if (shpnt->wish_block) sh[block_count++] = shpnt;
335: }
336:
337: if (block_count == 1) sh[0]->block = NULL;
338:
339: else if (block_count > 1) {
340:
341: for(index = 0; index < block_count - 1; index++) {
342: sh[index]->block = sh[index + 1];
343: printk("scsi%d : added to blocked host list.\n",
344: sh[index]->host_no);
345: }
346:
347: sh[block_count - 1]->block = sh[0];
348: printk("scsi%d : added to blocked host list.\n",
349: sh[index]->host_no);
350: }
351:
352: restore_flags(flags);
353: }
354:
355: static void scan_scsis_done (Scsi_Cmnd * SCpnt)
356: {
357:
358: #ifdef DEBUG
359: printk ("scan_scsis_done(%p, %06x)\n", SCpnt->host, SCpnt->result);
360: #endif
361: SCpnt->request.rq_status = RQ_SCSI_DONE;
362:
363: if (SCpnt->request.sem != NULL)
364: up(SCpnt->request.sem);
365: }
366:
367: #ifdef CONFIG_SCSI_MULTI_LUN
368: static int max_scsi_luns = 8;
369: #else
370: static int max_scsi_luns = 1;
371: #endif
372:
373: void scsi_luns_setup(char *str, int *ints) {
374: if (ints[0] != 1)
375: printk("scsi_luns_setup : usage max_scsi_luns=n (n should be between 1 and 8)\n");
376: else
377: max_scsi_luns = ints[1];
378: }
379:
380: /*
381: * Detecting SCSI devices :
382: * We scan all present host adapter's busses, from ID 0 to ID (max_id).
383: * We use the INQUIRY command, determine device type, and pass the ID /
384: * lun address of all sequential devices to the tape driver, all random
385: * devices to the disk driver.
386: */
387: static void scan_scsis (struct Scsi_Host *shpnt, unchar hardcoded,
388: unchar hchannel, unchar hid, unchar hlun)
389: {
390: int dev, lun, channel;
391: unsigned char scsi_result0[256];
392: unsigned char *scsi_result;
393: Scsi_Device *SDpnt;
394: int max_dev_lun;
395: Scsi_Cmnd *SCpnt;
396:
397: SCpnt = (Scsi_Cmnd *) scsi_init_malloc (sizeof (Scsi_Cmnd), GFP_ATOMIC | GFP_DMA);
398: SDpnt = (Scsi_Device *) scsi_init_malloc (sizeof (Scsi_Device), GFP_ATOMIC);
399: memset (SCpnt, 0, sizeof (Scsi_Cmnd));
400:
401:
402: /* Make sure we have something that is valid for DMA purposes */
403: scsi_result = ( ( !shpnt->unchecked_isa_dma )
404: ? &scsi_result0[0] : scsi_init_malloc (512, GFP_DMA));
405:
406: if (scsi_result == NULL) {
407: printk ("Unable to obtain scsi_result buffer\n");
408: goto leave;
409: }
410:
411: /* We must chain ourself in the host_queue, so commands can time out */
412: if(shpnt->host_queue)
413: shpnt->host_queue->prev = SCpnt;
414: SCpnt->next = shpnt->host_queue;
415: SCpnt->prev = NULL;
416: shpnt->host_queue = SCpnt;
417:
418:
419: if (hardcoded == 1) {
420: Scsi_Device *oldSDpnt=SDpnt;
421: struct Scsi_Device_Template * sdtpnt;
422: channel = hchannel;
423: if(channel > shpnt->max_channel) goto leave;
424: dev = hid;
425: if(dev >= shpnt->max_id) goto leave;
426: lun = hlun;
427: if(lun >= shpnt->max_lun) goto leave;
428: scan_scsis_single (channel, dev, lun, &max_dev_lun,
429: &SDpnt, SCpnt, shpnt, scsi_result);
430: if(SDpnt!=oldSDpnt) {
431:
432: /* it could happen the blockdevice hasn't yet been inited */
433: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
434: if(sdtpnt->init && sdtpnt->dev_noticed) (*sdtpnt->init)();
435:
436: oldSDpnt->scsi_request_fn = NULL;
437: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
438: if(sdtpnt->attach) {
439: (*sdtpnt->attach)(oldSDpnt);
440: if(oldSDpnt->attached) scsi_build_commandblocks(oldSDpnt);}
441: resize_dma_pool();
442:
443: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next) {
444: if(sdtpnt->finish && sdtpnt->nr_dev)
445: {(*sdtpnt->finish)();}
446: }
447: }
448:
449: }
450: else {
451: for (channel = 0; channel <= shpnt->max_channel; channel++) {
452: for (dev = 0; dev < shpnt->max_id; ++dev) {
453: if (shpnt->this_id != dev) {
454:
455: /*
456: * We need the for so our continue, etc. work fine. We put this in
457: * a variable so that we can override it during the scan if we
458: * detect a device *KNOWN* to have multiple logical units.
459: */
460: max_dev_lun = (max_scsi_luns < shpnt->max_lun ?
461: max_scsi_luns : shpnt->max_lun);
462: for (lun = 0; lun < max_dev_lun; ++lun) {
463: if (!scan_scsis_single (channel, dev, lun, &max_dev_lun,
464: &SDpnt, SCpnt, shpnt, scsi_result))
465: break; /* break means don't probe further for luns!=0 */
466: } /* for lun ends */
467: } /* if this_id != id ends */
468: } /* for dev ends */
469: } /* for channel ends */
470: } /* if/else hardcoded */
471:
472: leave:
473:
474: {/* Unchain SCpnt from host_queue */
475: Scsi_Cmnd *prev,*next,*hqptr;
476: for(hqptr=shpnt->host_queue; hqptr!=SCpnt; hqptr=hqptr->next) ;
477: if(hqptr) {
478: prev=hqptr->prev;
479: next=hqptr->next;
480: if(prev)
481: prev->next=next;
482: else
483: shpnt->host_queue=next;
484: if(next) next->prev=prev;
485: }
486: }
487:
488: /* Last device block does not exist. Free memory. */
489: if (SDpnt != NULL)
490: scsi_init_free ((char *) SDpnt, sizeof (Scsi_Device));
491:
492: if (SCpnt != NULL)
493: scsi_init_free ((char *) SCpnt, sizeof (Scsi_Cmnd));
494:
495: /* If we allocated a buffer so we could do DMA, free it now */
496: if (scsi_result != &scsi_result0[0] && scsi_result != NULL)
497: scsi_init_free (scsi_result, 512);
498:
499: }
500:
501: /*
502: * The worker for scan_scsis.
503: * Returning 0 means Please don't ask further for lun!=0, 1 means OK go on.
504: * Global variables used : scsi_devices(linked list)
505: */
506: int scan_scsis_single (int channel, int dev, int lun, int *max_dev_lun,
507: Scsi_Device **SDpnt2, Scsi_Cmnd * SCpnt, struct Scsi_Host * shpnt,
508: char *scsi_result)
509: {
510: unsigned char scsi_cmd[12];
511: struct Scsi_Device_Template *sdtpnt;
512: Scsi_Device * SDtail, *SDpnt=*SDpnt2;
513: int bflags, type=-1;
514:
515: SDtail = scsi_devices;
516: if (scsi_devices)
517: while (SDtail->next)
518: SDtail = SDtail->next;
519:
520: memset (SDpnt, 0, sizeof (Scsi_Device));
521: SDpnt->host = shpnt;
522: SDpnt->id = dev;
523: SDpnt->lun = lun;
524: SDpnt->channel = channel;
525:
526: /* Some low level driver could use device->type (DB) */
527: SDpnt->type = -1;
528:
529: /*
530: * Assume that the device will have handshaking problems, and then fix this
531: * field later if it turns out it doesn't
532: */
533: SDpnt->borken = 1;
534: SDpnt->was_reset = 0;
535: SDpnt->expecting_cc_ua = 0;
536:
537: scsi_cmd[0] = TEST_UNIT_READY;
538: scsi_cmd[1] = lun << 5;
539: scsi_cmd[2] = scsi_cmd[3] = scsi_cmd[4] = scsi_cmd[5] = 0;
540:
541: SCpnt->host = SDpnt->host;
542: SCpnt->device = SDpnt;
543: SCpnt->target = SDpnt->id;
544: SCpnt->lun = SDpnt->lun;
545: SCpnt->channel = SDpnt->channel;
546: {
547: struct semaphore sem = MUTEX_LOCKED;
548: SCpnt->request.sem = &sem;
549: SCpnt->request.rq_status = RQ_SCSI_BUSY;
550: scsi_do_cmd (SCpnt, (void *) scsi_cmd,
551: (void *) scsi_result,
552: 256, scan_scsis_done, SCSI_TIMEOUT + 4 * HZ, 5);
553: down (&sem);
554: }
555:
556: #if defined(DEBUG) || defined(DEBUG_INIT)
557: printk ("scsi: scan_scsis_single id %d lun %d. Return code 0x%08x\n",
558: dev, lun, SCpnt->result);
559: print_driverbyte(SCpnt->result); print_hostbyte(SCpnt->result);
560: printk("\n");
561: #endif
562:
563: if (SCpnt->result) {
564: if (((driver_byte (SCpnt->result) & DRIVER_SENSE) ||
565: (status_byte (SCpnt->result) & CHECK_CONDITION)) &&
566: ((SCpnt->sense_buffer[0] & 0x70) >> 4) == 7) {
567: if (((SCpnt->sense_buffer[2] & 0xf) != NOT_READY) &&
568: ((SCpnt->sense_buffer[2] & 0xf) != UNIT_ATTENTION) &&
569: ((SCpnt->sense_buffer[2] & 0xf) != ILLEGAL_REQUEST || lun > 0))
570: return 1;
571: }
572: else
573: return 0;
574: }
575:
576: #if defined (DEBUG) || defined(DEBUG_INIT)
577: printk ("scsi: performing INQUIRY\n");
578: #endif
579: /*
580: * Build an INQUIRY command block.
581: */
582: scsi_cmd[0] = INQUIRY;
583: scsi_cmd[1] = (lun << 5) & 0xe0;
584: scsi_cmd[2] = 0;
585: scsi_cmd[3] = 0;
586: scsi_cmd[4] = 255;
587: scsi_cmd[5] = 0;
588: SCpnt->cmd_len = 0;
589: {
590: struct semaphore sem = MUTEX_LOCKED;
591: SCpnt->request.sem = &sem;
592: SCpnt->request.rq_status = RQ_SCSI_BUSY;
593: scsi_do_cmd (SCpnt, (void *) scsi_cmd,
594: (void *) scsi_result,
595: 256, scan_scsis_done, SCSI_TIMEOUT, 3);
596: down (&sem);
597: }
598:
599: #if defined(DEBUG) || defined(DEBUG_INIT)
600: printk ("scsi: INQUIRY %s with code 0x%x\n",
601: SCpnt->result ? "failed" : "successful", SCpnt->result);
602: #endif
603:
604: if (SCpnt->result)
605: return 0; /* assume no peripheral if any sort of error */
606:
607: /*
608: * It would seem some TOSHIBA CDROM gets things wrong
609: */
610: if (!strncmp (scsi_result + 8, "TOSHIBA", 7) &&
611: !strncmp (scsi_result + 16, "CD-ROM", 6) &&
612: scsi_result[0] == TYPE_DISK) {
613: scsi_result[0] = TYPE_ROM;
614: scsi_result[1] |= 0x80; /* removable */
615: }
616:
617: if (!strncmp (scsi_result + 8, "NEC", 3)) {
618: if (!strncmp (scsi_result + 16, "CD-ROM DRIVE:84 ", 16) ||
619: !strncmp (scsi_result + 16, "CD-ROM DRIVE:25", 15))
620: SDpnt->manufacturer = SCSI_MAN_NEC_OLDCDR;
621: else
622: SDpnt->manufacturer = SCSI_MAN_NEC;
623: }
624: else if (!strncmp (scsi_result + 8, "TOSHIBA", 7))
625: SDpnt->manufacturer = SCSI_MAN_TOSHIBA;
626: else if (!strncmp (scsi_result + 8, "SONY", 4))
627: SDpnt->manufacturer = SCSI_MAN_SONY;
628: else if (!strncmp (scsi_result + 8, "PIONEER", 7))
629: SDpnt->manufacturer = SCSI_MAN_PIONEER;
630: else
631: SDpnt->manufacturer = SCSI_MAN_UNKNOWN;
632:
633: memcpy (SDpnt->vendor, scsi_result + 8, 8);
634: memcpy (SDpnt->model, scsi_result + 16, 16);
635: memcpy (SDpnt->rev, scsi_result + 32, 4);
636:
637: SDpnt->removable = (0x80 & scsi_result[1]) >> 7;
638: SDpnt->lockable = SDpnt->removable;
639: SDpnt->changed = 0;
640: SDpnt->access_count = 0;
641: SDpnt->busy = 0;
642: SDpnt->has_cmdblocks = 0;
643: /*
644: * Currently, all sequential devices are assumed to be tapes, all random
645: * devices disk, with the appropriate read only flags set for ROM / WORM
646: * treated as RO.
647: */
648: switch (type = (scsi_result[0] & 0x1f)) {
649: case TYPE_TAPE:
650: case TYPE_DISK:
651: case TYPE_MOD:
652: case TYPE_PROCESSOR:
653: case TYPE_SCANNER:
654: SDpnt->writeable = 1;
655: break;
656: case TYPE_WORM:
657: case TYPE_ROM:
658: SDpnt->writeable = 0;
659: break;
660: default:
661: printk ("scsi: unknown type %d\n", type);
662: }
663:
664: SDpnt->single_lun = 0;
665: SDpnt->soft_reset =
666: (scsi_result[7] & 1) && ((scsi_result[3] & 7) == 2);
667: SDpnt->random = (type == TYPE_TAPE) ? 0 : 1;
668: SDpnt->type = (type & 0x1f);
669:
670: print_inquiry (scsi_result);
671:
672: for (sdtpnt = scsi_devicelist; sdtpnt;
673: sdtpnt = sdtpnt->next)
674: if (sdtpnt->detect)
675: SDpnt->attached +=
676: (*sdtpnt->detect) (SDpnt);
677:
678: SDpnt->scsi_level = scsi_result[2] & 0x07;
679: if (SDpnt->scsi_level >= 2 ||
680: (SDpnt->scsi_level == 1 &&
681: (scsi_result[3] & 0x0f) == 1))
682: SDpnt->scsi_level++;
683:
684: /*
685: * Set the tagged_queue flag for SCSI-II devices that purport to support
686: * tagged queuing in the INQUIRY data.
687: */
688: SDpnt->tagged_queue = 0;
689: if ((SDpnt->scsi_level >= SCSI_2) &&
690: (scsi_result[7] & 2)) {
691: SDpnt->tagged_supported = 1;
692: SDpnt->current_tag = 0;
693: }
694:
695: /*
696: * Accommodate drivers that want to sleep when they should be in a polling
697: * loop.
698: */
699: SDpnt->disconnect = 0;
700:
701: /*
702: * Get any flags for this device.
703: */
704: bflags = get_device_flags (scsi_result);
705:
706: /*
707: * Some revisions of the Texel CD ROM drives have handshaking problems when
708: * used with the Seagate controllers. Before we know what type of device
709: * we're talking to, we assume it's borken and then change it here if it
710: * turns out that it isn't a TEXEL drive.
711: */
712: if ((bflags & BLIST_BORKEN) == 0)
713: SDpnt->borken = 0;
714:
715: /*
716: * These devices need this "key" to unlock the devices so we can use it
717: */
718: if ((bflags & BLIST_KEY) != 0) {
719: printk ("Unlocked floptical drive.\n");
720: SDpnt->lockable = 0;
721: scsi_cmd[0] = MODE_SENSE;
722: scsi_cmd[1] = (lun << 5) & 0xe0;
723: scsi_cmd[2] = 0x2e;
724: scsi_cmd[3] = 0;
725: scsi_cmd[4] = 0x2a;
726: scsi_cmd[5] = 0;
727: SCpnt->cmd_len = 0;
728: {
729: struct semaphore sem = MUTEX_LOCKED;
730: SCpnt->request.rq_status = RQ_SCSI_BUSY;
731: SCpnt->request.sem = &sem;
732: scsi_do_cmd (SCpnt, (void *) scsi_cmd,
733: (void *) scsi_result, 0x2a,
734: scan_scsis_done, SCSI_TIMEOUT, 3);
735: down (&sem);
736: }
737: }
738: /* Add this device to the linked list at the end */
739: if (SDtail)
740: SDtail->next = SDpnt;
741: else
742: scsi_devices = SDpnt;
743: SDtail = SDpnt;
744:
745: SDpnt = (Scsi_Device *) scsi_init_malloc (sizeof (Scsi_Device), GFP_ATOMIC);
746: *SDpnt2=SDpnt;
747: if (!SDpnt)
748: printk ("scsi: scan_scsis_single: Cannot malloc\n");
749:
750:
751: /*
752: * Some scsi devices cannot be polled for lun != 0 due to firmware bugs
753: */
754: if (bflags & BLIST_NOLUN)
755: return 0; /* break; */
756:
757: /*
758: * If we want to only allow I/O to one of the luns attached to this device
759: * at a time, then we set this flag.
760: */
761: if (bflags & BLIST_SINGLELUN)
762: SDpnt->single_lun = 1;
763:
764: /*
765: * If this device is known to support multiple units, override the other
766: * settings, and scan all of them.
767: */
768: if (bflags & BLIST_FORCELUN)
769: *max_dev_lun = 8;
770: /*
771: * We assume the device can't handle lun!=0 if: - it reports scsi-0 (ANSI
772: * SCSI Revision 0) (old drives like MAXTOR XT-3280) or - it reports scsi-1
773: * (ANSI SCSI Revision 1) and Response Data Format 0
774: */
775: if (((scsi_result[2] & 0x07) == 0)
776: ||
777: ((scsi_result[2] & 0x07) == 1 &&
778: (scsi_result[3] & 0x0f) == 0))
779: return 0;
780: return 1;
781: }
782:
783: /*
784: * Flag bits for the internal_timeout array
785: */
786: #define NORMAL_TIMEOUT 0
787: #define IN_ABORT 1
788: #define IN_RESET 2
789:
790: /*
791: * This is our time out function, called when the timer expires for a
792: * given host adapter. It will attempt to abort the currently executing
793: * command, that failing perform a kernel panic.
794: */
795:
796: static void scsi_times_out (Scsi_Cmnd * SCpnt, int pid)
797: {
798:
799: switch (SCpnt->internal_timeout & (IN_ABORT | IN_RESET))
800: {
801: case NORMAL_TIMEOUT:
802: {
803: #ifdef DEBUG_TIMEOUT
804: scsi_dump_status();
805: #endif
806: }
807:
808: if (!scsi_abort (SCpnt, DID_TIME_OUT, pid))
809: return;
810: case IN_ABORT:
811: printk("SCSI host %d abort (pid %ld) timed out - resetting\n",
812: SCpnt->host->host_no, SCpnt->pid);
813: if (!scsi_reset (SCpnt, FALSE))
814: return;
815: case IN_RESET:
816: case (IN_ABORT | IN_RESET):
817: /* This might be controversial, but if there is a bus hang,
818: * you might conceivably want the machine up and running
819: * esp if you have an ide disk.
820: */
821: printk("Unable to reset scsi host %d - ", SCpnt->host->host_no);
822: printk("probably a SCSI bus hang.\n");
823: SCpnt->internal_timeout &= ~IN_RESET;
824: scsi_reset (SCpnt, TRUE);
825: return;
826:
827: default:
828: INTERNAL_ERROR;
829: }
830:
831: }
832:
833:
834: /* This function takes a quick look at a request, and decides if it
835: * can be queued now, or if there would be a stall while waiting for
836: * something else to finish. This routine assumes that interrupts are
837: * turned off when entering the routine. It is the responsibility
838: * of the calling code to ensure that this is the case.
839: */
840:
841: Scsi_Cmnd * request_queueable (struct request * req, Scsi_Device * device)
842: {
843: Scsi_Cmnd * SCpnt = NULL;
844: int tablesize;
845: Scsi_Cmnd * found = NULL;
846: struct buffer_head * bh, *bhp;
847:
848: if (!device)
849: panic ("No device passed to request_queueable().\n");
850:
851: if (req && req->rq_status == RQ_INACTIVE)
852: panic("Inactive in request_queueable");
853:
854: SCpnt = device->host->host_queue;
855:
856: /*
857: * Look for a free command block. If we have been instructed not to queue
858: * multiple commands to multi-lun devices, then check to see what else is
859: * going for this device first.
860: */
861:
862: SCpnt = device->host->host_queue;
863: if (!device->single_lun) {
864: while(SCpnt){
865: if(SCpnt->target == device->id &&
866: SCpnt->lun == device->lun) {
867: if(SCpnt->request.rq_status == RQ_INACTIVE) break;
868: }
869: SCpnt = SCpnt->next;
870: }
871: } else {
872: while(SCpnt){
873: if(SCpnt->target == device->id) {
874: if (SCpnt->lun == device->lun) {
875: if(found == NULL
876: && SCpnt->request.rq_status == RQ_INACTIVE)
877: {
878: found=SCpnt;
879: }
880: }
881: if(SCpnt->request.rq_status != RQ_INACTIVE) {
882: /*
883: * I think that we should really limit things to one
884: * outstanding command per device - this is what tends
885: * to trip up buggy firmware.
886: */
887: return NULL;
888: }
889: }
890: SCpnt = SCpnt->next;
891: }
892: SCpnt = found;
893: }
894:
895: if (!SCpnt) return NULL;
896:
897: if (SCSI_BLOCK(device->host)) return NULL;
898:
899: if (req) {
900: memcpy(&SCpnt->request, req, sizeof(struct request));
901: tablesize = device->host->sg_tablesize;
902: bhp = bh = req->bh;
903: if(!tablesize) bh = NULL;
904: /* Take a quick look through the table to see how big it is.
905: * We already have our copy of req, so we can mess with that
906: * if we want to.
907: */
908: while(req->nr_sectors && bh){
909: bhp = bhp->b_reqnext;
910: if(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
911: req->nr_sectors -= bh->b_size >> 9;
912: req->sector += bh->b_size >> 9;
913: if(!tablesize) break;
914: bh = bhp;
915: }
916: if(req->nr_sectors && bh && bh->b_reqnext){ /* Any leftovers? */
917: SCpnt->request.bhtail = bh;
918: req->bh = bh->b_reqnext; /* Divide request */
919: bh->b_reqnext = NULL;
920: bh = req->bh;
921:
922: /* Now reset things so that req looks OK */
923: SCpnt->request.nr_sectors -= req->nr_sectors;
924: req->current_nr_sectors = bh->b_size >> 9;
925: req->buffer = bh->b_data;
926: SCpnt->request.sem = NULL; /* Wait until whole thing done */
927: } else {
928: req->rq_status = RQ_INACTIVE;
929: wake_up(&wait_for_request);
930: }
931: } else {
932: SCpnt->request.rq_status = RQ_SCSI_BUSY; /* Busy, but no request */
933: SCpnt->request.sem = NULL; /* And no one is waiting for the device
934: * either */
935: }
936:
937: SCpnt->use_sg = 0; /* Reset the scatter-gather flag */
938: SCpnt->old_use_sg = 0;
939: SCpnt->transfersize = 0;
940: SCpnt->underflow = 0;
941: SCpnt->cmd_len = 0;
942:
943: /* Since not everyone seems to set the device info correctly
944: * before Scsi_Cmnd gets send out to scsi_do_command, we do it here.
945: */
946: SCpnt->channel = device->channel;
947: SCpnt->lun = device->lun;
948: SCpnt->target = device->id;
949:
950: return SCpnt;
951: }
952:
953: /* This function returns a structure pointer that will be valid for
954: * the device. The wait parameter tells us whether we should wait for
955: * the unit to become free or not. We are also able to tell this routine
956: * not to return a descriptor if the host is unable to accept any more
957: * commands for the time being. We need to keep in mind that there is no
958: * guarantee that the host remain not busy. Keep in mind the
959: * request_queueable function also knows the internal allocation scheme
960: * of the packets for each device
961: */
962:
963: Scsi_Cmnd * allocate_device (struct request ** reqp, Scsi_Device * device,
964: int wait)
965: {
966: kdev_t dev;
967: struct request * req = NULL;
968: int tablesize;
969: unsigned int flags;
970: struct buffer_head * bh, *bhp;
971: struct Scsi_Host * host;
972: Scsi_Cmnd * SCpnt = NULL;
973: Scsi_Cmnd * SCwait = NULL;
974: Scsi_Cmnd * found = NULL;
975:
976: if (!device)
977: panic ("No device passed to allocate_device().\n");
978:
979: if (reqp) req = *reqp;
980:
981: /* See if this request has already been queued by an interrupt routine */
982: if (req) {
983: if(req->rq_status == RQ_INACTIVE) return NULL;
984: dev = req->rq_dev;
985: } else
986: dev = 0; /* unused */
987:
988: host = device->host;
989:
990: if (intr_count && SCSI_BLOCK(host)) return NULL;
991:
992: while (1==1){
993: SCpnt = device->host->host_queue;
994: if (!device->single_lun) {
995: while(SCpnt){
996: if(SCpnt->target == device->id &&
997: SCpnt->lun == device->lun) {
998: SCwait = SCpnt;
999: if(SCpnt->request.rq_status == RQ_INACTIVE) break;
1000: }
1001: SCpnt = SCpnt->next;
1002: }
1003: } else {
1004: while(SCpnt){
1005: if(SCpnt->target == device->id) {
1006: if (SCpnt->lun == device->lun) {
1007: SCwait = SCpnt;
1008: if(found == NULL
1009: && SCpnt->request.rq_status == RQ_INACTIVE)
1010: {
1011: found=SCpnt;
1012: }
1013: }
1014: if(SCpnt->request.rq_status != RQ_INACTIVE) {
1015: /*
1016: * I think that we should really limit things to one
1017: * outstanding command per device - this is what tends
1018: * to trip up buggy firmware.
1019: */
1020: found = NULL;
1021: break;
1022: }
1023: }
1024: SCpnt = SCpnt->next;
1025: }
1026: SCpnt = found;
1027: }
1028:
1029: save_flags(flags);
1030: cli();
1031: /* See if this request has already been queued by an interrupt routine
1032: */
1033: if (req && (req->rq_status == RQ_INACTIVE || req->rq_dev != dev)) {
1034: restore_flags(flags);
1035: return NULL;
1036: }
1037: if (!SCpnt || SCpnt->request.rq_status != RQ_INACTIVE) /* Might have changed */
1038: {
1039: restore_flags(flags);
1040: if(!wait) return NULL;
1041: if (!SCwait) {
1042: printk("Attempt to allocate device channel %d, target %d, "
1043: "lun %d\n", device->channel, device->id, device->lun);
1044: panic("No device found in allocate_device\n");
1045: }
1046: SCSI_SLEEP(&device->device_wait,
1047: (SCwait->request.rq_status != RQ_INACTIVE));
1048: } else {
1049: if (req) {
1050: memcpy(&SCpnt->request, req, sizeof(struct request));
1051: tablesize = device->host->sg_tablesize;
1052: bhp = bh = req->bh;
1053: if(!tablesize) bh = NULL;
1054: /* Take a quick look through the table to see how big it is.
1055: * We already have our copy of req, so we can mess with that
1056: * if we want to.
1057: */
1058: while(req->nr_sectors && bh){
1059: bhp = bhp->b_reqnext;
1060: if(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
1061: req->nr_sectors -= bh->b_size >> 9;
1062: req->sector += bh->b_size >> 9;
1063: if(!tablesize) break;
1064: bh = bhp;
1065: }
1066: if(req->nr_sectors && bh && bh->b_reqnext){/* Any leftovers? */
1067: SCpnt->request.bhtail = bh;
1068: req->bh = bh->b_reqnext; /* Divide request */
1069: bh->b_reqnext = NULL;
1070: bh = req->bh;
1071: /* Now reset things so that req looks OK */
1072: SCpnt->request.nr_sectors -= req->nr_sectors;
1073: req->current_nr_sectors = bh->b_size >> 9;
1074: req->buffer = bh->b_data;
1075: SCpnt->request.sem = NULL; /* Wait until whole thing done*/
1076: }
1077: else
1078: {
1079: req->rq_status = RQ_INACTIVE;
1080: *reqp = req->next;
1081: wake_up(&wait_for_request);
1082: }
1083: } else {
1084: SCpnt->request.rq_status = RQ_SCSI_BUSY;
1085: SCpnt->request.sem = NULL; /* And no one is waiting for this
1086: * to complete */
1087: }
1088: restore_flags(flags);
1089: break;
1090: }
1091: }
1092:
1093: SCpnt->use_sg = 0; /* Reset the scatter-gather flag */
1094: SCpnt->old_use_sg = 0;
1095: SCpnt->transfersize = 0; /* No default transfer size */
1096: SCpnt->cmd_len = 0;
1097:
1098: SCpnt->underflow = 0; /* Do not flag underflow conditions */
1099:
1100: /* Since not everyone seems to set the device info correctly
1101: * before Scsi_Cmnd gets send out to scsi_do_command, we do it here.
1102: */
1103: SCpnt->channel = device->channel;
1104: SCpnt->lun = device->lun;
1105: SCpnt->target = device->id;
1106:
1107: return SCpnt;
1108: }
1109:
1110: /*
1111: * This is inline because we have stack problemes if we recurse to deeply.
1112: */
1113:
1114: inline void internal_cmnd (Scsi_Cmnd * SCpnt)
1115: {
1116: int temp;
1117: struct Scsi_Host * host;
1118: unsigned int flags;
1119: #ifdef DEBUG_DELAY
1120: int clock;
1121: #endif
1122:
1123: host = SCpnt->host;
1124:
1125: /*
1126: * We will wait MIN_RESET_DELAY clock ticks after the last reset so
1127: * we can avoid the drive not being ready.
1128: */
1129: save_flags(flags);
1130: sti();
1131: temp = host->last_reset + MIN_RESET_DELAY;
1132: while (jiffies < temp);
1133: restore_flags(flags);
1134:
1135: update_timeout(SCpnt, SCpnt->timeout_per_command);
1136:
1137: /*
1138: * We will use a queued command if possible, otherwise we will emulate the
1139: * queuing and calling of completion function ourselves.
1140: */
1141: #ifdef DEBUG
1142: printk("internal_cmnd (host = %d, channel = %d, target = %d, "
1143: "command = %p, buffer = %p, \nbufflen = %d, done = %p)\n",
1144: SCpnt->host->host_no, SCpnt->channel, SCpnt->target, SCpnt->cmnd,
1145: SCpnt->buffer, SCpnt->bufflen, SCpnt->done);
1146: #endif
1147:
1148: if (host->can_queue)
1149: {
1150: #ifdef DEBUG
1151: printk("queuecommand : routine at %p\n",
1152: host->hostt->queuecommand);
1153: #endif
1154: /* This locking tries to prevent all sorts of races between
1155: * queuecommand and the interrupt code. In effect,
1156: * we are only allowed to be in queuecommand once at
1157: * any given time, and we can only be in the interrupt
1158: * handler and the queuecommand function at the same time
1159: * when queuecommand is called while servicing the
1160: * interrupt.
1161: */
1162:
1163: if(!intr_count && SCpnt->host->irq)
1164: disable_irq(SCpnt->host->irq);
1165:
1166: host->hostt->queuecommand (SCpnt, scsi_done);
1167:
1168: if(!intr_count && SCpnt->host->irq)
1169: enable_irq(SCpnt->host->irq);
1170: }
1171: else
1172: {
1173:
1174: #ifdef DEBUG
1175: printk("command() : routine at %p\n", host->hostt->command);
1176: #endif
1177: temp=host->hostt->command (SCpnt);
1178: SCpnt->result = temp;
1179: #ifdef DEBUG_DELAY
1180: clock = jiffies + 4 * HZ;
1181: while (jiffies < clock);
1182: printk("done(host = %d, result = %04x) : routine at %p\n",
1183: host->host_no, temp, host->hostt->command);
1184: #endif
1185: scsi_done(SCpnt);
1186: }
1187: #ifdef DEBUG
1188: printk("leaving internal_cmnd()\n");
1189: #endif
1190: }
1191:
1192: static void scsi_request_sense (Scsi_Cmnd * SCpnt)
1193: {
1194: unsigned int flags;
1195:
1196: save_flags(flags);
1197: cli();
1198: SCpnt->flags |= WAS_SENSE | ASKED_FOR_SENSE;
1199: update_timeout(SCpnt, SENSE_TIMEOUT);
1200: restore_flags(flags);
1201:
1202:
1203: memcpy ((void *) SCpnt->cmnd , (void *) generic_sense,
1204: sizeof(generic_sense));
1205:
1206: SCpnt->cmnd[1] = SCpnt->lun << 5;
1207: SCpnt->cmnd[4] = sizeof(SCpnt->sense_buffer);
1208:
1209: SCpnt->request_buffer = &SCpnt->sense_buffer;
1210: SCpnt->request_bufflen = sizeof(SCpnt->sense_buffer);
1211: SCpnt->use_sg = 0;
1212: SCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
1213: internal_cmnd (SCpnt);
1214: }
1215:
1216:
1217:
1218: /*
1219: * scsi_do_cmd sends all the commands out to the low-level driver. It
1220: * handles the specifics required for each low level driver - ie queued
1221: * or non queued. It also prevents conflicts when different high level
1222: * drivers go for the same host at the same time.
1223: */
1224:
1225: void scsi_do_cmd (Scsi_Cmnd * SCpnt, const void *cmnd ,
1226: void *buffer, unsigned bufflen, void (*done)(Scsi_Cmnd *),
1227: int timeout, int retries)
1228: {
1229: unsigned long flags;
1230: struct Scsi_Host * host = SCpnt->host;
1231:
1232: #ifdef DEBUG
1233: {
1234: int i;
1235: int target = SCpnt->target;
1236: printk ("scsi_do_cmd (host = %d, channel = %d target = %d, "
1237: "buffer =%p, bufflen = %d, done = %p, timeout = %d, "
1238: "retries = %d)\n"
1239: "command : " , host->host_no, SCpnt->channel, target, buffer,
1240: bufflen, done, timeout, retries);
1241: for (i = 0; i < 10; ++i)
1242: printk ("%02x ", ((unsigned char *) cmnd)[i]);
1243: printk("\n");
1244: }
1245: #endif
1246:
1247: if (!host)
1248: {
1249: panic ("Invalid or not present host.\n");
1250: }
1251:
1252:
1253: /*
1254: * We must prevent reentrancy to the lowlevel host driver. This prevents
1255: * it - we enter a loop until the host we want to talk to is not busy.
1256: * Race conditions are prevented, as interrupts are disabled in between the
1257: * time we check for the host being not busy, and the time we mark it busy
1258: * ourselves.
1259: */
1260:
1261: save_flags(flags);
1262: cli();
1263: SCpnt->pid = scsi_pid++;
1264:
1265: while (SCSI_BLOCK(host)) {
1266: restore_flags(flags);
1267: SCSI_SLEEP(&host->host_wait, SCSI_BLOCK(host));
1268: cli();
1269: }
1270:
1271: if (host->block) host_active = host;
1272:
1273: host->host_busy++;
1274: restore_flags(flags);
1275:
1276: /*
1277: * Our own function scsi_done (which marks the host as not busy, disables
1278: * the timeout counter, etc) will be called by us or by the
1279: * scsi_hosts[host].queuecommand() function needs to also call
1280: * the completion function for the high level driver.
1281: */
1282:
1283: memcpy ((void *) SCpnt->data_cmnd , (const void *) cmnd, 12);
1284: #if 0
1285: SCpnt->host = host;
1286: SCpnt->channel = channel;
1287: SCpnt->target = target;
1288: SCpnt->lun = (SCpnt->data_cmnd[1] >> 5);
1289: #endif
1290: SCpnt->bufflen = bufflen;
1291: SCpnt->buffer = buffer;
1292: SCpnt->flags=0;
1293: SCpnt->retries=0;
1294: SCpnt->allowed=retries;
1295: SCpnt->done = done;
1296: SCpnt->timeout_per_command = timeout;
1297:
1298: memcpy ((void *) SCpnt->cmnd , (const void *) cmnd, 12);
1299: /* Zero the sense buffer. Some host adapters automatically request
1300: * sense on error. 0 is not a valid sense code.
1301: */
1302: memset ((void *) SCpnt->sense_buffer, 0, sizeof SCpnt->sense_buffer);
1303: SCpnt->request_buffer = buffer;
1304: SCpnt->request_bufflen = bufflen;
1305: SCpnt->old_use_sg = SCpnt->use_sg;
1306: if (SCpnt->cmd_len == 0)
1307: SCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
1308: SCpnt->old_cmd_len = SCpnt->cmd_len;
1309:
1310: /* Start the timer ticking. */
1311:
1312: SCpnt->internal_timeout = 0;
1313: SCpnt->abort_reason = 0;
1314: internal_cmnd (SCpnt);
1315:
1316: #ifdef DEBUG
1317: printk ("Leaving scsi_do_cmd()\n");
1318: #endif
1319: }
1320:
1321: static int check_sense (Scsi_Cmnd * SCpnt)
1322: {
1323: /* If there is no sense information, request it. If we have already
1324: * requested it, there is no point in asking again - the firmware must
1325: * be confused.
1326: */
1327: if (((SCpnt->sense_buffer[0] & 0x70) >> 4) != 7) {
1328: if(!(SCpnt->flags & ASKED_FOR_SENSE))
1329: return SUGGEST_SENSE;
1330: else
1331: return SUGGEST_RETRY;
1332: }
1333:
1334: SCpnt->flags &= ~ASKED_FOR_SENSE;
1335:
1336: #ifdef DEBUG_INIT
1337: printk("scsi%d, channel%d : ", SCpnt->host->host_no, SCpnt->channel);
1338: print_sense("", SCpnt);
1339: printk("\n");
1340: #endif
1341: if (SCpnt->sense_buffer[2] & 0xe0)
1342: return SUGGEST_ABORT;
1343:
1344: switch (SCpnt->sense_buffer[2] & 0xf)
1345: {
1346: case NO_SENSE:
1347: return 0;
1348: case RECOVERED_ERROR:
1349: return SUGGEST_IS_OK;
1350:
1351: case ABORTED_COMMAND:
1352: return SUGGEST_RETRY;
1353: case NOT_READY:
1354: case UNIT_ATTENTION:
1355: /*
1356: * If we are expecting a CC/UA because of a bus reset that we
1357: * performed, treat this just as a retry. Otherwise this is
1358: * information that we should pass up to the upper-level driver
1359: * so that we can deal with it there.
1360: */
1361: if( SCpnt->device->expecting_cc_ua )
1362: {
1363: SCpnt->device->expecting_cc_ua = 0;
1364: return SUGGEST_RETRY;
1365: }
1366: return SUGGEST_ABORT;
1367:
1368: /* these three are not supported */
1369: case COPY_ABORTED:
1370: case VOLUME_OVERFLOW:
1371: case MISCOMPARE:
1372:
1373: case MEDIUM_ERROR:
1374: return SUGGEST_REMAP;
1375: case BLANK_CHECK:
1376: case DATA_PROTECT:
1377: case HARDWARE_ERROR:
1378: case ILLEGAL_REQUEST:
1379: default:
1380: return SUGGEST_ABORT;
1381: }
1382: }
1383:
1384: /* This function is the mid-level interrupt routine, which decides how
1385: * to handle error conditions. Each invocation of this function must
1386: * do one and *only* one of the following:
1387: *
1388: * (1) Call last_cmnd[host].done. This is done for fatal errors and
1389: * normal completion, and indicates that the handling for this
1390: * request is complete.
1391: * (2) Call internal_cmnd to requeue the command. This will result in
1392: * scsi_done being called again when the retry is complete.
1393: * (3) Call scsi_request_sense. This asks the host adapter/drive for
1394: * more information about the error condition. When the information
1395: * is available, scsi_done will be called again.
1396: * (4) Call reset(). This is sort of a last resort, and the idea is that
1397: * this may kick things loose and get the drive working again. reset()
1398: * automatically calls scsi_request_sense, and thus scsi_done will be
1399: * called again once the reset is complete.
1400: *
1401: * If none of the above actions are taken, the drive in question
1402: * will hang. If more than one of the above actions are taken by
1403: * scsi_done, then unpredictable behavior will result.
1404: */
1405: static void scsi_done (Scsi_Cmnd * SCpnt)
1406: {
1407: int status=0;
1408: int exit=0;
1409: int checked;
1410: int oldto;
1411: struct Scsi_Host * host = SCpnt->host;
1412: int result = SCpnt->result;
1413: oldto = update_timeout(SCpnt, 0);
1414:
1415: #ifdef DEBUG_TIMEOUT
1416: if(result) printk("Non-zero result in scsi_done %x %d:%d\n",
1417: result, SCpnt->target, SCpnt->lun);
1418: #endif
1419:
1420: /* If we requested an abort, (and we got it) then fix up the return
1421: * status to say why
1422: */
1423: if(host_byte(result) == DID_ABORT && SCpnt->abort_reason)
1424: SCpnt->result = result = (result & 0xff00ffff) |
1425: (SCpnt->abort_reason << 16);
1426:
1427:
1428: #define FINISHED 0
1429: #define MAYREDO 1
1430: #define REDO 3
1431: #define PENDING 4
1432:
1433: #ifdef DEBUG
1434: printk("In scsi_done(host = %d, result = %06x)\n", host->host_no, result);
1435: #endif
1436:
1437: if(SCpnt->flags & WAS_SENSE)
1438: {
1439: SCpnt->use_sg = SCpnt->old_use_sg;
1440: SCpnt->cmd_len = SCpnt->old_cmd_len;
1441: }
1442:
1443: switch (host_byte(result))
1444: {
1445: case DID_OK:
1446: if (status_byte(result) && (SCpnt->flags & WAS_SENSE))
1447: /* Failed to obtain sense information */
1448: {
1449: SCpnt->flags &= ~WAS_SENSE;
1450: SCpnt->internal_timeout &= ~SENSE_TIMEOUT;
1451:
1452: if (!(SCpnt->flags & WAS_RESET))
1453: {
1454: printk("scsi%d : channel %d target %d lun %d request sense"
1455: " failed, performing reset.\n",
1456: SCpnt->host->host_no, SCpnt->channel, SCpnt->target,
1457: SCpnt->lun);
1458: scsi_reset(SCpnt, FALSE);
1459: return;
1460: }
1461: else
1462: {
1463: exit = (DRIVER_HARD | SUGGEST_ABORT);
1464: status = FINISHED;
1465: }
1466: }
1467: else switch(msg_byte(result))
1468: {
1469: case COMMAND_COMPLETE:
1470: switch (status_byte(result))
1471: {
1472: case GOOD:
1473: if (SCpnt->flags & WAS_SENSE)
1474: {
1475: #ifdef DEBUG
1476: printk ("In scsi_done, GOOD status, COMMAND COMPLETE, parsing sense information.\n");
1477: #endif
1478: SCpnt->flags &= ~WAS_SENSE;
1479: SCpnt->internal_timeout &= ~SENSE_TIMEOUT;
1480:
1481: switch (checked = check_sense(SCpnt))
1482: {
1483: case SUGGEST_SENSE:
1484: case 0:
1485: #ifdef DEBUG
1486: printk("NO SENSE. status = REDO\n");
1487: #endif
1488: update_timeout(SCpnt, oldto);
1489: status = REDO;
1490: break;
1491: case SUGGEST_IS_OK:
1492: break;
1493: case SUGGEST_REMAP:
1494: case SUGGEST_RETRY:
1495: #ifdef DEBUG
1496: printk("SENSE SUGGEST REMAP or SUGGEST RETRY - status = MAYREDO\n");
1497: #endif
1498: status = MAYREDO;
1499: exit = DRIVER_SENSE | SUGGEST_RETRY;
1500: break;
1501: case SUGGEST_ABORT:
1502: #ifdef DEBUG
1503: printk("SENSE SUGGEST ABORT - status = FINISHED");
1504: #endif
1505: status = FINISHED;
1506: exit = DRIVER_SENSE | SUGGEST_ABORT;
1507: break;
1508: default:
1509: printk ("Internal error %s %d \n", __FILE__,
1510: __LINE__);
1511: }
1512: } /* end WAS_SENSE */
1513: else
1514: {
1515: #ifdef DEBUG
1516: printk("COMMAND COMPLETE message returned, status = FINISHED. \n");
1517: #endif
1518: exit = DRIVER_OK;
1519: status = FINISHED;
1520: }
1521: break;
1522:
1523: case CHECK_CONDITION:
1524: switch (check_sense(SCpnt))
1525: {
1526: case 0:
1527: update_timeout(SCpnt, oldto);
1528: status = REDO;
1529: break;
1530: case SUGGEST_REMAP:
1531: case SUGGEST_RETRY:
1532: status = MAYREDO;
1533: exit = DRIVER_SENSE | SUGGEST_RETRY;
1534: break;
1535: case SUGGEST_ABORT:
1536: status = FINISHED;
1537: exit = DRIVER_SENSE | SUGGEST_ABORT;
1538: break;
1539: case SUGGEST_SENSE:
1540: scsi_request_sense (SCpnt);
1541: status = PENDING;
1542: break;
1543: }
1544: break;
1545:
1546: case CONDITION_GOOD:
1547: case INTERMEDIATE_GOOD:
1548: case INTERMEDIATE_C_GOOD:
1549: break;
1550:
1551: case BUSY:
1552: update_timeout(SCpnt, oldto);
1553: status = REDO;
1554: break;
1555:
1556: case RESERVATION_CONFLICT:
1557: printk("scsi%d, channel %d : RESERVATION CONFLICT performing"
1558: " reset.\n", SCpnt->host->host_no, SCpnt->channel);
1559: scsi_reset(SCpnt, FALSE);
1560: return;
1561: #if 0
1562: exit = DRIVER_SOFT | SUGGEST_ABORT;
1563: status = MAYREDO;
1564: break;
1565: #endif
1566: default:
1567: printk ("Internal error %s %d \n"
1568: "status byte = %d \n", __FILE__,
1569: __LINE__, status_byte(result));
1570:
1571: }
1572: break;
1573: default:
1574: panic("scsi: unsupported message byte %d received\n",
1575: msg_byte(result));
1576: }
1577: break;
1578: case DID_TIME_OUT:
1579: #ifdef DEBUG
1580: printk("Host returned DID_TIME_OUT - ");
1581: #endif
1582:
1583: if (SCpnt->flags & WAS_TIMEDOUT)
1584: {
1585: #ifdef DEBUG
1586: printk("Aborting\n");
1587: #endif
1588: /*
1589: Allow TEST_UNIT_READY and INQUIRY commands to timeout early
1590: without causing resets. All other commands should be retried.
1591: */
1592: if (SCpnt->cmnd[0] != TEST_UNIT_READY &&
1593: SCpnt->cmnd[0] != INQUIRY)
1594: status = MAYREDO;
1595: exit = (DRIVER_TIMEOUT | SUGGEST_ABORT);
1596: }
1597: else
1598: {
1599: #ifdef DEBUG
1600: printk ("Retrying.\n");
1601: #endif
1602: SCpnt->flags |= WAS_TIMEDOUT;
1603: SCpnt->internal_timeout &= ~IN_ABORT;
1604: status = REDO;
1605: }
1606: break;
1607: case DID_BUS_BUSY:
1608: case DID_PARITY:
1609: status = REDO;
1610: break;
1611: case DID_NO_CONNECT:
1612: #ifdef DEBUG
1613: printk("Couldn't connect.\n");
1614: #endif
1615: exit = (DRIVER_HARD | SUGGEST_ABORT);
1616: break;
1617: case DID_ERROR:
1618: status = MAYREDO;
1619: exit = (DRIVER_HARD | SUGGEST_ABORT);
1620: break;
1621: case DID_BAD_TARGET:
1622: case DID_ABORT:
1623: exit = (DRIVER_INVALID | SUGGEST_ABORT);
1624: break;
1625: case DID_RESET:
1626: if (SCpnt->flags & IS_RESETTING)
1627: {
1628: SCpnt->flags &= ~IS_RESETTING;
1629: status = REDO;
1630: break;
1631: }
1632:
1633: if(msg_byte(result) == GOOD &&
1634: status_byte(result) == CHECK_CONDITION) {
1635: switch (check_sense(SCpnt)) {
1636: case 0:
1637: update_timeout(SCpnt, oldto);
1638: status = REDO;
1639: break;
1640: case SUGGEST_REMAP:
1641: case SUGGEST_RETRY:
1642: status = MAYREDO;
1643: exit = DRIVER_SENSE | SUGGEST_RETRY;
1644: break;
1645: case SUGGEST_ABORT:
1646: status = FINISHED;
1647: exit = DRIVER_SENSE | SUGGEST_ABORT;
1648: break;
1649: case SUGGEST_SENSE:
1650: scsi_request_sense (SCpnt);
1651: status = PENDING;
1652: break;
1653: }
1654: } else {
1655: status=REDO;
1656: exit = SUGGEST_RETRY;
1657: }
1658: break;
1659: default :
1660: exit = (DRIVER_ERROR | SUGGEST_DIE);
1661: }
1662:
1663: switch (status)
1664: {
1665: case FINISHED:
1666: case PENDING:
1667: break;
1668: case MAYREDO:
1669: #ifdef DEBUG
1670: printk("In MAYREDO, allowing %d retries, have %d\n",
1671: SCpnt->allowed, SCpnt->retries);
1672: #endif
1673: if ((++SCpnt->retries) < SCpnt->allowed)
1674: {
1675: if ((SCpnt->retries >= (SCpnt->allowed >> 1))
1676: && !(jiffies < SCpnt->host->last_reset + MIN_RESET_PERIOD)
1677: && !(SCpnt->flags & WAS_RESET))
1678: {
1679: printk("scsi%d channel %d : resetting for second half of retries.\n",
1680: SCpnt->host->host_no, SCpnt->channel);
1681: scsi_reset(SCpnt, FALSE);
1682: break;
1683: }
1684:
1685: }
1686: else
1687: {
1688: status = FINISHED;
1689: break;
1690: }
1691: /* fall through to REDO */
1692:
1693: case REDO:
1694:
1695: if (SCpnt->flags & WAS_SENSE)
1696: scsi_request_sense(SCpnt);
1697: else
1698: {
1699: memcpy ((void *) SCpnt->cmnd,
1700: (void*) SCpnt->data_cmnd,
1701: sizeof(SCpnt->data_cmnd));
1702: SCpnt->request_buffer = SCpnt->buffer;
1703: SCpnt->request_bufflen = SCpnt->bufflen;
1704: SCpnt->use_sg = SCpnt->old_use_sg;
1705: SCpnt->cmd_len = SCpnt->old_cmd_len;
1706: internal_cmnd (SCpnt);
1707: }
1708: break;
1709: default:
1710: INTERNAL_ERROR;
1711: }
1712:
1713: if (status == FINISHED) {
1714: #ifdef DEBUG
1715: printk("Calling done function - at address %p\n", SCpnt->done);
1716: #endif
1717: host->host_busy--; /* Indicate that we are free */
1718:
1719: if (host->block && host->host_busy == 0) {
1720: host_active = NULL;
1721:
1722: /* For block devices "wake_up" is done in end_scsi_request */
1723: if (MAJOR(SCpnt->request.rq_dev) != SCSI_DISK_MAJOR &&
1724: MAJOR(SCpnt->request.rq_dev) != SCSI_CDROM_MAJOR) {
1725: struct Scsi_Host * next;
1726:
1727: for (next = host->block; next != host; next = next->block)
1728: wake_up(&next->host_wait);
1729: }
1730:
1731: }
1732:
1733: wake_up(&host->host_wait);
1734: SCpnt->result = result | ((exit & 0xff) << 24);
1735: SCpnt->use_sg = SCpnt->old_use_sg;
1736: SCpnt->cmd_len = SCpnt->old_cmd_len;
1737: SCpnt->done (SCpnt);
1738: }
1739:
1740: #undef FINISHED
1741: #undef REDO
1742: #undef MAYREDO
1743: #undef PENDING
1744: }
1745:
1746: /*
1747: * The scsi_abort function interfaces with the abort() function of the host
1748: * we are aborting, and causes the current command to not complete. The
1749: * caller should deal with any error messages or status returned on the
1750: * next call.
1751: *
1752: * This will not be called reentrantly for a given host.
1753: */
1754:
1755: /*
1756: * Since we're nice guys and specified that abort() and reset()
1757: * can be non-reentrant. The internal_timeout flags are used for
1758: * this.
1759: */
1760:
1761:
1762: int scsi_abort (Scsi_Cmnd * SCpnt, int why, int pid)
1763: {
1764: int oldto;
1765: unsigned long flags;
1766: struct Scsi_Host * host = SCpnt->host;
1767:
1768: while(1)
1769: {
1770: save_flags(flags);
1771: cli();
1772:
1773: /*
1774: * Protect against races here. If the command is done, or we are
1775: * on a different command forget it.
1776: */
1777: if (SCpnt->request.rq_status == RQ_INACTIVE || pid != SCpnt->pid) {
1778: restore_flags(flags);
1779: return 0;
1780: }
1781:
1782: if (SCpnt->internal_timeout & IN_ABORT)
1783: {
1784: restore_flags(flags);
1785: while (SCpnt->internal_timeout & IN_ABORT)
1786: barrier();
1787: }
1788: else
1789: {
1790: SCpnt->internal_timeout |= IN_ABORT;
1791: oldto = update_timeout(SCpnt, ABORT_TIMEOUT);
1792:
1793: if ((SCpnt->flags & IS_RESETTING) && SCpnt->device->soft_reset) {
1794: /* OK, this command must have died when we did the
1795: * reset. The device itself must have lied.
1796: */
1797: printk("Stale command on %d %d:%d appears to have died when"
1798: " the bus was reset\n",
1799: SCpnt->channel, SCpnt->target, SCpnt->lun);
1800: }
1801:
1802: restore_flags(flags);
1803: if (!host->host_busy) {
1804: SCpnt->internal_timeout &= ~IN_ABORT;
1805: update_timeout(SCpnt, oldto);
1806: return 0;
1807: }
1808: printk("scsi : aborting command due to timeout : pid %lu, scsi%d,"
1809: " channel %d, id %d, lun %d ",
1810: SCpnt->pid, SCpnt->host->host_no, (int) SCpnt->channel,
1811: (int) SCpnt->target, (int) SCpnt->lun);
1812: print_command (SCpnt->cmnd);
1813: if (SCpnt->request.rq_status == RQ_INACTIVE || pid != SCpnt->pid)
1814: return 0;
1815: SCpnt->abort_reason = why;
1816: switch(host->hostt->abort(SCpnt)) {
1817: /* We do not know how to abort. Try waiting another
1818: * time increment and see if this helps. Set the
1819: * WAS_TIMEDOUT flag set so we do not try this twice
1820: */
1821: case SCSI_ABORT_BUSY: /* Tough call - returning 1 from
1822: * this is too severe
1823: */
1824: case SCSI_ABORT_SNOOZE:
1825: if(why == DID_TIME_OUT) {
1826: save_flags(flags);
1827: cli();
1828: SCpnt->internal_timeout &= ~IN_ABORT;
1829: if(SCpnt->flags & WAS_TIMEDOUT) {
1830: restore_flags(flags);
1831: return 1; /* Indicate we cannot handle this.
1832: * We drop down into the reset handler
1833: * and try again
1834: */
1835: } else {
1836: SCpnt->flags |= WAS_TIMEDOUT;
1837: oldto = SCpnt->timeout_per_command;
1838: update_timeout(SCpnt, oldto);
1839: }
1840: restore_flags(flags);
1841: }
1842: return 0;
1843: case SCSI_ABORT_PENDING:
1844: if(why != DID_TIME_OUT) {
1845: save_flags(flags);
1846: cli();
1847: update_timeout(SCpnt, oldto);
1848: restore_flags(flags);
1849: }
1850: return 0;
1851: case SCSI_ABORT_SUCCESS:
1852: /* We should have already aborted this one. No
1853: * need to adjust timeout
1854: */
1855: SCpnt->internal_timeout &= ~IN_ABORT;
1856: return 0;
1857: case SCSI_ABORT_NOT_RUNNING:
1858: SCpnt->internal_timeout &= ~IN_ABORT;
1859: update_timeout(SCpnt, 0);
1860: return 0;
1861: case SCSI_ABORT_ERROR:
1862: default:
1863: SCpnt->internal_timeout &= ~IN_ABORT;
1864: return 1;
1865: }
1866: }
1867: }
1868: }
1869:
1870:
1871: /* Mark a single SCSI Device as having been reset. */
1872:
1873: static inline void scsi_mark_device_reset(Scsi_Device *Device)
1874: {
1875: Device->was_reset = 1;
1876: Device->expecting_cc_ua = 1;
1877: }
1878:
1879:
1880: /* Mark all SCSI Devices on a specific Host as having been reset. */
1881:
1882: void scsi_mark_host_bus_reset(struct Scsi_Host *Host)
1883: {
1884: Scsi_Cmnd *SCpnt;
1885: for(SCpnt = Host->host_queue; SCpnt; SCpnt = SCpnt->next)
1886: scsi_mark_device_reset(SCpnt->device);
1887: }
1888:
1889:
1890: int scsi_reset (Scsi_Cmnd * SCpnt, int bus_reset_flag)
1891: {
1892: int temp, oldto;
1893: unsigned long flags;
1894: Scsi_Cmnd * SCpnt1;
1895: struct Scsi_Host * host = SCpnt->host;
1896:
1897: printk("SCSI bus is being reset for host %d.\n",
1898: host->host_no);
1899:
1900: /*
1901: * First of all, we need to make a recommendation to the low-level
1902: * driver as to whether a BUS_DEVICE_RESET should be performed,
1903: * or whether we should do a full BUS_RESET. There is no simple
1904: * algorithm here - we basically use a series of heuristics
1905: * to determine what we should do.
1906: */
1907: SCpnt->host->suggest_bus_reset = FALSE;
1908:
1909: /*
1910: * First see if all of the active devices on the bus have
1911: * been jammed up so that we are attempting resets. If so,
1912: * then suggest a bus reset. Forcing a bus reset could
1913: * result in some race conditions, but no more than
1914: * you would usually get with timeouts. We will cross
1915: * that bridge when we come to it.
1916: */
1917: SCpnt1 = host->host_queue;
1918: while(SCpnt1) {
1919: if( SCpnt1->request.rq_status != RQ_INACTIVE
1920: && (SCpnt1->flags & (WAS_RESET | IS_RESETTING)) == 0 )
1921: break;
1922: SCpnt1 = SCpnt1->next;
1923: }
1924: if( SCpnt1 == NULL ) {
1925: SCpnt->host->suggest_bus_reset = TRUE;
1926: }
1927:
1928:
1929: /*
1930: * If the code that called us is suggesting a hard reset, then
1931: * definitely request it. This usually occurs because a
1932: * BUS_DEVICE_RESET times out.
1933: */
1934: if( bus_reset_flag ) {
1935: SCpnt->host->suggest_bus_reset = TRUE;
1936: }
1937:
1938: while (1) {
1939: save_flags(flags);
1940: cli();
1941: if (SCpnt->internal_timeout & IN_RESET)
1942: {
1943: restore_flags(flags);
1944: while (SCpnt->internal_timeout & IN_RESET)
1945: barrier();
1946: }
1947: else
1948: {
1949: SCpnt->internal_timeout |= IN_RESET;
1950: oldto = update_timeout(SCpnt, RESET_TIMEOUT);
1951:
1952: if (host->host_busy)
1953: {
1954: restore_flags(flags);
1955: SCpnt1 = host->host_queue;
1956: while(SCpnt1) {
1957: if (SCpnt1->request.rq_status != RQ_INACTIVE) {
1958: #if 0
1959: if (!(SCpnt1->flags & IS_RESETTING) &&
1960: !(SCpnt1->internal_timeout & IN_ABORT))
1961: scsi_abort(SCpnt1, DID_RESET, SCpnt->pid);
1962: #endif
1963: SCpnt1->flags |= (WAS_RESET | IS_RESETTING);
1964: }
1965: SCpnt1 = SCpnt1->next;
1966: }
1967:
1968: host->last_reset = jiffies;
1969: temp = host->hostt->reset(SCpnt);
1970: host->last_reset = jiffies;
1971: }
1972: else
1973: {
1974: if (!host->block) host->host_busy++;
1975: restore_flags(flags);
1976: host->last_reset = jiffies;
1977: SCpnt->flags |= (WAS_RESET | IS_RESETTING);
1978: temp = host->hostt->reset(SCpnt);
1979: host->last_reset = jiffies;
1980: if (!host->block) host->host_busy--;
1981: }
1982:
1983: #ifdef DEBUG
1984: printk("scsi reset function returned %d\n", temp);
1985: #endif
1986:
1987: /*
1988: * Now figure out what we need to do, based upon
1989: * what the low level driver said that it did.
1990: * If the result is SCSI_RESET_SUCCESS, SCSI_RESET_PENDING,
1991: * or SCSI_RESET_WAKEUP, then the low level driver did a
1992: * bus device reset or bus reset, so we should go through
1993: * and mark one or all of the devices on that bus
1994: * as having been reset.
1995: */
1996: switch(temp & SCSI_RESET_ACTION) {
1997: case SCSI_RESET_SUCCESS:
1998: if (temp & SCSI_RESET_BUS_RESET)
1999: scsi_mark_host_bus_reset(host);
2000: else scsi_mark_device_reset(SCpnt->device);
2001: save_flags(flags);
2002: cli();
2003: SCpnt->internal_timeout &= ~IN_RESET;
2004: update_timeout(SCpnt, oldto);
2005: restore_flags(flags);
2006: return 0;
2007: case SCSI_RESET_PENDING:
2008: if (temp & SCSI_RESET_BUS_RESET)
2009: scsi_mark_host_bus_reset(host);
2010: else scsi_mark_device_reset(SCpnt->device);
2011: return 0;
2012: case SCSI_RESET_PUNT:
2013: SCpnt->internal_timeout &= ~IN_RESET;
2014: scsi_request_sense (SCpnt);
2015: return 0;
2016: case SCSI_RESET_WAKEUP:
2017: if (temp & SCSI_RESET_BUS_RESET)
2018: scsi_mark_host_bus_reset(host);
2019: else scsi_mark_device_reset(SCpnt->device);
2020: SCpnt->internal_timeout &= ~IN_RESET;
2021: scsi_request_sense (SCpnt);
2022: /*
2023: * Since a bus reset was performed, we
2024: * need to wake up each and every command
2025: * that was active on the bus.
2026: */
2027: if( temp & SCSI_RESET_BUS_RESET )
2028: {
2029: SCpnt1 = host->host_queue;
2030: while(SCpnt1) {
2031: if( SCpnt->request.rq_status != RQ_INACTIVE
2032: && SCpnt1 != SCpnt)
2033: scsi_request_sense (SCpnt);
2034: SCpnt1 = SCpnt1->next;
2035: }
2036: }
2037: return 0;
2038: case SCSI_RESET_SNOOZE:
2039: /* In this case, we set the timeout field to 0
2040: * so that this command does not time out any more,
2041: * and we return 1 so that we get a message on the
2042: * screen.
2043: */
2044: save_flags(flags);
2045: cli();
2046: SCpnt->internal_timeout &= ~IN_RESET;
2047: update_timeout(SCpnt, 0);
2048: restore_flags(flags);
2049: /* If you snooze, you lose... */
2050: case SCSI_RESET_ERROR:
2051: default:
2052: return 1;
2053: }
2054:
2055: return temp;
2056: }
2057: }
2058: }
2059:
2060:
2061: static void scsi_main_timeout(void)
2062: {
2063: /*
2064: * We must not enter update_timeout with a timeout condition still pending.
2065: */
2066:
2067: int timed_out, pid;
2068: unsigned long flags;
2069: struct Scsi_Host * host;
2070: Scsi_Cmnd * SCpnt = NULL;
2071:
2072: do {
2073: save_flags(flags);
2074: cli();
2075:
2076: update_timeout(NULL, 0);
2077: /*
2078: * Find all timers such that they have 0 or negative (shouldn't happen)
2079: * time remaining on them.
2080: */
2081:
2082: timed_out = 0;
2083: for(host = scsi_hostlist; host; host = host->next) {
2084: for(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
2085: if (SCpnt->timeout == -1)
2086: {
2087: SCpnt->timeout = 0;
2088: pid = SCpnt->pid;
2089: restore_flags(flags);
2090: scsi_times_out(SCpnt, pid);
2091: ++timed_out;
2092: save_flags(flags);
2093: cli();
2094: }
2095: }
2096: } while (timed_out);
2097: restore_flags(flags);
2098: }
2099:
2100: /*
2101: * The strategy is to cause the timer code to call scsi_times_out()
2102: * when the soonest timeout is pending.
2103: * The arguments are used when we are queueing a new command, because
2104: * we do not want to subtract the time used from this time, but when we
2105: * set the timer, we want to take this value into account.
2106: */
2107:
2108: static int update_timeout(Scsi_Cmnd * SCset, int timeout)
2109: {
2110: unsigned int least, used;
2111: unsigned int oldto;
2112: unsigned long flags;
2113: struct Scsi_Host * host;
2114: Scsi_Cmnd * SCpnt = NULL;
2115:
2116: save_flags(flags);
2117: cli();
2118:
2119: /*
2120: * Figure out how much time has passed since the last time the timeouts
2121: * were updated
2122: */
2123: used = (time_start) ? (jiffies - time_start) : 0;
2124:
2125: /*
2126: * Find out what is due to timeout soonest, and adjust all timeouts for
2127: * the amount of time that has passed since the last time we called
2128: * update_timeout.
2129: */
2130:
2131: oldto = 0;
2132:
2133: if(SCset){
2134: oldto = SCset->timeout - used;
2135: SCset->timeout = timeout + used;
2136: }
2137:
2138: least = 0xffffffff;
2139:
2140: for(host = scsi_hostlist; host; host = host->next)
2141: for(SCpnt = host->host_queue; SCpnt; SCpnt = SCpnt->next)
2142: if (SCpnt->timeout > 0) {
2143: SCpnt->timeout -= used;
2144: if(SCpnt->timeout <= 0) SCpnt->timeout = -1;
2145: if(SCpnt->timeout > 0 && SCpnt->timeout < least)
2146: least = SCpnt->timeout;
2147: }
2148:
2149: /*
2150: * If something is due to timeout again, then we will set the next timeout
2151: * interrupt to occur. Otherwise, timeouts are disabled.
2152: */
2153:
2154: if (least != 0xffffffff)
2155: {
2156: time_start = jiffies;
2157: timer_table[SCSI_TIMER].expires = (time_elapsed = least) + jiffies;
2158: timer_active |= 1 << SCSI_TIMER;
2159: }
2160: else
2161: {
2162: timer_table[SCSI_TIMER].expires = time_start = time_elapsed = 0;
2163: timer_active &= ~(1 << SCSI_TIMER);
2164: }
2165: restore_flags(flags);
2166: return oldto;
2167: }
2168:
2169: #ifdef CONFIG_MODULES
2170: static int scsi_register_host(Scsi_Host_Template *);
2171: static void scsi_unregister_host(Scsi_Host_Template *);
2172: #endif
2173:
2174: void *scsi_malloc(unsigned int len)
2175: {
2176: unsigned int nbits, mask;
2177: unsigned long flags;
2178: int i, j;
2179: if(len % SECTOR_SIZE != 0 || len > PAGE_SIZE)
2180: return NULL;
2181:
2182: save_flags(flags);
2183: cli();
2184: nbits = len >> 9;
2185: mask = (1 << nbits) - 1;
2186:
2187: for(i=0;i < dma_sectors / SECTORS_PER_PAGE; i++)
2188: for(j=0; j<=SECTORS_PER_PAGE - nbits; j++){
2189: if ((dma_malloc_freelist[i] & (mask << j)) == 0){
2190: dma_malloc_freelist[i] |= (mask << j);
2191: restore_flags(flags);
2192: dma_free_sectors -= nbits;
2193: #ifdef DEBUG
2194: printk("SMalloc: %d %p\n",len, dma_malloc_pages[i] + (j << 9));
2195: #endif
2196: return (void *) ((unsigned long) dma_malloc_pages[i] + (j << 9));
2197: }
2198: }
2199: restore_flags(flags);
2200: return NULL; /* Nope. No more */
2201: }
2202:
2203: int scsi_free(void *obj, unsigned int len)
2204: {
2205: unsigned int page, sector, nbits, mask;
2206: unsigned long flags;
2207:
2208: #ifdef DEBUG
2209: printk("scsi_free %p %d\n",obj, len);
2210: #endif
2211:
2212: for (page = 0; page < dma_sectors / SECTORS_PER_PAGE; page++) {
2213: unsigned long page_addr = (unsigned long) dma_malloc_pages[page];
2214: if ((unsigned long) obj >= page_addr &&
2215: (unsigned long) obj < page_addr + PAGE_SIZE)
2216: {
2217: sector = (((unsigned long) obj) - page_addr) >> 9;
2218:
2219: nbits = len >> 9;
2220: mask = (1 << nbits) - 1;
2221:
2222: if ((mask << sector) >= (1 << SECTORS_PER_PAGE))
2223: panic ("scsi_free:Bad memory alignment");
2224:
2225: save_flags(flags);
2226: cli();
2227: if((dma_malloc_freelist[page] & (mask << sector)) != (mask<<sector))
2228: panic("scsi_free:Trying to free unused memory");
2229:
2230: dma_free_sectors += nbits;
2231: dma_malloc_freelist[page] &= ~(mask << sector);
2232: restore_flags(flags);
2233: return 0;
2234: }
2235: }
2236: panic("scsi_free:Bad offset");
2237: }
2238:
2239:
2240: int scsi_loadable_module_flag; /* Set after we scan builtin drivers */
2241:
2242: void * scsi_init_malloc(unsigned int size, int priority)
2243: {
2244: void * retval;
2245:
2246: /*
2247: * For buffers used by the DMA pool, we assume page aligned
2248: * structures.
2249: */
2250: if ((size % PAGE_SIZE) == 0) {
2251: int order, a_size;
2252: for (order = 0, a_size = PAGE_SIZE;
2253: a_size < size; order++, a_size <<= 1)
2254: ;
2255: retval = (void *) __get_dma_pages(priority & GFP_LEVEL_MASK,
2256: order);
2257: } else
2258: retval = kmalloc(size, priority);
2259:
2260: if (retval)
2261: memset(retval, 0, size);
2262: return retval;
2263: }
2264:
2265:
2266: void scsi_init_free(char * ptr, unsigned int size)
2267: {
2268: /*
2269: * We need this special code here because the DMA pool assumes
2270: * page aligned data. Besides, it is wasteful to allocate
2271: * page sized chunks with kmalloc.
2272: */
2273: if ((size % PAGE_SIZE) == 0) {
2274: int order, a_size;
2275:
2276: for (order = 0, a_size = PAGE_SIZE;
2277: a_size < size; order++, a_size <<= 1)
2278: ;
2279: free_pages((unsigned long)ptr, order);
2280: } else
2281: kfree(ptr);
2282: }
2283:
2284: void scsi_build_commandblocks(Scsi_Device * SDpnt)
2285: {
2286: int j;
2287: Scsi_Cmnd * SCpnt;
2288: struct Scsi_Host * host = NULL;
2289:
2290: for(j=0;j<SDpnt->host->cmd_per_lun;j++){
2291: SCpnt = (Scsi_Cmnd *) scsi_init_malloc(sizeof(Scsi_Cmnd), GFP_ATOMIC);
2292: SCpnt->host = SDpnt->host;
2293: SCpnt->device = SDpnt;
2294: SCpnt->target = SDpnt->id;
2295: SCpnt->lun = SDpnt->lun;
2296: SCpnt->channel = SDpnt->channel;
2297: SCpnt->request.rq_status = RQ_INACTIVE;
2298: SCpnt->use_sg = 0;
2299: SCpnt->old_use_sg = 0;
2300: SCpnt->old_cmd_len = 0;
2301: SCpnt->timeout = 0;
2302: SCpnt->underflow = 0;
2303: SCpnt->transfersize = 0;
2304: SCpnt->host_scribble = NULL;
2305: host = SDpnt->host;
2306: if(host->host_queue)
2307: host->host_queue->prev = SCpnt;
2308: SCpnt->next = host->host_queue;
2309: SCpnt->prev = NULL;
2310: host->host_queue = SCpnt;
2311: }
2312: SDpnt->has_cmdblocks = 1;
2313: }
2314:
2315: /*
2316: * scsi_dev_init() is our initialization routine, which in turn calls host
2317: * initialization, bus scanning, and sd/st initialization routines.
2318: */
2319:
2320: int scsi_dev_init(void)
2321: {
2322: Scsi_Device * SDpnt;
2323: struct Scsi_Host * shpnt;
2324: struct Scsi_Device_Template * sdtpnt;
2325: #ifdef FOO_ON_YOU
2326: return;
2327: #endif
2328:
2329: /* Yes we're here... */
2330: dispatch_scsi_info_ptr = dispatch_scsi_info;
2331:
2332: /* Init a few things so we can "malloc" memory. */
2333: scsi_loadable_module_flag = 0;
2334:
2335: timer_table[SCSI_TIMER].fn = scsi_main_timeout;
2336: timer_table[SCSI_TIMER].expires = 0;
2337:
2338: #ifdef CONFIG_MODULES
2339: register_symtab(&scsi_symbol_table);
2340: #endif
2341:
2342: /* Register the /proc/scsi/scsi entry */
2343: #if CONFIG_PROC_FS
2344: proc_scsi_register(0, &proc_scsi_scsi);
2345: #endif
2346:
2347: /* initialize all hosts */
2348: scsi_init();
2349:
2350: scsi_devices = (Scsi_Device *) NULL;
2351:
2352: for (shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
2353: scan_scsis(shpnt,0,0,0,0); /* scan for scsi devices */
2354:
2355: #if 0
2356: printk("scsi : detected ");
2357: for (sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2358: if (sdtpnt->dev_noticed && sdtpnt->name)
2359: printk("%d SCSI %s%s ", sdtpnt->dev_noticed, sdtpnt->name,
2360: (sdtpnt->dev_noticed != 1) ? "s" : "");
2361: printk("total.\n");
2362: #endif
2363:
2364: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2365: if(sdtpnt->init && sdtpnt->dev_noticed) (*sdtpnt->init)();
2366:
2367: for (SDpnt=scsi_devices; SDpnt; SDpnt = SDpnt->next) {
2368: SDpnt->scsi_request_fn = NULL;
2369: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2370: if(sdtpnt->attach) (*sdtpnt->attach)(SDpnt);
2371: if(SDpnt->attached) scsi_build_commandblocks(SDpnt);
2372: }
2373:
2374:
2375: /*
2376: * This should build the DMA pool.
2377: */
2378: resize_dma_pool();
2379:
2380: /*
2381: * OK, now we finish the initialization by doing spin-up, read
2382: * capacity, etc, etc
2383: */
2384: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2385: if(sdtpnt->finish && sdtpnt->nr_dev)
2386: (*sdtpnt->finish)();
2387:
2388: scsi_loadable_module_flag = 1;
2389:
2390: return 0;
2391: }
2392:
2393: static void print_inquiry(unsigned char *data)
2394: {
2395: int i;
2396:
2397: printk(" Vendor: ");
2398: for (i = 8; i < 16; i++)
2399: {
2400: if (data[i] >= 0x20 && i < data[4] + 5)
2401: printk("%c", data[i]);
2402: else
2403: printk(" ");
2404: }
2405:
2406: printk(" Model: ");
2407: for (i = 16; i < 32; i++)
2408: {
2409: if (data[i] >= 0x20 && i < data[4] + 5)
2410: printk("%c", data[i]);
2411: else
2412: printk(" ");
2413: }
2414:
2415: printk(" Rev: ");
2416: for (i = 32; i < 36; i++)
2417: {
2418: if (data[i] >= 0x20 && i < data[4] + 5)
2419: printk("%c", data[i]);
2420: else
2421: printk(" ");
2422: }
2423:
2424: printk("\n");
2425:
2426: i = data[0] & 0x1f;
2427:
2428: printk(" Type: %s ",
2429: i < MAX_SCSI_DEVICE_CODE ? scsi_device_types[i] : "Unknown " );
2430: printk(" ANSI SCSI revision: %02x", data[2] & 0x07);
2431: if ((data[2] & 0x07) == 1 && (data[3] & 0x0f) == 1)
2432: printk(" CCS\n");
2433: else
2434: printk("\n");
2435: }
2436:
2437:
2438: #ifdef CONFIG_PROC_FS
2439: int scsi_proc_info(char *buffer, char **start, off_t offset, int length,
2440: int hostno, int inout)
2441: {
2442: Scsi_Device *scd;
2443: struct Scsi_Host *HBA_ptr;
2444: int parameter[4];
2445: char *p;
2446: int i,size, len = 0;
2447: off_t begin = 0;
2448: off_t pos = 0;
2449:
2450: scd = scsi_devices;
2451: HBA_ptr = scsi_hostlist;
2452:
2453: if(inout == 0) {
2454: size = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
2455: len += size;
2456: pos = begin + len;
2457: while (HBA_ptr) {
2458: #if 0
2459: size += sprintf(buffer+len,"scsi%2d: %s\n", (int) HBA_ptr->host_no,
2460: HBA_ptr->hostt->procname);
2461: len += size;
2462: pos = begin + len;
2463: #endif
2464: scd = scsi_devices;
2465: while (scd) {
2466: if (scd->host == HBA_ptr) {
2467: proc_print_scsidevice(scd, buffer, &size, len);
2468: len += size;
2469: pos = begin + len;
2470:
2471: if (pos < offset) {
2472: len = 0;
2473: begin = pos;
2474: }
2475: if (pos > offset + length)
2476: goto stop_output;
2477: }
2478: scd = scd->next;
2479: }
2480: HBA_ptr = HBA_ptr->next;
2481: }
2482:
2483: stop_output:
2484: *start=buffer+(offset-begin); /* Start of wanted data */
2485: len-=(offset-begin); /* Start slop */
2486: if(len>length)
2487: len = length; /* Ending slop */
2488: return (len);
2489: }
2490:
2491: /*
2492: * Usage: echo "scsi singledevice 0 1 2 3" >/proc/scsi/scsi
2493: * with "0 1 2 3" replaced by your "Host Channel Id Lun".
2494: * Consider this feature BETA.
2495: * CAUTION: This is not for hotplugging your peripherals. As
2496: * SCSI was not designed for this you could damage your
2497: * hardware !
2498: * However perhaps it is legal to switch on an
2499: * already connected device. It is perhaps not
2500: * guaranteed this device doesn't corrupt an ongoing data transfer.
2501: */
2502: if(!buffer || length < 25 || strncmp("scsi", buffer, 4))
2503: return(-EINVAL);
2504:
2505: if(!strncmp("singledevice", buffer + 5, 12)) {
2506: p = buffer + 17;
2507:
2508: for(i=0; i<4; i++) {
2509: p++;
2510: parameter[i] = simple_strtoul(p, &p, 0);
2511: }
2512: printk("scsi singledevice %d %d %d %d\n", parameter[0], parameter[1],
2513: parameter[2], parameter[3]);
2514:
2515: while(scd && (scd->host->host_no != parameter[0]
2516: || scd->channel != parameter[1]
2517: || scd->id != parameter[2]
2518: || scd->lun != parameter[3])) {
2519: scd = scd->next;
2520: }
2521: if(scd)
2522: return(-ENOSYS); /* We do not yet support unplugging */
2523: while(HBA_ptr && HBA_ptr->host_no != parameter[0])
2524: HBA_ptr = HBA_ptr->next;
2525:
2526: if(!HBA_ptr)
2527: return(-ENXIO);
2528:
2529: scan_scsis (HBA_ptr, 1, parameter[1], parameter[2], parameter[3]);
2530: return(length);
2531: }
2532: return(-EINVAL);
2533: }
2534: #endif
2535:
2536: /*
2537: * Go through the device list and recompute the most appropriate size
2538: * for the dma pool. Then grab more memory (as required).
2539: */
2540: static void resize_dma_pool(void)
2541: {
2542: int i;
2543: unsigned long size;
2544: struct Scsi_Host * shpnt;
2545: struct Scsi_Host * host = NULL;
2546: Scsi_Device * SDpnt;
2547: unsigned long flags;
2548: FreeSectorBitmap * new_dma_malloc_freelist = NULL;
2549: unsigned int new_dma_sectors = 0;
2550: unsigned int new_need_isa_buffer = 0;
2551: unsigned char ** new_dma_malloc_pages = NULL;
2552:
2553: if( !scsi_devices )
2554: {
2555: /*
2556: * Free up the DMA pool.
2557: */
2558: if( dma_free_sectors != dma_sectors )
2559: panic("SCSI DMA pool memory leak %d %d\n",dma_free_sectors,dma_sectors);
2560:
2561: for(i=0; i < dma_sectors / SECTORS_PER_PAGE; i++)
2562: scsi_init_free(dma_malloc_pages[i], PAGE_SIZE);
2563: if (dma_malloc_pages)
2564: scsi_init_free((char *) dma_malloc_pages,
2565: (dma_sectors / SECTORS_PER_PAGE)*sizeof(*dma_malloc_pages));
2566: dma_malloc_pages = NULL;
2567: if (dma_malloc_freelist)
2568: scsi_init_free((char *) dma_malloc_freelist,
2569: (dma_sectors / SECTORS_PER_PAGE)*sizeof(*dma_malloc_freelist));
2570: dma_malloc_freelist = NULL;
2571: dma_sectors = 0;
2572: dma_free_sectors = 0;
2573: return;
2574: }
2575: /* Next, check to see if we need to extend the DMA buffer pool */
2576:
2577: new_dma_sectors = 2*SECTORS_PER_PAGE; /* Base value we use */
2578:
2579: if (high_memory-1 > ISA_DMA_THRESHOLD)
2580: scsi_need_isa_bounce_buffers = 1;
2581: else
2582: scsi_need_isa_bounce_buffers = 0;
2583:
2584: if (scsi_devicelist)
2585: for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next)
2586: new_dma_sectors += SECTORS_PER_PAGE; /* Increment for each host */
2587:
2588: for (SDpnt=scsi_devices; SDpnt; SDpnt = SDpnt->next) {
2589: host = SDpnt->host;
2590:
2591: if(SDpnt->type != TYPE_TAPE)
2592: new_dma_sectors += ((host->sg_tablesize *
2593: sizeof(struct scatterlist) + 511) >> 9) *
2594: host->cmd_per_lun;
2595:
2596: if(host->unchecked_isa_dma &&
2597: scsi_need_isa_bounce_buffers &&
2598: SDpnt->type != TYPE_TAPE) {
2599: new_dma_sectors += (PAGE_SIZE >> 9) * host->sg_tablesize *
2600: host->cmd_per_lun;
2601: new_need_isa_buffer++;
2602: }
2603: }
2604:
2605: /* limit DMA memory to 32MB: */
2606: new_dma_sectors = (new_dma_sectors + 15) & 0xfff0;
2607:
2608: /*
2609: * We never shrink the buffers - this leads to
2610: * race conditions that I would rather not even think
2611: * about right now.
2612: */
2613: if( new_dma_sectors < dma_sectors )
2614: new_dma_sectors = dma_sectors;
2615:
2616: if (new_dma_sectors)
2617: {
2618: size = (new_dma_sectors / SECTORS_PER_PAGE)*sizeof(FreeSectorBitmap);
2619: new_dma_malloc_freelist = (FreeSectorBitmap *) scsi_init_malloc(size, GFP_ATOMIC);
2620: memset(new_dma_malloc_freelist, 0, size);
2621:
2622: size = (new_dma_sectors / SECTORS_PER_PAGE)*sizeof(*new_dma_malloc_pages);
2623: new_dma_malloc_pages = (unsigned char **) scsi_init_malloc(size, GFP_ATOMIC);
2624: memset(new_dma_malloc_pages, 0, size);
2625: }
2626:
2627: /*
2628: * If we need more buffers, expand the list.
2629: */
2630: if( new_dma_sectors > dma_sectors ) {
2631: for(i=dma_sectors / SECTORS_PER_PAGE; i< new_dma_sectors / SECTORS_PER_PAGE; i++)
2632: new_dma_malloc_pages[i] = (unsigned char *)
2633: scsi_init_malloc(PAGE_SIZE, GFP_ATOMIC | GFP_DMA);
2634: }
2635:
2636: /* When we dick with the actual DMA list, we need to
2637: * protect things
2638: */
2639: save_flags(flags);
2640: cli();
2641: if (dma_malloc_freelist)
2642: {
2643: size = (dma_sectors / SECTORS_PER_PAGE)*sizeof(FreeSectorBitmap);
2644: memcpy(new_dma_malloc_freelist, dma_malloc_freelist, size);
2645: scsi_init_free((char *) dma_malloc_freelist, size);
2646: }
2647: dma_malloc_freelist = new_dma_malloc_freelist;
2648:
2649: if (dma_malloc_pages)
2650: {
2651: size = (dma_sectors / SECTORS_PER_PAGE)*sizeof(*dma_malloc_pages);
2652: memcpy(new_dma_malloc_pages, dma_malloc_pages, size);
2653: scsi_init_free((char *) dma_malloc_pages, size);
2654: }
2655:
2656: dma_free_sectors += new_dma_sectors - dma_sectors;
2657: dma_malloc_pages = new_dma_malloc_pages;
2658: dma_sectors = new_dma_sectors;
2659: need_isa_buffer = new_need_isa_buffer;
2660: restore_flags(flags);
2661: }
2662:
2663: #ifdef CONFIG_MODULES /* a big #ifdef block... */
2664:
2665: /*
2666: * This entry point should be called by a loadable module if it is trying
2667: * add a low level scsi driver to the system.
2668: */
2669: static int scsi_register_host(Scsi_Host_Template * tpnt)
2670: {
2671: int pcount;
2672: struct Scsi_Host * shpnt;
2673: Scsi_Device * SDpnt;
2674: struct Scsi_Device_Template * sdtpnt;
2675: const char * name;
2676:
2677: if (tpnt->next || !tpnt->detect) return 1;/* Must be already loaded, or
2678: * no detect routine available
2679: */
2680: pcount = next_scsi_host;
2681: if ((tpnt->present = tpnt->detect(tpnt)))
2682: {
2683: if(pcount == next_scsi_host) {
2684: if(tpnt->present > 1) {
2685: printk("Failure to register low-level scsi driver");
2686: scsi_unregister_host(tpnt);
2687: return 1;
2688: }
2689: /* The low-level driver failed to register a driver. We
2690: * can do this now.
2691: */
2692: scsi_register(tpnt,0);
2693: }
2694: tpnt->next = scsi_hosts; /* Add to the linked list */
2695: scsi_hosts = tpnt;
2696:
2697: /* Add the new driver to /proc/scsi */
2698: #if CONFIG_PROC_FS
2699: build_proc_dir_entries(tpnt);
2700: #endif
2701:
2702: for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next)
2703: if(shpnt->hostt == tpnt)
2704: {
2705: if(tpnt->info)
2706: name = tpnt->info(shpnt);
2707: else
2708: name = tpnt->name;
2709: printk ("scsi%d : %s\n", /* And print a little message */
2710: shpnt->host_no, name);
2711: }
2712:
2713: printk ("scsi : %d host%s.\n", next_scsi_host,
2714: (next_scsi_host == 1) ? "" : "s");
2715:
2716: scsi_make_blocked_list();
2717:
2718: /* The next step is to call scan_scsis here. This generates the
2719: * Scsi_Devices entries
2720: */
2721:
2722: for(shpnt=scsi_hostlist; shpnt; shpnt = shpnt->next)
2723: if(shpnt->hostt == tpnt) scan_scsis(shpnt,0,0,0,0);
2724:
2725: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2726: if(sdtpnt->init && sdtpnt->dev_noticed) (*sdtpnt->init)();
2727:
2728: /* Next we create the Scsi_Cmnd structures for this host */
2729:
2730: for(SDpnt = scsi_devices; SDpnt; SDpnt = SDpnt->next)
2731: if(SDpnt->host->hostt == tpnt)
2732: {
2733: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2734: if(sdtpnt->attach) (*sdtpnt->attach)(SDpnt);
2735: if(SDpnt->attached) scsi_build_commandblocks(SDpnt);
2736: }
2737:
2738: /*
2739: * Now that we have all of the devices, resize the DMA pool,
2740: * as required. */
2741: resize_dma_pool();
2742:
2743:
2744: /* This does any final handling that is required. */
2745: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2746: if(sdtpnt->finish && sdtpnt->nr_dev)
2747: (*sdtpnt->finish)();
2748: }
2749:
2750: #if defined(USE_STATIC_SCSI_MEMORY)
2751: printk ("SCSI memory: total %ldKb, used %ldKb, free %ldKb.\n",
2752: (scsi_memory_upper_value - scsi_memory_lower_value) / 1024,
2753: (scsi_init_memory_start - scsi_memory_lower_value) / 1024,
2754: (scsi_memory_upper_value - scsi_init_memory_start) / 1024);
2755: #endif
2756:
2757: MOD_INC_USE_COUNT;
2758: return 0;
2759: }
2760:
2761: /*
2762: * Similarly, this entry point should be called by a loadable module if it
2763: * is trying to remove a low level scsi driver from the system.
2764: */
2765: static void scsi_unregister_host(Scsi_Host_Template * tpnt)
2766: {
2767: Scsi_Host_Template * SHT, *SHTp;
2768: Scsi_Device *sdpnt, * sdppnt, * sdpnt1;
2769: Scsi_Cmnd * SCpnt;
2770: unsigned long flags;
2771: struct Scsi_Device_Template * sdtpnt;
2772: struct Scsi_Host * shpnt, *sh1;
2773: int pcount;
2774:
2775: /* First verify that this host adapter is completely free with no pending
2776: * commands */
2777:
2778: for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt->next)
2779: if(sdpnt->host->hostt == tpnt && sdpnt->host->hostt->usage_count
2780: && *sdpnt->host->hostt->usage_count) return;
2781:
2782: for(shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
2783: {
2784: if (shpnt->hostt != tpnt) continue;
2785: for(SCpnt = shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
2786: {
2787: save_flags(flags);
2788: cli();
2789: if(SCpnt->request.rq_status != RQ_INACTIVE) {
2790: restore_flags(flags);
2791: for(SCpnt = shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
2792: if(SCpnt->request.rq_status == RQ_SCSI_DISCONNECTING)
2793: SCpnt->request.rq_status = RQ_INACTIVE;
2794: printk("Device busy???\n");
2795: return;
2796: }
2797: SCpnt->request.rq_status = RQ_SCSI_DISCONNECTING; /* Mark as busy */
2798: restore_flags(flags);
2799: }
2800: }
2801: /* Next we detach the high level drivers from the Scsi_Device structures */
2802:
2803: for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt->next)
2804: if(sdpnt->host->hostt == tpnt)
2805: {
2806: for(sdtpnt = scsi_devicelist; sdtpnt; sdtpnt = sdtpnt->next)
2807: if(sdtpnt->detach) (*sdtpnt->detach)(sdpnt);
2808: /* If something still attached, punt */
2809: if (sdpnt->attached) {
2810: printk("Attached usage count = %d\n", sdpnt->attached);
2811: return;
2812: }
2813: }
2814:
2815: /* Next we free up the Scsi_Cmnd structures for this host */
2816:
2817: for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt->next)
2818: if(sdpnt->host->hostt == tpnt)
2819: while (sdpnt->host->host_queue) {
2820: SCpnt = sdpnt->host->host_queue->next;
2821: scsi_init_free((char *) sdpnt->host->host_queue, sizeof(Scsi_Cmnd));
2822: sdpnt->host->host_queue = SCpnt;
2823: if (SCpnt) SCpnt->prev = NULL;
2824: sdpnt->has_cmdblocks = 0;
2825: }
2826:
2827: /* Next free up the Scsi_Device structures for this host */
2828:
2829: sdppnt = NULL;
2830: for(sdpnt = scsi_devices; sdpnt; sdpnt = sdpnt1)
2831: {
2832: sdpnt1 = sdpnt->next;
2833: if (sdpnt->host->hostt == tpnt) {
2834: if (sdppnt)
2835: sdppnt->next = sdpnt->next;
2836: else
2837: scsi_devices = sdpnt->next;
2838: scsi_init_free((char *) sdpnt, sizeof (Scsi_Device));
2839: } else
2840: sdppnt = sdpnt;
2841: }
2842:
2843: /* Next we go through and remove the instances of the individual hosts
2844: * that were detected */
2845:
2846: shpnt = scsi_hostlist;
2847: while(shpnt) {
2848: sh1 = shpnt->next;
2849: if(shpnt->hostt == tpnt) {
2850: if(shpnt->loaded_as_module) {
2851: pcount = next_scsi_host;
2852: /* Remove the /proc/scsi directory entry */
2853: #if CONFIG_PROC_FS
2854: proc_scsi_unregister(tpnt->proc_dir,
2855: shpnt->host_no + PROC_SCSI_FILE);
2856: #endif
2857: if(tpnt->release)
2858: (*tpnt->release)(shpnt);
2859: else {
2860: /* This is the default case for the release function.
2861: * It should do the right thing for most correctly
2862: * written host adapters.
2863: */
2864: if (shpnt->irq) free_irq(shpnt->irq);
2865: if (shpnt->dma_channel != 0xff) free_dma(shpnt->dma_channel);
2866: if (shpnt->io_port && shpnt->n_io_port)
2867: release_region(shpnt->io_port, shpnt->n_io_port);
2868: }
2869: if(pcount == next_scsi_host) scsi_unregister(shpnt);
2870: tpnt->present--;
2871: }
2872: }
2873: shpnt = sh1;
2874: }
2875:
2876: /*
2877: * If there are absolutely no more hosts left, it is safe
2878: * to completely nuke the DMA pool. The resize operation will
2879: * do the right thing and free everything.
2880: */
2881: if( !scsi_devices )
2882: resize_dma_pool();
2883:
2884: printk ("scsi : %d host%s.\n", next_scsi_host,
2885: (next_scsi_host == 1) ? "" : "s");
2886:
2887: #if defined(USE_STATIC_SCSI_MEMORY)
2888: printk ("SCSI memory: total %ldKb, used %ldKb, free %ldKb.\n",
2889: (scsi_memory_upper_value - scsi_memory_lower_value) / 1024,
2890: (scsi_init_memory_start - scsi_memory_lower_value) / 1024,
2891: (scsi_memory_upper_value - scsi_init_memory_start) / 1024);
2892: #endif
2893:
2894: scsi_make_blocked_list();
2895:
2896: /* There were some hosts that were loaded at boot time, so we cannot
2897: do any more than this */
2898: if (tpnt->present) return;
2899:
2900: /* OK, this is the very last step. Remove this host adapter from the
2901: linked list. */
2902: for(SHTp=NULL, SHT=scsi_hosts; SHT; SHTp=SHT, SHT=SHT->next)
2903: if(SHT == tpnt) {
2904: if(SHTp)
2905: SHTp->next = SHT->next;
2906: else
2907: scsi_hosts = SHT->next;
2908: SHT->next = NULL;
2909: break;
2910: }
2911:
2912: /* Rebuild the /proc/scsi directory entries */
2913: #if CONFIG_PROC_FS
2914: proc_scsi_unregister(tpnt->proc_dir, tpnt->proc_dir->low_ino);
2915: #endif
2916: MOD_DEC_USE_COUNT;
2917: }
2918:
2919: /*
2920: * This entry point should be called by a loadable module if it is trying
2921: * add a high level scsi driver to the system.
2922: */
2923: static int scsi_register_device_module(struct Scsi_Device_Template * tpnt)
2924: {
2925: Scsi_Device * SDpnt;
2926:
2927: if (tpnt->next) return 1;
2928:
2929: scsi_register_device(tpnt);
2930: /*
2931: * First scan the devices that we know about, and see if we notice them.
2932: */
2933:
2934: for(SDpnt = scsi_devices; SDpnt; SDpnt = SDpnt->next)
2935: if(tpnt->detect) SDpnt->attached += (*tpnt->detect)(SDpnt);
2936:
2937: /*
2938: * If any of the devices would match this driver, then perform the
2939: * init function.
2940: */
2941: if(tpnt->init && tpnt->dev_noticed)
2942: if ((*tpnt->init)()) return 1;
2943:
2944: /*
2945: * Now actually connect the devices to the new driver.
2946: */
2947: for(SDpnt = scsi_devices; SDpnt; SDpnt = SDpnt->next)
2948: {
2949: if(tpnt->attach) (*tpnt->attach)(SDpnt);
2950: /*
2951: * If this driver attached to the device, and we no longer
2952: * have anything attached, release the scso command blocks.
2953: */
2954: if(SDpnt->attached && SDpnt->has_cmdblocks == 0)
2955: scsi_build_commandblocks(SDpnt);
2956: }
2957:
2958: /*
2959: * This does any final handling that is required.
2960: */
2961: if(tpnt->finish && tpnt->nr_dev) (*tpnt->finish)();
2962: MOD_INC_USE_COUNT;
2963: return 0;
2964: }
2965:
2966: static int scsi_unregister_device(struct Scsi_Device_Template * tpnt)
2967: {
2968: Scsi_Device * SDpnt;
2969: Scsi_Cmnd * SCpnt;
2970: struct Scsi_Device_Template * spnt;
2971: struct Scsi_Device_Template * prev_spnt;
2972:
2973: /*
2974: * If we are busy, this is not going to fly.
2975: */
2976: if( *tpnt->usage_count != 0) return 0;
2977: /*
2978: * Next, detach the devices from the driver.
2979: */
2980:
2981: for(SDpnt = scsi_devices; SDpnt; SDpnt = SDpnt->next)
2982: {
2983: if(tpnt->detach) (*tpnt->detach)(SDpnt);
2984: if(SDpnt->attached == 0)
2985: {
2986: /*
2987: * Nobody is using this device any more. Free all of the
2988: * command structures.
2989: */
2990: for(SCpnt = SDpnt->host->host_queue; SCpnt; SCpnt = SCpnt->next)
2991: {
2992: if(SCpnt->device == SDpnt)
2993: {
2994: if(SCpnt->prev != NULL)
2995: SCpnt->prev->next = SCpnt->next;
2996: if(SCpnt->next != NULL)
2997: SCpnt->next->prev = SCpnt->prev;
2998: if(SCpnt == SDpnt->host->host_queue)
2999: SDpnt->host->host_queue = SCpnt->next;
3000: scsi_init_free((char *) SCpnt, sizeof(*SCpnt));
3001: }
3002: }
3003: SDpnt->has_cmdblocks = 0;
3004: }
3005: }
3006: /*
3007: * Extract the template from the linked list.
3008: */
3009: spnt = scsi_devicelist;
3010: prev_spnt = NULL;
3011: while(spnt != tpnt)
3012: {
3013: prev_spnt = spnt;
3014: spnt = spnt->next;
3015: }
3016: if(prev_spnt == NULL)
3017: scsi_devicelist = tpnt->next;
3018: else
3019: prev_spnt->next = spnt->next;
3020:
3021: MOD_DEC_USE_COUNT;
3022: /*
3023: * Final cleanup for the driver is done in the driver sources in the
3024: * cleanup function.
3025: */
3026: return 0;
3027: }
3028:
3029:
3030: int scsi_register_module(int module_type, void * ptr)
3031: {
3032: switch(module_type){
3033: case MODULE_SCSI_HA:
3034: return scsi_register_host((Scsi_Host_Template *) ptr);
3035:
3036: /* Load upper level device handler of some kind */
3037: case MODULE_SCSI_DEV:
3038: return scsi_register_device_module((struct Scsi_Device_Template *) ptr);
3039: /* The rest of these are not yet implemented */
3040:
3041: /* Load constants.o */
3042: case MODULE_SCSI_CONST:
3043:
3044: /* Load specialized ioctl handler for some device. Intended for
3045: * cdroms that have non-SCSI2 audio command sets. */
3046: case MODULE_SCSI_IOCTL:
3047:
3048: default:
3049: return 1;
3050: }
3051: }
3052:
3053: void scsi_unregister_module(int module_type, void * ptr)
3054: {
3055: switch(module_type) {
3056: case MODULE_SCSI_HA:
3057: scsi_unregister_host((Scsi_Host_Template *) ptr);
3058: break;
3059: case MODULE_SCSI_DEV:
3060: scsi_unregister_device((struct Scsi_Device_Template *) ptr);
3061: break;
3062: /* The rest of these are not yet implemented. */
3063: case MODULE_SCSI_CONST:
3064: case MODULE_SCSI_IOCTL:
3065: break;
3066: default:
3067: }
3068: return;
3069: }
3070:
3071: #endif /* CONFIG_MODULES */
3072:
3073: #ifdef DEBUG_TIMEOUT
3074: static void
3075: scsi_dump_status(void)
3076: {
3077: int i;
3078: struct Scsi_Host * shpnt;
3079: Scsi_Cmnd * SCpnt;
3080: printk("Dump of scsi parameters:\n");
3081: i = 0;
3082: for(shpnt = scsi_hostlist; shpnt; shpnt = shpnt->next)
3083: for(SCpnt=shpnt->host_queue; SCpnt; SCpnt = SCpnt->next)
3084: {
3085: /* (0) 0:0:0:0 (802 123434 8 8 0) (3 3 2) (%d %d %d) %d %x */
3086: printk("(%d) %d:%d:%d:%d (%s %ld %ld %ld %d) (%d %d %x) (%d %d %d) %x %x %x\n",
3087: i++, SCpnt->host->host_no,
3088: SCpnt->channel,
3089: SCpnt->target,
3090: SCpnt->lun,
3091: kdevname(SCpnt->request.rq_dev),
3092: SCpnt->request.sector,
3093: SCpnt->request.nr_sectors,
3094: SCpnt->request.current_nr_sectors,
3095: SCpnt->use_sg,
3096: SCpnt->retries,
3097: SCpnt->allowed,
3098: SCpnt->flags,
3099: SCpnt->timeout_per_command,
3100: SCpnt->timeout,
3101: SCpnt->internal_timeout,
3102: SCpnt->cmnd[0],
3103: SCpnt->sense_buffer[2],
3104: SCpnt->result);
3105: }
3106: printk("wait_for_request = %p\n", wait_for_request);
3107: /* Now dump the request lists for each block device */
3108: printk("Dump of pending block device requests\n");
3109: for(i=0; i<MAX_BLKDEV; i++)
3110: if(blk_dev[i].current_request)
3111: {
3112: struct request * req;
3113: printk("%d: ", i);
3114: req = blk_dev[i].current_request;
3115: while(req) {
3116: printk("(%s %d %ld %ld %ld) ",
3117: kdevname(req->rq_dev),
3118: req->cmd,
3119: req->sector,
3120: req->nr_sectors,
3121: req->current_nr_sectors);
3122: req = req->next;
3123: }
3124: printk("\n");
3125: }
3126: }
3127: #endif
3128:
3129: #ifdef MODULE
3130:
3131: int init_module(void) {
3132: unsigned long size;
3133:
3134: /*
3135: * This makes /proc/scsi visible.
3136: */
3137: dispatch_scsi_info_ptr = dispatch_scsi_info;
3138:
3139: timer_table[SCSI_TIMER].fn = scsi_main_timeout;
3140: timer_table[SCSI_TIMER].expires = 0;
3141: register_symtab(&scsi_symbol_table);
3142: scsi_loadable_module_flag = 1;
3143:
3144: /* Register the /proc/scsi/scsi entry */
3145: #if CONFIG_PROC_FS
3146: proc_scsi_register(0, &proc_scsi_scsi);
3147: #endif
3148:
3149:
3150: dma_sectors = PAGE_SIZE / SECTOR_SIZE;
3151: dma_free_sectors= dma_sectors;
3152: /*
3153: * Set up a minimal DMA buffer list - this will be used during scan_scsis
3154: * in some cases.
3155: */
3156:
3157: /* One bit per sector to indicate free/busy */
3158: size = (dma_sectors / SECTORS_PER_PAGE)*sizeof(FreeSectorBitmap);
3159: dma_malloc_freelist = (unsigned char *) scsi_init_malloc(size, GFP_ATOMIC);
3160: memset(dma_malloc_freelist, 0, size);
3161:
3162: /* One pointer per page for the page list */
3163: dma_malloc_pages = (unsigned char **)
3164: scsi_init_malloc((dma_sectors / SECTORS_PER_PAGE)*sizeof(*dma_malloc_pages), GFP_ATOMIC);
3165: dma_malloc_pages[0] = (unsigned char *)
3166: scsi_init_malloc(PAGE_SIZE, GFP_ATOMIC | GFP_DMA);
3167: return 0;
3168: }
3169:
3170: void cleanup_module( void)
3171: {
3172: #if CONFIG_PROC_FS
3173: proc_scsi_unregister(0, PROC_SCSI_SCSI);
3174: #endif
3175:
3176: /* No, we're not here anymore. Don't show the /proc/scsi files. */
3177: dispatch_scsi_info_ptr = 0L;
3178:
3179: /*
3180: * Free up the DMA pool.
3181: */
3182: resize_dma_pool();
3183:
3184: timer_table[SCSI_TIMER].fn = NULL;
3185: timer_table[SCSI_TIMER].expires = 0;
3186: }
3187: #endif /* MODULE */
3188:
3189: /*
3190: * Overrides for Emacs so that we follow Linus's tabbing style.
3191: * Emacs will notice this stuff at the end of the file and automatically
3192: * adjust the settings for this buffer only. This must remain at the end
3193: * of the file.
3194: * ---------------------------------------------------------------------------
3195: * Local variables:
3196: * c-indent-level: 4
3197: * c-brace-imaginary-offset: 0
3198: * c-brace-offset: -4
3199: * c-argdecl-indent: 4
3200: * c-label-offset: -4
3201: * c-continued-statement-offset: 4
3202: * c-continued-brace-offset: 0
3203: * indent-tabs-mode: nil
3204: * tab-width: 8
3205: * End:
3206: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.