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