Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[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             max_ws_blocks;
71         u32             max_unmap_blocks;
72         u32             unmap_granularity;
73         u32             unmap_alignment;
74         u32             index;
75         unsigned int    physical_block_size;
76         unsigned int    max_medium_access_timeouts;
77         unsigned int    medium_access_timed_out;
78         u8              media_present;
79         u8              write_prot;
80         u8              protection_type;/* Data Integrity Field */
81         u8              provisioning_mode;
82         unsigned        ATO : 1;        /* state of disk ATO bit */
83         unsigned        cache_override : 1; /* temp override of WCE,RCD */
84         unsigned        WCE : 1;        /* state of disk WCE bit */
85         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
86         unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
87         unsigned        first_scan : 1;
88         unsigned        lbpme : 1;
89         unsigned        lbprz : 1;
90         unsigned        lbpu : 1;
91         unsigned        lbpws : 1;
92         unsigned        lbpws10 : 1;
93         unsigned        lbpvpd : 1;
94         unsigned        ws10 : 1;
95         unsigned        ws16 : 1;
96 };
97 #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
98
99 static inline struct scsi_disk *scsi_disk(struct gendisk *disk)
100 {
101         return container_of(disk->private_data, struct scsi_disk, driver);
102 }
103
104 #define sd_printk(prefix, sdsk, fmt, a...)                              \
105         (sdsk)->disk ?                                                  \
106               sdev_prefix_printk(prefix, (sdsk)->device,                \
107                                  (sdsk)->disk->disk_name, fmt, ##a) :   \
108               sdev_printk(prefix, (sdsk)->device, fmt, ##a)
109
110 #define sd_first_printk(prefix, sdsk, fmt, a...)                        \
111         do {                                                            \
112                 if ((sdkp)->first_scan)                                 \
113                         sd_printk(prefix, sdsk, fmt, ##a);              \
114         } while (0)
115
116 static inline int scsi_medium_access_command(struct scsi_cmnd *scmd)
117 {
118         switch (scmd->cmnd[0]) {
119         case READ_6:
120         case READ_10:
121         case READ_12:
122         case READ_16:
123         case SYNCHRONIZE_CACHE:
124         case VERIFY:
125         case VERIFY_12:
126         case VERIFY_16:
127         case WRITE_6:
128         case WRITE_10:
129         case WRITE_12:
130         case WRITE_16:
131         case WRITE_SAME:
132         case WRITE_SAME_16:
133         case UNMAP:
134                 return 1;
135         case VARIABLE_LENGTH_CMD:
136                 switch (scmd->cmnd[9]) {
137                 case READ_32:
138                 case VERIFY_32:
139                 case WRITE_32:
140                 case WRITE_SAME_32:
141                         return 1;
142                 }
143         }
144
145         return 0;
146 }
147
148 /*
149  * A DIF-capable target device can be formatted with different
150  * protection schemes.  Currently 0 through 3 are defined:
151  *
152  * Type 0 is regular (unprotected) I/O
153  *
154  * Type 1 defines the contents of the guard and reference tags
155  *
156  * Type 2 defines the contents of the guard and reference tags and
157  * uses 32-byte commands to seed the latter
158  *
159  * Type 3 defines the contents of the guard tag only
160  */
161
162 enum sd_dif_target_protection_types {
163         SD_DIF_TYPE0_PROTECTION = 0x0,
164         SD_DIF_TYPE1_PROTECTION = 0x1,
165         SD_DIF_TYPE2_PROTECTION = 0x2,
166         SD_DIF_TYPE3_PROTECTION = 0x3,
167 };
168
169 /*
170  * Look up the DIX operation based on whether the command is read or
171  * write and whether dix and dif are enabled.
172  */
173 static inline unsigned int sd_prot_op(bool write, bool dix, bool dif)
174 {
175         /* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
176         const unsigned int ops[] = {    /* wrt dix dif */
177                 SCSI_PROT_NORMAL,       /*  0   0   0  */
178                 SCSI_PROT_READ_STRIP,   /*  0   0   1  */
179                 SCSI_PROT_READ_INSERT,  /*  0   1   0  */
180                 SCSI_PROT_READ_PASS,    /*  0   1   1  */
181                 SCSI_PROT_NORMAL,       /*  1   0   0  */
182                 SCSI_PROT_WRITE_INSERT, /*  1   0   1  */
183                 SCSI_PROT_WRITE_STRIP,  /*  1   1   0  */
184                 SCSI_PROT_WRITE_PASS,   /*  1   1   1  */
185         };
186
187         return ops[write << 2 | dix << 1 | dif];
188 }
189
190 /*
191  * Returns a mask of the protection flags that are valid for a given DIX
192  * operation.
193  */
194 static inline unsigned int sd_prot_flag_mask(unsigned int prot_op)
195 {
196         const unsigned int flag_mask[] = {
197                 [SCSI_PROT_NORMAL]              = 0,
198
199                 [SCSI_PROT_READ_STRIP]          = SCSI_PROT_TRANSFER_PI |
200                                                   SCSI_PROT_GUARD_CHECK |
201                                                   SCSI_PROT_REF_CHECK |
202                                                   SCSI_PROT_REF_INCREMENT,
203
204                 [SCSI_PROT_READ_INSERT]         = SCSI_PROT_REF_INCREMENT |
205                                                   SCSI_PROT_IP_CHECKSUM,
206
207                 [SCSI_PROT_READ_PASS]           = SCSI_PROT_TRANSFER_PI |
208                                                   SCSI_PROT_GUARD_CHECK |
209                                                   SCSI_PROT_REF_CHECK |
210                                                   SCSI_PROT_REF_INCREMENT |
211                                                   SCSI_PROT_IP_CHECKSUM,
212
213                 [SCSI_PROT_WRITE_INSERT]        = SCSI_PROT_TRANSFER_PI |
214                                                   SCSI_PROT_REF_INCREMENT,
215
216                 [SCSI_PROT_WRITE_STRIP]         = SCSI_PROT_GUARD_CHECK |
217                                                   SCSI_PROT_REF_CHECK |
218                                                   SCSI_PROT_REF_INCREMENT |
219                                                   SCSI_PROT_IP_CHECKSUM,
220
221                 [SCSI_PROT_WRITE_PASS]          = SCSI_PROT_TRANSFER_PI |
222                                                   SCSI_PROT_GUARD_CHECK |
223                                                   SCSI_PROT_REF_CHECK |
224                                                   SCSI_PROT_REF_INCREMENT |
225                                                   SCSI_PROT_IP_CHECKSUM,
226         };
227
228         return flag_mask[prot_op];
229 }
230
231 /*
232  * Data Integrity Field tuple.
233  */
234 struct sd_dif_tuple {
235        __be16 guard_tag;        /* Checksum */
236        __be16 app_tag;          /* Opaque storage */
237        __be32 ref_tag;          /* Target LBA or indirect LBA */
238 };
239
240 #ifdef CONFIG_BLK_DEV_INTEGRITY
241
242 extern void sd_dif_config_host(struct scsi_disk *);
243 extern void sd_dif_prepare(struct scsi_cmnd *scmd);
244 extern void sd_dif_complete(struct scsi_cmnd *, unsigned int);
245
246 #else /* CONFIG_BLK_DEV_INTEGRITY */
247
248 static inline void sd_dif_config_host(struct scsi_disk *disk)
249 {
250 }
251 static inline int sd_dif_prepare(struct scsi_cmnd *scmd)
252 {
253         return 0;
254 }
255 static inline void sd_dif_complete(struct scsi_cmnd *cmd, unsigned int a)
256 {
257 }
258
259 #endif /* CONFIG_BLK_DEV_INTEGRITY */
260
261 #endif /* _SCSI_DISK_H */