1/* SPDX-License-Identifier: GPL-2.0 */
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_request.h>
14
15struct Scsi_Host;
16struct scsi_driver;
17
18/*
19 * MAX_COMMAND_SIZE is:
20 * The longest fixed-length SCSI CDB as per the SCSI standard.
21 * fixed-length means: commands that their size can be determined
22 * by their opcode and the CDB does not carry a length specifier, (unlike
23 * the VARIABLE_LENGTH_CMD(0x7f) command). This is actually not exactly
24 * true and the SCSI standard also defines extended commands and
25 * vendor specific commands that can be bigger than 16 bytes. The kernel
26 * will support these using the same infrastructure used for VARLEN CDB's.
27 * So in effect MAX_COMMAND_SIZE means the maximum size command scsi-ml
28 * supports without specifying a cmd_len by ULD's
29 */
30#define MAX_COMMAND_SIZE 16
31#if (MAX_COMMAND_SIZE > BLK_MAX_CDB)
32# error MAX_COMMAND_SIZE can not be bigger than BLK_MAX_CDB
33#endif
34
35struct scsi_data_buffer {
36	struct sg_table table;
37	unsigned length;
38};
39
40/* embedded in scsi_cmnd */
41struct scsi_pointer {
42	char *ptr;		/* data pointer */
43	int this_residual;	/* left in this buffer */
44	struct scatterlist *buffer;	/* which buffer */
45	int buffers_residual;	/* how many buffers left */
46
47        dma_addr_t dma_handle;
48
49	volatile int Status;
50	volatile int Message;
51	volatile int have_data_in;
52	volatile int sent_command;
53	volatile int phase;
54};
55
56/* for scmd->flags */
57#define SCMD_TAGGED		(1 << 0)
58#define SCMD_UNCHECKED_ISA_DMA	(1 << 1)
59#define SCMD_INITIALIZED	(1 << 2)
60#define SCMD_LAST		(1 << 3)
61/* flags preserved across unprep / reprep */
62#define SCMD_PRESERVED_FLAGS	(SCMD_UNCHECKED_ISA_DMA | SCMD_INITIALIZED)
63
64/* for scmd->state */
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; /* entry for the host eh_cmd_q */
72	struct delayed_work abort_work;
73
74	struct rcu_head rcu;
75
76	int eh_eflags;		/* Used by error handlr */
77
78	/*
79	 * This is set to jiffies as it was when the command was first
80	 * allocated.  It is used to time how long the command has
81	 * been outstanding
82	 */
83	unsigned long jiffies_at_alloc;
84
85	int retries;
86	int allowed;
87
88	unsigned char prot_op;
89	unsigned char prot_type;
90	unsigned char prot_flags;
91
92	unsigned short cmd_len;
93	enum dma_data_direction sc_data_direction;
94
95	/* These elements define the operation we are about to perform */
96	unsigned char *cmnd;
97
98
99	/* These elements define the operation we ultimately want to perform */
100	struct scsi_data_buffer sdb;
101	struct scsi_data_buffer *prot_sdb;
102
103	unsigned underflow;	/* Return error if less than
104				   this amount is transferred */
105
106	unsigned transfersize;	/* How much we are guaranteed to
107				   transfer with each SCSI transfer
108				   (ie, between disconnect /
109				   reconnects.   Probably == sector
110				   size */
111
112	struct request *request;	/* The command we are
113				   	   working on */
114
115	unsigned char *sense_buffer;
116				/* obtained by REQUEST SENSE when
117				 * CHECK CONDITION is received on original
118				 * command (auto-sense). Length must be
119				 * SCSI_SENSE_BUFFERSIZE bytes. */
120
121	/* Low-level done function - can be used by low-level driver to point
122	 *        to completion function.  Not used by mid/upper level code. */
123	void (*scsi_done) (struct scsi_cmnd *);
124
125	/*
126	 * The following fields can be written to by the host specific code.
127	 * Everything else should be left alone.
128	 */
129	struct scsi_pointer SCp;	/* Scratchpad used by some host adapters */
130
131	unsigned char *host_scribble;	/* The host adapter is allowed to
132					 * call scsi_malloc and get some memory
133					 * and hang it here.  The host adapter
134					 * is also expected to call scsi_free
135					 * to release this memory.  (The memory
136					 * obtained by scsi_malloc is guaranteed
137					 * to be at an address < 16Mb). */
138
139	int result;		/* Status code from lower level driver */
140	int flags;		/* Command flags */
141	unsigned long state;	/* Command completion state */
142
143	unsigned char tag;	/* SCSI-II queued command tag */
144	unsigned int extra_len;	/* length of alignment and padding */
145};
146
147/* Variant of blk_mq_rq_from_pdu() that verifies the type of its argument. */
148static inline struct request *scsi_cmd_to_rq(struct scsi_cmnd *scmd)
149{
150	return blk_mq_rq_from_pdu(scmd);
151}
152
153/*
154 * Return the driver private allocation behind the command.
155 * Only works if cmd_size is set in the host template.
156 */
157static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd)
158{
159	return cmd + 1;
160}
161
162/* make sure not to use it with passthrough commands */
163static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
164{
165	return *(struct scsi_driver **)cmd->request->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 /* !CONFIG_SCSI_DMA */
181static inline int scsi_dma_map(struct scsi_cmnd *cmd) { return -ENOSYS; }
182static inline void scsi_dma_unmap(struct scsi_cmnd *cmd) { }
183#endif /* !CONFIG_SCSI_DMA */
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					   const 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
227/*
228 * The operations below are hints that tell the controller driver how
229 * to handle I/Os with DIF or similar types of protection information.
230 */
231enum scsi_prot_operations {
232	/* Normal I/O */
233	SCSI_PROT_NORMAL = 0,
234
235	/* OS-HBA: Protected, HBA-Target: Unprotected */
236	SCSI_PROT_READ_INSERT,
237	SCSI_PROT_WRITE_STRIP,
238
239	/* OS-HBA: Unprotected, HBA-Target: Protected */
240	SCSI_PROT_READ_STRIP,
241	SCSI_PROT_WRITE_INSERT,
242
243	/* OS-HBA: Protected, HBA-Target: Protected */
244	SCSI_PROT_READ_PASS,
245	SCSI_PROT_WRITE_PASS,
246};
247
248static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
249{
250	scmd->prot_op = op;
251}
252
253static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
254{
255	return scmd->prot_op;
256}
257
258enum scsi_prot_flags {
259	SCSI_PROT_TRANSFER_PI		= 1 << 0,
260	SCSI_PROT_GUARD_CHECK		= 1 << 1,
261	SCSI_PROT_REF_CHECK		= 1 << 2,
262	SCSI_PROT_REF_INCREMENT		= 1 << 3,
263	SCSI_PROT_IP_CHECKSUM		= 1 << 4,
264};
265
266/*
267 * The controller usually does not know anything about the target it
268 * is communicating with.  However, when DIX is enabled the controller
269 * must be know target type so it can verify the protection
270 * information passed along with the I/O.
271 */
272enum scsi_prot_target_type {
273	SCSI_PROT_DIF_TYPE0 = 0,
274	SCSI_PROT_DIF_TYPE1,
275	SCSI_PROT_DIF_TYPE2,
276	SCSI_PROT_DIF_TYPE3,
277};
278
279static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
280{
281	scmd->prot_type = type;
282}
283
284static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
285{
286	return scmd->prot_type;
287}
288
289static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
290{
291	return blk_rq_pos(scmd->request);
292}
293
294static inline unsigned int scsi_prot_interval(struct scsi_cmnd *scmd)
295{
296	return scmd->device->sector_size;
297}
298
299static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
300{
301	return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
302}
303
304static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
305{
306	return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
307}
308
309static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
310{
311	return cmd->prot_sdb;
312}
313
314#define scsi_for_each_prot_sg(cmd, sg, nseg, __i)		\
315	for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
316
317static inline void set_msg_byte(struct scsi_cmnd *cmd, char status)
318{
319	cmd->result = (cmd->result & 0xffff00ff) | (status << 8);
320}
321
322static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
323{
324	cmd->result = (cmd->result & 0xff00ffff) | (status << 16);
325}
326
327static inline void set_driver_byte(struct scsi_cmnd *cmd, char status)
328{
329	cmd->result = (cmd->result & 0x00ffffff) | (status << 24);
330}
331
332static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
333{
334	unsigned int xfer_len = scmd->sdb.length;
335	unsigned int prot_interval = scsi_prot_interval(scmd);
336
337	if (scmd->prot_flags & SCSI_PROT_TRANSFER_PI)
338		xfer_len += (xfer_len >> ilog2(prot_interval)) * 8;
339
340	return xfer_len;
341}
342
343#endif /* _SCSI_SCSI_CMND_H */
344