![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/n_last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 * scsi.h Copyright (C) 1992 Drew Eckhardt
3 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
4 * generic SCSI package header file by
5 * Initial versions: Drew Eckhardt
6 * Subsequent revisions: Eric Youngdale
7 *
8 * <drew@colorado.edu>
9 *
10 * Modified by Eric Youngdale eric@aib.com to
11 * add scatter-gather, multiple outstanding request, and other
12 * enhancements.
13 */
14
15 #ifndef _SCSI_H
16 #define _SCSI_H
17
18 /*
19 * Some of the public constants are being moved to this file.
20 * We include it here so that what came from where is transparent.
21 */
22 #include <linux/scsi.h>
23
24
25 /*
26 * Some defs, in case these are not defined elsewhere.
27 */
28 #ifndef TRUE
29 # define TRUE 1
30 #endif
31 #ifndef FALSE
32 # define FALSE 0
33 #endif
34
35
36 extern void scsi_make_blocked_list(void);
37 extern volatile int in_scan_scsis;
38 extern const unsigned char scsi_command_size[8];
39 #define COMMAND_SIZE(opcode) scsi_command_size[((opcode) >> 5) & 7]
40
41 #define IDENTIFY_BASE 0x80
42 #define IDENTIFY(can_disconnect, lun) (IDENTIFY_BASE |\
43 ((can_disconnect) ? 0x40 : 0) |\
44 ((lun) & 0x07))
45
46
47
48 /*
49 * the return of the status word will be in the following format :
50 * The low byte is the status returned by the SCSI command,
51 * with vendor specific bits masked.
52 *
53 * The next byte is the message which followed the SCSI status.
54 * This allows a stos to be used, since the Intel is a little
55 * endian machine.
56 *
57 * The final byte is a host return code, which is one of the following.
58 *
59 * IE
60 * lsb msb
61 * status msg host code
62 *
63 * Our errors returned by OUR driver, NOT SCSI message. Or'd with
64 * SCSI message passed back to driver <IF any>.
65 */
66
67
68 #define DID_OK 0x00 /* NO error */
69 #define DID_NO_CONNECT 0x01 /* Couldn't connect before timeout period */
70 #define DID_BUS_BUSY 0x02 /* BUS stayed busy through time out period */
71 #define DID_TIME_OUT 0x03 /* TIMED OUT for other reason */
72 #define DID_BAD_TARGET 0x04 /* BAD target. */
73 #define DID_ABORT 0x05 /* Told to abort for some other reason */
74 #define DID_PARITY 0x06 /* Parity error */
75 #define DID_ERROR 0x07 /* Internal error */
76 #define DID_RESET 0x08 /* Reset by somebody. */
77 #define DID_BAD_INTR 0x09 /* Got an interrupt we weren't expecting. */
78 #define DRIVER_OK 0x00 /* Driver status */
79
80 /*
81 * These indicate the error that occurred, and what is available.
82 */
83
84 #define DRIVER_BUSY 0x01
85 #define DRIVER_SOFT 0x02
86 #define DRIVER_MEDIA 0x03
87 #define DRIVER_ERROR 0x04
88
89 #define DRIVER_INVALID 0x05
90 #define DRIVER_TIMEOUT 0x06
91 #define DRIVER_HARD 0x07
92 #define DRIVER_SENSE 0x08
93
94 #define SUGGEST_RETRY 0x10
95 #define SUGGEST_ABORT 0x20
96 #define SUGGEST_REMAP 0x30
97 #define SUGGEST_DIE 0x40
98 #define SUGGEST_SENSE 0x80
99 #define SUGGEST_IS_OK 0xff
100
101 #define DRIVER_MASK 0x0f
102 #define SUGGEST_MASK 0xf0
103
104 #define MAX_COMMAND_SIZE 12
105
106 /*
107 * SCSI command sets
108 */
109
110 #define SCSI_UNKNOWN 0
111 #define SCSI_1 1
112 #define SCSI_1_CCS 2
113 #define SCSI_2 3
114
115 /*
116 * Every SCSI command starts with a one byte OP-code.
117 * The next byte's high three bits are the LUN of the
118 * device. Any multi-byte quantities are stored high byte
119 * first, and may have a 5 bit MSB in the same byte
120 * as the LUN.
121 */
122
123 /*
124 * Manufacturers list
125 */
126
127 #define SCSI_MAN_UNKNOWN 0
128 #define SCSI_MAN_NEC 1
129 #define SCSI_MAN_TOSHIBA 2
130 #define SCSI_MAN_NEC_OLDCDR 3
131 #define SCSI_MAN_SONY 4
132 #define SCSI_MAN_PIONEER 5
133
134 /*
135 * As the scsi do command functions are intelligent, and may need to
136 * redo a command, we need to keep track of the last command
137 * executed on each one.
138 */
139
140 #define WAS_RESET 0x01
141 #define WAS_TIMEDOUT 0x02
142 #define WAS_SENSE 0x04
143 #define IS_RESETTING 0x08
144 #define IS_ABORTING 0x10
145 #define ASKED_FOR_SENSE 0x20
146
147 /*
148 * The scsi_device struct contains what we know about each given scsi
149 * device.
150 */
151
152 typedef struct scsi_device {
153 struct scsi_device * next; /* Used for linked list */
154
155 unsigned char id, lun, channel;
156
157 unsigned int manufacturer; /* Manufacturer of device, for using
158 * vendor-specific cmd's */
159 int attached; /* # of high level drivers attached to
160 * this */
161 int access_count; /* Count of open channels/mounts */
162 struct wait_queue * device_wait;/* Used to wait if device is busy */
163 struct Scsi_Host * host;
164 void (*scsi_request_fn)(void); /* Used to jumpstart things after an
165 * ioctl */
166 struct scsi_cmnd *device_queue; /* queue of SCSI Command structures */
167 void *hostdata; /* available to low-level driver */
168 char type;
169 char scsi_level;
170 char vendor[8], model[16], rev[4];
171 unsigned char current_tag; /* current tag */
172 unsigned char sync_min_period; /* Not less than this period */
173 unsigned char sync_max_offset; /* Not greater than this offset */
174 unsigned char queue_depth; /* How deep a queue to use */
175
176 unsigned writeable:1;
177 unsigned removable:1;
178 unsigned random:1;
179 unsigned has_cmdblocks:1;
180 unsigned changed:1; /* Data invalid due to media change */
181 unsigned busy:1; /* Used to prevent races */
182 unsigned lockable:1; /* Able to prevent media removal */
183 unsigned borken:1; /* Tell the Seagate driver to be
184 * painfully slow on this device */
185 unsigned tagged_supported:1; /* Supports SCSI-II tagged queuing */
186 unsigned tagged_queue:1; /* SCSI-II tagged queuing enabled */
187 unsigned disconnect:1; /* can disconnect */
188 unsigned soft_reset:1; /* Uses soft reset option */
189 unsigned sync:1; /* Negotiate for sync transfers */
190 unsigned single_lun:1; /* Indicates we should only allow I/O to
191 * one of the luns for the device at a
192 * time. */
193 unsigned was_reset:1; /* There was a bus reset on the bus for
194 * this device */
195 unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
196 * because we did a bus reset. */
197 } Scsi_Device;
198
199 /*
200 * Use these to separate status msg and our bytes
201 */
202
203 #define status_byte(result) (((result) >> 1) & 0xf)
204 #define msg_byte(result) (((result) >> 8) & 0xff)
205 #define host_byte(result) (((result) >> 16) & 0xff)
206 #define driver_byte(result) (((result) >> 24) & 0xff)
207 #define suggestion(result) (driver_byte(result) & SUGGEST_MASK)
208
209 #define sense_class(sense) (((sense) >> 4) & 0x7)
210 #define sense_error(sense) ((sense) & 0xf)
211 #define sense_valid(sense) ((sense) & 0x80);
212
213 /*
214 * These are the SCSI devices available on the system.
215 */
216
217 extern Scsi_Device * scsi_devices;
218
219 /*
220 * Initializes all SCSI devices. This scans all scsi busses.
221 */
222
223 extern int scsi_dev_init (void);
224
225 struct scatterlist {
226 char * address; /* Location data is to be transferred to */
227 char * alt_address; /* Location of actual if address is a
228 * dma indirect buffer. NULL otherwise */
229 unsigned int length;
230 };
231
232 #ifdef __alpha__
233 # define ISA_DMA_THRESHOLD (~0UL)
234 #else
235 # define ISA_DMA_THRESHOLD (0x00ffffff)
236 #endif
237 #define CONTIGUOUS_BUFFERS(X,Y) ((X->b_data+X->b_size) == Y->b_data)
238
239
240 /*
241 * These are the return codes for the abort and reset functions. The mid-level
242 * code uses these to decide what to do next. Each of the low level abort
243 * and reset functions must correctly indicate what it has done.
244 * The descriptions are written from the point of view of the mid-level code,
245 * so that the return code is telling the mid-level drivers exactly what
246 * the low level driver has already done, and what remains to be done.
247 */
248
249 /* We did not do anything.
250 * Wait some more for this command to complete, and if this does not work,
251 * try something more serious. */
252 #define SCSI_ABORT_SNOOZE 0
253
254 /* This means that we were able to abort the command. We have already
255 * called the mid-level done function, and do not expect an interrupt that
256 * will lead to another call to the mid-level done function for this command */
257 #define SCSI_ABORT_SUCCESS 1
258
259 /* We called for an abort of this command, and we should get an interrupt
260 * when this succeeds. Thus we should not restore the timer for this
261 * command in the mid-level abort function. */
262 #define SCSI_ABORT_PENDING 2
263
264 /* Unable to abort - command is currently on the bus. Grin and bear it. */
265 #define SCSI_ABORT_BUSY 3
266
267 /* The command is not active in the low level code. Command probably
268 * finished. */
269 #define SCSI_ABORT_NOT_RUNNING 4
270
271 /* Something went wrong. The low level driver will indicate the correct
272 * error condition when it calls scsi_done, so the mid-level abort function
273 * can simply wait until this comes through */
274 #define SCSI_ABORT_ERROR 5
275
276 /* We do not know how to reset the bus, or we do not want to. Bummer.
277 * Anyway, just wait a little more for the command in question, and hope that
278 * it eventually finishes. If it never finishes, the SCSI device could
279 * hang, so use this with caution. */
280 #define SCSI_RESET_SNOOZE 0
281
282 /* We do not know how to reset the bus, or we do not want to. Bummer.
283 * We have given up on this ever completing. The mid-level code will
284 * request sense information to decide how to proceed from here. */
285 #define SCSI_RESET_PUNT 1
286
287 /* This means that we were able to reset the bus. We have restarted all of
288 * the commands that should be restarted, and we should be able to continue
289 * on normally from here. We do not expect any interrupts that will return
290 * DID_RESET to any of the other commands in the host_queue, and the mid-level
291 * code does not need to do anything special to keep the commands alive.
292 * If a hard reset was performed then all outstanding commands on the
293 * bus have been restarted. */
294 #define SCSI_RESET_SUCCESS 2
295
296 /* We called for a reset of this bus, and we should get an interrupt
297 * when this succeeds. Each command should get its own status
298 * passed up to scsi_done, but this has not happened yet.
299 * If a hard reset was performed, then we expect an interrupt
300 * for *each* of the outstanding commands that will have the
301 * effect of restarting the commands.
302 */
303 #define SCSI_RESET_PENDING 3
304
305 /* We did a reset, but do not expect an interrupt to signal DID_RESET.
306 * This tells the upper level code to request the sense info, and this
307 * should keep the command alive. */
308 #define SCSI_RESET_WAKEUP 4
309
310 /* The command is not active in the low level code. Command probably
311 finished. */
312 #define SCSI_RESET_NOT_RUNNING 5
313
314 /* Something went wrong, and we do not know how to fix it. */
315 #define SCSI_RESET_ERROR 6
316
317 #define SCSI_RESET_SYNCHRONOUS 0x01
318 #define SCSI_RESET_ASYNCHRONOUS 0x02
319 #define SCSI_RESET_SUGGEST_BUS_RESET 0x04
320
321 /*
322 * This is a bitmask that is ored with one of the above codes.
323 * It tells the mid-level code that we did a hard reset.
324 */
325 #define SCSI_RESET_BUS_RESET 0x100
326 /*
327 * Used to mask off bits and to obtain the basic action that was
328 * performed.
329 */
330 #define SCSI_RESET_ACTION 0xff
331
332 void * scsi_malloc(unsigned int);
333 int scsi_free(void *, unsigned int);
334 extern unsigned int dma_free_sectors; /* How much room do we have left */
335 extern unsigned int need_isa_buffer; /* True if some devices need indirection
336 * buffers */
337
338 /*
339 * The Scsi_Cmnd structure is used by scsi.c internally, and for communication
340 * with low level drivers that support multiple outstanding commands.
341 */
342 typedef struct scsi_pointer {
343 char * ptr; /* data pointer */
344 int this_residual; /* left in this buffer */
345 struct scatterlist *buffer; /* which buffer */
346 int buffers_residual; /* how many buffers left */
347
348 volatile int Status;
349 volatile int Message;
350 volatile int have_data_in;
351 volatile int sent_command;
352 volatile int phase;
353 } Scsi_Pointer;
354
355 typedef struct scsi_cmnd {
356 struct Scsi_Host * host;
357 Scsi_Device * device;
358 unsigned char target, lun, channel;
359 unsigned char cmd_len;
360 unsigned char old_cmd_len;
361 struct scsi_cmnd *next, *prev, *device_next, *reset_chain;
362
363 /* These elements define the operation we are about to perform */
364 unsigned char cmnd[12];
365 unsigned request_bufflen; /* Actual request size */
366
367 void * request_buffer; /* Actual requested buffer */
368
369 /* These elements define the operation we ultimately want to perform */
370 unsigned char data_cmnd[12];
371 unsigned short old_use_sg; /* We save use_sg here when requesting
372 * sense info */
373 unsigned short use_sg; /* Number of pieces of scatter-gather */
374 unsigned short sglist_len; /* size of malloc'd scatter-gather list */
375 unsigned short abort_reason;/* If the mid-level code requests an
376 * abort, this is the reason. */
377 unsigned bufflen; /* Size of data buffer */
378 void *buffer; /* Data buffer */
379
380 unsigned underflow; /* Return error if less than this amount is
381 * transfered */
382
383 unsigned transfersize; /* How much we are guaranteed to transfer with
384 * each SCSI transfer (ie, between disconnect /
385 * reconnects. Probably == sector size */
386
387
388 struct request request; /* A copy of the command we are working on */
389
390 unsigned char sense_buffer[16]; /* Sense for this command, if needed */
391
392 /*
393 A SCSI Command is assigned a nonzero serial_number when internal_cmnd
394 passes it to the driver's queue command function. The serial_number
395 is cleared when scsi_done is entered indicating that the command has
396 been completed. If a timeout occurs, the serial number at the moment
397 of timeout is copied into serial_number_at_timeout. By subsequently
398 comparing the serial_number and serial_number_at_timeout fields
399 during abort or reset processing, we can detect whether the command
400 has already completed. This also detects cases where the command has
401 completed and the SCSI Command structure has already being reused
402 for another command, so that we can avoid incorrectly aborting or
403 resetting the new command.
404 */
405
406 unsigned long serial_number;
407 unsigned long serial_number_at_timeout;
408
409 int retries;
410 int allowed;
411 int timeout_per_command, timeout_total, timeout;
412
413 /*
414 * We handle the timeout differently if it happens when a reset,
415 * abort, etc are in process.
416 */
417 unsigned volatile char internal_timeout;
418
419 unsigned flags;
420
421 /* These variables are for the cdrom only. Once we have variable size
422 * buffers in the buffer cache, they will go away. */
423 int this_count;
424 /* End of special cdrom variables */
425
426 /* Low-level done function - can be used by low-level driver to point
427 * to completion function. Not used by mid/upper level code. */
428 void (*scsi_done)(struct scsi_cmnd *);
429 void (*done)(struct scsi_cmnd *); /* Mid-level done function */
430
431 /*
432 * The following fields can be written to by the host specific code.
433 * Everything else should be left alone.
434 */
435
436 Scsi_Pointer SCp; /* Scratchpad used by some host adapters */
437
438 unsigned char * host_scribble; /* The host adapter is allowed to
439 * call scsi_malloc and get some memory
440 * and hang it here. The host adapter
441 * is also expected to call scsi_free
442 * to release this memory. (The memory
443 * obtained by scsi_malloc is guaranteed
444 * to be at an address < 16Mb). */
445
446 int result; /* Status code from lower level driver */
447
448 unsigned char tag; /* SCSI-II queued command tag */
449 unsigned long pid; /* Process ID, starts at 0 */
450 } Scsi_Cmnd;
451
452 /*
453 * scsi_abort aborts the current command that is executing on host host.
454 * The error code, if non zero is returned in the host byte, otherwise
455 * DID_ABORT is returned in the hostbyte.
456 */
457
458 extern int scsi_abort (Scsi_Cmnd *, int code);
459
460 extern void scsi_do_cmd (Scsi_Cmnd *, const void *cmnd ,
461 void *buffer, unsigned bufflen,
462 void (*done)(struct scsi_cmnd *),
463 int timeout, int retries);
464
465
466 extern Scsi_Cmnd * allocate_device(struct request **, Scsi_Device *, int);
467
468 extern Scsi_Cmnd * request_queueable(struct request *, Scsi_Device *);
469 extern int scsi_reset (Scsi_Cmnd *, unsigned int);
470
471 extern int max_scsi_hosts;
472
473 extern void proc_print_scsidevice(Scsi_Device *, char *, int *, int);
474
475 extern void print_command(unsigned char *);
476 extern void print_sense(const char *, Scsi_Cmnd *);
477 extern void print_driverbyte(int scsiresult);
478 extern void print_hostbyte(int scsiresult);
479
480 extern void scsi_mark_host_bus_reset(struct Scsi_Host *Host);
481
482 #if defined(MAJOR_NR) && (MAJOR_NR != SCSI_TAPE_MAJOR)
483 #include "hosts.h"
484
485 static Scsi_Cmnd * end_scsi_request(Scsi_Cmnd * SCpnt, int uptodate, int sectors)
/* ![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
486 {
487 struct request * req;
488 struct buffer_head * bh;
489
490 req = &SCpnt->request;
491 req->errors = 0;
492 if (!uptodate) {
493 printk(DEVICE_NAME " I/O error: dev %s, sector %lu\n",
494 kdevname(req->rq_dev), req->sector);
495 }
496
497 do {
498 if ((bh = req->bh) != NULL) {
499 req->bh = bh->b_reqnext;
500 req->nr_sectors -= bh->b_size >> 9;
501 req->sector += bh->b_size >> 9;
502 bh->b_reqnext = NULL;
503 mark_buffer_uptodate(bh, uptodate);
504 unlock_buffer(bh);
505 sectors -= bh->b_size >> 9;
506 if ((bh = req->bh) != NULL) {
507 req->current_nr_sectors = bh->b_size >> 9;
508 if (req->nr_sectors < req->current_nr_sectors) {
509 req->nr_sectors = req->current_nr_sectors;
510 printk("end_scsi_request: buffer-list destroyed\n");
511 }
512 }
513 }
514 } while(sectors && bh);
515 if (req->bh){
516 req->buffer = bh->b_data;
517 return SCpnt;
518 };
519 DEVICE_OFF(req->rq_dev);
520 if (req->sem != NULL) {
521 up(req->sem);
522 }
523
524 if (SCpnt->host->block) {
525 struct Scsi_Host * next;
526
527 for (next = SCpnt->host->block; next != SCpnt->host;
528 next = next->block)
529 wake_up(&next->host_wait);
530 }
531
532 req->rq_status = RQ_INACTIVE;
533 wake_up(&wait_for_request);
534 wake_up(&SCpnt->device->device_wait);
535 return NULL;
536 }
537
538
539 /* This is just like INIT_REQUEST, but we need to be aware of the fact
540 * that an interrupt may start another request, so we run this with interrupts
541 * turned off
542 */
543 #define INIT_SCSI_REQUEST \
544 if (!CURRENT) { \
545 CLEAR_INTR; \
546 restore_flags(flags); \
547 return; \
548 } \
549 if (MAJOR(CURRENT->rq_dev) != MAJOR_NR) \
550 panic(DEVICE_NAME ": request list destroyed");\
551 if (CURRENT->bh) { \
552 if (!buffer_locked(CURRENT->bh)) \
553 panic(DEVICE_NAME ": block not locked"); \
554 }
555 #endif
556
557 #define SCSI_SLEEP(QUEUE, CONDITION) { \
558 if (CONDITION) { \
559 struct wait_queue wait = { current, NULL}; \
560 add_wait_queue(QUEUE, &wait); \
561 for(;;) { \
562 current->state = TASK_UNINTERRUPTIBLE; \
563 if (CONDITION) { \
564 if (intr_count) \
565 panic("scsi: trying to call schedule() in interrupt" \
566 ", file %s, line %d.\n", __FILE__, __LINE__); \
567 schedule(); \
568 } \
569 else \
570 break; \
571 } \
572 remove_wait_queue(QUEUE, &wait);\
573 current->state = TASK_RUNNING; \
574 }; }
575
576 #endif
577
578 /*
579 * Overrides for Emacs so that we follow Linus's tabbing style.
580 * Emacs will notice this stuff at the end of the file and automatically
581 * adjust the settings for this buffer only. This must remain at the end
582 * of the file.
583 * ---------------------------------------------------------------------------
584 * Local variables:
585 * c-indent-level: 4
586 * c-brace-imaginary-offset: 0
587 * c-brace-offset: -4
588 * c-argdecl-indent: 4
589 * c-label-offset: -4
590 * c-continued-statement-offset: 4
591 * c-continued-brace-offset: 0
592 * indent-tabs-mode: nil
593 * tab-width: 8
594 * End:
595 */
![[last]](../icons/last.png){kind=icon}
![[bottom]](../icons/n_bottom.png){kind=icon}
*/