![[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 <scsi/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 #define SCSI_RESET_SUGGEST_HOST_RESET 0x08
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 * This is a bitmask that is ored with one of the above codes.
328 * It tells the mid-level code that we did a host adapter reset.
329 */
330 #define SCSI_RESET_HOST_RESET 0x200
331 /*
332 * Used to mask off bits and to obtain the basic action that was
333 * performed.
334 */
335 #define SCSI_RESET_ACTION 0xff
336
337 void * scsi_malloc(unsigned int);
338 int scsi_free(void *, unsigned int);
339 extern unsigned int dma_free_sectors; /* How much room do we have left */
340 extern unsigned int need_isa_buffer; /* True if some devices need indirection
341 * buffers */
342
343 /*
344 * The Scsi_Cmnd structure is used by scsi.c internally, and for communication
345 * with low level drivers that support multiple outstanding commands.
346 */
347 typedef struct scsi_pointer {
348 char * ptr; /* data pointer */
349 int this_residual; /* left in this buffer */
350 struct scatterlist *buffer; /* which buffer */
351 int buffers_residual; /* how many buffers left */
352
353 volatile int Status;
354 volatile int Message;
355 volatile int have_data_in;
356 volatile int sent_command;
357 volatile int phase;
358 } Scsi_Pointer;
359
360 typedef struct scsi_cmnd {
361 struct Scsi_Host * host;
362 Scsi_Device * device;
363 unsigned char target, lun, channel;
364 unsigned char cmd_len;
365 unsigned char old_cmd_len;
366 struct scsi_cmnd *next, *prev, *device_next, *reset_chain;
367
368 /* These elements define the operation we are about to perform */
369 unsigned char cmnd[12];
370 unsigned request_bufflen; /* Actual request size */
371
372 void * request_buffer; /* Actual requested buffer */
373
374 /* These elements define the operation we ultimately want to perform */
375 unsigned char data_cmnd[12];
376 unsigned short old_use_sg; /* We save use_sg here when requesting
377 * sense info */
378 unsigned short use_sg; /* Number of pieces of scatter-gather */
379 unsigned short sglist_len; /* size of malloc'd scatter-gather list */
380 unsigned short abort_reason;/* If the mid-level code requests an
381 * abort, this is the reason. */
382 unsigned bufflen; /* Size of data buffer */
383 void *buffer; /* Data buffer */
384
385 unsigned underflow; /* Return error if less than this amount is
386 * transfered */
387
388 unsigned transfersize; /* How much we are guaranteed to transfer with
389 * each SCSI transfer (ie, between disconnect /
390 * reconnects. Probably == sector size */
391
392
393 struct request request; /* A copy of the command we are working on */
394
395 unsigned char sense_buffer[16]; /* Sense for this command, if needed */
396
397 /*
398 A SCSI Command is assigned a nonzero serial_number when internal_cmnd
399 passes it to the driver's queue command function. The serial_number
400 is cleared when scsi_done is entered indicating that the command has
401 been completed. If a timeout occurs, the serial number at the moment
402 of timeout is copied into serial_number_at_timeout. By subsequently
403 comparing the serial_number and serial_number_at_timeout fields
404 during abort or reset processing, we can detect whether the command
405 has already completed. This also detects cases where the command has
406 completed and the SCSI Command structure has already being reused
407 for another command, so that we can avoid incorrectly aborting or
408 resetting the new command.
409 */
410
411 unsigned long serial_number;
412 unsigned long serial_number_at_timeout;
413
414 int retries;
415 int allowed;
416 int timeout_per_command, timeout_total, timeout;
417
418 /*
419 * We handle the timeout differently if it happens when a reset,
420 * abort, etc are in process.
421 */
422 unsigned volatile char internal_timeout;
423
424 unsigned flags;
425
426 /* These variables are for the cdrom only. Once we have variable size
427 * buffers in the buffer cache, they will go away. */
428 int this_count;
429 /* End of special cdrom variables */
430
431 /* Low-level done function - can be used by low-level driver to point
432 * to completion function. Not used by mid/upper level code. */
433 void (*scsi_done)(struct scsi_cmnd *);
434 void (*done)(struct scsi_cmnd *); /* Mid-level done function */
435
436 /*
437 * The following fields can be written to by the host specific code.
438 * Everything else should be left alone.
439 */
440
441 Scsi_Pointer SCp; /* Scratchpad used by some host adapters */
442
443 unsigned char * host_scribble; /* The host adapter is allowed to
444 * call scsi_malloc and get some memory
445 * and hang it here. The host adapter
446 * is also expected to call scsi_free
447 * to release this memory. (The memory
448 * obtained by scsi_malloc is guaranteed
449 * to be at an address < 16Mb). */
450
451 int result; /* Status code from lower level driver */
452
453 unsigned char tag; /* SCSI-II queued command tag */
454 unsigned long pid; /* Process ID, starts at 0 */
455 } Scsi_Cmnd;
456
457 /*
458 * scsi_abort aborts the current command that is executing on host host.
459 * The error code, if non zero is returned in the host byte, otherwise
460 * DID_ABORT is returned in the hostbyte.
461 */
462
463 extern int scsi_abort (Scsi_Cmnd *, int code);
464
465 extern void scsi_do_cmd (Scsi_Cmnd *, const void *cmnd ,
466 void *buffer, unsigned bufflen,
467 void (*done)(struct scsi_cmnd *),
468 int timeout, int retries);
469
470
471 extern Scsi_Cmnd * allocate_device(struct request **, Scsi_Device *, int);
472
473 extern Scsi_Cmnd * request_queueable(struct request *, Scsi_Device *);
474 extern int scsi_reset (Scsi_Cmnd *, unsigned int);
475
476 extern int max_scsi_hosts;
477
478 extern void proc_print_scsidevice(Scsi_Device *, char *, int *, int);
479
480 extern void print_command(unsigned char *);
481 extern void print_sense(const char *, Scsi_Cmnd *);
482 extern void print_driverbyte(int scsiresult);
483 extern void print_hostbyte(int scsiresult);
484
485 extern void scsi_mark_host_reset(struct Scsi_Host *Host);
486 extern void scsi_mark_bus_reset(struct Scsi_Host *Host, int channel);
487
488 #if defined(MAJOR_NR) && (MAJOR_NR != SCSI_TAPE_MAJOR)
489 #include "hosts.h"
490
491 static Scsi_Cmnd * end_scsi_request(Scsi_Cmnd * SCpnt, int uptodate, int sectors)
/* ![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
492 {
493 struct request * req;
494 struct buffer_head * bh;
495
496 req = &SCpnt->request;
497 req->errors = 0;
498 if (!uptodate) {
499 printk(DEVICE_NAME " I/O error: dev %s, sector %lu\n",
500 kdevname(req->rq_dev), req->sector);
501 }
502
503 do {
504 if ((bh = req->bh) != NULL) {
505 req->bh = bh->b_reqnext;
506 req->nr_sectors -= bh->b_size >> 9;
507 req->sector += bh->b_size >> 9;
508 bh->b_reqnext = NULL;
509 mark_buffer_uptodate(bh, uptodate);
510 unlock_buffer(bh);
511 sectors -= bh->b_size >> 9;
512 if ((bh = req->bh) != NULL) {
513 req->current_nr_sectors = bh->b_size >> 9;
514 if (req->nr_sectors < req->current_nr_sectors) {
515 req->nr_sectors = req->current_nr_sectors;
516 printk("end_scsi_request: buffer-list destroyed\n");
517 }
518 }
519 }
520 } while(sectors && bh);
521 if (req->bh){
522 req->buffer = bh->b_data;
523 return SCpnt;
524 };
525 DEVICE_OFF(req->rq_dev);
526 if (req->sem != NULL) {
527 up(req->sem);
528 }
529
530 if (SCpnt->host->block) {
531 struct Scsi_Host * next;
532
533 for (next = SCpnt->host->block; next != SCpnt->host;
534 next = next->block)
535 wake_up(&next->host_wait);
536 }
537
538 req->rq_status = RQ_INACTIVE;
539 wake_up(&wait_for_request);
540 wake_up(&SCpnt->device->device_wait);
541 return NULL;
542 }
543
544
545 /* This is just like INIT_REQUEST, but we need to be aware of the fact
546 * that an interrupt may start another request, so we run this with interrupts
547 * turned off
548 */
549 #define INIT_SCSI_REQUEST \
550 if (!CURRENT) { \
551 CLEAR_INTR; \
552 restore_flags(flags); \
553 return; \
554 } \
555 if (MAJOR(CURRENT->rq_dev) != MAJOR_NR) \
556 panic(DEVICE_NAME ": request list destroyed");\
557 if (CURRENT->bh) { \
558 if (!buffer_locked(CURRENT->bh)) \
559 panic(DEVICE_NAME ": block not locked"); \
560 }
561 #endif
562
563 #define SCSI_SLEEP(QUEUE, CONDITION) { \
564 if (CONDITION) { \
565 struct wait_queue wait = { current, NULL}; \
566 add_wait_queue(QUEUE, &wait); \
567 for(;;) { \
568 current->state = TASK_UNINTERRUPTIBLE; \
569 if (CONDITION) { \
570 if (intr_count) \
571 panic("scsi: trying to call schedule() in interrupt" \
572 ", file %s, line %d.\n", __FILE__, __LINE__); \
573 schedule(); \
574 } \
575 else \
576 break; \
577 } \
578 remove_wait_queue(QUEUE, &wait);\
579 current->state = TASK_RUNNING; \
580 }; }
581
582 #endif
583
584 /*
585 * Overrides for Emacs so that we follow Linus's tabbing style.
586 * Emacs will notice this stuff at the end of the file and automatically
587 * adjust the settings for this buffer only. This must remain at the end
588 * of the file.
589 * ---------------------------------------------------------------------------
590 * Local variables:
591 * c-indent-level: 4
592 * c-brace-imaginary-offset: 0
593 * c-brace-offset: -4
594 * c-argdecl-indent: 4
595 * c-label-offset: -4
596 * c-continued-statement-offset: 4
597 * c-continued-brace-offset: 0
598 * indent-tabs-mode: nil
599 * tab-width: 8
600 * End:
601 */
![[last]](../icons/last.png){kind=icon}
![[bottom]](../icons/n_bottom.png){kind=icon}
*/