home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / scsi / scsi_device.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  13.0 KB  |  360 lines
  1. #ifndef _SCSI_SCSI_DEVICE_H
  2. #define _SCSI_SCSI_DEVICE_H
  3.  
  4. #include <linux/device.h>
  5. #include <linux/list.h>
  6. #include <linux/spinlock.h>
  7. #include <linux/workqueue.h>
  8. #include <asm/atomic.h>
  9.  
  10. struct request_queue;
  11. struct scsi_cmnd;
  12. struct scsi_lun;
  13. struct scsi_sense_hdr;
  14.  
  15. struct scsi_mode_data {
  16.     __u32    length;
  17.     __u16    block_descriptor_length;
  18.     __u8    medium_type;
  19.     __u8    device_specific;
  20.     __u8    header_length;
  21.     __u8    longlba:1;
  22. };
  23.  
  24. /*
  25.  * sdev state: If you alter this, you also need to alter scsi_sysfs.c
  26.  * (for the ascii descriptions) and the state model enforcer:
  27.  * scsi_lib:scsi_device_set_state().
  28.  */
  29. enum scsi_device_state {
  30.     SDEV_CREATED = 1,    /* device created but not added to sysfs
  31.                  * Only internal commands allowed (for inq) */
  32.     SDEV_RUNNING,        /* device properly configured
  33.                  * All commands allowed */
  34.     SDEV_CANCEL,        /* beginning to delete device
  35.                  * Only error handler commands allowed */
  36.     SDEV_DEL,        /* device deleted 
  37.                  * no commands allowed */
  38.     SDEV_QUIESCE,        /* Device quiescent.  No block commands
  39.                  * will be accepted, only specials (which
  40.                  * originate in the mid-layer) */
  41.     SDEV_OFFLINE,        /* Device offlined (by error handling or
  42.                  * user request */
  43.     SDEV_BLOCK,        /* Device blocked by scsi lld.  No scsi 
  44.                  * commands from user or midlayer should be issued
  45.                  * to the scsi lld. */
  46. };
  47.  
  48. struct scsi_device {
  49.     struct Scsi_Host *host;
  50.     struct request_queue *request_queue;
  51.  
  52.     /* the next two are protected by the host->host_lock */
  53.     struct list_head    siblings;   /* list of all devices on this host */
  54.     struct list_head    same_target_siblings; /* just the devices sharing same target id */
  55.  
  56.     /* this is now protected by the request_queue->queue_lock */
  57.     unsigned int device_busy;    /* commands actually active on
  58.                      * low-level. protected by queue_lock. */
  59.     spinlock_t list_lock;
  60.     struct list_head cmd_list;    /* queue of in use SCSI Command structures */
  61.     struct list_head starved_entry;
  62.     struct scsi_cmnd *current_cmnd;    /* currently active command */
  63.     unsigned short queue_depth;    /* How deep of a queue we want */
  64.     unsigned short last_queue_full_depth; /* These two are used by */
  65.     unsigned short last_queue_full_count; /* scsi_track_queue_full() */
  66.     unsigned long last_queue_full_time;/* don't let QUEUE_FULLs on the same
  67.                        jiffie count on our counter, they
  68.                        could all be from the same event. */
  69.  
  70.     unsigned int id, lun, channel;
  71.  
  72.     unsigned int manufacturer;    /* Manufacturer of device, for using 
  73.                      * vendor-specific cmd's */
  74.     unsigned sector_size;    /* size in bytes */
  75.  
  76.     void *hostdata;        /* available to low-level driver */
  77.     char type;
  78.     char scsi_level;
  79.     char inq_periph_qual;    /* PQ from INQUIRY data */    
  80.     unsigned char inquiry_len;    /* valid bytes in 'inquiry' */
  81.     unsigned char * inquiry;    /* INQUIRY response data */
  82.     const char * vendor;        /* [back_compat] point into 'inquiry' ... */
  83.     const char * model;        /* ... after scan; point to static string */
  84.     const char * rev;        /* ... "nullnullnullnull" before scan */
  85.     unsigned char current_tag;    /* current tag */
  86.     struct scsi_target      *sdev_target;   /* used only for single_lun */
  87.  
  88.     unsigned int    sdev_bflags; /* black/white flags as also found in
  89.                  * scsi_devinfo.[hc]. For now used only to
  90.                  * pass settings from slave_alloc to scsi
  91.                  * core. */
  92.     unsigned writeable:1;
  93.     unsigned removable:1;
  94.     unsigned changed:1;    /* Data invalid due to media change */
  95.     unsigned busy:1;    /* Used to prevent races */
  96.     unsigned lockable:1;    /* Able to prevent media removal */
  97.     unsigned locked:1;      /* Media removal disabled */
  98.     unsigned borken:1;    /* Tell the Seagate driver to be 
  99.                  * painfully slow on this device */
  100.     unsigned disconnect:1;    /* can disconnect */
  101.     unsigned soft_reset:1;    /* Uses soft reset option */
  102.     unsigned sdtr:1;    /* Device supports SDTR messages */
  103.     unsigned wdtr:1;    /* Device supports WDTR messages */
  104.     unsigned ppr:1;        /* Device supports PPR messages */
  105.     unsigned tagged_supported:1;    /* Supports SCSI-II tagged queuing */
  106.     unsigned simple_tags:1;    /* simple queue tag messages are enabled */
  107.     unsigned ordered_tags:1;/* ordered queue tag messages are enabled */
  108.     unsigned single_lun:1;    /* Indicates we should only allow I/O to
  109.                  * one of the luns for the device at a 
  110.                  * time. */
  111.     unsigned was_reset:1;    /* There was a bus reset on the bus for 
  112.                  * this device */
  113.     unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
  114.                      * because we did a bus reset. */
  115.     unsigned use_10_for_rw:1; /* first try 10-byte read / write */
  116.     unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
  117.     unsigned skip_ms_page_8:1;    /* do not use MODE SENSE page 0x08 */
  118.     unsigned skip_ms_page_3f:1;    /* do not use MODE SENSE page 0x3f */
  119.     unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
  120.     unsigned no_start_on_add:1;    /* do not issue start on add */
  121.     unsigned allow_restart:1; /* issue START_UNIT in error handler */
  122.     unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
  123.     unsigned select_no_atn:1;
  124.     unsigned fix_capacity:1;    /* READ_CAPACITY is too high by 1 */
  125.     unsigned retry_hwerror:1;    /* Retry HARDWARE_ERROR */
  126.  
  127.     unsigned int device_blocked;    /* Device returned QUEUE_FULL. */
  128.  
  129.     unsigned int max_device_blocked; /* what device_blocked counts down from  */
  130. #define SCSI_DEFAULT_DEVICE_BLOCKED    3
  131.  
  132.     atomic_t iorequest_cnt;
  133.     atomic_t iodone_cnt;
  134.     atomic_t ioerr_cnt;
  135.  
  136.     int timeout;
  137.  
  138.     struct device        sdev_gendev;
  139.     struct class_device    sdev_classdev;
  140.  
  141.     struct execute_work    ew; /* used to get process context on put */
  142.  
  143.     enum scsi_device_state sdev_state;
  144.     unsigned long        sdev_data[0];
  145. } __attribute__((aligned(sizeof(unsigned long))));
  146. #define    to_scsi_device(d)    \
  147.     container_of(d, struct scsi_device, sdev_gendev)
  148. #define    class_to_sdev(d)    \
  149.     container_of(d, struct scsi_device, sdev_classdev)
  150. #define transport_class_to_sdev(class_dev) \
  151.     to_scsi_device(class_dev->dev)
  152.  
  153. #define sdev_printk(prefix, sdev, fmt, a...)    \
  154.     dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
  155.  
  156. #define scmd_printk(prefix, scmd, fmt, a...)    \
  157.     dev_printk(prefix, &(scmd)->device->sdev_gendev, fmt, ##a)
  158.  
  159. enum scsi_target_state {
  160.     STARGET_RUNNING = 1,
  161.     STARGET_DEL,
  162. };
  163.  
  164. /*
  165.  * scsi_target: representation of a scsi target, for now, this is only
  166.  * used for single_lun devices. If no one has active IO to the target,
  167.  * starget_sdev_user is NULL, else it points to the active sdev.
  168.  */
  169. struct scsi_target {
  170.     struct scsi_device    *starget_sdev_user;
  171.     struct list_head    siblings;
  172.     struct list_head    devices;
  173.     struct device        dev;
  174.     unsigned int        reap_ref; /* protected by the host lock */
  175.     unsigned int        channel;
  176.     unsigned int        id; /* target id ... replace
  177.                      * scsi_device.id eventually */
  178.     unsigned int        create:1; /* signal that it needs to be added */
  179.     unsigned int        pdt_1f_for_no_lun;    /* PDT = 0x1f */
  180.                         /* means no lun present */
  181.  
  182.     char            scsi_level;
  183.     struct execute_work    ew;
  184.     enum scsi_target_state    state;
  185.     void             *hostdata; /* available to low-level driver */
  186.     unsigned long        starget_data[0]; /* for the transport */
  187.     /* starget_data must be the last element!!!! */
  188. } __attribute__((aligned(sizeof(unsigned long))));
  189.  
  190. #define to_scsi_target(d)    container_of(d, struct scsi_target, dev)
  191. static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
  192. {
  193.     return to_scsi_target(sdev->sdev_gendev.parent);
  194. }
  195. #define transport_class_to_starget(class_dev) \
  196.     to_scsi_target(class_dev->dev)
  197.  
  198. #define starget_printk(prefix, starget, fmt, a...)    \
  199.     dev_printk(prefix, &(starget)->dev, fmt, ##a)
  200.  
  201. extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
  202.         uint, uint, uint, void *hostdata);
  203. extern int scsi_add_device(struct Scsi_Host *host, uint channel,
  204.                uint target, uint lun);
  205. extern void scsi_remove_device(struct scsi_device *);
  206. extern int scsi_device_cancel(struct scsi_device *, int);
  207.  
  208. extern int scsi_device_get(struct scsi_device *);
  209. extern void scsi_device_put(struct scsi_device *);
  210. extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
  211.                           uint, uint, uint);
  212. extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
  213.                         uint, uint, uint);
  214. extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
  215.                             uint);
  216. extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
  217.                               uint);
  218. extern void starget_for_each_device(struct scsi_target *, void *,
  219.              void (*fn)(struct scsi_device *, void *));
  220.  
  221. /* only exposed to implement shost_for_each_device */
  222. extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
  223.                           struct scsi_device *);
  224.  
  225. /**
  226.  * shost_for_each_device  -  iterate over all devices of a host
  227.  * @sdev:    iterator
  228.  * @host:    host whiches devices we want to iterate over
  229.  *
  230.  * This traverses over each devices of @shost.  The devices have
  231.  * a reference that must be released by scsi_host_put when breaking
  232.  * out of the loop.
  233.  */
  234. #define shost_for_each_device(sdev, shost) \
  235.     for ((sdev) = __scsi_iterate_devices((shost), NULL); \
  236.          (sdev); \
  237.          (sdev) = __scsi_iterate_devices((shost), (sdev)))
  238.  
  239. /**
  240.  * __shost_for_each_device  -  iterate over all devices of a host (UNLOCKED)
  241.  * @sdev:    iterator
  242.  * @host:    host whiches devices we want to iterate over
  243.  *
  244.  * This traverses over each devices of @shost.  It does _not_ take a
  245.  * reference on the scsi_device, thus it the whole loop must be protected
  246.  * by shost->host_lock.
  247.  *
  248.  * Note:  The only reason why drivers would want to use this is because
  249.  * they're need to access the device list in irq context.  Otherwise you
  250.  * really want to use shost_for_each_device instead.
  251.  */
  252. #define __shost_for_each_device(sdev, shost) \
  253.     list_for_each_entry((sdev), &((shost)->__devices), siblings)
  254.  
  255. extern void scsi_adjust_queue_depth(struct scsi_device *, int, int);
  256. extern int scsi_track_queue_full(struct scsi_device *, int);
  257.  
  258. extern int scsi_set_medium_removal(struct scsi_device *, char);
  259.  
  260. extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
  261.                unsigned char *buffer, int len, int timeout,
  262.                int retries, struct scsi_mode_data *data,
  263.                struct scsi_sense_hdr *);
  264. extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
  265.                 int modepage, unsigned char *buffer, int len,
  266.                 int timeout, int retries,
  267.                 struct scsi_mode_data *data,
  268.                 struct scsi_sense_hdr *);
  269. extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
  270.                 int retries);
  271. extern int scsi_device_set_state(struct scsi_device *sdev,
  272.                  enum scsi_device_state state);
  273. extern int scsi_device_quiesce(struct scsi_device *sdev);
  274. extern void scsi_device_resume(struct scsi_device *sdev);
  275. extern void scsi_target_quiesce(struct scsi_target *);
  276. extern void scsi_target_resume(struct scsi_target *);
  277. extern void scsi_scan_target(struct device *parent, unsigned int channel,
  278.                  unsigned int id, unsigned int lun, int rescan);
  279. extern void scsi_target_reap(struct scsi_target *);
  280. extern void scsi_target_block(struct device *);
  281. extern void scsi_target_unblock(struct device *);
  282. extern void scsi_remove_target(struct device *);
  283. extern void int_to_scsilun(unsigned int, struct scsi_lun *);
  284. extern const char *scsi_device_state_name(enum scsi_device_state);
  285. extern int scsi_is_sdev_device(const struct device *);
  286. extern int scsi_is_target_device(const struct device *);
  287. extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
  288.             int data_direction, void *buffer, unsigned bufflen,
  289.             unsigned char *sense, int timeout, int retries,
  290.             int flag);
  291. extern int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
  292.                 int data_direction, void *buffer, unsigned bufflen,
  293.                 struct scsi_sense_hdr *, int timeout, int retries);
  294. extern int scsi_execute_async(struct scsi_device *sdev,
  295.                   const unsigned char *cmd, int cmd_len, int data_direction,
  296.                   void *buffer, unsigned bufflen, int use_sg,
  297.                   int timeout, int retries, void *privdata,
  298.                   void (*done)(void *, char *, int, int),
  299.                   gfp_t gfp);
  300.  
  301. struct async_scan_data;
  302. struct async_scan_data * scsi_prep_async_scan(struct Scsi_Host *shost);
  303. void scsi_finish_async_scan(struct async_scan_data *data);
  304.  
  305. static inline void scsi_device_reprobe(struct scsi_device *sdev)
  306. {
  307.     device_reprobe(&sdev->sdev_gendev);
  308. }
  309.  
  310. static inline unsigned int sdev_channel(struct scsi_device *sdev)
  311. {
  312.     return sdev->channel;
  313. }
  314.  
  315. static inline unsigned int sdev_id(struct scsi_device *sdev)
  316. {
  317.     return sdev->id;
  318. }
  319.  
  320. #define scmd_id(scmd) sdev_id((scmd)->device)
  321. #define scmd_channel(scmd) sdev_channel((scmd)->device)
  322.  
  323. static inline int scsi_device_online(struct scsi_device *sdev)
  324. {
  325.     return sdev->sdev_state != SDEV_OFFLINE;
  326. }
  327.  
  328. /* accessor functions for the SCSI parameters */
  329. static inline int scsi_device_sync(struct scsi_device *sdev)
  330. {
  331.     return sdev->sdtr;
  332. }
  333. static inline int scsi_device_wide(struct scsi_device *sdev)
  334. {
  335.     return sdev->wdtr;
  336. }
  337. static inline int scsi_device_dt(struct scsi_device *sdev)
  338. {
  339.     return sdev->ppr;
  340. }
  341. static inline int scsi_device_dt_only(struct scsi_device *sdev)
  342. {
  343.     if (sdev->inquiry_len < 57)
  344.         return 0;
  345.     return (sdev->inquiry[56] & 0x0c) == 0x04;
  346. }
  347. static inline int scsi_device_ius(struct scsi_device *sdev)
  348. {
  349.     if (sdev->inquiry_len < 57)
  350.         return 0;
  351.     return sdev->inquiry[56] & 0x01;
  352. }
  353. static inline int scsi_device_qas(struct scsi_device *sdev)
  354. {
  355.     if (sdev->inquiry_len < 57)
  356.         return 0;
  357.     return sdev->inquiry[56] & 0x02;
  358. }
  359. #endif /* _SCSI_SCSI_DEVICE_H */
  360.