1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * sr.c Copyright (C) 1992 David Giller |
4 | * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale |
5 | * |
6 | * adapted from: |
7 | * sd.c Copyright (C) 1992 Drew Eckhardt |
8 | * Linux scsi disk driver by |
9 | * Drew Eckhardt <drew@colorado.edu> |
10 | * |
11 | * Modified by Eric Youngdale ericy@andante.org to |
12 | * add scatter-gather, multiple outstanding request, and other |
13 | * enhancements. |
14 | * |
15 | * Modified by Eric Youngdale eric@andante.org to support loadable |
16 | * low-level scsi drivers. |
17 | * |
18 | * Modified by Thomas Quinot thomas@melchior.cuivre.fdn.fr to |
19 | * provide auto-eject. |
20 | * |
21 | * Modified by Gerd Knorr <kraxel@cs.tu-berlin.de> to support the |
22 | * generic cdrom interface |
23 | * |
24 | * Modified by Jens Axboe <axboe@suse.de> - Uniform sr_packet() |
25 | * interface, capabilities probe additions, ioctl cleanups, etc. |
26 | * |
27 | * Modified by Richard Gooch <rgooch@atnf.csiro.au> to support devfs |
28 | * |
29 | * Modified by Jens Axboe <axboe@suse.de> - support DVD-RAM |
30 | * transparently and lose the GHOST hack |
31 | * |
32 | * Modified by Arnaldo Carvalho de Melo <acme@conectiva.com.br> |
33 | * check resource allocation in sr_init and some cleanups |
34 | */ |
35 | |
36 | #include <linux/module.h> |
37 | #include <linux/fs.h> |
38 | #include <linux/kernel.h> |
39 | #include <linux/mm.h> |
40 | #include <linux/bio.h> |
41 | #include <linux/compat.h> |
42 | #include <linux/string.h> |
43 | #include <linux/errno.h> |
44 | #include <linux/cdrom.h> |
45 | #include <linux/interrupt.h> |
46 | #include <linux/init.h> |
47 | #include <linux/major.h> |
48 | #include <linux/blkdev.h> |
49 | #include <linux/blk-pm.h> |
50 | #include <linux/mutex.h> |
51 | #include <linux/slab.h> |
52 | #include <linux/pm_runtime.h> |
53 | #include <linux/uaccess.h> |
54 | |
55 | #include <asm/unaligned.h> |
56 | |
57 | #include <scsi/scsi.h> |
58 | #include <scsi/scsi_dbg.h> |
59 | #include <scsi/scsi_device.h> |
60 | #include <scsi/scsi_driver.h> |
61 | #include <scsi/scsi_cmnd.h> |
62 | #include <scsi/scsi_eh.h> |
63 | #include <scsi/scsi_host.h> |
64 | #include <scsi/scsi_ioctl.h> /* For the door lock/unlock commands */ |
65 | |
66 | #include "scsi_logging.h" |
67 | #include "sr.h" |
68 | |
69 | |
70 | MODULE_DESCRIPTION("SCSI cdrom (sr) driver" ); |
71 | MODULE_LICENSE("GPL" ); |
72 | MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_CDROM_MAJOR); |
73 | MODULE_ALIAS_SCSI_DEVICE(TYPE_ROM); |
74 | MODULE_ALIAS_SCSI_DEVICE(TYPE_WORM); |
75 | |
76 | #define SR_DISKS 256 |
77 | |
78 | #define SR_CAPABILITIES \ |
79 | (CDC_CLOSE_TRAY|CDC_OPEN_TRAY|CDC_LOCK|CDC_SELECT_SPEED| \ |
80 | CDC_SELECT_DISC|CDC_MULTI_SESSION|CDC_MCN|CDC_MEDIA_CHANGED| \ |
81 | CDC_PLAY_AUDIO|CDC_RESET|CDC_DRIVE_STATUS| \ |
82 | CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_DVD_RAM|CDC_GENERIC_PACKET| \ |
83 | CDC_MRW|CDC_MRW_W|CDC_RAM) |
84 | |
85 | static int sr_probe(struct device *); |
86 | static int sr_remove(struct device *); |
87 | static blk_status_t sr_init_command(struct scsi_cmnd *SCpnt); |
88 | static int sr_done(struct scsi_cmnd *); |
89 | static int sr_runtime_suspend(struct device *dev); |
90 | |
91 | static const struct dev_pm_ops sr_pm_ops = { |
92 | .runtime_suspend = sr_runtime_suspend, |
93 | }; |
94 | |
95 | static struct scsi_driver sr_template = { |
96 | .gendrv = { |
97 | .name = "sr" , |
98 | .owner = THIS_MODULE, |
99 | .probe = sr_probe, |
100 | .remove = sr_remove, |
101 | .pm = &sr_pm_ops, |
102 | }, |
103 | .init_command = sr_init_command, |
104 | .done = sr_done, |
105 | }; |
106 | |
107 | static unsigned long sr_index_bits[SR_DISKS / BITS_PER_LONG]; |
108 | static DEFINE_SPINLOCK(sr_index_lock); |
109 | |
110 | static struct lock_class_key sr_bio_compl_lkclass; |
111 | |
112 | static int sr_open(struct cdrom_device_info *, int); |
113 | static void sr_release(struct cdrom_device_info *); |
114 | |
115 | static void get_sectorsize(struct scsi_cd *); |
116 | static int get_capabilities(struct scsi_cd *); |
117 | |
118 | static unsigned int sr_check_events(struct cdrom_device_info *cdi, |
119 | unsigned int clearing, int slot); |
120 | static int sr_packet(struct cdrom_device_info *, struct packet_command *); |
121 | static int sr_read_cdda_bpc(struct cdrom_device_info *cdi, void __user *ubuf, |
122 | u32 lba, u32 nr, u8 *last_sense); |
123 | |
124 | static const struct cdrom_device_ops sr_dops = { |
125 | .open = sr_open, |
126 | .release = sr_release, |
127 | .drive_status = sr_drive_status, |
128 | .check_events = sr_check_events, |
129 | .tray_move = sr_tray_move, |
130 | .lock_door = sr_lock_door, |
131 | .select_speed = sr_select_speed, |
132 | .get_last_session = sr_get_last_session, |
133 | .get_mcn = sr_get_mcn, |
134 | .reset = sr_reset, |
135 | .audio_ioctl = sr_audio_ioctl, |
136 | .generic_packet = sr_packet, |
137 | .read_cdda_bpc = sr_read_cdda_bpc, |
138 | .capability = SR_CAPABILITIES, |
139 | }; |
140 | |
141 | static inline struct scsi_cd *scsi_cd(struct gendisk *disk) |
142 | { |
143 | return disk->private_data; |
144 | } |
145 | |
146 | static int sr_runtime_suspend(struct device *dev) |
147 | { |
148 | struct scsi_cd *cd = dev_get_drvdata(dev); |
149 | |
150 | if (!cd) /* E.g.: runtime suspend following sr_remove() */ |
151 | return 0; |
152 | |
153 | if (cd->media_present) |
154 | return -EBUSY; |
155 | else |
156 | return 0; |
157 | } |
158 | |
159 | static unsigned int sr_get_events(struct scsi_device *sdev) |
160 | { |
161 | u8 buf[8]; |
162 | u8 cmd[] = { GET_EVENT_STATUS_NOTIFICATION, |
163 | 1, /* polled */ |
164 | 0, 0, /* reserved */ |
165 | 1 << 4, /* notification class: media */ |
166 | 0, 0, /* reserved */ |
167 | 0, sizeof(buf), /* allocation length */ |
168 | 0, /* control */ |
169 | }; |
170 | struct event_header *eh = (void *)buf; |
171 | struct media_event_desc *med = (void *)(buf + 4); |
172 | struct scsi_sense_hdr sshdr; |
173 | const struct scsi_exec_args exec_args = { |
174 | .sshdr = &sshdr, |
175 | }; |
176 | int result; |
177 | |
178 | result = scsi_execute_cmd(sdev, cmd, opf: REQ_OP_DRV_IN, buffer: buf, bufflen: sizeof(buf), |
179 | SR_TIMEOUT, MAX_RETRIES, args: &exec_args); |
180 | if (result > 0 && scsi_sense_valid(sshdr: &sshdr) && |
181 | sshdr.sense_key == UNIT_ATTENTION) |
182 | return DISK_EVENT_MEDIA_CHANGE; |
183 | |
184 | if (result || be16_to_cpu(eh->data_len) < sizeof(*med)) |
185 | return 0; |
186 | |
187 | if (eh->nea || eh->notification_class != 0x4) |
188 | return 0; |
189 | |
190 | if (med->media_event_code == 1) |
191 | return DISK_EVENT_EJECT_REQUEST; |
192 | else if (med->media_event_code == 2) |
193 | return DISK_EVENT_MEDIA_CHANGE; |
194 | else if (med->media_event_code == 3) |
195 | return DISK_EVENT_MEDIA_CHANGE; |
196 | return 0; |
197 | } |
198 | |
199 | /* |
200 | * This function checks to see if the media has been changed or eject |
201 | * button has been pressed. It is possible that we have already |
202 | * sensed a change, or the drive may have sensed one and not yet |
203 | * reported it. The past events are accumulated in sdev->changed and |
204 | * returned together with the current state. |
205 | */ |
206 | static unsigned int sr_check_events(struct cdrom_device_info *cdi, |
207 | unsigned int clearing, int slot) |
208 | { |
209 | struct scsi_cd *cd = cdi->handle; |
210 | bool last_present; |
211 | struct scsi_sense_hdr sshdr; |
212 | unsigned int events; |
213 | int ret; |
214 | |
215 | /* no changer support */ |
216 | if (CDSL_CURRENT != slot) |
217 | return 0; |
218 | |
219 | events = sr_get_events(sdev: cd->device); |
220 | cd->get_event_changed |= events & DISK_EVENT_MEDIA_CHANGE; |
221 | |
222 | /* |
223 | * If earlier GET_EVENT_STATUS_NOTIFICATION and TUR did not agree |
224 | * for several times in a row. We rely on TUR only for this likely |
225 | * broken device, to prevent generating incorrect media changed |
226 | * events for every open(). |
227 | */ |
228 | if (cd->ignore_get_event) { |
229 | events &= ~DISK_EVENT_MEDIA_CHANGE; |
230 | goto do_tur; |
231 | } |
232 | |
233 | /* |
234 | * GET_EVENT_STATUS_NOTIFICATION is enough unless MEDIA_CHANGE |
235 | * is being cleared. Note that there are devices which hang |
236 | * if asked to execute TUR repeatedly. |
237 | */ |
238 | if (cd->device->changed) { |
239 | events |= DISK_EVENT_MEDIA_CHANGE; |
240 | cd->device->changed = 0; |
241 | cd->tur_changed = true; |
242 | } |
243 | |
244 | if (!(clearing & DISK_EVENT_MEDIA_CHANGE)) |
245 | return events; |
246 | do_tur: |
247 | /* let's see whether the media is there with TUR */ |
248 | last_present = cd->media_present; |
249 | ret = scsi_test_unit_ready(sdev: cd->device, SR_TIMEOUT, MAX_RETRIES, sshdr: &sshdr); |
250 | |
251 | /* |
252 | * Media is considered to be present if TUR succeeds or fails with |
253 | * sense data indicating something other than media-not-present |
254 | * (ASC 0x3a). |
255 | */ |
256 | cd->media_present = scsi_status_is_good(status: ret) || |
257 | (scsi_sense_valid(sshdr: &sshdr) && sshdr.asc != 0x3a); |
258 | |
259 | if (last_present != cd->media_present) |
260 | cd->device->changed = 1; |
261 | |
262 | if (cd->device->changed) { |
263 | events |= DISK_EVENT_MEDIA_CHANGE; |
264 | cd->device->changed = 0; |
265 | cd->tur_changed = true; |
266 | } |
267 | |
268 | if (cd->ignore_get_event) |
269 | return events; |
270 | |
271 | /* check whether GET_EVENT is reporting spurious MEDIA_CHANGE */ |
272 | if (!cd->tur_changed) { |
273 | if (cd->get_event_changed) { |
274 | if (cd->tur_mismatch++ > 8) { |
275 | sr_printk(KERN_WARNING, cd, |
276 | "GET_EVENT and TUR disagree continuously, suppress GET_EVENT events\n" ); |
277 | cd->ignore_get_event = true; |
278 | } |
279 | } else { |
280 | cd->tur_mismatch = 0; |
281 | } |
282 | } |
283 | cd->tur_changed = false; |
284 | cd->get_event_changed = false; |
285 | |
286 | return events; |
287 | } |
288 | |
289 | /* |
290 | * sr_done is the interrupt routine for the device driver. |
291 | * |
292 | * It will be notified on the end of a SCSI read / write, and will take one |
293 | * of several actions based on success or failure. |
294 | */ |
295 | static int sr_done(struct scsi_cmnd *SCpnt) |
296 | { |
297 | int result = SCpnt->result; |
298 | int this_count = scsi_bufflen(cmd: SCpnt); |
299 | int good_bytes = (result == 0 ? this_count : 0); |
300 | int block_sectors = 0; |
301 | long error_sector; |
302 | struct request *rq = scsi_cmd_to_rq(scmd: SCpnt); |
303 | struct scsi_cd *cd = scsi_cd(disk: rq->q->disk); |
304 | |
305 | #ifdef DEBUG |
306 | scmd_printk(KERN_INFO, SCpnt, "done: %x\n" , result); |
307 | #endif |
308 | |
309 | /* |
310 | * Handle MEDIUM ERRORs or VOLUME OVERFLOWs that indicate partial |
311 | * success. Since this is a relatively rare error condition, no |
312 | * care is taken to avoid unnecessary additional work such as |
313 | * memcpy's that could be avoided. |
314 | */ |
315 | if (scsi_status_is_check_condition(status: result) && |
316 | (SCpnt->sense_buffer[0] & 0x7f) == 0x70) { /* Sense current */ |
317 | switch (SCpnt->sense_buffer[2]) { |
318 | case MEDIUM_ERROR: |
319 | case VOLUME_OVERFLOW: |
320 | case ILLEGAL_REQUEST: |
321 | if (!(SCpnt->sense_buffer[0] & 0x90)) |
322 | break; |
323 | error_sector = |
324 | get_unaligned_be32(p: &SCpnt->sense_buffer[3]); |
325 | if (rq->bio != NULL) |
326 | block_sectors = bio_sectors(rq->bio); |
327 | if (block_sectors < 4) |
328 | block_sectors = 4; |
329 | if (cd->device->sector_size == 2048) |
330 | error_sector <<= 2; |
331 | error_sector &= ~(block_sectors - 1); |
332 | good_bytes = (error_sector - blk_rq_pos(rq)) << 9; |
333 | if (good_bytes < 0 || good_bytes >= this_count) |
334 | good_bytes = 0; |
335 | /* |
336 | * The SCSI specification allows for the value |
337 | * returned by READ CAPACITY to be up to 75 2K |
338 | * sectors past the last readable block. |
339 | * Therefore, if we hit a medium error within the |
340 | * last 75 2K sectors, we decrease the saved size |
341 | * value. |
342 | */ |
343 | if (error_sector < get_capacity(disk: cd->disk) && |
344 | cd->capacity - error_sector < 4 * 75) |
345 | set_capacity(disk: cd->disk, size: error_sector); |
346 | break; |
347 | |
348 | case RECOVERED_ERROR: |
349 | good_bytes = this_count; |
350 | break; |
351 | |
352 | default: |
353 | break; |
354 | } |
355 | } |
356 | |
357 | return good_bytes; |
358 | } |
359 | |
360 | static blk_status_t sr_init_command(struct scsi_cmnd *SCpnt) |
361 | { |
362 | int block = 0, this_count, s_size; |
363 | struct scsi_cd *cd; |
364 | struct request *rq = scsi_cmd_to_rq(scmd: SCpnt); |
365 | blk_status_t ret; |
366 | |
367 | ret = scsi_alloc_sgtables(cmd: SCpnt); |
368 | if (ret != BLK_STS_OK) |
369 | return ret; |
370 | cd = scsi_cd(disk: rq->q->disk); |
371 | |
372 | SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt, |
373 | "Doing sr request, block = %d\n" , block)); |
374 | |
375 | if (!cd->device || !scsi_device_online(sdev: cd->device)) { |
376 | SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, |
377 | "Finishing %u sectors\n" , blk_rq_sectors(rq))); |
378 | SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, |
379 | "Retry with 0x%p\n" , SCpnt)); |
380 | goto out; |
381 | } |
382 | |
383 | if (cd->device->changed) { |
384 | /* |
385 | * quietly refuse to do anything to a changed disc until the |
386 | * changed bit has been reset |
387 | */ |
388 | goto out; |
389 | } |
390 | |
391 | s_size = cd->device->sector_size; |
392 | if (s_size != 512 && s_size != 1024 && s_size != 2048) { |
393 | scmd_printk(KERN_ERR, SCpnt, "bad sector size %d\n" , s_size); |
394 | goto out; |
395 | } |
396 | |
397 | switch (req_op(req: rq)) { |
398 | case REQ_OP_WRITE: |
399 | if (!cd->writeable) |
400 | goto out; |
401 | SCpnt->cmnd[0] = WRITE_10; |
402 | cd->cdi.media_written = 1; |
403 | break; |
404 | case REQ_OP_READ: |
405 | SCpnt->cmnd[0] = READ_10; |
406 | break; |
407 | default: |
408 | blk_dump_rq_flags(rq, "Unknown sr command" ); |
409 | goto out; |
410 | } |
411 | |
412 | { |
413 | struct scatterlist *sg; |
414 | int i, size = 0, sg_count = scsi_sg_count(cmd: SCpnt); |
415 | |
416 | scsi_for_each_sg(SCpnt, sg, sg_count, i) |
417 | size += sg->length; |
418 | |
419 | if (size != scsi_bufflen(cmd: SCpnt)) { |
420 | scmd_printk(KERN_ERR, SCpnt, |
421 | "mismatch count %d, bytes %d\n" , |
422 | size, scsi_bufflen(cmd: SCpnt)); |
423 | if (scsi_bufflen(cmd: SCpnt) > size) |
424 | SCpnt->sdb.length = size; |
425 | } |
426 | } |
427 | |
428 | /* |
429 | * request doesn't start on hw block boundary, add scatter pads |
430 | */ |
431 | if (((unsigned int)blk_rq_pos(rq) % (s_size >> 9)) || |
432 | (scsi_bufflen(cmd: SCpnt) % s_size)) { |
433 | scmd_printk(KERN_NOTICE, SCpnt, "unaligned transfer\n" ); |
434 | goto out; |
435 | } |
436 | |
437 | this_count = (scsi_bufflen(cmd: SCpnt) >> 9) / (s_size >> 9); |
438 | |
439 | |
440 | SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, |
441 | "%s %d/%u 512 byte blocks.\n" , |
442 | (rq_data_dir(rq) == WRITE) ? |
443 | "writing" : "reading" , |
444 | this_count, blk_rq_sectors(rq))); |
445 | |
446 | SCpnt->cmnd[1] = 0; |
447 | block = (unsigned int)blk_rq_pos(rq) / (s_size >> 9); |
448 | |
449 | if (this_count > 0xffff) { |
450 | this_count = 0xffff; |
451 | SCpnt->sdb.length = this_count * s_size; |
452 | } |
453 | |
454 | put_unaligned_be32(val: block, p: &SCpnt->cmnd[2]); |
455 | SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0; |
456 | put_unaligned_be16(val: this_count, p: &SCpnt->cmnd[7]); |
457 | |
458 | /* |
459 | * We shouldn't disconnect in the middle of a sector, so with a dumb |
460 | * host adapter, it's safe to assume that we can at least transfer |
461 | * this many bytes between each connect / disconnect. |
462 | */ |
463 | SCpnt->transfersize = cd->device->sector_size; |
464 | SCpnt->underflow = this_count << 9; |
465 | SCpnt->allowed = MAX_RETRIES; |
466 | SCpnt->cmd_len = 10; |
467 | |
468 | /* |
469 | * This indicates that the command is ready from our end to be queued. |
470 | */ |
471 | return BLK_STS_OK; |
472 | out: |
473 | scsi_free_sgtables(cmd: SCpnt); |
474 | return BLK_STS_IOERR; |
475 | } |
476 | |
477 | static void sr_revalidate_disk(struct scsi_cd *cd) |
478 | { |
479 | struct scsi_sense_hdr sshdr; |
480 | |
481 | /* if the unit is not ready, nothing more to do */ |
482 | if (scsi_test_unit_ready(sdev: cd->device, SR_TIMEOUT, MAX_RETRIES, sshdr: &sshdr)) |
483 | return; |
484 | sr_cd_check(&cd->cdi); |
485 | get_sectorsize(cd); |
486 | } |
487 | |
488 | static int sr_block_open(struct gendisk *disk, blk_mode_t mode) |
489 | { |
490 | struct scsi_cd *cd = scsi_cd(disk); |
491 | struct scsi_device *sdev = cd->device; |
492 | int ret; |
493 | |
494 | if (scsi_device_get(cd->device)) |
495 | return -ENXIO; |
496 | |
497 | scsi_autopm_get_device(sdev); |
498 | if (disk_check_media_change(disk)) |
499 | sr_revalidate_disk(cd); |
500 | |
501 | mutex_lock(&cd->lock); |
502 | ret = cdrom_open(cdi: &cd->cdi, mode); |
503 | mutex_unlock(lock: &cd->lock); |
504 | |
505 | scsi_autopm_put_device(sdev); |
506 | if (ret) |
507 | scsi_device_put(cd->device); |
508 | return ret; |
509 | } |
510 | |
511 | static void sr_block_release(struct gendisk *disk) |
512 | { |
513 | struct scsi_cd *cd = scsi_cd(disk); |
514 | |
515 | mutex_lock(&cd->lock); |
516 | cdrom_release(cdi: &cd->cdi); |
517 | mutex_unlock(lock: &cd->lock); |
518 | |
519 | scsi_device_put(cd->device); |
520 | } |
521 | |
522 | static int sr_block_ioctl(struct block_device *bdev, blk_mode_t mode, |
523 | unsigned cmd, unsigned long arg) |
524 | { |
525 | struct scsi_cd *cd = scsi_cd(disk: bdev->bd_disk); |
526 | struct scsi_device *sdev = cd->device; |
527 | void __user *argp = (void __user *)arg; |
528 | int ret; |
529 | |
530 | if (bdev_is_partition(bdev) && !capable(CAP_SYS_RAWIO)) |
531 | return -ENOIOCTLCMD; |
532 | |
533 | mutex_lock(&cd->lock); |
534 | |
535 | ret = scsi_ioctl_block_when_processing_errors(sdev, cmd, |
536 | ndelay: (mode & BLK_OPEN_NDELAY)); |
537 | if (ret) |
538 | goto out; |
539 | |
540 | scsi_autopm_get_device(sdev); |
541 | |
542 | if (cmd != CDROMCLOSETRAY && cmd != CDROMEJECT) { |
543 | ret = cdrom_ioctl(cdi: &cd->cdi, bdev, cmd, arg); |
544 | if (ret != -ENOSYS) |
545 | goto put; |
546 | } |
547 | ret = scsi_ioctl(sdev, open_for_write: mode & BLK_OPEN_WRITE, cmd, arg: argp); |
548 | |
549 | put: |
550 | scsi_autopm_put_device(sdev); |
551 | out: |
552 | mutex_unlock(lock: &cd->lock); |
553 | return ret; |
554 | } |
555 | |
556 | static unsigned int sr_block_check_events(struct gendisk *disk, |
557 | unsigned int clearing) |
558 | { |
559 | struct scsi_cd *cd = disk->private_data; |
560 | |
561 | if (atomic_read(v: &cd->device->disk_events_disable_depth)) |
562 | return 0; |
563 | return cdrom_check_events(cdi: &cd->cdi, clearing); |
564 | } |
565 | |
566 | static void sr_free_disk(struct gendisk *disk) |
567 | { |
568 | struct scsi_cd *cd = disk->private_data; |
569 | |
570 | spin_lock(lock: &sr_index_lock); |
571 | clear_bit(MINOR(disk_devt(disk)), addr: sr_index_bits); |
572 | spin_unlock(lock: &sr_index_lock); |
573 | |
574 | unregister_cdrom(cdi: &cd->cdi); |
575 | mutex_destroy(lock: &cd->lock); |
576 | kfree(objp: cd); |
577 | } |
578 | |
579 | static const struct block_device_operations sr_bdops = |
580 | { |
581 | .owner = THIS_MODULE, |
582 | .open = sr_block_open, |
583 | .release = sr_block_release, |
584 | .ioctl = sr_block_ioctl, |
585 | .compat_ioctl = blkdev_compat_ptr_ioctl, |
586 | .check_events = sr_block_check_events, |
587 | .free_disk = sr_free_disk, |
588 | }; |
589 | |
590 | static int sr_open(struct cdrom_device_info *cdi, int purpose) |
591 | { |
592 | struct scsi_cd *cd = cdi->handle; |
593 | struct scsi_device *sdev = cd->device; |
594 | |
595 | /* |
596 | * If the device is in error recovery, wait until it is done. |
597 | * If the device is offline, then disallow any access to it. |
598 | */ |
599 | if (!scsi_block_when_processing_errors(sdev)) |
600 | return -ENXIO; |
601 | |
602 | return 0; |
603 | } |
604 | |
605 | static void sr_release(struct cdrom_device_info *cdi) |
606 | { |
607 | } |
608 | |
609 | static int sr_probe(struct device *dev) |
610 | { |
611 | struct scsi_device *sdev = to_scsi_device(dev); |
612 | struct gendisk *disk; |
613 | struct scsi_cd *cd; |
614 | int minor, error; |
615 | |
616 | scsi_autopm_get_device(sdev); |
617 | error = -ENODEV; |
618 | if (sdev->type != TYPE_ROM && sdev->type != TYPE_WORM) |
619 | goto fail; |
620 | |
621 | error = -ENOMEM; |
622 | cd = kzalloc(size: sizeof(*cd), GFP_KERNEL); |
623 | if (!cd) |
624 | goto fail; |
625 | |
626 | disk = blk_mq_alloc_disk_for_queue(q: sdev->request_queue, |
627 | lkclass: &sr_bio_compl_lkclass); |
628 | if (!disk) |
629 | goto fail_free; |
630 | mutex_init(&cd->lock); |
631 | |
632 | spin_lock(lock: &sr_index_lock); |
633 | minor = find_first_zero_bit(addr: sr_index_bits, SR_DISKS); |
634 | if (minor == SR_DISKS) { |
635 | spin_unlock(lock: &sr_index_lock); |
636 | error = -EBUSY; |
637 | goto fail_put; |
638 | } |
639 | __set_bit(minor, sr_index_bits); |
640 | spin_unlock(lock: &sr_index_lock); |
641 | |
642 | disk->major = SCSI_CDROM_MAJOR; |
643 | disk->first_minor = minor; |
644 | disk->minors = 1; |
645 | sprintf(buf: disk->disk_name, fmt: "sr%d" , minor); |
646 | disk->fops = &sr_bdops; |
647 | disk->flags |= GENHD_FL_REMOVABLE | GENHD_FL_NO_PART; |
648 | disk->events = DISK_EVENT_MEDIA_CHANGE | DISK_EVENT_EJECT_REQUEST; |
649 | disk->event_flags = DISK_EVENT_FLAG_POLL | DISK_EVENT_FLAG_UEVENT | |
650 | DISK_EVENT_FLAG_BLOCK_ON_EXCL_WRITE; |
651 | |
652 | blk_queue_rq_timeout(sdev->request_queue, SR_TIMEOUT); |
653 | |
654 | cd->device = sdev; |
655 | cd->disk = disk; |
656 | cd->capacity = 0x1fffff; |
657 | cd->device->changed = 1; /* force recheck CD type */ |
658 | cd->media_present = 1; |
659 | cd->use = 1; |
660 | cd->readcd_known = 0; |
661 | cd->readcd_cdda = 0; |
662 | |
663 | cd->cdi.ops = &sr_dops; |
664 | cd->cdi.handle = cd; |
665 | cd->cdi.mask = 0; |
666 | cd->cdi.capacity = 1; |
667 | sprintf(buf: cd->cdi.name, fmt: "sr%d" , minor); |
668 | |
669 | sdev->sector_size = 2048; /* A guess, just in case */ |
670 | |
671 | error = -ENOMEM; |
672 | if (get_capabilities(cd)) |
673 | goto fail_minor; |
674 | sr_vendor_init(cd); |
675 | |
676 | set_capacity(disk, size: cd->capacity); |
677 | disk->private_data = cd; |
678 | |
679 | if (register_cdrom(disk, cdi: &cd->cdi)) |
680 | goto fail_minor; |
681 | |
682 | /* |
683 | * Initialize block layer runtime PM stuffs before the |
684 | * periodic event checking request gets started in add_disk. |
685 | */ |
686 | blk_pm_runtime_init(q: sdev->request_queue, dev); |
687 | |
688 | dev_set_drvdata(dev, data: cd); |
689 | sr_revalidate_disk(cd); |
690 | |
691 | error = device_add_disk(parent: &sdev->sdev_gendev, disk, NULL); |
692 | if (error) |
693 | goto unregister_cdrom; |
694 | |
695 | sdev_printk(KERN_DEBUG, sdev, |
696 | "Attached scsi CD-ROM %s\n" , cd->cdi.name); |
697 | scsi_autopm_put_device(cd->device); |
698 | |
699 | return 0; |
700 | |
701 | unregister_cdrom: |
702 | unregister_cdrom(cdi: &cd->cdi); |
703 | fail_minor: |
704 | spin_lock(lock: &sr_index_lock); |
705 | clear_bit(nr: minor, addr: sr_index_bits); |
706 | spin_unlock(lock: &sr_index_lock); |
707 | fail_put: |
708 | put_disk(disk); |
709 | mutex_destroy(lock: &cd->lock); |
710 | fail_free: |
711 | kfree(objp: cd); |
712 | fail: |
713 | scsi_autopm_put_device(sdev); |
714 | return error; |
715 | } |
716 | |
717 | |
718 | static void get_sectorsize(struct scsi_cd *cd) |
719 | { |
720 | unsigned char cmd[10]; |
721 | unsigned char buffer[8]; |
722 | int the_result, retries = 3; |
723 | int sector_size; |
724 | struct request_queue *queue; |
725 | |
726 | do { |
727 | cmd[0] = READ_CAPACITY; |
728 | memset((void *) &cmd[1], 0, 9); |
729 | memset(buffer, 0, sizeof(buffer)); |
730 | |
731 | /* Do the command and wait.. */ |
732 | the_result = scsi_execute_cmd(sdev: cd->device, cmd, opf: REQ_OP_DRV_IN, |
733 | buffer, bufflen: sizeof(buffer), |
734 | SR_TIMEOUT, MAX_RETRIES, NULL); |
735 | |
736 | retries--; |
737 | |
738 | } while (the_result && retries); |
739 | |
740 | |
741 | if (the_result) { |
742 | cd->capacity = 0x1fffff; |
743 | sector_size = 2048; /* A guess, just in case */ |
744 | } else { |
745 | long last_written; |
746 | |
747 | cd->capacity = 1 + get_unaligned_be32(p: &buffer[0]); |
748 | /* |
749 | * READ_CAPACITY doesn't return the correct size on |
750 | * certain UDF media. If last_written is larger, use |
751 | * it instead. |
752 | * |
753 | * http://bugzilla.kernel.org/show_bug.cgi?id=9668 |
754 | */ |
755 | if (!cdrom_get_last_written(cdi: &cd->cdi, last_written: &last_written)) |
756 | cd->capacity = max_t(long, cd->capacity, last_written); |
757 | |
758 | sector_size = get_unaligned_be32(p: &buffer[4]); |
759 | switch (sector_size) { |
760 | /* |
761 | * HP 4020i CD-Recorder reports 2340 byte sectors |
762 | * Philips CD-Writers report 2352 byte sectors |
763 | * |
764 | * Use 2k sectors for them.. |
765 | */ |
766 | case 0: |
767 | case 2340: |
768 | case 2352: |
769 | sector_size = 2048; |
770 | fallthrough; |
771 | case 2048: |
772 | cd->capacity *= 4; |
773 | fallthrough; |
774 | case 512: |
775 | break; |
776 | default: |
777 | sr_printk(KERN_INFO, cd, |
778 | "unsupported sector size %d." , sector_size); |
779 | cd->capacity = 0; |
780 | } |
781 | |
782 | cd->device->sector_size = sector_size; |
783 | |
784 | /* |
785 | * Add this so that we have the ability to correctly gauge |
786 | * what the device is capable of. |
787 | */ |
788 | set_capacity(disk: cd->disk, size: cd->capacity); |
789 | } |
790 | |
791 | queue = cd->device->request_queue; |
792 | blk_queue_logical_block_size(queue, sector_size); |
793 | |
794 | return; |
795 | } |
796 | |
797 | static int get_capabilities(struct scsi_cd *cd) |
798 | { |
799 | unsigned char *buffer; |
800 | struct scsi_mode_data data; |
801 | struct scsi_sense_hdr sshdr; |
802 | unsigned int ms_len = 128; |
803 | int rc, n; |
804 | |
805 | static const char *loadmech[] = |
806 | { |
807 | "caddy" , |
808 | "tray" , |
809 | "pop-up" , |
810 | "" , |
811 | "changer" , |
812 | "cartridge changer" , |
813 | "" , |
814 | "" |
815 | }; |
816 | |
817 | |
818 | /* allocate transfer buffer */ |
819 | buffer = kmalloc(size: 512, GFP_KERNEL); |
820 | if (!buffer) { |
821 | sr_printk(KERN_ERR, cd, "out of memory.\n" ); |
822 | return -ENOMEM; |
823 | } |
824 | |
825 | /* eat unit attentions */ |
826 | scsi_test_unit_ready(sdev: cd->device, SR_TIMEOUT, MAX_RETRIES, sshdr: &sshdr); |
827 | |
828 | /* ask for mode page 0x2a */ |
829 | rc = scsi_mode_sense(sdev: cd->device, dbd: 0, modepage: 0x2a, subpage: 0, buffer, len: ms_len, |
830 | SR_TIMEOUT, retries: 3, data: &data, NULL); |
831 | |
832 | if (rc < 0 || data.length > ms_len || |
833 | data.header_length + data.block_descriptor_length > data.length) { |
834 | /* failed, drive doesn't have capabilities mode page */ |
835 | cd->cdi.speed = 1; |
836 | cd->cdi.mask |= (CDC_CD_R | CDC_CD_RW | CDC_DVD_R | |
837 | CDC_DVD | CDC_DVD_RAM | |
838 | CDC_SELECT_DISC | CDC_SELECT_SPEED | |
839 | CDC_MRW | CDC_MRW_W | CDC_RAM); |
840 | kfree(objp: buffer); |
841 | sr_printk(KERN_INFO, cd, "scsi-1 drive" ); |
842 | return 0; |
843 | } |
844 | |
845 | n = data.header_length + data.block_descriptor_length; |
846 | cd->cdi.speed = get_unaligned_be16(p: &buffer[n + 8]) / 176; |
847 | cd->readcd_known = 1; |
848 | cd->readcd_cdda = buffer[n + 5] & 0x01; |
849 | /* print some capability bits */ |
850 | sr_printk(KERN_INFO, cd, |
851 | "scsi3-mmc drive: %dx/%dx %s%s%s%s%s%s\n" , |
852 | get_unaligned_be16(&buffer[n + 14]) / 176, |
853 | cd->cdi.speed, |
854 | buffer[n + 3] & 0x01 ? "writer " : "" , /* CD Writer */ |
855 | buffer[n + 3] & 0x20 ? "dvd-ram " : "" , |
856 | buffer[n + 2] & 0x02 ? "cd/rw " : "" , /* can read rewriteable */ |
857 | buffer[n + 4] & 0x20 ? "xa/form2 " : "" , /* can read xa/from2 */ |
858 | buffer[n + 5] & 0x01 ? "cdda " : "" , /* can read audio data */ |
859 | loadmech[buffer[n + 6] >> 5]); |
860 | if ((buffer[n + 6] >> 5) == 0) |
861 | /* caddy drives can't close tray... */ |
862 | cd->cdi.mask |= CDC_CLOSE_TRAY; |
863 | if ((buffer[n + 2] & 0x8) == 0) |
864 | /* not a DVD drive */ |
865 | cd->cdi.mask |= CDC_DVD; |
866 | if ((buffer[n + 3] & 0x20) == 0) |
867 | /* can't write DVD-RAM media */ |
868 | cd->cdi.mask |= CDC_DVD_RAM; |
869 | if ((buffer[n + 3] & 0x10) == 0) |
870 | /* can't write DVD-R media */ |
871 | cd->cdi.mask |= CDC_DVD_R; |
872 | if ((buffer[n + 3] & 0x2) == 0) |
873 | /* can't write CD-RW media */ |
874 | cd->cdi.mask |= CDC_CD_RW; |
875 | if ((buffer[n + 3] & 0x1) == 0) |
876 | /* can't write CD-R media */ |
877 | cd->cdi.mask |= CDC_CD_R; |
878 | if ((buffer[n + 6] & 0x8) == 0) |
879 | /* can't eject */ |
880 | cd->cdi.mask |= CDC_OPEN_TRAY; |
881 | |
882 | if ((buffer[n + 6] >> 5) == mechtype_individual_changer || |
883 | (buffer[n + 6] >> 5) == mechtype_cartridge_changer) |
884 | cd->cdi.capacity = |
885 | cdrom_number_of_slots(cdi: &cd->cdi); |
886 | if (cd->cdi.capacity <= 1) |
887 | /* not a changer */ |
888 | cd->cdi.mask |= CDC_SELECT_DISC; |
889 | /*else I don't think it can close its tray |
890 | cd->cdi.mask |= CDC_CLOSE_TRAY; */ |
891 | |
892 | /* |
893 | * if DVD-RAM, MRW-W or CD-RW, we are randomly writable |
894 | */ |
895 | if ((cd->cdi.mask & (CDC_DVD_RAM | CDC_MRW_W | CDC_RAM | CDC_CD_RW)) != |
896 | (CDC_DVD_RAM | CDC_MRW_W | CDC_RAM | CDC_CD_RW)) { |
897 | cd->writeable = 1; |
898 | } |
899 | |
900 | kfree(objp: buffer); |
901 | return 0; |
902 | } |
903 | |
904 | /* |
905 | * sr_packet() is the entry point for the generic commands generated |
906 | * by the Uniform CD-ROM layer. |
907 | */ |
908 | static int sr_packet(struct cdrom_device_info *cdi, |
909 | struct packet_command *cgc) |
910 | { |
911 | struct scsi_cd *cd = cdi->handle; |
912 | struct scsi_device *sdev = cd->device; |
913 | |
914 | if (cgc->cmd[0] == GPCMD_READ_DISC_INFO && sdev->no_read_disc_info) |
915 | return -EDRIVE_CANT_DO_THIS; |
916 | |
917 | if (cgc->timeout <= 0) |
918 | cgc->timeout = IOCTL_TIMEOUT; |
919 | |
920 | sr_do_ioctl(cd, cgc); |
921 | |
922 | return cgc->stat; |
923 | } |
924 | |
925 | static int sr_read_cdda_bpc(struct cdrom_device_info *cdi, void __user *ubuf, |
926 | u32 lba, u32 nr, u8 *last_sense) |
927 | { |
928 | struct gendisk *disk = cdi->disk; |
929 | u32 len = nr * CD_FRAMESIZE_RAW; |
930 | struct scsi_cmnd *scmd; |
931 | struct request *rq; |
932 | struct bio *bio; |
933 | int ret; |
934 | |
935 | rq = scsi_alloc_request(q: disk->queue, opf: REQ_OP_DRV_IN, flags: 0); |
936 | if (IS_ERR(ptr: rq)) |
937 | return PTR_ERR(ptr: rq); |
938 | scmd = blk_mq_rq_to_pdu(rq); |
939 | |
940 | ret = blk_rq_map_user(disk->queue, rq, NULL, ubuf, len, GFP_KERNEL); |
941 | if (ret) |
942 | goto out_put_request; |
943 | |
944 | scmd->cmnd[0] = GPCMD_READ_CD; |
945 | scmd->cmnd[1] = 1 << 2; |
946 | scmd->cmnd[2] = (lba >> 24) & 0xff; |
947 | scmd->cmnd[3] = (lba >> 16) & 0xff; |
948 | scmd->cmnd[4] = (lba >> 8) & 0xff; |
949 | scmd->cmnd[5] = lba & 0xff; |
950 | scmd->cmnd[6] = (nr >> 16) & 0xff; |
951 | scmd->cmnd[7] = (nr >> 8) & 0xff; |
952 | scmd->cmnd[8] = nr & 0xff; |
953 | scmd->cmnd[9] = 0xf8; |
954 | scmd->cmd_len = 12; |
955 | rq->timeout = 60 * HZ; |
956 | bio = rq->bio; |
957 | |
958 | blk_execute_rq(rq, at_head: false); |
959 | if (scmd->result) { |
960 | struct scsi_sense_hdr sshdr; |
961 | |
962 | scsi_normalize_sense(sense_buffer: scmd->sense_buffer, sb_len: scmd->sense_len, |
963 | sshdr: &sshdr); |
964 | *last_sense = sshdr.sense_key; |
965 | ret = -EIO; |
966 | } |
967 | |
968 | if (blk_rq_unmap_user(bio)) |
969 | ret = -EFAULT; |
970 | out_put_request: |
971 | blk_mq_free_request(rq); |
972 | return ret; |
973 | } |
974 | |
975 | static int sr_remove(struct device *dev) |
976 | { |
977 | struct scsi_cd *cd = dev_get_drvdata(dev); |
978 | |
979 | scsi_autopm_get_device(cd->device); |
980 | |
981 | del_gendisk(gp: cd->disk); |
982 | put_disk(disk: cd->disk); |
983 | |
984 | return 0; |
985 | } |
986 | |
987 | static int __init init_sr(void) |
988 | { |
989 | int rc; |
990 | |
991 | rc = register_blkdev(SCSI_CDROM_MAJOR, "sr" ); |
992 | if (rc) |
993 | return rc; |
994 | rc = scsi_register_driver(&sr_template.gendrv); |
995 | if (rc) |
996 | unregister_blkdev(SCSI_CDROM_MAJOR, name: "sr" ); |
997 | |
998 | return rc; |
999 | } |
1000 | |
1001 | static void __exit exit_sr(void) |
1002 | { |
1003 | scsi_unregister_driver(&sr_template.gendrv); |
1004 | unregister_blkdev(SCSI_CDROM_MAJOR, name: "sr" ); |
1005 | } |
1006 | |
1007 | module_init(init_sr); |
1008 | module_exit(exit_sr); |
1009 | MODULE_LICENSE("GPL" ); |
1010 | |