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