~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/scsi/scsi_cmnd.h

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp