blob: 73f3490449411af899d71d4be6e4ceb09277e57d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _SCSI_SCSI_CMND_H
2#define _SCSI_SCSI_CMND_H
3
4#include <linux/dma-mapping.h>
Boaz Harrosh6f9a35e2007-12-13 13:50:53 +02005#include <linux/blkdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/list.h>
7#include <linux/types.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -08008#include <linux/timer.h>
Jens Axboec6132da2007-10-16 11:08:49 +02009#include <linux/scatterlist.h>
Sagi Grimberg8846bab2014-06-11 12:09:57 +030010#include <scsi/scsi_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011
FUJITA Tomonorib58d9152006-11-16 19:24:10 +090012struct Scsi_Host;
Linus Torvalds1da177e2005-04-16 15:20:36 -070013struct scsi_device;
Martin K. Petersen18a4d0a2012-02-09 13:48:53 -050014struct scsi_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Boaz Harrosh64a87b22008-04-30 11:19:47 +030016/*
17 * MAX_COMMAND_SIZE is:
18 * The longest fixed-length SCSI CDB as per the SCSI standard.
19 * fixed-length means: commands that their size can be determined
20 * by their opcode and the CDB does not carry a length specifier, (unlike
21 * the VARIABLE_LENGTH_CMD(0x7f) command). This is actually not exactly
22 * true and the SCSI standard also defines extended commands and
23 * vendor specific commands that can be bigger than 16 bytes. The kernel
24 * will support these using the same infrastructure used for VARLEN CDB's.
25 * So in effect MAX_COMMAND_SIZE means the maximum size command scsi-ml
26 * supports without specifying a cmd_len by ULD's
27 */
28#define MAX_COMMAND_SIZE 16
29#if (MAX_COMMAND_SIZE > BLK_MAX_CDB)
30# error MAX_COMMAND_SIZE can not be bigger than BLK_MAX_CDB
31#endif
32
Boaz Harrosh30b0c372007-12-13 13:47:40 +020033struct scsi_data_buffer {
34 struct sg_table table;
35 unsigned length;
36 int resid;
37};
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39/* embedded in scsi_cmnd */
40struct scsi_pointer {
41 char *ptr; /* data pointer */
42 int this_residual; /* left in this buffer */
43 struct scatterlist *buffer; /* which buffer */
44 int buffers_residual; /* how many buffers left */
45
46 dma_addr_t dma_handle;
47
48 volatile int Status;
49 volatile int Message;
50 volatile int have_data_in;
51 volatile int sent_command;
52 volatile int phase;
53};
54
55struct scsi_cmnd {
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 struct scsi_device *device;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 struct list_head list; /* scsi_cmnd participates in queue lists */
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 struct list_head eh_entry; /* entry for the host eh_cmd_q */
Hannes Reineckee494f6a2013-11-11 13:44:54 +010059 struct delayed_work abort_work;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 int eh_eflags; /* Used by error handlr */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 /*
c6295cd2005-04-03 14:59:11 -050063 * A SCSI Command is assigned a nonzero serial_number before passed
64 * to the driver's queue command function. The serial_number is
65 * cleared when scsi_done is entered indicating that the command
Matthew Wilcox12a44162007-09-18 19:54:43 -060066 * has been completed. It is a bug for LLDDs to use this number
67 * for purposes other than printk (and even that is only useful
68 * for debugging).
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 */
70 unsigned long serial_number;
Matthew Wilcox12a44162007-09-18 19:54:43 -060071
James Bottomleyb21a4132005-08-05 21:45:40 -050072 /*
73 * This is set to jiffies as it was when the command was first
74 * allocated. It is used to time how long the command has
75 * been outstanding
76 */
77 unsigned long jiffies_at_alloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79 int retries;
80 int allowed;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Martin K. Petersendb007fc2008-07-17 04:28:31 -040082 unsigned char prot_op;
83 unsigned char prot_type;
84
Boaz Harroshdb4742d2008-04-30 11:27:26 +030085 unsigned short cmd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 enum dma_data_direction sc_data_direction;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88 /* These elements define the operation we are about to perform */
Boaz Harrosh64a87b22008-04-30 11:19:47 +030089 unsigned char *cmnd;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92 /* These elements define the operation we ultimately want to perform */
Boaz Harrosh30b0c372007-12-13 13:47:40 +020093 struct scsi_data_buffer sdb;
Martin K. Petersen7027ad72008-07-17 17:08:48 -040094 struct scsi_data_buffer *prot_sdb;
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 unsigned underflow; /* Return error if less than
97 this amount is transferred */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99 unsigned transfersize; /* How much we are guaranteed to
100 transfer with each SCSI transfer
101 (ie, between disconnect /
102 reconnects. Probably == sector
103 size */
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 struct request *request; /* The command we are
106 working on */
107
108#define SCSI_SENSE_BUFFERSIZE 96
FUJITA Tomonoride25deb2008-01-16 13:32:17 +0900109 unsigned char *sense_buffer;
Matthew Wilcoxc67a8482006-01-17 11:54:24 -0700110 /* obtained by REQUEST SENSE when
111 * CHECK CONDITION is received on original
112 * command (auto-sense) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114 /* Low-level done function - can be used by low-level driver to point
115 * to completion function. Not used by mid/upper level code. */
116 void (*scsi_done) (struct scsi_cmnd *);
117
118 /*
119 * The following fields can be written to by the host specific code.
120 * Everything else should be left alone.
121 */
122 struct scsi_pointer SCp; /* Scratchpad used by some host adapters */
123
124 unsigned char *host_scribble; /* The host adapter is allowed to
Matthew Wilcoxc67a8482006-01-17 11:54:24 -0700125 * call scsi_malloc and get some memory
126 * and hang it here. The host adapter
127 * is also expected to call scsi_free
128 * to release this memory. (The memory
129 * obtained by scsi_malloc is guaranteed
130 * to be at an address < 16Mb). */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132 int result; /* Status code from lower level driver */
133
134 unsigned char tag; /* SCSI-II queued command tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135};
136
Christoph Hellwigb54197c2014-05-01 16:51:50 +0200137/*
138 * Return the driver private allocation behind the command.
139 * Only works if cmd_size is set in the host template.
140 */
141static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd)
142{
143 return cmd + 1;
144}
145
Li Zhong329a4022012-09-29 12:23:37 +0800146/* make sure not to use it with REQ_TYPE_BLOCK_PC commands */
Martin K. Petersen18a4d0a2012-02-09 13:48:53 -0500147static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
148{
Li Zhong329a4022012-09-29 12:23:37 +0800149 return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
Martin K. Petersen18a4d0a2012-02-09 13:48:53 -0500150}
151
Al Viroc53033f2005-10-21 03:22:08 -0400152extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153extern void scsi_put_command(struct scsi_cmnd *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154extern void scsi_finish_command(struct scsi_cmnd *cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Guennadi Liakhovetskicdb8c2a2006-04-02 21:57:43 +0200156extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
157 size_t *offset, size_t *len);
158extern void scsi_kunmap_atomic_sg(void *virt);
159
Boaz Harroshbb52d822007-12-13 16:14:27 -0800160extern int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask);
FUJITA Tomonorib58d9152006-11-16 19:24:10 +0900161
FUJITA Tomonori824d7b52007-05-26 14:04:03 +0900162extern int scsi_dma_map(struct scsi_cmnd *cmd);
163extern void scsi_dma_unmap(struct scsi_cmnd *cmd);
164
Boaz Harrosh30b0c372007-12-13 13:47:40 +0200165static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
166{
167 return cmd->sdb.table.nents;
168}
169
170static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
171{
172 return cmd->sdb.table.sgl;
173}
174
175static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
176{
177 return cmd->sdb.length;
178}
FUJITA Tomonori824d7b52007-05-26 14:04:03 +0900179
180static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
181{
Boaz Harrosh30b0c372007-12-13 13:47:40 +0200182 cmd->sdb.resid = resid;
FUJITA Tomonori824d7b52007-05-26 14:04:03 +0900183}
184
185static inline int scsi_get_resid(struct scsi_cmnd *cmd)
186{
Boaz Harrosh30b0c372007-12-13 13:47:40 +0200187 return cmd->sdb.resid;
FUJITA Tomonori824d7b52007-05-26 14:04:03 +0900188}
189
190#define scsi_for_each_sg(cmd, sg, nseg, __i) \
Jens Axboec6132da2007-10-16 11:08:49 +0200191 for_each_sg(scsi_sglist(cmd), sg, nseg, __i)
FUJITA Tomonori824d7b52007-05-26 14:04:03 +0900192
Boaz Harrosh6f9a35e2007-12-13 13:50:53 +0200193static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd)
194{
195 return blk_bidi_rq(cmd->request) &&
196 (cmd->request->next_rq->special != NULL);
197}
198
199static inline struct scsi_data_buffer *scsi_in(struct scsi_cmnd *cmd)
200{
201 return scsi_bidi_cmnd(cmd) ?
202 cmd->request->next_rq->special : &cmd->sdb;
203}
204
205static inline struct scsi_data_buffer *scsi_out(struct scsi_cmnd *cmd)
206{
207 return &cmd->sdb;
208}
209
FUJITA Tomonori9ac16b62008-03-09 13:44:29 +0900210static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd,
211 void *buf, int buflen)
212{
213 return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
214 buf, buflen);
215}
216
217static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
218 void *buf, int buflen)
219{
220 return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
221 buf, buflen);
222}
223
Martin K. Petersendb007fc2008-07-17 04:28:31 -0400224/*
225 * The operations below are hints that tell the controller driver how
226 * to handle I/Os with DIF or similar types of protection information.
227 */
228enum scsi_prot_operations {
229 /* Normal I/O */
230 SCSI_PROT_NORMAL = 0,
231
232 /* OS-HBA: Protected, HBA-Target: Unprotected */
233 SCSI_PROT_READ_INSERT,
234 SCSI_PROT_WRITE_STRIP,
235
236 /* OS-HBA: Unprotected, HBA-Target: Protected */
237 SCSI_PROT_READ_STRIP,
238 SCSI_PROT_WRITE_INSERT,
239
240 /* OS-HBA: Protected, HBA-Target: Protected */
241 SCSI_PROT_READ_PASS,
242 SCSI_PROT_WRITE_PASS,
Martin K. Petersendb007fc2008-07-17 04:28:31 -0400243};
244
245static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
246{
247 scmd->prot_op = op;
248}
249
250static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
251{
252 return scmd->prot_op;
253}
254
255/*
256 * The controller usually does not know anything about the target it
257 * is communicating with. However, when DIX is enabled the controller
258 * must be know target type so it can verify the protection
259 * information passed along with the I/O.
260 */
261enum scsi_prot_target_type {
262 SCSI_PROT_DIF_TYPE0 = 0,
263 SCSI_PROT_DIF_TYPE1,
264 SCSI_PROT_DIF_TYPE2,
265 SCSI_PROT_DIF_TYPE3,
266};
267
268static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
269{
270 scmd->prot_type = type;
271}
272
273static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
274{
275 return scmd->prot_type;
276}
277
278static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
279{
Tejun Heo83096eb2009-05-07 22:24:39 +0900280 return blk_rq_pos(scmd->request);
Martin K. Petersendb007fc2008-07-17 04:28:31 -0400281}
282
Martin K. Petersen7027ad72008-07-17 17:08:48 -0400283static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
284{
285 return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
286}
287
288static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
289{
290 return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
291}
292
293static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
294{
295 return cmd->prot_sdb;
296}
297
298#define scsi_for_each_prot_sg(cmd, sg, nseg, __i) \
299 for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
300
James Bottomleyf290f192009-02-08 21:59:48 -0600301static inline void set_msg_byte(struct scsi_cmnd *cmd, char status)
302{
Moger, Babu3384db92012-01-24 20:38:42 +0000303 cmd->result = (cmd->result & 0xffff00ff) | (status << 8);
James Bottomleyf290f192009-02-08 21:59:48 -0600304}
305
306static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
307{
Moger, Babu3384db92012-01-24 20:38:42 +0000308 cmd->result = (cmd->result & 0xff00ffff) | (status << 16);
James Bottomleyf290f192009-02-08 21:59:48 -0600309}
310
311static inline void set_driver_byte(struct scsi_cmnd *cmd, char status)
312{
Moger, Babu3384db92012-01-24 20:38:42 +0000313 cmd->result = (cmd->result & 0x00ffffff) | (status << 24);
James Bottomleyf290f192009-02-08 21:59:48 -0600314}
315
Sagi Grimberg8846bab2014-06-11 12:09:57 +0300316static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
317{
Martin K. Petersen5616b0a2014-06-24 16:59:35 +0200318 unsigned int xfer_len = scsi_out(scmd)->length;
Sagi Grimberg8846bab2014-06-11 12:09:57 +0300319 unsigned int prot_op = scsi_get_prot_op(scmd);
320 unsigned int sector_size = scmd->device->sector_size;
321
322 switch (prot_op) {
323 case SCSI_PROT_NORMAL:
324 case SCSI_PROT_WRITE_STRIP:
325 case SCSI_PROT_READ_INSERT:
326 return xfer_len;
327 }
328
329 return xfer_len + (xfer_len >> ilog2(sector_size)) * 8;
330}
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332#endif /* _SCSI_SCSI_CMND_H */