ore: RAID5 Write
[linux-2.6.git] / include / scsi / scsi_cmnd.h
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
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
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         return cmd->sdb.table.nents;
157 }
158
159 static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
160 {
161         return cmd->sdb.table.sgl;
162 }
163
164 static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
165 {
166         return cmd->sdb.length;
167 }
168
169 static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
170 {
171         cmd->sdb.resid = resid;
172 }
173
174 static inline int scsi_get_resid(struct scsi_cmnd *cmd)
175 {
176         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
305 #endif /* _SCSI_SCSI_CMND_H */