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 | /** |
71 | * struct zoned_disk_info - Specific properties of a ZBC SCSI device. |
72 | * @nr_zones: number of zones. |
73 | * @zone_blocks: number of logical blocks per zone. |
74 | * |
75 | * This data structure holds the ZBC SCSI device properties that are retrieved |
76 | * twice: a first time before the gendisk capacity is known and a second time |
77 | * after the gendisk capacity is known. |
78 | */ |
79 | struct zoned_disk_info { |
80 | u32 nr_zones; |
81 | u32 zone_blocks; |
82 | }; |
83 | |
84 | struct scsi_disk { |
85 | struct scsi_device *device; |
86 | |
87 | /* |
88 | * disk_dev is used to show attributes in /sys/class/scsi_disk/, |
89 | * but otherwise not really needed. Do not use for refcounting. |
90 | */ |
91 | struct device disk_dev; |
92 | struct gendisk *disk; |
93 | struct opal_dev *opal_dev; |
94 | #ifdef CONFIG_BLK_DEV_ZONED |
95 | /* Updated during revalidation before the gendisk capacity is known. */ |
96 | struct zoned_disk_info early_zone_info; |
97 | /* Updated during revalidation after the gendisk capacity is known. */ |
98 | struct zoned_disk_info zone_info; |
99 | u32 zones_optimal_open; |
100 | u32 zones_optimal_nonseq; |
101 | u32 zones_max_open; |
102 | /* |
103 | * Either zero or a power of two. If not zero it means that the offset |
104 | * between zone starting LBAs is constant. |
105 | */ |
106 | u32 zone_starting_lba_gran; |
107 | u32 *zones_wp_offset; |
108 | spinlock_t zones_wp_offset_lock; |
109 | u32 *rev_wp_offset; |
110 | struct mutex rev_mutex; |
111 | struct work_struct zone_wp_offset_work; |
112 | char *zone_wp_update_buf; |
113 | #endif |
114 | atomic_t openers; |
115 | sector_t capacity; /* size in logical blocks */ |
116 | int max_retries; |
117 | u32 min_xfer_blocks; |
118 | u32 max_xfer_blocks; |
119 | u32 opt_xfer_blocks; |
120 | u32 max_ws_blocks; |
121 | u32 max_unmap_blocks; |
122 | u32 unmap_granularity; |
123 | u32 unmap_alignment; |
124 | u32 index; |
125 | unsigned int physical_block_size; |
126 | unsigned int max_medium_access_timeouts; |
127 | unsigned int medium_access_timed_out; |
128 | u8 media_present; |
129 | u8 write_prot; |
130 | u8 protection_type;/* Data Integrity Field */ |
131 | u8 provisioning_mode; |
132 | u8 zeroing_mode; |
133 | u8 nr_actuators; /* Number of actuators */ |
134 | bool suspended; /* Disk is suspended (stopped) */ |
135 | unsigned ATO : 1; /* state of disk ATO bit */ |
136 | unsigned cache_override : 1; /* temp override of WCE,RCD */ |
137 | unsigned WCE : 1; /* state of disk WCE bit */ |
138 | unsigned RCD : 1; /* state of disk RCD bit, unused */ |
139 | unsigned DPOFUA : 1; /* state of disk DPOFUA bit */ |
140 | unsigned first_scan : 1; |
141 | unsigned lbpme : 1; |
142 | unsigned lbprz : 1; |
143 | unsigned lbpu : 1; |
144 | unsigned lbpws : 1; |
145 | unsigned lbpws10 : 1; |
146 | unsigned lbpvpd : 1; |
147 | unsigned ws10 : 1; |
148 | unsigned ws16 : 1; |
149 | unsigned rc_basis: 2; |
150 | unsigned zoned: 2; |
151 | unsigned urswrz : 1; |
152 | unsigned security : 1; |
153 | unsigned ignore_medium_access_errors : 1; |
154 | }; |
155 | #define to_scsi_disk(obj) container_of(obj, struct scsi_disk, disk_dev) |
156 | |
157 | static inline struct scsi_disk *scsi_disk(struct gendisk *disk) |
158 | { |
159 | return disk->private_data; |
160 | } |
161 | |
162 | #define sd_printk(prefix, sdsk, fmt, a...) \ |
163 | (sdsk)->disk ? \ |
164 | sdev_prefix_printk(prefix, (sdsk)->device, \ |
165 | (sdsk)->disk->disk_name, fmt, ##a) : \ |
166 | sdev_printk(prefix, (sdsk)->device, fmt, ##a) |
167 | |
168 | #define sd_first_printk(prefix, sdsk, fmt, a...) \ |
169 | do { \ |
170 | if ((sdsk)->first_scan) \ |
171 | sd_printk(prefix, sdsk, fmt, ##a); \ |
172 | } while (0) |
173 | |
174 | static inline int scsi_medium_access_command(struct scsi_cmnd *scmd) |
175 | { |
176 | switch (scmd->cmnd[0]) { |
177 | case READ_6: |
178 | case READ_10: |
179 | case READ_12: |
180 | case READ_16: |
181 | case SYNCHRONIZE_CACHE: |
182 | case VERIFY: |
183 | case VERIFY_12: |
184 | case VERIFY_16: |
185 | case WRITE_6: |
186 | case WRITE_10: |
187 | case WRITE_12: |
188 | case WRITE_16: |
189 | case WRITE_SAME: |
190 | case WRITE_SAME_16: |
191 | case UNMAP: |
192 | return 1; |
193 | case VARIABLE_LENGTH_CMD: |
194 | switch (scmd->cmnd[9]) { |
195 | case READ_32: |
196 | case VERIFY_32: |
197 | case WRITE_32: |
198 | case WRITE_SAME_32: |
199 | return 1; |
200 | } |
201 | } |
202 | |
203 | return 0; |
204 | } |
205 | |
206 | static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks) |
207 | { |
208 | return blocks << (ilog2(sdev->sector_size) - 9); |
209 | } |
210 | |
211 | static inline unsigned int logical_to_bytes(struct scsi_device *sdev, sector_t blocks) |
212 | { |
213 | return blocks * sdev->sector_size; |
214 | } |
215 | |
216 | static inline sector_t bytes_to_logical(struct scsi_device *sdev, unsigned int bytes) |
217 | { |
218 | return bytes >> ilog2(sdev->sector_size); |
219 | } |
220 | |
221 | static inline sector_t sectors_to_logical(struct scsi_device *sdev, sector_t sector) |
222 | { |
223 | return sector >> (ilog2(sdev->sector_size) - 9); |
224 | } |
225 | |
226 | #ifdef CONFIG_BLK_DEV_INTEGRITY |
227 | |
228 | extern void sd_dif_config_host(struct scsi_disk *); |
229 | |
230 | #else /* CONFIG_BLK_DEV_INTEGRITY */ |
231 | |
232 | static inline void sd_dif_config_host(struct scsi_disk *disk) |
233 | { |
234 | } |
235 | |
236 | #endif /* CONFIG_BLK_DEV_INTEGRITY */ |
237 | |
238 | static inline int sd_is_zoned(struct scsi_disk *sdkp) |
239 | { |
240 | return sdkp->zoned == 1 || sdkp->device->type == TYPE_ZBC; |
241 | } |
242 | |
243 | #ifdef CONFIG_BLK_DEV_ZONED |
244 | |
245 | void sd_zbc_free_zone_info(struct scsi_disk *sdkp); |
246 | int sd_zbc_read_zones(struct scsi_disk *sdkp, u8 buf[SD_BUF_SIZE]); |
247 | int sd_zbc_revalidate_zones(struct scsi_disk *sdkp); |
248 | blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd, |
249 | unsigned char op, bool all); |
250 | unsigned int sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes, |
251 | struct scsi_sense_hdr *sshdr); |
252 | int sd_zbc_report_zones(struct gendisk *disk, sector_t sector, |
253 | unsigned int nr_zones, report_zones_cb cb, void *data); |
254 | |
255 | blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd, sector_t *lba, |
256 | unsigned int nr_blocks); |
257 | |
258 | #else /* CONFIG_BLK_DEV_ZONED */ |
259 | |
260 | static inline void sd_zbc_free_zone_info(struct scsi_disk *sdkp) {} |
261 | |
262 | static inline int sd_zbc_read_zones(struct scsi_disk *sdkp, u8 buf[SD_BUF_SIZE]) |
263 | { |
264 | return 0; |
265 | } |
266 | |
267 | static inline int sd_zbc_revalidate_zones(struct scsi_disk *sdkp) |
268 | { |
269 | return 0; |
270 | } |
271 | |
272 | static inline blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd, |
273 | unsigned char op, |
274 | bool all) |
275 | { |
276 | return BLK_STS_TARGET; |
277 | } |
278 | |
279 | static inline unsigned int sd_zbc_complete(struct scsi_cmnd *cmd, |
280 | unsigned int good_bytes, struct scsi_sense_hdr *sshdr) |
281 | { |
282 | return good_bytes; |
283 | } |
284 | |
285 | static inline blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd, |
286 | sector_t *lba, |
287 | unsigned int nr_blocks) |
288 | { |
289 | return BLK_STS_TARGET; |
290 | } |
291 | |
292 | #define sd_zbc_report_zones NULL |
293 | |
294 | #endif /* CONFIG_BLK_DEV_ZONED */ |
295 | |
296 | void sd_print_sense_hdr(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr); |
297 | void sd_print_result(const struct scsi_disk *sdkp, const char *msg, int result); |
298 | |
299 | #endif /* _SCSI_DISK_H */ |
300 | |