LCOV - code coverage report
Current view: top level - lkbce/include/scsi - scsi_cmnd.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 9 33.3 %
Date: 2017-01-25 Functions: 0 5 0.0 %

          Line data    Source code
       1             : #ifndef _SCSI_SCSI_CMND_H
       2             : #define _SCSI_SCSI_CMND_H
       3             : 
       4             : #include <linux/dma-mapping.h>
       5             : #include <linux/blkdev.h>
       6             : #include <linux/list.h>
       7             : #include <linux/types.h>
       8             : #include <linux/timer.h>
       9             : #include <linux/scatterlist.h>
      10             : 
      11             : struct Scsi_Host;
      12             : struct scsi_device;
      13             : 
      14             : /*
      15             :  * MAX_COMMAND_SIZE is:
      16             :  * The longest fixed-length SCSI CDB as per the SCSI standard.
      17             :  * fixed-length means: commands that their size can be determined
      18             :  * by their opcode and the CDB does not carry a length specifier, (unlike
      19             :  * the VARIABLE_LENGTH_CMD(0x7f) command). This is actually not exactly
      20             :  * true and the SCSI standard also defines extended commands and
      21             :  * vendor specific commands that can be bigger than 16 bytes. The kernel
      22             :  * will support these using the same infrastructure used for VARLEN CDB's.
      23             :  * So in effect MAX_COMMAND_SIZE means the maximum size command scsi-ml
      24             :  * supports without specifying a cmd_len by ULD's
      25             :  */
      26             : #define MAX_COMMAND_SIZE 16
      27             : #if (MAX_COMMAND_SIZE > BLK_MAX_CDB)
      28             : # error MAX_COMMAND_SIZE can not be bigger than BLK_MAX_CDB
      29             : #endif
      30             : 
      31             : struct scsi_data_buffer {
      32             :         struct sg_table table;
      33             :         unsigned length;
      34             :         int resid;
      35             : };
      36           1 : 
      37             : /* embedded in scsi_cmnd */
      38             : struct scsi_pointer {
      39             :         char *ptr;              /* data pointer */
      40             :         int this_residual;      /* left in this buffer */
      41             :         struct scatterlist *buffer;     /* which buffer */
      42             :         int buffers_residual;   /* how many buffers left */
      43             : 
      44             :         dma_addr_t dma_handle;
      45             : 
      46             :         volatile int Status;
      47             :         volatile int Message;
      48             :         volatile int have_data_in;
      49             :         volatile int sent_command;
      50             :         volatile int phase;
      51             : };
      52           1 : 
      53             : struct scsi_cmnd {
      54             :         struct scsi_device *device;
      55             :         struct list_head list;  /* scsi_cmnd participates in queue lists */
      56             :         struct list_head eh_entry; /* entry for the host eh_cmd_q */
      57             :         int eh_eflags;          /* Used by error handlr */
      58             : 
      59             :         /*
      60             :          * A SCSI Command is assigned a nonzero serial_number before passed
      61             :          * to the driver's queue command function.  The serial_number is
      62             :          * cleared when scsi_done is entered indicating that the command
      63             :          * has been completed.  It is a bug for LLDDs to use this number
      64             :          * for purposes other than printk (and even that is only useful
      65             :          * for debugging).
      66             :          */
      67             :         unsigned long serial_number;
      68             : 
      69             :         /*
      70             :          * This is set to jiffies as it was when the command was first
      71             :          * allocated.  It is used to time how long the command has
      72             :          * been outstanding
      73             :          */
      74             :         unsigned long jiffies_at_alloc;
      75             : 
      76             :         int retries;
      77             :         int allowed;
      78             : 
      79             :         unsigned char prot_op;
      80             :         unsigned char prot_type;
      81             : 
      82             :         unsigned short cmd_len;
      83             :         enum dma_data_direction sc_data_direction;
      84             : 
      85             :         /* These elements define the operation we are about to perform */
      86             :         unsigned char *cmnd;
      87             : 
      88             : 
      89             :         /* These elements define the operation we ultimately want to perform */
      90             :         struct scsi_data_buffer sdb;
      91             :         struct scsi_data_buffer *prot_sdb;
      92             : 
      93             :         unsigned underflow;     /* Return error if less than
      94             :                                    this amount is transferred */
      95             : 
      96             :         unsigned transfersize;  /* How much we are guaranteed to
      97             :                                    transfer with each SCSI transfer
      98             :                                    (ie, between disconnect / 
      99             :                                    reconnects.   Probably == sector
     100             :                                    size */
     101             : 
     102             :         struct request *request;        /* The command we are
     103             :                                            working on */
     104             : 
     105             : #define SCSI_SENSE_BUFFERSIZE   96
     106             :         unsigned char *sense_buffer;
     107             :                                 /* obtained by REQUEST SENSE when
     108             :                                  * CHECK CONDITION is received on original
     109             :                                  * command (auto-sense) */
     110             : 
     111             :         /* Low-level done function - can be used by low-level driver to point
     112             :          *        to completion function.  Not used by mid/upper level code. */
     113             :         void (*scsi_done) (struct scsi_cmnd *);
     114             : 
     115             :         /*
     116             :          * The following fields can be written to by the host specific code. 
     117             :          * Everything else should be left alone. 
     118             :          */
     119             :         struct scsi_pointer SCp;        /* Scratchpad used by some host adapters */
     120             : 
     121             :         unsigned char *host_scribble;   /* The host adapter is allowed to
     122             :                                          * call scsi_malloc and get some memory
     123             :                                          * and hang it here.  The host adapter
     124             :                                          * is also expected to call scsi_free
     125             :                                          * to release this memory.  (The memory
     126             :                                          * obtained by scsi_malloc is guaranteed
     127             :                                          * to be at an address < 16Mb). */
     128             : 
     129             :         int result;             /* Status code from lower level driver */
     130             : 
     131             :         unsigned char tag;      /* SCSI-II queued command tag */
     132             : };
     133             : 
     134             : extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
     135             : extern struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *, gfp_t);
     136             : extern void scsi_put_command(struct scsi_cmnd *);
     137             : extern void __scsi_put_command(struct Scsi_Host *, struct scsi_cmnd *,
     138             :                                struct device *);
     139             : extern void scsi_finish_command(struct scsi_cmnd *cmd);
     140             : 
     141             : extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
     142             :                                  size_t *offset, size_t *len);
     143             : extern void scsi_kunmap_atomic_sg(void *virt);
     144             : 
     145             : extern int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask);
     146             : extern void scsi_release_buffers(struct scsi_cmnd *cmd);
     147             : 
     148             : extern int scsi_dma_map(struct scsi_cmnd *cmd);
     149             : extern void scsi_dma_unmap(struct scsi_cmnd *cmd);
     150             : 
     151             : struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask);
     152             : void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd);
     153             : 
     154             : static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
     155             : {
     156           0 :         return cmd->sdb.table.nents;
     157             : }
     158             : 
     159             : static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
     160             : {
     161           0 :         return cmd->sdb.table.sgl;
     162             : }
     163             : 
     164             : static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
     165             : {
     166           0 :         return cmd->sdb.length;
     167             : }
     168             : 
     169             : static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
     170             : {
     171           0 :         cmd->sdb.resid = resid;
     172           0 : }
     173             : 
     174             : static inline int scsi_get_resid(struct scsi_cmnd *cmd)
     175             : {
     176           0 :         return cmd->sdb.resid;
     177             : }
     178             : 
     179             : #define scsi_for_each_sg(cmd, sg, nseg, __i)                    \
     180             :         for_each_sg(scsi_sglist(cmd), sg, nseg, __i)
     181             : 
     182             : static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd)
     183             : {
     184             :         return blk_bidi_rq(cmd->request) &&
     185             :                 (cmd->request->next_rq->special != NULL);
     186             : }
     187             : 
     188             : static inline struct scsi_data_buffer *scsi_in(struct scsi_cmnd *cmd)
     189             : {
     190             :         return scsi_bidi_cmnd(cmd) ?
     191             :                 cmd->request->next_rq->special : &cmd->sdb;
     192             : }
     193             : 
     194             : static inline struct scsi_data_buffer *scsi_out(struct scsi_cmnd *cmd)
     195             : {
     196             :         return &cmd->sdb;
     197             : }
     198             : 
     199             : static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd,
     200             :                                            void *buf, int buflen)
     201             : {
     202             :         return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
     203             :                                    buf, buflen);
     204             : }
     205             : 
     206             : static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
     207             :                                          void *buf, int buflen)
     208             : {
     209             :         return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
     210             :                                  buf, buflen);
     211             : }
     212             : 
     213             : /*
     214             :  * The operations below are hints that tell the controller driver how
     215             :  * to handle I/Os with DIF or similar types of protection information.
     216             :  */
     217             : enum scsi_prot_operations {
     218             :         /* Normal I/O */
     219             :         SCSI_PROT_NORMAL = 0,
     220             : 
     221             :         /* OS-HBA: Protected, HBA-Target: Unprotected */
     222             :         SCSI_PROT_READ_INSERT,
     223             :         SCSI_PROT_WRITE_STRIP,
     224             : 
     225             :         /* OS-HBA: Unprotected, HBA-Target: Protected */
     226             :         SCSI_PROT_READ_STRIP,
     227             :         SCSI_PROT_WRITE_INSERT,
     228             : 
     229             :         /* OS-HBA: Protected, HBA-Target: Protected */
     230             :         SCSI_PROT_READ_PASS,
     231             :         SCSI_PROT_WRITE_PASS,
     232             : };
     233             : 
     234             : static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
     235             : {
     236             :         scmd->prot_op = op;
     237             : }
     238             : 
     239             : static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
     240             : {
     241             :         return scmd->prot_op;
     242             : }
     243             : 
     244             : /*
     245             :  * The controller usually does not know anything about the target it
     246             :  * is communicating with.  However, when DIX is enabled the controller
     247             :  * must be know target type so it can verify the protection
     248             :  * information passed along with the I/O.
     249             :  */
     250             : enum scsi_prot_target_type {
     251             :         SCSI_PROT_DIF_TYPE0 = 0,
     252             :         SCSI_PROT_DIF_TYPE1,
     253             :         SCSI_PROT_DIF_TYPE2,
     254             :         SCSI_PROT_DIF_TYPE3,
     255             : };
     256             : 
     257             : static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
     258             : {
     259             :         scmd->prot_type = type;
     260             : }
     261             : 
     262             : static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
     263             : {
     264             :         return scmd->prot_type;
     265             : }
     266             : 
     267             : static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
     268             : {
     269             :         return blk_rq_pos(scmd->request);
     270             : }
     271             : 
     272             : static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
     273             : {
     274             :         return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
     275             : }
     276             : 
     277             : static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
     278             : {
     279             :         return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
     280             : }
     281             : 
     282             : static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
     283             : {
     284             :         return cmd->prot_sdb;
     285             : }
     286             : 
     287             : #define scsi_for_each_prot_sg(cmd, sg, nseg, __i)               \
     288             :         for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
     289             : 
     290             : static inline void set_msg_byte(struct scsi_cmnd *cmd, char status)
     291             : {
     292             :         cmd->result |= status << 8;
     293             : }
     294             : 
     295             : static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
     296             : {
     297             :         cmd->result |= status << 16;
     298             : }
     299             : 
     300             : static inline void set_driver_byte(struct scsi_cmnd *cmd, char status)
     301             : {
     302             :         cmd->result |= status << 24;
     303             : }
     304           1 : 
     305             : #endif /* _SCSI_SCSI_CMND_H */

Generated by: LCOV version 1.10