]>
Commit | Line | Data |
---|---|---|
e73aec82 MP |
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 | ||
e73aec82 MP |
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) | |
7e660100 JB |
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 | |
5db44863 | 21 | #define SD_WRITE_SAME_TIMEOUT (120 * HZ) |
e73aec82 MP |
22 | |
23 | /* | |
24 | * Number of allowed retries | |
25 | */ | |
26 | #define SD_MAX_RETRIES 5 | |
27 | #define SD_PASSTHROUGH_RETRIES 1 | |
18a4d0a2 | 28 | #define SD_MAX_MEDIUM_TIMEOUTS 2 |
e73aec82 MP |
29 | |
30 | /* | |
31 | * Size of the initial data buffer for mode and read capacity data | |
32 | */ | |
33 | #define SD_BUF_SIZE 512 | |
34 | ||
18351070 LT |
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 | ||
4e7392ec MP |
41 | enum { |
42 | SD_EXT_CDB_SIZE = 32, /* Extended CDB size */ | |
43 | SD_MEMPOOL_SIZE = 2, /* CDB pool size */ | |
44 | }; | |
45 | ||
5db44863 | 46 | enum { |
bcdb247c MP |
47 | SD_DEF_XFER_BLOCKS = 0xffff, |
48 | SD_MAX_XFER_BLOCKS = 0xffffffff, | |
5db44863 MP |
49 | SD_MAX_WS10_BLOCKS = 0xffff, |
50 | SD_MAX_WS16_BLOCKS = 0x7fffff, | |
51 | }; | |
52 | ||
c98a0eb0 MP |
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 | ||
e73aec82 MP |
62 | struct scsi_disk { |
63 | struct scsi_driver *driver; /* always &sd_template */ | |
64 | struct scsi_device *device; | |
ee959b00 | 65 | struct device dev; |
e73aec82 | 66 | struct gendisk *disk; |
89d94756 HR |
67 | #ifdef CONFIG_BLK_DEV_ZONED |
68 | unsigned int nr_zones; | |
69 | unsigned int zone_blocks; | |
70 | unsigned int zone_shift; | |
71 | unsigned long *zones_wlock; | |
72 | unsigned int zones_optimal_open; | |
73 | unsigned int zones_optimal_nonseq; | |
74 | unsigned int zones_max_open; | |
75 | #endif | |
409f3499 | 76 | atomic_t openers; |
f08bb1e0 | 77 | sector_t capacity; /* size in logical blocks */ |
bcdb247c | 78 | u32 max_xfer_blocks; |
ca369d51 | 79 | u32 opt_xfer_blocks; |
c98a0eb0 MP |
80 | u32 max_ws_blocks; |
81 | u32 max_unmap_blocks; | |
82 | u32 unmap_granularity; | |
83 | u32 unmap_alignment; | |
e73aec82 | 84 | u32 index; |
526f7c79 | 85 | unsigned int physical_block_size; |
18a4d0a2 MP |
86 | unsigned int max_medium_access_timeouts; |
87 | unsigned int medium_access_timed_out; | |
e73aec82 MP |
88 | u8 media_present; |
89 | u8 write_prot; | |
e0597d70 | 90 | u8 protection_type;/* Data Integrity Field */ |
c98a0eb0 | 91 | u8 provisioning_mode; |
e0597d70 | 92 | unsigned ATO : 1; /* state of disk ATO bit */ |
39c60a09 | 93 | unsigned cache_override : 1; /* temp override of WCE,RCD */ |
e73aec82 MP |
94 | unsigned WCE : 1; /* state of disk WCE bit */ |
95 | unsigned RCD : 1; /* state of disk RCD bit, unused */ | |
96 | unsigned DPOFUA : 1; /* state of disk DPOFUA bit */ | |
70a9b873 | 97 | unsigned first_scan : 1; |
c98a0eb0 MP |
98 | unsigned lbpme : 1; |
99 | unsigned lbprz : 1; | |
100 | unsigned lbpu : 1; | |
101 | unsigned lbpws : 1; | |
102 | unsigned lbpws10 : 1; | |
103 | unsigned lbpvpd : 1; | |
66c28f97 | 104 | unsigned ws10 : 1; |
5db44863 | 105 | unsigned ws16 : 1; |
89d94756 HR |
106 | unsigned rc_basis: 2; |
107 | unsigned zoned: 2; | |
108 | unsigned urswrz : 1; | |
e73aec82 | 109 | }; |
ee959b00 | 110 | #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev) |
e73aec82 | 111 | |
5b635da1 MP |
112 | static inline struct scsi_disk *scsi_disk(struct gendisk *disk) |
113 | { | |
114 | return container_of(disk->private_data, struct scsi_disk, driver); | |
115 | } | |
116 | ||
e73aec82 MP |
117 | #define sd_printk(prefix, sdsk, fmt, a...) \ |
118 | (sdsk)->disk ? \ | |
22e0d994 HR |
119 | sdev_prefix_printk(prefix, (sdsk)->device, \ |
120 | (sdsk)->disk->disk_name, fmt, ##a) : \ | |
121 | sdev_printk(prefix, (sdsk)->device, fmt, ##a) | |
e73aec82 | 122 | |
b2bff6ce MP |
123 | #define sd_first_printk(prefix, sdsk, fmt, a...) \ |
124 | do { \ | |
125 | if ((sdkp)->first_scan) \ | |
126 | sd_printk(prefix, sdsk, fmt, ##a); \ | |
127 | } while (0) | |
128 | ||
18a4d0a2 MP |
129 | static inline int scsi_medium_access_command(struct scsi_cmnd *scmd) |
130 | { | |
131 | switch (scmd->cmnd[0]) { | |
132 | case READ_6: | |
133 | case READ_10: | |
134 | case READ_12: | |
135 | case READ_16: | |
136 | case SYNCHRONIZE_CACHE: | |
137 | case VERIFY: | |
138 | case VERIFY_12: | |
139 | case VERIFY_16: | |
140 | case WRITE_6: | |
141 | case WRITE_10: | |
142 | case WRITE_12: | |
143 | case WRITE_16: | |
144 | case WRITE_SAME: | |
145 | case WRITE_SAME_16: | |
146 | case UNMAP: | |
147 | return 1; | |
148 | case VARIABLE_LENGTH_CMD: | |
149 | switch (scmd->cmnd[9]) { | |
150 | case READ_32: | |
151 | case VERIFY_32: | |
152 | case WRITE_32: | |
153 | case WRITE_SAME_32: | |
154 | return 1; | |
155 | } | |
156 | } | |
157 | ||
158 | return 0; | |
159 | } | |
160 | ||
f08bb1e0 MP |
161 | static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks) |
162 | { | |
163 | return blocks << (ilog2(sdev->sector_size) - 9); | |
164 | } | |
165 | ||
6b7e9cde MP |
166 | static inline unsigned int logical_to_bytes(struct scsi_device *sdev, sector_t blocks) |
167 | { | |
168 | return blocks * sdev->sector_size; | |
169 | } | |
170 | ||
89d94756 HR |
171 | static inline sector_t sectors_to_logical(struct scsi_device *sdev, sector_t sector) |
172 | { | |
173 | return sector >> (ilog2(sdev->sector_size) - 9); | |
174 | } | |
175 | ||
c611529e MP |
176 | /* |
177 | * Look up the DIX operation based on whether the command is read or | |
178 | * write and whether dix and dif are enabled. | |
179 | */ | |
180 | static inline unsigned int sd_prot_op(bool write, bool dix, bool dif) | |
181 | { | |
182 | /* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */ | |
183 | const unsigned int ops[] = { /* wrt dix dif */ | |
184 | SCSI_PROT_NORMAL, /* 0 0 0 */ | |
185 | SCSI_PROT_READ_STRIP, /* 0 0 1 */ | |
186 | SCSI_PROT_READ_INSERT, /* 0 1 0 */ | |
187 | SCSI_PROT_READ_PASS, /* 0 1 1 */ | |
188 | SCSI_PROT_NORMAL, /* 1 0 0 */ | |
189 | SCSI_PROT_WRITE_INSERT, /* 1 0 1 */ | |
190 | SCSI_PROT_WRITE_STRIP, /* 1 1 0 */ | |
191 | SCSI_PROT_WRITE_PASS, /* 1 1 1 */ | |
192 | }; | |
193 | ||
194 | return ops[write << 2 | dix << 1 | dif]; | |
195 | } | |
196 | ||
197 | /* | |
198 | * Returns a mask of the protection flags that are valid for a given DIX | |
199 | * operation. | |
200 | */ | |
201 | static inline unsigned int sd_prot_flag_mask(unsigned int prot_op) | |
202 | { | |
203 | const unsigned int flag_mask[] = { | |
204 | [SCSI_PROT_NORMAL] = 0, | |
205 | ||
206 | [SCSI_PROT_READ_STRIP] = SCSI_PROT_TRANSFER_PI | | |
207 | SCSI_PROT_GUARD_CHECK | | |
208 | SCSI_PROT_REF_CHECK | | |
209 | SCSI_PROT_REF_INCREMENT, | |
210 | ||
211 | [SCSI_PROT_READ_INSERT] = SCSI_PROT_REF_INCREMENT | | |
212 | SCSI_PROT_IP_CHECKSUM, | |
213 | ||
214 | [SCSI_PROT_READ_PASS] = SCSI_PROT_TRANSFER_PI | | |
215 | SCSI_PROT_GUARD_CHECK | | |
216 | SCSI_PROT_REF_CHECK | | |
217 | SCSI_PROT_REF_INCREMENT | | |
218 | SCSI_PROT_IP_CHECKSUM, | |
219 | ||
220 | [SCSI_PROT_WRITE_INSERT] = SCSI_PROT_TRANSFER_PI | | |
221 | SCSI_PROT_REF_INCREMENT, | |
222 | ||
223 | [SCSI_PROT_WRITE_STRIP] = SCSI_PROT_GUARD_CHECK | | |
224 | SCSI_PROT_REF_CHECK | | |
225 | SCSI_PROT_REF_INCREMENT | | |
226 | SCSI_PROT_IP_CHECKSUM, | |
227 | ||
228 | [SCSI_PROT_WRITE_PASS] = SCSI_PROT_TRANSFER_PI | | |
229 | SCSI_PROT_GUARD_CHECK | | |
230 | SCSI_PROT_REF_CHECK | | |
231 | SCSI_PROT_REF_INCREMENT | | |
232 | SCSI_PROT_IP_CHECKSUM, | |
233 | }; | |
234 | ||
235 | return flag_mask[prot_op]; | |
236 | } | |
237 | ||
4c393e6e | 238 | #ifdef CONFIG_BLK_DEV_INTEGRITY |
af55ff67 | 239 | |
af55ff67 | 240 | extern void sd_dif_config_host(struct scsi_disk *); |
c611529e | 241 | extern void sd_dif_prepare(struct scsi_cmnd *scmd); |
af55ff67 MP |
242 | extern void sd_dif_complete(struct scsi_cmnd *, unsigned int); |
243 | ||
244 | #else /* CONFIG_BLK_DEV_INTEGRITY */ | |
245 | ||
4c393e6e JB |
246 | static inline void sd_dif_config_host(struct scsi_disk *disk) |
247 | { | |
248 | } | |
c611529e | 249 | static inline int sd_dif_prepare(struct scsi_cmnd *scmd) |
4c393e6e JB |
250 | { |
251 | return 0; | |
252 | } | |
253 | static inline void sd_dif_complete(struct scsi_cmnd *cmd, unsigned int a) | |
254 | { | |
255 | } | |
af55ff67 MP |
256 | |
257 | #endif /* CONFIG_BLK_DEV_INTEGRITY */ | |
258 | ||
89d94756 HR |
259 | static inline int sd_is_zoned(struct scsi_disk *sdkp) |
260 | { | |
261 | return sdkp->zoned == 1 || sdkp->device->type == TYPE_ZBC; | |
262 | } | |
263 | ||
264 | #ifdef CONFIG_BLK_DEV_ZONED | |
265 | ||
266 | extern int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buffer); | |
267 | extern void sd_zbc_remove(struct scsi_disk *sdkp); | |
268 | extern void sd_zbc_print_zones(struct scsi_disk *sdkp); | |
269 | extern int sd_zbc_setup_write_cmnd(struct scsi_cmnd *cmd); | |
270 | extern void sd_zbc_cancel_write_cmnd(struct scsi_cmnd *cmd); | |
271 | extern int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd); | |
272 | extern int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd); | |
273 | extern void sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes, | |
274 | struct scsi_sense_hdr *sshdr); | |
275 | ||
276 | #else /* CONFIG_BLK_DEV_ZONED */ | |
277 | ||
278 | static inline int sd_zbc_read_zones(struct scsi_disk *sdkp, | |
279 | unsigned char *buf) | |
280 | { | |
281 | return 0; | |
282 | } | |
283 | ||
284 | static inline void sd_zbc_remove(struct scsi_disk *sdkp) {} | |
285 | ||
286 | static inline void sd_zbc_print_zones(struct scsi_disk *sdkp) {} | |
287 | ||
288 | static inline int sd_zbc_setup_write_cmnd(struct scsi_cmnd *cmd) | |
289 | { | |
290 | /* Let the drive fail requests */ | |
291 | return BLKPREP_OK; | |
292 | } | |
293 | ||
294 | static inline void sd_zbc_cancel_write_cmnd(struct scsi_cmnd *cmd) {} | |
295 | ||
296 | static inline int sd_zbc_setup_report_cmnd(struct scsi_cmnd *cmd) | |
297 | { | |
298 | return BLKPREP_INVALID; | |
299 | } | |
300 | ||
301 | static inline int sd_zbc_setup_reset_cmnd(struct scsi_cmnd *cmd) | |
302 | { | |
303 | return BLKPREP_INVALID; | |
304 | } | |
305 | ||
306 | static inline void sd_zbc_complete(struct scsi_cmnd *cmd, | |
307 | unsigned int good_bytes, | |
308 | struct scsi_sense_hdr *sshdr) {} | |
309 | ||
310 | #endif /* CONFIG_BLK_DEV_ZONED */ | |
311 | ||
e73aec82 | 312 | #endif /* _SCSI_DISK_H */ |