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