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