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 #include <scsi/scsi_device.h> 11 #include <scsi/scsi_request.h> 12 13 struct Scsi_Host; 14 struct scsi_driver; 15 16 #include <scsi/scsi_device.h> 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 35 struct scsi_data_buffer { 36 struct sg_table table; 37 unsigned length; 38 int resid; 39 }; 40 41 /* embedded in scsi_cmnd */ 42 struct scsi_pointer { 43 char *ptr; /* data pointer */ 44 int this_residual; /* left in this buffer */ 45 struct scatterlist *buffer; /* which buffer */ 46 int buffers_residual; /* how many buffers left */ 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 /* for scmd->flags */ 58 #define SCMD_TAGGED (1 << 0) 59 #define SCMD_UNCHECKED_ISA_DMA (1 << 1) 60 #define SCMD_ZONE_WRITE_LOCK (1 << 2) 61 62 struct scsi_cmnd { 63 struct scsi_request req; 64 struct scsi_device *device; 65 struct list_head list; /* scsi_cmnd participates in queue lists */ 66 struct list_head eh_entry; /* entry for the host eh_cmd_q */ 67 struct delayed_work abort_work; 68 int eh_eflags; /* Used by error handlr */ 69 70 /* 71 * A SCSI Command is assigned a nonzero serial_number before passed 72 * to the driver's queue command function. The serial_number is 73 * cleared when scsi_done is entered indicating that the command 74 * has been completed. It is a bug for LLDDs to use this number 75 * for purposes other than printk (and even that is only useful 76 * for debugging). 77 */ 78 unsigned long serial_number; 79 80 /* 81 * This is set to jiffies as it was when the command was first 82 * allocated. It is used to time how long the command has 83 * been outstanding 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 /* These elements define the operation we are about to perform */ 98 unsigned char *cmnd; 99 100 101 /* These elements define the operation we ultimately want to perform */ 102 struct scsi_data_buffer sdb; 103 struct scsi_data_buffer *prot_sdb; 104 105 unsigned underflow; /* Return error if less than 106 this amount is transferred */ 107 108 unsigned transfersize; /* How much we are guaranteed to 109 transfer with each SCSI transfer 110 (ie, between disconnect / 111 reconnects. Probably == sector 112 size */ 113 114 struct request *request; /* The command we are 115 working on */ 116 117 #define SCSI_SENSE_BUFFERSIZE 96 118 unsigned char *sense_buffer; 119 /* obtained by REQUEST SENSE when 120 * CHECK CONDITION is received on original 121 * command (auto-sense) */ 122 123 /* Low-level done function - can be used by low-level driver to point 124 * to completion function. Not used by mid/upper level code. */ 125 void (*scsi_done) (struct scsi_cmnd *); 126 127 /* 128 * The following fields can be written to by the host specific code. 129 * Everything else should be left alone. 130 */ 131 struct scsi_pointer SCp; /* Scratchpad used by some host adapters */ 132 133 unsigned char *host_scribble; /* The host adapter is allowed to 134 * call scsi_malloc and get some memory 135 * and hang it here. The host adapter 136 * is also expected to call scsi_free 137 * to release this memory. (The memory 138 * obtained by scsi_malloc is guaranteed 139 * to be at an address < 16Mb). */ 140 141 int result; /* Status code from lower level driver */ 142 int flags; /* Command flags */ 143 144 unsigned char tag; /* SCSI-II queued command tag */ 145 }; 146 147 /* 148 * Return the driver private allocation behind the command. 149 * Only works if cmd_size is set in the host template. 150 */ 151 static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd) 152 { 153 return cmd + 1; 154 } 155 156 /* make sure not to use it with passthrough commands */ 157 static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd) 158 { 159 return *(struct scsi_driver **)cmd->request->rq_disk->private_data; 160 } 161 162 extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t); 163 extern void scsi_put_command(struct scsi_cmnd *); 164 extern void scsi_finish_command(struct scsi_cmnd *cmd); 165 166 extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count, 167 size_t *offset, size_t *len); 168 extern void scsi_kunmap_atomic_sg(void *virt); 169 170 extern int scsi_init_io(struct scsi_cmnd *cmd); 171 extern void scsi_initialize_rq(struct request *rq); 172 173 extern int scsi_dma_map(struct scsi_cmnd *cmd); 174 extern void scsi_dma_unmap(struct scsi_cmnd *cmd); 175 176 static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd) 177 { 178 return cmd->sdb.table.nents; 179 } 180 181 static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd) 182 { 183 return cmd->sdb.table.sgl; 184 } 185 186 static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd) 187 { 188 return cmd->sdb.length; 189 } 190 191 static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid) 192 { 193 cmd->sdb.resid = resid; 194 } 195 196 static inline int scsi_get_resid(struct scsi_cmnd *cmd) 197 { 198 return cmd->sdb.resid; 199 } 200 201 #define scsi_for_each_sg(cmd, sg, nseg, __i) \ 202 for_each_sg(scsi_sglist(cmd), sg, nseg, __i) 203 204 static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd) 205 { 206 return blk_bidi_rq(cmd->request) && 207 (cmd->request->next_rq->special != NULL); 208 } 209 210 static inline struct scsi_data_buffer *scsi_in(struct scsi_cmnd *cmd) 211 { 212 return scsi_bidi_cmnd(cmd) ? 213 cmd->request->next_rq->special : &cmd->sdb; 214 } 215 216 static inline struct scsi_data_buffer *scsi_out(struct scsi_cmnd *cmd) 217 { 218 return &cmd->sdb; 219 } 220 221 static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd, 222 void *buf, int buflen) 223 { 224 return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd), 225 buf, buflen); 226 } 227 228 static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd, 229 void *buf, int buflen) 230 { 231 return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd), 232 buf, buflen); 233 } 234 235 /* 236 * The operations below are hints that tell the controller driver how 237 * to handle I/Os with DIF or similar types of protection information. 238 */ 239 enum scsi_prot_operations { 240 /* Normal I/O */ 241 SCSI_PROT_NORMAL = 0, 242 243 /* OS-HBA: Protected, HBA-Target: Unprotected */ 244 SCSI_PROT_READ_INSERT, 245 SCSI_PROT_WRITE_STRIP, 246 247 /* OS-HBA: Unprotected, HBA-Target: Protected */ 248 SCSI_PROT_READ_STRIP, 249 SCSI_PROT_WRITE_INSERT, 250 251 /* OS-HBA: Protected, HBA-Target: Protected */ 252 SCSI_PROT_READ_PASS, 253 SCSI_PROT_WRITE_PASS, 254 }; 255 256 static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op) 257 { 258 scmd->prot_op = op; 259 } 260 261 static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd) 262 { 263 return scmd->prot_op; 264 } 265 266 enum scsi_prot_flags { 267 SCSI_PROT_TRANSFER_PI = 1 << 0, 268 SCSI_PROT_GUARD_CHECK = 1 << 1, 269 SCSI_PROT_REF_CHECK = 1 << 2, 270 SCSI_PROT_REF_INCREMENT = 1 << 3, 271 SCSI_PROT_IP_CHECKSUM = 1 << 4, 272 }; 273 274 /* 275 * The controller usually does not know anything about the target it 276 * is communicating with. However, when DIX is enabled the controller 277 * must be know target type so it can verify the protection 278 * information passed along with the I/O. 279 */ 280 enum scsi_prot_target_type { 281 SCSI_PROT_DIF_TYPE0 = 0, 282 SCSI_PROT_DIF_TYPE1, 283 SCSI_PROT_DIF_TYPE2, 284 SCSI_PROT_DIF_TYPE3, 285 }; 286 287 static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type) 288 { 289 scmd->prot_type = type; 290 } 291 292 static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd) 293 { 294 return scmd->prot_type; 295 } 296 297 static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd) 298 { 299 return blk_rq_pos(scmd->request); 300 } 301 302 static inline unsigned int scsi_prot_interval(struct scsi_cmnd *scmd) 303 { 304 return scmd->device->sector_size; 305 } 306 307 static inline u32 scsi_prot_ref_tag(struct scsi_cmnd *scmd) 308 { 309 return blk_rq_pos(scmd->request) >> 310 (ilog2(scsi_prot_interval(scmd)) - 9) & 0xffffffff; 311 } 312 313 static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd) 314 { 315 return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0; 316 } 317 318 static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd) 319 { 320 return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL; 321 } 322 323 static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd) 324 { 325 return cmd->prot_sdb; 326 } 327 328 #define scsi_for_each_prot_sg(cmd, sg, nseg, __i) \ 329 for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i) 330 331 static inline void set_msg_byte(struct scsi_cmnd *cmd, char status) 332 { 333 cmd->result = (cmd->result & 0xffff00ff) | (status << 8); 334 } 335 336 static inline void set_host_byte(struct scsi_cmnd *cmd, char status) 337 { 338 cmd->result = (cmd->result & 0xff00ffff) | (status << 16); 339 } 340 341 static inline void set_driver_byte(struct scsi_cmnd *cmd, char status) 342 { 343 cmd->result = (cmd->result & 0x00ffffff) | (status << 24); 344 } 345 346 static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd) 347 { 348 unsigned int xfer_len = scsi_out(scmd)->length; 349 unsigned int prot_interval = scsi_prot_interval(scmd); 350 351 if (scmd->prot_flags & SCSI_PROT_TRANSFER_PI) 352 xfer_len += (xfer_len >> ilog2(prot_interval)) * 8; 353 354 return xfer_len; 355 } 356 357 #endif /* _SCSI_SCSI_CMND_H */ 358