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 0 : 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 0 : 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 0 : 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 */
|