![[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 movedd 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 void *hostdata; /* available to low-level driver */
167 char type;
168 char scsi_level;
169 char vendor[8], model[16], rev[4];
170 unsigned char current_tag; /* current tag */
171 unsigned char sync_min_period; /* Not less than this period */
172 unsigned char sync_max_offset; /* Not greater than this offset */
173
174 unsigned writeable:1;
175 unsigned removable:1;
176 unsigned random:1;
177 unsigned has_cmdblocks:1;
178 unsigned changed:1; /* Data invalid due to media change */
179 unsigned busy:1; /* Used to prevent races */
180 unsigned lockable:1; /* Able to prevent media removal */
181 unsigned borken:1; /* Tell the Seagate driver to be
182 * painfully slow on this device */
183 unsigned tagged_supported:1; /* Supports SCSI-II tagged queuing */
184 unsigned tagged_queue:1; /* SCSI-II tagged queuing enabled */
185 unsigned disconnect:1; /* can disconnect */
186 unsigned soft_reset:1; /* Uses soft reset option */
187 unsigned sync:1; /* Negotiate for sync transfers */
188 unsigned single_lun:1; /* Indicates we should only allow I/O to
189 one of the luns for the device at a time. */
190 unsigned was_reset:1; /* There was a bus reset on the bus for this
191 device */
192 unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
193 because we did a bus reset. */
194 } Scsi_Device;
195
196 /*
197 * Use these to separate status msg and our bytes
198 */
199
200 #define status_byte(result) (((result) >> 1) & 0xf)
201 #define msg_byte(result) (((result) >> 8) & 0xff)
202 #define host_byte(result) (((result) >> 16) & 0xff)
203 #define driver_byte(result) (((result) >> 24) & 0xff)
204 #define suggestion(result) (driver_byte(result) & SUGGEST_MASK)
205
206 #define sense_class(sense) (((sense) >> 4) & 0x7)
207 #define sense_error(sense) ((sense) & 0xf)
208 #define sense_valid(sense) ((sense) & 0x80);
209
210 /*
211 * These are the SCSI devices available on the system.
212 */
213
214 extern Scsi_Device * scsi_devices;
215
216 /*
217 * Initializes all SCSI devices. This scans all scsi busses.
218 */
219
220 extern int scsi_dev_init (void);
221
222 struct scatterlist {
223 char * address; /* Location data is to be transferred to */
224 char * alt_address; /* Location of actual if address is a
225 * dma indirect buffer. NULL otherwise */
226 unsigned int length;
227 };
228
229 #ifdef __alpha__
230 # define ISA_DMA_THRESHOLD (~0UL)
231 #else
232 # define ISA_DMA_THRESHOLD (0x00ffffff)
233 #endif
234 #define CONTIGUOUS_BUFFERS(X,Y) ((X->b_data+X->b_size) == Y->b_data)
235
236
237 /*
238 * These are the return codes for the abort and reset functions. The mid-level
239 * code uses these to decide what to do next. Each of the low level abort
240 * and reset functions must correctly indicate what it has done.
241 * The descriptions are written from the point of view of the mid-level code,
242 * so that the return code is telling the mid-level drivers exactly what
243 * the low level driver has already done, and what remains to be done.
244 */
245
246 /* We did not do anything.
247 * Wait some more for this command to complete, and if this does not work,
248 * try something more serious. */
249 #define SCSI_ABORT_SNOOZE 0
250
251 /* This means that we were able to abort the command. We have already
252 * called the mid-level done function, and do not expect an interrupt that
253 * will lead to another call to the mid-level done function for this command */
254 #define SCSI_ABORT_SUCCESS 1
255
256 /* We called for an abort of this command, and we should get an interrupt
257 * when this succeeds. Thus we should not restore the timer for this
258 * command in the mid-level abort function. */
259 #define SCSI_ABORT_PENDING 2
260
261 /* Unable to abort - command is currently on the bus. Grin and bear it. */
262 #define SCSI_ABORT_BUSY 3
263
264 /* The command is not active in the low level code. Command probably
265 * finished. */
266 #define SCSI_ABORT_NOT_RUNNING 4
267
268 /* Something went wrong. The low level driver will indicate the correct
269 * error condition when it calls scsi_done, so the mid-level abort function
270 * can simply wait until this comes through */
271 #define SCSI_ABORT_ERROR 5
272
273 /* We do not know how to reset the bus, or we do not want to. Bummer.
274 * Anyway, just wait a little more for the command in question, and hope that
275 * it eventually finishes. If it never finishes, the SCSI device could
276 * hang, so use this with caution. */
277 #define SCSI_RESET_SNOOZE 0
278
279 /* We do not know how to reset the bus, or we do not want to. Bummer.
280 * We have given up on this ever completing. The mid-level code will
281 * request sense information to decide how to proceed from here. */
282 #define SCSI_RESET_PUNT 1
283
284 /* This means that we were able to reset the bus. We have restarted all of
285 * the commands that should be restarted, and we should be able to continue
286 * on normally from here. We do not expect any interrupts that will return
287 * DID_RESET to any of the other commands in the host_queue, and the mid-level
288 * code does not need to do anything special to keep the commands alive.
289 * If a hard reset was performed then all outstanding commands on the
290 * bus have been restarted. */
291 #define SCSI_RESET_SUCCESS 2
292
293 /* We called for a reset of this bus, and we should get an interrupt
294 * when this succeeds. Each command should get its own status
295 * passed up to scsi_done, but this has not happened yet.
296 * If a hard reset was performed, then we expect an interrupt
297 * for *each* of the outstanding commands that will have the
298 * effect of restarting the commands.
299 */
300 #define SCSI_RESET_PENDING 3
301
302 /* We did a reset, but do not expect an interrupt to signal DID_RESET.
303 * This tells the upper level code to request the sense info, and this
304 * should keep the command alive. */
305 #define SCSI_RESET_WAKEUP 4
306
307 /* Something went wrong, and we do not know how to fix it. */
308 #define SCSI_RESET_ERROR 5
309
310 /*
311 * This is a bitmask that is ored with one of the above codes.
312 * It tells the mid-level code that we did a hard reset.
313 */
314 #define SCSI_RESET_BUS_RESET 0x100
315 /*
316 * Used to mask off bits and to obtain the basic action that was
317 * performed.
318 */
319 #define SCSI_RESET_ACTION 0xff
320
321 void * scsi_malloc(unsigned int);
322 int scsi_free(void *, unsigned int);
323 extern unsigned int dma_free_sectors; /* How much room do we have left */
324 extern unsigned int need_isa_buffer; /* True if some devices need indirection
325 * buffers */
326
327 /*
328 * The Scsi_Cmnd structure is used by scsi.c internally, and for communication
329 * with low level drivers that support multiple outstanding commands.
330 */
331 typedef struct scsi_pointer {
332 char * ptr; /* data pointer */
333 int this_residual; /* left in this buffer */
334 struct scatterlist *buffer; /* which buffer */
335 int buffers_residual; /* how many buffers left */
336
337 volatile int Status;
338 volatile int Message;
339 volatile int have_data_in;
340 volatile int sent_command;
341 volatile int phase;
342 } Scsi_Pointer;
343
344 typedef struct scsi_cmnd {
345 struct Scsi_Host * host;
346 Scsi_Device * device;
347 unsigned char target, lun, channel;
348 unsigned char cmd_len;
349 unsigned char old_cmd_len;
350 struct scsi_cmnd *next, *prev;
351
352 /* These elements define the operation we are about to perform */
353 unsigned char cmnd[12];
354 unsigned request_bufflen; /* Actual request size */
355
356 void * request_buffer; /* Actual requested buffer */
357
358 /* These elements define the operation we ultimately want to perform */
359 unsigned char data_cmnd[12];
360 unsigned short old_use_sg; /* We save use_sg here when requesting
361 * sense info */
362 unsigned short use_sg; /* Number of pieces of scatter-gather */
363 unsigned short sglist_len; /* size of malloc'd scatter-gather list */
364 unsigned short abort_reason;/* If the mid-level code requests an
365 * abort, this is the reason. */
366 unsigned bufflen; /* Size of data buffer */
367 void *buffer; /* Data buffer */
368
369 unsigned underflow; /* Return error if less than this amount is
370 * transfered */
371
372 unsigned transfersize; /* How much we are guaranteed to transfer with
373 * each SCSI transfer (ie, between disconnect /
374 * reconnects. Probably == sector size */
375
376
377 struct request request; /* A copy of the command we are working on */
378
379 unsigned char sense_buffer[16]; /* Sense for this command, if needed */
380
381
382 int retries;
383 int allowed;
384 int timeout_per_command, timeout_total, timeout;
385
386 /*
387 * We handle the timeout differently if it happens when a reset,
388 * abort, etc are in process.
389 */
390 unsigned volatile char internal_timeout;
391
392 unsigned flags;
393
394 /* These variables are for the cdrom only. Once we have variable size
395 * buffers in the buffer cache, they will go away. */
396 int this_count;
397 /* End of special cdrom variables */
398
399 /* Low-level done function - can be used by low-level driver to point
400 * to completion function. Not used by mid/upper level code. */
401 void (*scsi_done)(struct scsi_cmnd *);
402 void (*done)(struct scsi_cmnd *); /* Mid-level done function */
403
404 /*
405 * The following fields can be written to by the host specific code.
406 * Everything else should be left alone.
407 */
408
409 Scsi_Pointer SCp; /* Scratchpad used by some host adapters */
410
411 unsigned char * host_scribble; /* The host adapter is allowed to
412 * call scsi_malloc and get some memory
413 * and hang it here. The host adapter
414 * is also expected to call scsi_free
415 * to release this memory. (The memory
416 * obtained by scsi_malloc is guaranteed
417 * to be at an address < 16Mb). */
418
419 int result; /* Status code from lower level driver */
420
421 unsigned char tag; /* SCSI-II queued command tag */
422 unsigned long pid; /* Process ID, starts at 0 */
423 } Scsi_Cmnd;
424
425 /*
426 * scsi_abort aborts the current command that is executing on host host.
427 * The error code, if non zero is returned in the host byte, otherwise
428 * DID_ABORT is returned in the hostbyte.
429 */
430
431 extern int scsi_abort (Scsi_Cmnd *, int code, int pid);
432
433 extern void scsi_do_cmd (Scsi_Cmnd *, const void *cmnd ,
434 void *buffer, unsigned bufflen,
435 void (*done)(struct scsi_cmnd *),
436 int timeout, int retries);
437
438
439 extern Scsi_Cmnd * allocate_device(struct request **, Scsi_Device *, int);
440
441 extern Scsi_Cmnd * request_queueable(struct request *, Scsi_Device *);
442 extern int scsi_reset (Scsi_Cmnd *, int);
443
444 extern int max_scsi_hosts;
445
446 extern void proc_print_scsidevice(Scsi_Device *, char *, int *, int);
447
448 extern void print_command(unsigned char *);
449 extern void print_sense(const char *, Scsi_Cmnd *);
450 extern void print_driverbyte(int scsiresult);
451 extern void print_hostbyte(int scsiresult);
452
453 extern void scsi_mark_host_bus_reset(struct Scsi_Host *Host);
454
455 #if defined(MAJOR_NR) && (MAJOR_NR != SCSI_TAPE_MAJOR)
456 #include "hosts.h"
457
458 static Scsi_Cmnd * end_scsi_request(Scsi_Cmnd * SCpnt, int uptodate, int sectors)
/* ![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
459 {
460 struct request * req;
461 struct buffer_head * bh;
462
463 req = &SCpnt->request;
464 req->errors = 0;
465 if (!uptodate) {
466 printk(DEVICE_NAME " I/O error: dev %s, sector %lu\n",
467 kdevname(req->rq_dev), req->sector);
468 }
469
470 do {
471 if ((bh = req->bh) != NULL) {
472 req->bh = bh->b_reqnext;
473 req->nr_sectors -= bh->b_size >> 9;
474 req->sector += bh->b_size >> 9;
475 bh->b_reqnext = NULL;
476 mark_buffer_uptodate(bh, uptodate);
477 unlock_buffer(bh);
478 sectors -= bh->b_size >> 9;
479 if ((bh = req->bh) != NULL) {
480 req->current_nr_sectors = bh->b_size >> 9;
481 if (req->nr_sectors < req->current_nr_sectors) {
482 req->nr_sectors = req->current_nr_sectors;
483 printk("end_scsi_request: buffer-list destroyed\n");
484 }
485 }
486 }
487 } while(sectors && bh);
488 if (req->bh){
489 req->buffer = bh->b_data;
490 return SCpnt;
491 };
492 DEVICE_OFF(req->rq_dev);
493 if (req->sem != NULL) {
494 up(req->sem);
495 }
496
497 if (SCpnt->host->block) {
498 struct Scsi_Host * next;
499
500 for (next = SCpnt->host->block; next != SCpnt->host;
501 next = next->block)
502 wake_up(&next->host_wait);
503 }
504
505 req->rq_status = RQ_INACTIVE;
506 wake_up(&wait_for_request);
507 wake_up(&SCpnt->device->device_wait);
508 return NULL;
509 }
510
511
512 /* This is just like INIT_REQUEST, but we need to be aware of the fact
513 * that an interrupt may start another request, so we run this with interrupts
514 * turned off
515 */
516 #define INIT_SCSI_REQUEST \
517 if (!CURRENT) { \
518 CLEAR_INTR; \
519 restore_flags(flags); \
520 return; \
521 } \
522 if (MAJOR(CURRENT->rq_dev) != MAJOR_NR) \
523 panic(DEVICE_NAME ": request list destroyed");\
524 if (CURRENT->bh) { \
525 if (!buffer_locked(CURRENT->bh)) \
526 panic(DEVICE_NAME ": block not locked"); \
527 }
528 #endif
529
530 #define SCSI_SLEEP(QUEUE, CONDITION) { \
531 if (CONDITION) { \
532 struct wait_queue wait = { current, NULL}; \
533 add_wait_queue(QUEUE, &wait); \
534 for(;;) { \
535 current->state = TASK_UNINTERRUPTIBLE; \
536 if (CONDITION) { \
537 if (intr_count) \
538 panic("scsi: trying to call schedule() in interrupt" \
539 ", file %s, line %d.\n", __FILE__, __LINE__); \
540 schedule(); \
541 } \
542 else \
543 break; \
544 } \
545 remove_wait_queue(QUEUE, &wait);\
546 current->state = TASK_RUNNING; \
547 }; }
548
549 #endif
550
551 /*
552 * Overrides for Emacs so that we follow Linus's tabbing style.
553 * Emacs will notice this stuff at the end of the file and automatically
554 * adjust the settings for this buffer only. This must remain at the end
555 * of the file.
556 * ---------------------------------------------------------------------------
557 * Local variables:
558 * c-indent-level: 4
559 * c-brace-imaginary-offset: 0
560 * c-brace-offset: -4
561 * c-argdecl-indent: 4
562 * c-label-offset: -4
563 * c-continued-statement-offset: 4
564 * c-continued-brace-offset: 0
565 * indent-tabs-mode: nil
566 * tab-width: 8
567 * End:
568 */
![[last]](../icons/last.png){kind=icon}
![[bottom]](../icons/n_bottom.png){kind=icon}
*/