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