scsi: sd: Remove zone write locking
[sfrench/cifs-2.6.git] / drivers / scsi / sd.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _SCSI_DISK_H
3 #define _SCSI_DISK_H
4
5 /*
6  * More than enough for everybody ;)  The huge number of majors
7  * is a leftover from 16bit dev_t days, we don't really need that
8  * much numberspace.
9  */
10 #define SD_MAJORS       16
11
12 /*
13  * Time out in seconds for disks and Magneto-opticals (which are slower).
14  */
15 #define SD_TIMEOUT              (30 * HZ)
16 #define SD_MOD_TIMEOUT          (75 * HZ)
17 /*
18  * Flush timeout is a multiplier over the standard device timeout which is
19  * user modifiable via sysfs but initially set to SD_TIMEOUT
20  */
21 #define SD_FLUSH_TIMEOUT_MULTIPLIER     2
22 #define SD_WRITE_SAME_TIMEOUT   (120 * HZ)
23
24 /*
25  * Number of allowed retries
26  */
27 #define SD_MAX_RETRIES          5
28 #define SD_PASSTHROUGH_RETRIES  1
29 #define SD_MAX_MEDIUM_TIMEOUTS  2
30
31 /*
32  * Size of the initial data buffer for mode and read capacity data
33  */
34 #define SD_BUF_SIZE             512
35
36 /*
37  * Number of sectors at the end of the device to avoid multi-sector
38  * accesses to in the case of last_sector_bug
39  */
40 #define SD_LAST_BUGGY_SECTORS   8
41
42 enum {
43         SD_EXT_CDB_SIZE = 32,   /* Extended CDB size */
44         SD_MEMPOOL_SIZE = 2,    /* CDB pool size */
45 };
46
47 enum {
48         SD_DEF_XFER_BLOCKS = 0xffff,
49         SD_MAX_XFER_BLOCKS = 0xffffffff,
50         SD_MAX_WS10_BLOCKS = 0xffff,
51         SD_MAX_WS16_BLOCKS = 0x7fffff,
52 };
53
54 enum {
55         SD_LBP_FULL = 0,        /* Full logical block provisioning */
56         SD_LBP_UNMAP,           /* Use UNMAP command */
57         SD_LBP_WS16,            /* Use WRITE SAME(16) with UNMAP bit */
58         SD_LBP_WS10,            /* Use WRITE SAME(10) with UNMAP bit */
59         SD_LBP_ZERO,            /* Use WRITE SAME(10) with zero payload */
60         SD_LBP_DISABLE,         /* Discard disabled due to failed cmd */
61 };
62
63 enum {
64         SD_ZERO_WRITE = 0,      /* Use WRITE(10/16) command */
65         SD_ZERO_WS,             /* Use WRITE SAME(10/16) command */
66         SD_ZERO_WS16_UNMAP,     /* Use WRITE SAME(16) with UNMAP */
67         SD_ZERO_WS10_UNMAP,     /* Use WRITE SAME(10) with UNMAP */
68 };
69
70 struct scsi_disk {
71         struct scsi_driver *driver;     /* always &sd_template */
72         struct scsi_device *device;
73         struct device   dev;
74         struct gendisk  *disk;
75         struct opal_dev *opal_dev;
76 #ifdef CONFIG_BLK_DEV_ZONED
77         unsigned int    nr_zones;
78         unsigned int    zone_blocks;
79         unsigned int    zone_shift;
80         unsigned int    zones_optimal_open;
81         unsigned int    zones_optimal_nonseq;
82         unsigned int    zones_max_open;
83 #endif
84         atomic_t        openers;
85         sector_t        capacity;       /* size in logical blocks */
86         u32             max_xfer_blocks;
87         u32             opt_xfer_blocks;
88         u32             max_ws_blocks;
89         u32             max_unmap_blocks;
90         u32             unmap_granularity;
91         u32             unmap_alignment;
92         u32             index;
93         unsigned int    physical_block_size;
94         unsigned int    max_medium_access_timeouts;
95         unsigned int    medium_access_timed_out;
96         u8              media_present;
97         u8              write_prot;
98         u8              protection_type;/* Data Integrity Field */
99         u8              provisioning_mode;
100         u8              zeroing_mode;
101         unsigned        ATO : 1;        /* state of disk ATO bit */
102         unsigned        cache_override : 1; /* temp override of WCE,RCD */
103         unsigned        WCE : 1;        /* state of disk WCE bit */
104         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
105         unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
106         unsigned        first_scan : 1;
107         unsigned        lbpme : 1;
108         unsigned        lbprz : 1;
109         unsigned        lbpu : 1;
110         unsigned        lbpws : 1;
111         unsigned        lbpws10 : 1;
112         unsigned        lbpvpd : 1;
113         unsigned        ws10 : 1;
114         unsigned        ws16 : 1;
115         unsigned        rc_basis: 2;
116         unsigned        zoned: 2;
117         unsigned        urswrz : 1;
118         unsigned        security : 1;
119         unsigned        ignore_medium_access_errors : 1;
120 };
121 #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
122
123 static inline struct scsi_disk *scsi_disk(struct gendisk *disk)
124 {
125         return container_of(disk->private_data, struct scsi_disk, driver);
126 }
127
128 #define sd_printk(prefix, sdsk, fmt, a...)                              \
129         (sdsk)->disk ?                                                  \
130               sdev_prefix_printk(prefix, (sdsk)->device,                \
131                                  (sdsk)->disk->disk_name, fmt, ##a) :   \
132               sdev_printk(prefix, (sdsk)->device, fmt, ##a)
133
134 #define sd_first_printk(prefix, sdsk, fmt, a...)                        \
135         do {                                                            \
136                 if ((sdkp)->first_scan)                                 \
137                         sd_printk(prefix, sdsk, fmt, ##a);              \
138         } while (0)
139
140 static inline int scsi_medium_access_command(struct scsi_cmnd *scmd)
141 {
142         switch (scmd->cmnd[0]) {
143         case READ_6:
144         case READ_10:
145         case READ_12:
146         case READ_16:
147         case SYNCHRONIZE_CACHE:
148         case VERIFY:
149         case VERIFY_12:
150         case VERIFY_16:
151         case WRITE_6:
152         case WRITE_10:
153         case WRITE_12:
154         case WRITE_16:
155         case WRITE_SAME:
156         case WRITE_SAME_16:
157         case UNMAP:
158                 return 1;
159         case VARIABLE_LENGTH_CMD:
160                 switch (scmd->cmnd[9]) {
161                 case READ_32:
162                 case VERIFY_32:
163                 case WRITE_32:
164                 case WRITE_SAME_32:
165                         return 1;
166                 }
167         }
168
169         return 0;
170 }
171
172 static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks)
173 {
174         return blocks << (ilog2(sdev->sector_size) - 9);
175 }
176
177 static inline unsigned int logical_to_bytes(struct scsi_device *sdev, sector_t blocks)
178 {
179         return blocks * sdev->sector_size;
180 }
181
182 static inline sector_t bytes_to_logical(struct scsi_device *sdev, unsigned int bytes)
183 {
184         return bytes >> ilog2(sdev->sector_size);
185 }
186
187 static inline sector_t sectors_to_logical(struct scsi_device *sdev, sector_t sector)
188 {
189         return sector >> (ilog2(sdev->sector_size) - 9);
190 }
191
192 /*
193  * Look up the DIX operation based on whether the command is read or
194  * write and whether dix and dif are enabled.
195  */
196 static inline unsigned int sd_prot_op(bool write, bool dix, bool dif)
197 {
198         /* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
199         const unsigned int ops[] = {    /* wrt dix dif */
200                 SCSI_PROT_NORMAL,       /*  0   0   0  */
201                 SCSI_PROT_READ_STRIP,   /*  0   0   1  */
202                 SCSI_PROT_READ_INSERT,  /*  0   1   0  */
203                 SCSI_PROT_READ_PASS,    /*  0   1   1  */
204                 SCSI_PROT_NORMAL,       /*  1   0   0  */
205                 SCSI_PROT_WRITE_INSERT, /*  1   0   1  */
206                 SCSI_PROT_WRITE_STRIP,  /*  1   1   0  */
207                 SCSI_PROT_WRITE_PASS,   /*  1   1   1  */
208         };
209
210         return ops[write << 2 | dix << 1 | dif];
211 }
212
213 /*
214  * Returns a mask of the protection flags that are valid for a given DIX
215  * operation.
216  */
217 static inline unsigned int sd_prot_flag_mask(unsigned int prot_op)
218 {
219         const unsigned int flag_mask[] = {
220                 [SCSI_PROT_NORMAL]              = 0,
221
222                 [SCSI_PROT_READ_STRIP]          = SCSI_PROT_TRANSFER_PI |
223                                                   SCSI_PROT_GUARD_CHECK |
224                                                   SCSI_PROT_REF_CHECK |
225                                                   SCSI_PROT_REF_INCREMENT,
226
227                 [SCSI_PROT_READ_INSERT]         = SCSI_PROT_REF_INCREMENT |
228                                                   SCSI_PROT_IP_CHECKSUM,
229
230                 [SCSI_PROT_READ_PASS]           = SCSI_PROT_TRANSFER_PI |
231                                                   SCSI_PROT_GUARD_CHECK |
232                                                   SCSI_PROT_REF_CHECK |
233                                                   SCSI_PROT_REF_INCREMENT |
234                                                   SCSI_PROT_IP_CHECKSUM,
235
236                 [SCSI_PROT_WRITE_INSERT]        = SCSI_PROT_TRANSFER_PI |
237                                                   SCSI_PROT_REF_INCREMENT,
238
239                 [SCSI_PROT_WRITE_STRIP]         = SCSI_PROT_GUARD_CHECK |
240                                                   SCSI_PROT_REF_CHECK |
241                                                   SCSI_PROT_REF_INCREMENT |
242                                                   SCSI_PROT_IP_CHECKSUM,
243
244                 [SCSI_PROT_WRITE_PASS]          = SCSI_PROT_TRANSFER_PI |
245                                                   SCSI_PROT_GUARD_CHECK |
246                                                   SCSI_PROT_REF_CHECK |
247                                                   SCSI_PROT_REF_INCREMENT |
248                                                   SCSI_PROT_IP_CHECKSUM,
249         };
250
251         return flag_mask[prot_op];
252 }
253
254 #ifdef CONFIG_BLK_DEV_INTEGRITY
255
256 extern void sd_dif_config_host(struct scsi_disk *);
257 extern void sd_dif_prepare(struct scsi_cmnd *scmd);
258 extern void sd_dif_complete(struct scsi_cmnd *, unsigned int);
259
260 #else /* CONFIG_BLK_DEV_INTEGRITY */
261
262 static inline void sd_dif_config_host(struct scsi_disk *disk)
263 {
264 }
265 static inline int sd_dif_prepare(struct scsi_cmnd *scmd)
266 {
267         return 0;
268 }
269 static inline void sd_dif_complete(struct scsi_cmnd *cmd, unsigned int a)
270 {
271 }
272
273 #endif /* CONFIG_BLK_DEV_INTEGRITY */
274
275 static inline int sd_is_zoned(struct scsi_disk *sdkp)
276 {
277         return sdkp->zoned == 1 || sdkp->device->type == TYPE_ZBC;
278 }
279
280 #ifdef CONFIG_BLK_DEV_ZONED
281
282 extern int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buffer);
283 extern void sd_zbc_remove(struct scsi_disk *sdkp);
284 extern void sd_zbc_print_zones(struct scsi_disk *sdkp);
285 extern int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd);
286 extern int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd);
287 extern void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
288                             struct scsi_sense_hdr *sshdr);
289
290 #else /* CONFIG_BLK_DEV_ZONED */
291
292 static inline int sd_zbc_read_zones(struct scsi_disk *sdkp,
293                                     unsigned char *buf)
294 {
295         return 0;
296 }
297
298 static inline void sd_zbc_remove(struct scsi_disk *sdkp) {}
299
300 static inline void sd_zbc_print_zones(struct scsi_disk *sdkp) {}
301
302 static inline int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd)
303 {
304         return BLKPREP_INVALID;
305 }
306
307 static inline int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd)
308 {
309         return BLKPREP_INVALID;
310 }
311
312 static inline void sd_zbc_complete(struct scsi_cmnd *cmd,
313                                    unsigned int good_bytes,
314                                    struct scsi_sense_hdr *sshdr) {}
315
316 #endif /* CONFIG_BLK_DEV_ZONED */
317
318 #endif /* _SCSI_DISK_H */