1
2#ifndef _SCSI_SCSI_CMND_H
3#define _SCSI_SCSI_CMND_H
4
5#include <linux/dma-mapping.h>
6#include <linux/blkdev.h>
7#include <linux/t10-pi.h>
8#include <linux/list.h>
9#include <linux/types.h>
10#include <linux/timer.h>
11#include <linux/scatterlist.h>
12#include <scsi/scsi_device.h>
13#include <scsi/scsi_host.h>
14#include <scsi/scsi_request.h>
15
16struct Scsi_Host;
17struct scsi_driver;
18
19
20
21
22
23
24
25
26
27
28
29
30
31#define MAX_COMMAND_SIZE 16
32#if (MAX_COMMAND_SIZE > BLK_MAX_CDB)
33# error MAX_COMMAND_SIZE can not be bigger than BLK_MAX_CDB
34#endif
35
36struct scsi_data_buffer {
37 struct sg_table table;
38 unsigned length;
39};
40
41
42struct scsi_pointer {
43 char *ptr;
44 int this_residual;
45 struct scatterlist *buffer;
46 int buffers_residual;
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
58#define SCMD_TAGGED (1 << 0)
59#define SCMD_INITIALIZED (1 << 1)
60#define SCMD_LAST (1 << 2)
61
62#define SCMD_PRESERVED_FLAGS (SCMD_INITIALIZED)
63
64
65#define SCMD_STATE_COMPLETE 0
66#define SCMD_STATE_INFLIGHT 1
67
68struct scsi_cmnd {
69 struct scsi_request req;
70 struct scsi_device *device;
71 struct list_head eh_entry;
72 struct delayed_work abort_work;
73
74 struct rcu_head rcu;
75
76 int eh_eflags;
77
78 int budget_token;
79
80
81
82
83
84
85 unsigned long jiffies_at_alloc;
86
87 int retries;
88 int allowed;
89
90 unsigned char prot_op;
91 unsigned char prot_type;
92 unsigned char prot_flags;
93
94 unsigned short cmd_len;
95 enum dma_data_direction sc_data_direction;
96
97
98 unsigned char *cmnd;
99
100
101
102 struct scsi_data_buffer sdb;
103 struct scsi_data_buffer *prot_sdb;
104
105 unsigned underflow;
106
107
108 unsigned transfersize;
109
110
111
112
113
114 struct request *request;
115
116
117 unsigned char *sense_buffer;
118
119
120
121
122
123
124
125 void (*scsi_done) (struct scsi_cmnd *);
126
127
128
129
130
131 struct scsi_pointer SCp;
132
133 unsigned char *host_scribble;
134
135
136
137
138
139
140
141 int result;
142 int flags;
143 unsigned long state;
144
145 unsigned char tag;
146 unsigned int extra_len;
147};
148
149
150
151
152
153static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd)
154{
155 return cmd + 1;
156}
157
158
159static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
160{
161 return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
162}
163
164extern void scsi_finish_command(struct scsi_cmnd *cmd);
165
166extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
167 size_t *offset, size_t *len);
168extern void scsi_kunmap_atomic_sg(void *virt);
169
170blk_status_t scsi_alloc_sgtables(struct scsi_cmnd *cmd);
171void scsi_free_sgtables(struct scsi_cmnd *cmd);
172
173#ifdef CONFIG_SCSI_DMA
174extern int scsi_dma_map(struct scsi_cmnd *cmd);
175extern void scsi_dma_unmap(struct scsi_cmnd *cmd);
176#else
177static inline int scsi_dma_map(struct scsi_cmnd *cmd) { return -ENOSYS; }
178static inline void scsi_dma_unmap(struct scsi_cmnd *cmd) { }
179#endif
180
181static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
182{
183 return cmd->sdb.table.nents;
184}
185
186static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
187{
188 return cmd->sdb.table.sgl;
189}
190
191static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
192{
193 return cmd->sdb.length;
194}
195
196static inline void scsi_set_resid(struct scsi_cmnd *cmd, unsigned int resid)
197{
198 cmd->req.resid_len = resid;
199}
200
201static inline unsigned int scsi_get_resid(struct scsi_cmnd *cmd)
202{
203 return cmd->req.resid_len;
204}
205
206#define scsi_for_each_sg(cmd, sg, nseg, __i) \
207 for_each_sg(scsi_sglist(cmd), sg, nseg, __i)
208
209static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd,
210 void *buf, int buflen)
211{
212 return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
213 buf, buflen);
214}
215
216static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
217 void *buf, int buflen)
218{
219 return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
220 buf, buflen);
221}
222
223
224
225
226
227enum scsi_prot_operations {
228
229 SCSI_PROT_NORMAL = 0,
230
231
232 SCSI_PROT_READ_INSERT,
233 SCSI_PROT_WRITE_STRIP,
234
235
236 SCSI_PROT_READ_STRIP,
237 SCSI_PROT_WRITE_INSERT,
238
239
240 SCSI_PROT_READ_PASS,
241 SCSI_PROT_WRITE_PASS,
242};
243
244static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
245{
246 scmd->prot_op = op;
247}
248
249static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
250{
251 return scmd->prot_op;
252}
253
254enum scsi_prot_flags {
255 SCSI_PROT_TRANSFER_PI = 1 << 0,
256 SCSI_PROT_GUARD_CHECK = 1 << 1,
257 SCSI_PROT_REF_CHECK = 1 << 2,
258 SCSI_PROT_REF_INCREMENT = 1 << 3,
259 SCSI_PROT_IP_CHECKSUM = 1 << 4,
260};
261
262
263
264
265
266
267
268enum scsi_prot_target_type {
269 SCSI_PROT_DIF_TYPE0 = 0,
270 SCSI_PROT_DIF_TYPE1,
271 SCSI_PROT_DIF_TYPE2,
272 SCSI_PROT_DIF_TYPE3,
273};
274
275static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
276{
277 scmd->prot_type = type;
278}
279
280static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
281{
282 return scmd->prot_type;
283}
284
285static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
286{
287 return blk_rq_pos(scmd->request);
288}
289
290static inline unsigned int scsi_prot_interval(struct scsi_cmnd *scmd)
291{
292 return scmd->device->sector_size;
293}
294
295static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
296{
297 return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
298}
299
300static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
301{
302 return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
303}
304
305static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
306{
307 return cmd->prot_sdb;
308}
309
310#define scsi_for_each_prot_sg(cmd, sg, nseg, __i) \
311 for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
312
313static inline void set_status_byte(struct scsi_cmnd *cmd, char status)
314{
315 cmd->result = (cmd->result & 0xffffff00) | status;
316}
317
318static inline u8 get_status_byte(struct scsi_cmnd *cmd)
319{
320 return cmd->result & 0xff;
321}
322
323static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
324{
325 cmd->result = (cmd->result & 0xff00ffff) | (status << 16);
326}
327
328static inline u8 get_host_byte(struct scsi_cmnd *cmd)
329{
330 return (cmd->result >> 16) & 0xff;
331}
332
333
334
335
336
337
338
339
340
341
342
343static inline void scsi_msg_to_host_byte(struct scsi_cmnd *cmd, u8 msg)
344{
345 switch (msg) {
346 case COMMAND_COMPLETE:
347 break;
348 case ABORT_TASK_SET:
349 set_host_byte(cmd, DID_ABORT);
350 break;
351 case TARGET_RESET:
352 set_host_byte(cmd, DID_RESET);
353 break;
354 default:
355 set_host_byte(cmd, DID_ERROR);
356 break;
357 }
358}
359
360static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
361{
362 unsigned int xfer_len = scmd->sdb.length;
363 unsigned int prot_interval = scsi_prot_interval(scmd);
364
365 if (scmd->prot_flags & SCSI_PROT_TRANSFER_PI)
366 xfer_len += (xfer_len >> ilog2(prot_interval)) * 8;
367
368 return xfer_len;
369}
370
371extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,
372 u8 key, u8 asc, u8 ascq);
373
374#endif
375