root/drivers/scsi/scsi.h

/* [previous][next][first][last][top][bottom][index][help] */

INCLUDED FROM


DEFINITIONS

This source file includes following definitions.
  1. end_scsi_request

   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 #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)
     /* [previous][next][first][last][top][bottom][index][help] */
 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  */

/* [previous][next][first][last][top][bottom][index][help] */