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 unsigned char *sense_buffer;
115
116
117
118
119
120
121
122 void (*scsi_done) (struct scsi_cmnd *);
123
124
125
126
127
128 struct scsi_pointer SCp;
129
130 unsigned char *host_scribble;
131
132
133
134
135
136
137
138 int result;
139 int flags;
140 unsigned long state;
141
142 unsigned int extra_len;
143};
144
145
146static inline struct request *scsi_cmd_to_rq(struct scsi_cmnd *scmd)
147{
148 return blk_mq_rq_from_pdu(scmd);
149}
150
151
152
153
154
155static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd)
156{
157 return cmd + 1;
158}
159
160
161static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
162{
163 struct request *rq = scsi_cmd_to_rq(cmd);
164
165 return *(struct scsi_driver **)rq->rq_disk->private_data;
166}
167
168extern void scsi_finish_command(struct scsi_cmnd *cmd);
169
170extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
171 size_t *offset, size_t *len);
172extern void scsi_kunmap_atomic_sg(void *virt);
173
174blk_status_t scsi_alloc_sgtables(struct scsi_cmnd *cmd);
175void scsi_free_sgtables(struct scsi_cmnd *cmd);
176
177#ifdef CONFIG_SCSI_DMA
178extern int scsi_dma_map(struct scsi_cmnd *cmd);
179extern void scsi_dma_unmap(struct scsi_cmnd *cmd);
180#else
181static inline int scsi_dma_map(struct scsi_cmnd *cmd) { return -ENOSYS; }
182static inline void scsi_dma_unmap(struct scsi_cmnd *cmd) { }
183#endif
184
185static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
186{
187 return cmd->sdb.table.nents;
188}
189
190static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
191{
192 return cmd->sdb.table.sgl;
193}
194
195static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
196{
197 return cmd->sdb.length;
198}
199
200static inline void scsi_set_resid(struct scsi_cmnd *cmd, unsigned int resid)
201{
202 cmd->req.resid_len = resid;
203}
204
205static inline unsigned int scsi_get_resid(struct scsi_cmnd *cmd)
206{
207 return cmd->req.resid_len;
208}
209
210#define scsi_for_each_sg(cmd, sg, nseg, __i) \
211 for_each_sg(scsi_sglist(cmd), sg, nseg, __i)
212
213static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd,
214 void *buf, int buflen)
215{
216 return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
217 buf, buflen);
218}
219
220static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
221 void *buf, int buflen)
222{
223 return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
224 buf, buflen);
225}
226
227static inline sector_t scsi_get_sector(struct scsi_cmnd *scmd)
228{
229 return blk_rq_pos(scsi_cmd_to_rq(scmd));
230}
231
232static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
233{
234 unsigned int shift = ilog2(scmd->device->sector_size) - SECTOR_SHIFT;
235
236 return blk_rq_pos(scsi_cmd_to_rq(scmd)) >> shift;
237}
238
239static inline unsigned int scsi_logical_block_count(struct scsi_cmnd *scmd)
240{
241 unsigned int shift = ilog2(scmd->device->sector_size) - SECTOR_SHIFT;
242
243 return blk_rq_bytes(scsi_cmd_to_rq(scmd)) >> shift;
244}
245
246
247
248
249
250enum scsi_prot_operations {
251
252 SCSI_PROT_NORMAL = 0,
253
254
255 SCSI_PROT_READ_INSERT,
256 SCSI_PROT_WRITE_STRIP,
257
258
259 SCSI_PROT_READ_STRIP,
260 SCSI_PROT_WRITE_INSERT,
261
262
263 SCSI_PROT_READ_PASS,
264 SCSI_PROT_WRITE_PASS,
265};
266
267static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
268{
269 scmd->prot_op = op;
270}
271
272static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
273{
274 return scmd->prot_op;
275}
276
277enum scsi_prot_flags {
278 SCSI_PROT_TRANSFER_PI = 1 << 0,
279 SCSI_PROT_GUARD_CHECK = 1 << 1,
280 SCSI_PROT_REF_CHECK = 1 << 2,
281 SCSI_PROT_REF_INCREMENT = 1 << 3,
282 SCSI_PROT_IP_CHECKSUM = 1 << 4,
283};
284
285
286
287
288
289
290
291enum scsi_prot_target_type {
292 SCSI_PROT_DIF_TYPE0 = 0,
293 SCSI_PROT_DIF_TYPE1,
294 SCSI_PROT_DIF_TYPE2,
295 SCSI_PROT_DIF_TYPE3,
296};
297
298static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
299{
300 scmd->prot_type = type;
301}
302
303static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
304{
305 return scmd->prot_type;
306}
307
308static inline u32 scsi_prot_ref_tag(struct scsi_cmnd *scmd)
309{
310 struct request *rq = blk_mq_rq_from_pdu(scmd);
311
312 return t10_pi_ref_tag(rq);
313}
314
315static inline unsigned int scsi_prot_interval(struct scsi_cmnd *scmd)
316{
317 return scmd->device->sector_size;
318}
319
320static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
321{
322 return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
323}
324
325static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
326{
327 return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
328}
329
330static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
331{
332 return cmd->prot_sdb;
333}
334
335#define scsi_for_each_prot_sg(cmd, sg, nseg, __i) \
336 for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
337
338static inline void set_status_byte(struct scsi_cmnd *cmd, char status)
339{
340 cmd->result = (cmd->result & 0xffffff00) | status;
341}
342
343static inline u8 get_status_byte(struct scsi_cmnd *cmd)
344{
345 return cmd->result & 0xff;
346}
347
348static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
349{
350 cmd->result = (cmd->result & 0xff00ffff) | (status << 16);
351}
352
353static inline u8 get_host_byte(struct scsi_cmnd *cmd)
354{
355 return (cmd->result >> 16) & 0xff;
356}
357
358
359
360
361
362
363
364
365
366
367
368static inline void scsi_msg_to_host_byte(struct scsi_cmnd *cmd, u8 msg)
369{
370 switch (msg) {
371 case COMMAND_COMPLETE:
372 break;
373 case ABORT_TASK_SET:
374 set_host_byte(cmd, DID_ABORT);
375 break;
376 case TARGET_RESET:
377 set_host_byte(cmd, DID_RESET);
378 break;
379 default:
380 set_host_byte(cmd, DID_ERROR);
381 break;
382 }
383}
384
385static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
386{
387 unsigned int xfer_len = scmd->sdb.length;
388 unsigned int prot_interval = scsi_prot_interval(scmd);
389
390 if (scmd->prot_flags & SCSI_PROT_TRANSFER_PI)
391 xfer_len += (xfer_len >> ilog2(prot_interval)) * 8;
392
393 return xfer_len;
394}
395
396extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,
397 u8 key, u8 asc, u8 ascq);
398
399#endif
400