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 | /* number of permanent streams */ |
129 | u16 permanent_stream_count; |
130 | u8 media_present; |
131 | u8 write_prot; |
132 | u8 protection_type;/* Data Integrity Field */ |
133 | u8 provisioning_mode; |
134 | u8 zeroing_mode; |
135 | u8 nr_actuators; /* Number of actuators */ |
136 | bool suspended; /* Disk is suspended (stopped) */ |
137 | unsigned ATO : 1; /* state of disk ATO bit */ |
138 | unsigned cache_override : 1; /* temp override of WCE,RCD */ |
139 | unsigned WCE : 1; /* state of disk WCE bit */ |
140 | unsigned RCD : 1; /* state of disk RCD bit, unused */ |
141 | unsigned DPOFUA : 1; /* state of disk DPOFUA bit */ |
142 | unsigned first_scan : 1; |
143 | unsigned lbpme : 1; |
144 | unsigned lbprz : 1; |
145 | unsigned lbpu : 1; |
146 | unsigned lbpws : 1; |
147 | unsigned lbpws10 : 1; |
148 | unsigned lbpvpd : 1; |
149 | unsigned ws10 : 1; |
150 | unsigned ws16 : 1; |
151 | unsigned rc_basis: 2; |
152 | unsigned zoned: 2; |
153 | unsigned urswrz : 1; |
154 | unsigned security : 1; |
155 | unsigned ignore_medium_access_errors : 1; |
156 | unsigned rscs : 1; /* reduced stream control support */ |
157 | }; |
158 | #define to_scsi_disk(obj) container_of(obj, struct scsi_disk, disk_dev) |
159 | |
160 | static inline struct scsi_disk *scsi_disk(struct gendisk *disk) |
161 | { |
162 | return disk->private_data; |
163 | } |
164 | |
165 | #define sd_printk(prefix, sdsk, fmt, a...) \ |
166 | (sdsk)->disk ? \ |
167 | sdev_prefix_printk(prefix, (sdsk)->device, \ |
168 | (sdsk)->disk->disk_name, fmt, ##a) : \ |
169 | sdev_printk(prefix, (sdsk)->device, fmt, ##a) |
170 | |
171 | #define sd_first_printk(prefix, sdsk, fmt, a...) \ |
172 | do { \ |
173 | if ((sdsk)->first_scan) \ |
174 | sd_printk(prefix, sdsk, fmt, ##a); \ |
175 | } while (0) |
176 | |
177 | static inline int scsi_medium_access_command(struct scsi_cmnd *scmd) |
178 | { |
179 | switch (scmd->cmnd[0]) { |
180 | case READ_6: |
181 | case READ_10: |
182 | case READ_12: |
183 | case READ_16: |
184 | case SYNCHRONIZE_CACHE: |
185 | case VERIFY: |
186 | case VERIFY_12: |
187 | case VERIFY_16: |
188 | case WRITE_6: |
189 | case WRITE_10: |
190 | case WRITE_12: |
191 | case WRITE_16: |
192 | case WRITE_SAME: |
193 | case WRITE_SAME_16: |
194 | case UNMAP: |
195 | return 1; |
196 | case VARIABLE_LENGTH_CMD: |
197 | switch (scmd->cmnd[9]) { |
198 | case READ_32: |
199 | case VERIFY_32: |
200 | case WRITE_32: |
201 | case WRITE_SAME_32: |
202 | return 1; |
203 | } |
204 | } |
205 | |
206 | return 0; |
207 | } |
208 | |
209 | static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks) |
210 | { |
211 | return blocks << (ilog2(sdev->sector_size) - 9); |
212 | } |
213 | |
214 | static inline unsigned int logical_to_bytes(struct scsi_device *sdev, sector_t blocks) |
215 | { |
216 | return blocks * sdev->sector_size; |
217 | } |
218 | |
219 | static inline sector_t bytes_to_logical(struct scsi_device *sdev, unsigned int bytes) |
220 | { |
221 | return bytes >> ilog2(sdev->sector_size); |
222 | } |
223 | |
224 | static inline sector_t sectors_to_logical(struct scsi_device *sdev, sector_t sector) |
225 | { |
226 | return sector >> (ilog2(sdev->sector_size) - 9); |
227 | } |
228 | |
229 | #ifdef CONFIG_BLK_DEV_INTEGRITY |
230 | |
231 | extern void sd_dif_config_host(struct scsi_disk *); |
232 | |
233 | #else /* CONFIG_BLK_DEV_INTEGRITY */ |
234 | |
235 | static inline void sd_dif_config_host(struct scsi_disk *disk) |
236 | { |
237 | } |
238 | |
239 | #endif /* CONFIG_BLK_DEV_INTEGRITY */ |
240 | |
241 | static inline int sd_is_zoned(struct scsi_disk *sdkp) |
242 | { |
243 | return sdkp->zoned == 1 || sdkp->device->type == TYPE_ZBC; |
244 | } |
245 | |
246 | #ifdef CONFIG_BLK_DEV_ZONED |
247 | |
248 | void sd_zbc_free_zone_info(struct scsi_disk *sdkp); |
249 | int sd_zbc_read_zones(struct scsi_disk *sdkp, u8 buf[SD_BUF_SIZE]); |
250 | int sd_zbc_revalidate_zones(struct scsi_disk *sdkp); |
251 | blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd, |
252 | unsigned char op, bool all); |
253 | unsigned int sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes, |
254 | struct scsi_sense_hdr *sshdr); |
255 | int sd_zbc_report_zones(struct gendisk *disk, sector_t sector, |
256 | unsigned int nr_zones, report_zones_cb cb, void *data); |
257 | |
258 | blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd, sector_t *lba, |
259 | unsigned int nr_blocks); |
260 | |
261 | #else /* CONFIG_BLK_DEV_ZONED */ |
262 | |
263 | static inline void sd_zbc_free_zone_info(struct scsi_disk *sdkp) {} |
264 | |
265 | static inline int sd_zbc_read_zones(struct scsi_disk *sdkp, u8 buf[SD_BUF_SIZE]) |
266 | { |
267 | return 0; |
268 | } |
269 | |
270 | static inline int sd_zbc_revalidate_zones(struct scsi_disk *sdkp) |
271 | { |
272 | return 0; |
273 | } |
274 | |
275 | static inline blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd, |
276 | unsigned char op, |
277 | bool all) |
278 | { |
279 | return BLK_STS_TARGET; |
280 | } |
281 | |
282 | static inline unsigned int sd_zbc_complete(struct scsi_cmnd *cmd, |
283 | unsigned int good_bytes, struct scsi_sense_hdr *sshdr) |
284 | { |
285 | return good_bytes; |
286 | } |
287 | |
288 | static inline blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd, |
289 | sector_t *lba, |
290 | unsigned int nr_blocks) |
291 | { |
292 | return BLK_STS_TARGET; |
293 | } |
294 | |
295 | #define sd_zbc_report_zones NULL |
296 | |
297 | #endif /* CONFIG_BLK_DEV_ZONED */ |
298 | |
299 | void sd_print_sense_hdr(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr); |
300 | void sd_print_result(const struct scsi_disk *sdkp, const char *msg, int result); |
301 | |
302 | #endif /* _SCSI_DISK_H */ |
303 | |