sr.c

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