Merge branch 'linux-4.4' of https://github.com/skeggsb/linux into drm-fixes
[firefly-linux-kernel-4.4.55.git] / drivers / scsi / sd.h
1 #ifndef _SCSI_DISK_H
2 #define _SCSI_DISK_H
3
4 /*
5  * More than enough for everybody ;)  The huge number of majors
6  * is a leftover from 16bit dev_t days, we don't really need that
7  * much numberspace.
8  */
9 #define SD_MAJORS       16
10
11 /*
12  * Time out in seconds for disks and Magneto-opticals (which are slower).
13  */
14 #define SD_TIMEOUT              (30 * HZ)
15 #define SD_MOD_TIMEOUT          (75 * HZ)
16 /*
17  * Flush timeout is a multiplier over the standard device timeout which is
18  * user modifiable via sysfs but initially set to SD_TIMEOUT
19  */
20 #define SD_FLUSH_TIMEOUT_MULTIPLIER     2
21 #define SD_WRITE_SAME_TIMEOUT   (120 * HZ)
22
23 /*
24  * Number of allowed retries
25  */
26 #define SD_MAX_RETRIES          5
27 #define SD_PASSTHROUGH_RETRIES  1
28 #define SD_MAX_MEDIUM_TIMEOUTS  2
29
30 /*
31  * Size of the initial data buffer for mode and read capacity data
32  */
33 #define SD_BUF_SIZE             512
34
35 /*
36  * Number of sectors at the end of the device to avoid multi-sector
37  * accesses to in the case of last_sector_bug
38  */
39 #define SD_LAST_BUGGY_SECTORS   8
40
41 enum {
42         SD_EXT_CDB_SIZE = 32,   /* Extended CDB size */
43         SD_MEMPOOL_SIZE = 2,    /* CDB pool size */
44 };
45
46 enum {
47         SD_DEF_XFER_BLOCKS = 0xffff,
48         SD_MAX_XFER_BLOCKS = 0xffffffff,
49         SD_MAX_WS10_BLOCKS = 0xffff,
50         SD_MAX_WS16_BLOCKS = 0x7fffff,
51 };
52
53 enum {
54         SD_LBP_FULL = 0,        /* Full logical block provisioning */
55         SD_LBP_UNMAP,           /* Use UNMAP command */
56         SD_LBP_WS16,            /* Use WRITE SAME(16) with UNMAP bit */
57         SD_LBP_WS10,            /* Use WRITE SAME(10) with UNMAP bit */
58         SD_LBP_ZERO,            /* Use WRITE SAME(10) with zero payload */
59         SD_LBP_DISABLE,         /* Discard disabled due to failed cmd */
60 };
61
62 struct scsi_disk {
63         struct scsi_driver *driver;     /* always &sd_template */
64         struct scsi_device *device;
65         struct device   dev;
66         struct gendisk  *disk;
67         atomic_t        openers;
68         sector_t        capacity;       /* size in 512-byte sectors */
69         u32             max_xfer_blocks;
70         u32             opt_xfer_blocks;
71         u32             max_ws_blocks;
72         u32             max_unmap_blocks;
73         u32             unmap_granularity;
74         u32             unmap_alignment;
75         u32             index;
76         unsigned int    physical_block_size;
77         unsigned int    max_medium_access_timeouts;
78         unsigned int    medium_access_timed_out;
79         u8              media_present;
80         u8              write_prot;
81         u8              protection_type;/* Data Integrity Field */
82         u8              provisioning_mode;
83         unsigned        ATO : 1;        /* state of disk ATO bit */
84         unsigned        cache_override : 1; /* temp override of WCE,RCD */
85         unsigned        WCE : 1;        /* state of disk WCE bit */
86         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
87         unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
88         unsigned        first_scan : 1;
89         unsigned        lbpme : 1;
90         unsigned        lbprz : 1;
91         unsigned        lbpu : 1;
92         unsigned        lbpws : 1;
93         unsigned        lbpws10 : 1;
94         unsigned        lbpvpd : 1;
95         unsigned        ws10 : 1;
96         unsigned        ws16 : 1;
97 };
98 #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
99
100 static inline struct scsi_disk *scsi_disk(struct gendisk *disk)
101 {
102         return container_of(disk->private_data, struct scsi_disk, driver);
103 }
104
105 #define sd_printk(prefix, sdsk, fmt, a...)                              \
106         (sdsk)->disk ?                                                  \
107               sdev_prefix_printk(prefix, (sdsk)->device,                \
108                                  (sdsk)->disk->disk_name, fmt, ##a) :   \
109               sdev_printk(prefix, (sdsk)->device, fmt, ##a)
110
111 #define sd_first_printk(prefix, sdsk, fmt, a...)                        \
112         do {                                                            \
113                 if ((sdkp)->first_scan)                                 \
114                         sd_printk(prefix, sdsk, fmt, ##a);              \
115         } while (0)
116
117 static inline int scsi_medium_access_command(struct scsi_cmnd *scmd)
118 {
119         switch (scmd->cmnd[0]) {
120         case READ_6:
121         case READ_10:
122         case READ_12:
123         case READ_16:
124         case SYNCHRONIZE_CACHE:
125         case VERIFY:
126         case VERIFY_12:
127         case VERIFY_16:
128         case WRITE_6:
129         case WRITE_10:
130         case WRITE_12:
131         case WRITE_16:
132         case WRITE_SAME:
133         case WRITE_SAME_16:
134         case UNMAP:
135                 return 1;
136         case VARIABLE_LENGTH_CMD:
137                 switch (scmd->cmnd[9]) {
138                 case READ_32:
139                 case VERIFY_32:
140                 case WRITE_32:
141                 case WRITE_SAME_32:
142                         return 1;
143                 }
144         }
145
146         return 0;
147 }
148
149 /*
150  * A DIF-capable target device can be formatted with different
151  * protection schemes.  Currently 0 through 3 are defined:
152  *
153  * Type 0 is regular (unprotected) I/O
154  *
155  * Type 1 defines the contents of the guard and reference tags
156  *
157  * Type 2 defines the contents of the guard and reference tags and
158  * uses 32-byte commands to seed the latter
159  *
160  * Type 3 defines the contents of the guard tag only
161  */
162
163 enum sd_dif_target_protection_types {
164         SD_DIF_TYPE0_PROTECTION = 0x0,
165         SD_DIF_TYPE1_PROTECTION = 0x1,
166         SD_DIF_TYPE2_PROTECTION = 0x2,
167         SD_DIF_TYPE3_PROTECTION = 0x3,
168 };
169
170 /*
171  * Look up the DIX operation based on whether the command is read or
172  * write and whether dix and dif are enabled.
173  */
174 static inline unsigned int sd_prot_op(bool write, bool dix, bool dif)
175 {
176         /* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
177         const unsigned int ops[] = {    /* wrt dix dif */
178                 SCSI_PROT_NORMAL,       /*  0   0   0  */
179                 SCSI_PROT_READ_STRIP,   /*  0   0   1  */
180                 SCSI_PROT_READ_INSERT,  /*  0   1   0  */
181                 SCSI_PROT_READ_PASS,    /*  0   1   1  */
182                 SCSI_PROT_NORMAL,       /*  1   0   0  */
183                 SCSI_PROT_WRITE_INSERT, /*  1   0   1  */
184                 SCSI_PROT_WRITE_STRIP,  /*  1   1   0  */
185                 SCSI_PROT_WRITE_PASS,   /*  1   1   1  */
186         };
187
188         return ops[write << 2 | dix << 1 | dif];
189 }
190
191 /*
192  * Returns a mask of the protection flags that are valid for a given DIX
193  * operation.
194  */
195 static inline unsigned int sd_prot_flag_mask(unsigned int prot_op)
196 {
197         const unsigned int flag_mask[] = {
198                 [SCSI_PROT_NORMAL]              = 0,
199
200                 [SCSI_PROT_READ_STRIP]          = SCSI_PROT_TRANSFER_PI |
201                                                   SCSI_PROT_GUARD_CHECK |
202                                                   SCSI_PROT_REF_CHECK |
203                                                   SCSI_PROT_REF_INCREMENT,
204
205                 [SCSI_PROT_READ_INSERT]         = SCSI_PROT_REF_INCREMENT |
206                                                   SCSI_PROT_IP_CHECKSUM,
207
208                 [SCSI_PROT_READ_PASS]           = SCSI_PROT_TRANSFER_PI |
209                                                   SCSI_PROT_GUARD_CHECK |
210                                                   SCSI_PROT_REF_CHECK |
211                                                   SCSI_PROT_REF_INCREMENT |
212                                                   SCSI_PROT_IP_CHECKSUM,
213
214                 [SCSI_PROT_WRITE_INSERT]        = SCSI_PROT_TRANSFER_PI |
215                                                   SCSI_PROT_REF_INCREMENT,
216
217                 [SCSI_PROT_WRITE_STRIP]         = SCSI_PROT_GUARD_CHECK |
218                                                   SCSI_PROT_REF_CHECK |
219                                                   SCSI_PROT_REF_INCREMENT |
220                                                   SCSI_PROT_IP_CHECKSUM,
221
222                 [SCSI_PROT_WRITE_PASS]          = SCSI_PROT_TRANSFER_PI |
223                                                   SCSI_PROT_GUARD_CHECK |
224                                                   SCSI_PROT_REF_CHECK |
225                                                   SCSI_PROT_REF_INCREMENT |
226                                                   SCSI_PROT_IP_CHECKSUM,
227         };
228
229         return flag_mask[prot_op];
230 }
231
232 /*
233  * Data Integrity Field tuple.
234  */
235 struct sd_dif_tuple {
236        __be16 guard_tag;        /* Checksum */
237        __be16 app_tag;          /* Opaque storage */
238        __be32 ref_tag;          /* Target LBA or indirect LBA */
239 };
240
241 #ifdef CONFIG_BLK_DEV_INTEGRITY
242
243 extern void sd_dif_config_host(struct scsi_disk *);
244 extern void sd_dif_prepare(struct scsi_cmnd *scmd);
245 extern void sd_dif_complete(struct scsi_cmnd *, unsigned int);
246
247 #else /* CONFIG_BLK_DEV_INTEGRITY */
248
249 static inline void sd_dif_config_host(struct scsi_disk *disk)
250 {
251 }
252 static inline int sd_dif_prepare(struct scsi_cmnd *scmd)
253 {
254         return 0;
255 }
256 static inline void sd_dif_complete(struct scsi_cmnd *cmd, unsigned int a)
257 {
258 }
259
260 #endif /* CONFIG_BLK_DEV_INTEGRITY */
261
262 #endif /* _SCSI_DISK_H */