ide-cd.c 55.6 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * ATAPI CD-ROM driver.
L
Linus Torvalds 已提交
3
 *
4 5 6 7
 * Copyright (C) 1994-1996   Scott Snyder <snyder@fnald0.fnal.gov>
 * Copyright (C) 1996-1998   Erik Andersen <andersee@debian.org>
 * Copyright (C) 1998-2000   Jens Axboe <axboe@suse.de>
 * Copyright (C) 2005, 2007  Bartlomiej Zolnierkiewicz
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15
 *
 * May be copied or modified under the terms of the GNU General Public
 * License.  See linux/COPYING for more information.
 *
 * See Documentation/cdrom/ide-cd for usage information.
 *
 * Suggestions are welcome. Patches that work are more welcome though. ;-)
 * For those wishing to work on this driver, please be sure you download
16 17
 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
L
Linus Torvalds 已提交
18 19 20 21
 * anonymous ftp from:
 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
 *
22 23 24 25
 * For historical changelog please see:
 *	Documentation/ide/ChangeLog.ide-cd.1994-2004
 */

26
#define IDECD_VERSION "5.00"
L
Linus Torvalds 已提交
27 28 29 30 31 32 33 34 35 36 37 38

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/cdrom.h>
#include <linux/ide.h>
#include <linux/completion.h>
39
#include <linux/mutex.h>
40
#include <linux/bcd.h>
L
Linus Torvalds 已提交
41

B
Borislav Petkov 已提交
42 43
/* For SCSI -> ATAPI command conversion */
#include <scsi/scsi.h>
L
Linus Torvalds 已提交
44

B
Borislav Petkov 已提交
45 46
#include <linux/irq.h>
#include <linux/io.h>
L
Linus Torvalds 已提交
47
#include <asm/byteorder.h>
B
Borislav Petkov 已提交
48
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
49 50 51 52
#include <asm/unaligned.h>

#include "ide-cd.h"

53
static DEFINE_MUTEX(idecd_ref_mutex);
L
Linus Torvalds 已提交
54

55
#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63

#define ide_cd_g(disk) \
	container_of((disk)->private_data, struct cdrom_info, driver)

static struct cdrom_info *ide_cd_get(struct gendisk *disk)
{
	struct cdrom_info *cd = NULL;

64
	mutex_lock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
65 66 67
	cd = ide_cd_g(disk);
	if (cd)
		kref_get(&cd->kref);
68
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
69 70 71 72 73 74 75
	return cd;
}

static void ide_cd_release(struct kref *);

static void ide_cd_put(struct cdrom_info *cd)
{
76
	mutex_lock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
77
	kref_put(&cd->kref, ide_cd_release);
78
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
79 80
}

B
Borislav Petkov 已提交
81
/*
L
Linus Torvalds 已提交
82 83 84
 * Generic packet command support and error handling routines.
 */

B
Borislav Petkov 已提交
85
/* Mark that we've seen a media change and invalidate our internal buffers. */
86
static void cdrom_saw_media_change(ide_drive_t *drive)
L
Linus Torvalds 已提交
87
{
88 89
	struct cdrom_info *cd = drive->driver_data;

90 91
	cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
	cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
L
Linus Torvalds 已提交
92 93 94 95 96 97 98
}

static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
			   struct request_sense *sense)
{
	int log = 0;

99
	if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
L
Linus Torvalds 已提交
100 101 102
		return 0;

	switch (sense->sense_key) {
103 104 105 106 107
	case NO_SENSE:
	case RECOVERED_ERROR:
		break;
	case NOT_READY:
		/*
B
Borislav Petkov 已提交
108 109
		 * don't care about tray state messages for e.g. capacity
		 * commands or in-progress or becoming ready
110 111
		 */
		if (sense->asc == 0x3a || sense->asc == 0x04)
L
Linus Torvalds 已提交
112
			break;
113 114 115 116
		log = 1;
		break;
	case ILLEGAL_REQUEST:
		/*
B
Borislav Petkov 已提交
117 118
		 * don't log START_STOP unit with LoEj set, since we cannot
		 * reliably check if drive can auto-close
119 120
		 */
		if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
L
Linus Torvalds 已提交
121
			break;
122 123 124 125
		log = 1;
		break;
	case UNIT_ATTENTION:
		/*
B
Borislav Petkov 已提交
126 127 128
		 * Make good and sure we've seen this potential media change.
		 * Some drives (i.e. Creative) fail to present the correct sense
		 * key in the error register.
129 130 131 132 133 134
		 */
		cdrom_saw_media_change(drive);
		break;
	default:
		log = 1;
		break;
L
Linus Torvalds 已提交
135 136 137 138
	}
	return log;
}

139
static void cdrom_analyze_sense_data(ide_drive_t *drive,
L
Linus Torvalds 已提交
140 141 142
			      struct request *failed_command,
			      struct request_sense *sense)
{
A
Alan Cox 已提交
143 144 145 146
	unsigned long sector;
	unsigned long bio_sectors;
	struct cdrom_info *info = drive->driver_data;

L
Linus Torvalds 已提交
147 148 149 150
	if (!cdrom_log_sense(drive, failed_command, sense))
		return;

	/*
B
Borislav Petkov 已提交
151 152 153
	 * If a read toc is executed for a CD-R or CD-RW medium where the first
	 * toc has not been recorded yet, it will fail with 05/24/00 (which is a
	 * confusing error)
L
Linus Torvalds 已提交
154 155 156 157 158
	 */
	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
		if (sense->sense_key == 0x05 && sense->asc == 0x24)
			return;

B
Borislav Petkov 已提交
159 160
	/* current error */
	if (sense->error_code == 0x70) {
161
		switch (sense->sense_key) {
A
Alan Cox 已提交
162 163 164 165 166 167 168 169 170 171 172 173 174 175
		case MEDIUM_ERROR:
		case VOLUME_OVERFLOW:
		case ILLEGAL_REQUEST:
			if (!sense->valid)
				break;
			if (failed_command == NULL ||
					!blk_fs_request(failed_command))
				break;
			sector = (sense->information[0] << 24) |
				 (sense->information[1] << 16) |
				 (sense->information[2] <<  8) |
				 (sense->information[3]);

			if (drive->queue->hardsect_size == 2048)
B
Borislav Petkov 已提交
176 177
				/* device sector size is 2K */
				sector <<= 2;
178 179

			bio_sectors = max(bio_sectors(failed_command->bio), 4U);
180
			sector &= ~(bio_sectors - 1);
A
Alan Cox 已提交
181 182

			if (sector < get_capacity(info->disk) &&
183
			    drive->probed_capacity - sector < 4 * 75)
A
Alan Cox 已提交
184
				set_capacity(info->disk, sector);
185 186
		}
	}
L
Linus Torvalds 已提交
187

188
	ide_cd_log_error(drive->name, failed_command, sense);
L
Linus Torvalds 已提交
189 190 191 192 193 194 195 196 197 198 199 200
}

static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
				      struct request *failed_command)
{
	struct cdrom_info *info		= drive->driver_data;
	struct request *rq		= &info->request_sense_request;

	if (sense == NULL)
		sense = &info->sense_data;

	/* stuff the sense request in front of our current request */
F
FUJITA Tomonori 已提交
201 202 203
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_ATA_PC;
	rq->rq_disk = info->disk;
L
Linus Torvalds 已提交
204 205 206

	rq->data = sense;
	rq->cmd[0] = GPCMD_REQUEST_SENSE;
207 208
	rq->cmd[4] = 18;
	rq->data_len = 18;
L
Linus Torvalds 已提交
209

210
	rq->cmd_type = REQ_TYPE_SENSE;
211
	rq->cmd_flags |= REQ_PREEMPT;
L
Linus Torvalds 已提交
212 213 214 215

	/* NOTE! Save the failed command in "rq->buffer" */
	rq->buffer = (void *) failed_command;

216
	ide_do_drive_cmd(drive, rq);
L
Linus Torvalds 已提交
217 218
}

219
static void cdrom_end_request(ide_drive_t *drive, int uptodate)
L
Linus Torvalds 已提交
220 221 222 223
{
	struct request *rq = HWGROUP(drive)->rq;
	int nsectors = rq->hard_cur_sectors;

224
	if (blk_sense_request(rq) && uptodate) {
L
Linus Torvalds 已提交
225
		/*
226 227
		 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
		 * failed request
L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235 236 237 238
		 */
		struct request *failed = (struct request *) rq->buffer;
		struct cdrom_info *info = drive->driver_data;
		void *sense = &info->sense_data;
		unsigned long flags;

		if (failed) {
			if (failed->sense) {
				sense = failed->sense;
				failed->sense_len = rq->sense_len;
			}
A
Alan Cox 已提交
239
			cdrom_analyze_sense_data(drive, failed, sense);
L
Linus Torvalds 已提交
240
			/*
B
Borislav Petkov 已提交
241
			 * now end the failed request
L
Linus Torvalds 已提交
242
			 */
A
Alan Cox 已提交
243 244 245 246 247 248
			if (blk_fs_request(failed)) {
				if (ide_end_dequeued_request(drive, failed, 0,
						failed->hard_nr_sectors))
					BUG();
			} else {
				spin_lock_irqsave(&ide_lock, flags);
249 250 251
				if (__blk_end_request(failed, -EIO,
						      failed->data_len))
					BUG();
A
Alan Cox 已提交
252 253 254 255
				spin_unlock_irqrestore(&ide_lock, flags);
			}
		} else
			cdrom_analyze_sense_data(drive, NULL, sense);
L
Linus Torvalds 已提交
256 257 258 259 260 261 262 263 264 265 266 267 268
	}

	if (!rq->current_nr_sectors && blk_fs_request(rq))
		uptodate = 1;
	/* make sure it's fully ended */
	if (blk_pc_request(rq))
		nsectors = (rq->data_len + 511) >> 9;
	if (!nsectors)
		nsectors = 1;

	ide_end_request(drive, uptodate, nsectors);
}

269
static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 st)
A
Alan Cox 已提交
270
{
271
	if (st & 0x80)
A
Alan Cox 已提交
272
		return;
273
	ide_dump_status(drive, msg, st);
A
Alan Cox 已提交
274 275
}

B
Borislav Petkov 已提交
276 277 278 279 280
/*
 * Returns:
 * 0: if the request should be continued.
 * 1: if the request was ended.
 */
L
Linus Torvalds 已提交
281 282 283 284
static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
{
	struct request *rq = HWGROUP(drive)->rq;
	int stat, err, sense_key;
285

B
Borislav Petkov 已提交
286
	/* check for errors */
287 288
	stat = ide_read_status(drive);

L
Linus Torvalds 已提交
289 290 291 292 293 294
	if (stat_ret)
		*stat_ret = stat;

	if (OK_STAT(stat, good_stat, BAD_R_STAT))
		return 0;

B
Borislav Petkov 已提交
295
	/* get the IDE error register */
296
	err = ide_read_error(drive);
L
Linus Torvalds 已提交
297 298 299
	sense_key = err >> 4;

	if (rq == NULL) {
300 301
		printk(KERN_ERR "%s: missing rq in %s\n",
				drive->name, __func__);
L
Linus Torvalds 已提交
302 303 304
		return 1;
	}

305
	if (blk_sense_request(rq)) {
B
Borislav Petkov 已提交
306 307 308 309 310
		/*
		 * We got an error trying to get sense info from the drive
		 * (probably while trying to recover from a former error).
		 * Just give up.
		 */
311
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
312 313 314 315
		cdrom_end_request(drive, 0);
		ide_error(drive, "request sense failure", stat);
		return 1;

316
	} else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
L
Linus Torvalds 已提交
317 318 319 320 321 322
		/* All other functions, except for READ. */

		/*
		 * if we have an error, pass back CHECK_CONDITION as the
		 * scsi status byte
		 */
323
		if (blk_pc_request(rq) && !rq->errors)
L
Linus Torvalds 已提交
324 325
			rq->errors = SAM_STAT_CHECK_CONDITION;

B
Borislav Petkov 已提交
326
		/* check for tray open */
L
Linus Torvalds 已提交
327
		if (sense_key == NOT_READY) {
328
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
329
		} else if (sense_key == UNIT_ATTENTION) {
B
Borislav Petkov 已提交
330
			/* check for media change */
331
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
332
			return 0;
333 334 335 336 337 338 339 340 341
		} else if (sense_key == ILLEGAL_REQUEST &&
			   rq->cmd[0] == GPCMD_START_STOP_UNIT) {
			/*
			 * Don't print error message for this condition--
			 * SFF8090i indicates that 5/24/00 is the correct
			 * response to a request to close the tray if the
			 * drive doesn't have that capability.
			 * cdrom_log_sense() knows this!
			 */
342
		} else if (!(rq->cmd_flags & REQ_QUIET)) {
B
Borislav Petkov 已提交
343
			/* otherwise, print an error */
L
Linus Torvalds 已提交
344 345
			ide_dump_status(drive, "packet command error", stat);
		}
346

347
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
348 349 350 351 352 353

		/*
		 * instead of playing games with moving completions around,
		 * remove failed request completely and end it when the
		 * request sense has completed
		 */
354
		goto end_request;
L
Linus Torvalds 已提交
355 356 357 358

	} else if (blk_fs_request(rq)) {
		int do_end_request = 0;

B
Borislav Petkov 已提交
359
		/* handle errors from READ and WRITE requests */
L
Linus Torvalds 已提交
360 361 362 363 364

		if (blk_noretry_request(rq))
			do_end_request = 1;

		if (sense_key == NOT_READY) {
B
Borislav Petkov 已提交
365
			/* tray open */
L
Linus Torvalds 已提交
366
			if (rq_data_dir(rq) == READ) {
367
				cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
368

B
Borislav Petkov 已提交
369
				/* fail the request */
370
				printk(KERN_ERR "%s: tray open\n", drive->name);
L
Linus Torvalds 已提交
371 372 373 374
				do_end_request = 1;
			} else {
				struct cdrom_info *info = drive->driver_data;

B
Borislav Petkov 已提交
375 376
				/*
				 * Allow the drive 5 seconds to recover, some
L
Linus Torvalds 已提交
377
				 * devices will return this error while flushing
B
Borislav Petkov 已提交
378 379
				 * data from cache.
				 */
L
Linus Torvalds 已提交
380
				if (!rq->errors)
381 382
					info->write_timeout = jiffies +
							ATAPI_WAIT_WRITE_BUSY;
L
Linus Torvalds 已提交
383 384 385 386 387 388 389
				rq->errors = 1;
				if (time_after(jiffies, info->write_timeout))
					do_end_request = 1;
				else {
					unsigned long flags;

					/*
B
Borislav Petkov 已提交
390 391
					 * take a breather relying on the unplug
					 * timer to kick us again
L
Linus Torvalds 已提交
392 393 394
					 */
					spin_lock_irqsave(&ide_lock, flags);
					blk_plug_device(drive->queue);
395 396
					spin_unlock_irqrestore(&ide_lock,
								flags);
L
Linus Torvalds 已提交
397 398 399 400
					return 1;
				}
			}
		} else if (sense_key == UNIT_ATTENTION) {
B
Borislav Petkov 已提交
401
			/* media change */
402
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
403

404
			/*
B
Borislav Petkov 已提交
405 406
			 * Arrange to retry the request but be sure to give up
			 * if we've retried too many times.
407
			 */
L
Linus Torvalds 已提交
408 409 410 411
			if (++rq->errors > ERROR_MAX)
				do_end_request = 1;
		} else if (sense_key == ILLEGAL_REQUEST ||
			   sense_key == DATA_PROTECT) {
412
			/*
B
Borislav Petkov 已提交
413 414
			 * No point in retrying after an illegal request or data
			 * protect error.
415 416
			 */
			ide_dump_status_no_sense(drive, "command error", stat);
L
Linus Torvalds 已提交
417 418
			do_end_request = 1;
		} else if (sense_key == MEDIUM_ERROR) {
419 420
			/*
			 * No point in re-trying a zillion times on a bad
B
Borislav Petkov 已提交
421
			 * sector. If we got here the error is not correctable.
422
			 */
423 424 425
			ide_dump_status_no_sense(drive,
						 "media error (bad sector)",
						 stat);
L
Linus Torvalds 已提交
426 427
			do_end_request = 1;
		} else if (sense_key == BLANK_CHECK) {
B
Borislav Petkov 已提交
428
			/* disk appears blank ?? */
429 430
			ide_dump_status_no_sense(drive, "media error (blank)",
						 stat);
L
Linus Torvalds 已提交
431 432
			do_end_request = 1;
		} else if ((err & ~ABRT_ERR) != 0) {
B
Borislav Petkov 已提交
433
			/* go to the default handler for other errors */
L
Linus Torvalds 已提交
434 435 436
			ide_error(drive, "cdrom_decode_status", stat);
			return 1;
		} else if ((++rq->errors > ERROR_MAX)) {
B
Borislav Petkov 已提交
437
			/* we've racked up too many retries, abort */
L
Linus Torvalds 已提交
438 439 440
			do_end_request = 1;
		}

B
Borislav Petkov 已提交
441 442 443 444 445
		/*
		 * End a request through request sense analysis when we have
		 * sense data. We need this in order to perform end of media
		 * processing.
		 */
446 447
		if (do_end_request)
			goto end_request;
A
Alan Cox 已提交
448

449
		/*
B
Borislav Petkov 已提交
450 451
		 * If we got a CHECK_CONDITION status, queue
		 * a request sense command.
452 453 454
		 */
		if (stat & ERR_STAT)
			cdrom_queue_request_sense(drive, NULL, NULL);
L
Linus Torvalds 已提交
455 456 457 458 459
	} else {
		blk_dump_rq_flags(rq, "ide-cd: bad rq");
		cdrom_end_request(drive, 0);
	}

B
Borislav Petkov 已提交
460
	/* retry, or handle the next request */
L
Linus Torvalds 已提交
461
	return 1;
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

end_request:
	if (stat & ERR_STAT) {
		unsigned long flags;

		spin_lock_irqsave(&ide_lock, flags);
		blkdev_dequeue_request(rq);
		HWGROUP(drive)->rq = NULL;
		spin_unlock_irqrestore(&ide_lock, flags);

		cdrom_queue_request_sense(drive, rq->sense, rq);
	} else
		cdrom_end_request(drive, 0);

	return 1;
L
Linus Torvalds 已提交
477 478 479 480 481 482 483 484
}

static int cdrom_timer_expiry(ide_drive_t *drive)
{
	struct request *rq = HWGROUP(drive)->rq;
	unsigned long wait = 0;

	/*
B
Borislav Petkov 已提交
485 486 487 488
	 * Some commands are *slow* and normally take a long time to complete.
	 * Usually we can use the ATAPI "disconnect" to bypass this, but not all
	 * commands/drives support that. Let ide_timer_expiry keep polling us
	 * for these.
L
Linus Torvalds 已提交
489 490
	 */
	switch (rq->cmd[0]) {
491 492 493 494 495 496 497 498 499
	case GPCMD_BLANK:
	case GPCMD_FORMAT_UNIT:
	case GPCMD_RESERVE_RZONE_TRACK:
	case GPCMD_CLOSE_TRACK:
	case GPCMD_FLUSH_CACHE:
		wait = ATAPI_WAIT_PC;
		break;
	default:
		if (!(rq->cmd_flags & REQ_QUIET))
500 501
			printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n",
					 rq->cmd[0]);
502 503
		wait = 0;
		break;
L
Linus Torvalds 已提交
504 505 506 507
	}
	return wait;
}

B
Borislav Petkov 已提交
508 509 510 511 512 513 514 515
/*
 * Set up the device registers for transferring a packet command on DEV,
 * expecting to later transfer XFERLEN bytes.  HANDLER is the routine
 * which actually transfers the command to the drive.  If this is a
 * drq_interrupt device, this routine will arrange for HANDLER to be
 * called when the interrupt from the drive arrives.  Otherwise, HANDLER
 * will be called immediately after the drive is prepared for the transfer.
 */
L
Linus Torvalds 已提交
516 517 518 519 520 521 522
static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
						  int xferlen,
						  ide_handler_t *handler)
{
	struct cdrom_info *info = drive->driver_data;
	ide_hwif_t *hwif = drive->hwif;

523
	/* FIXME: for Virtual DMA we must check harder */
L
Linus Torvalds 已提交
524
	if (info->dma)
525
		info->dma = !hwif->dma_ops->dma_setup(drive);
L
Linus Torvalds 已提交
526

B
Borislav Petkov 已提交
527
	/* set up the controller registers */
528 529
	ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL,
			   xferlen, info->dma);
530

531
	if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
532 533 534 535
		/* waiting for CDB interrupt, not DMA yet. */
		if (info->dma)
			drive->waiting_for_dma = 0;

L
Linus Torvalds 已提交
536
		/* packet command */
537 538
		ide_execute_command(drive, WIN_PACKETCMD, handler,
				    ATAPI_WAIT_PC, cdrom_timer_expiry);
L
Linus Torvalds 已提交
539 540
		return ide_started;
	} else {
541
		ide_execute_pkt_cmd(drive);
L
Linus Torvalds 已提交
542 543 544 545 546

		return (*handler) (drive);
	}
}

B
Borislav Petkov 已提交
547 548 549 550 551 552
/*
 * Send a packet command to DRIVE described by CMD_BUF and CMD_LEN. The device
 * registers must have already been prepared by cdrom_start_packet_command.
 * HANDLER is the interrupt handler to call when the command completes or
 * there's data ready.
 */
L
Linus Torvalds 已提交
553
#define ATAPI_MIN_CDB_BYTES 12
554
static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
L
Linus Torvalds 已提交
555 556 557 558 559 560 561 562
					  struct request *rq,
					  ide_handler_t *handler)
{
	ide_hwif_t *hwif = drive->hwif;
	int cmd_len;
	struct cdrom_info *info = drive->driver_data;
	ide_startstop_t startstop;

563
	if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
B
Borislav Petkov 已提交
564 565 566 567
		/*
		 * Here we should have been called after receiving an interrupt
		 * from the device.  DRQ should how be set.
		 */
L
Linus Torvalds 已提交
568

B
Borislav Petkov 已提交
569
		/* check for errors */
L
Linus Torvalds 已提交
570 571
		if (cdrom_decode_status(drive, DRQ_STAT, NULL))
			return ide_stopped;
572

B
Borislav Petkov 已提交
573
		/* ok, next interrupt will be DMA interrupt */
574 575
		if (info->dma)
			drive->waiting_for_dma = 1;
L
Linus Torvalds 已提交
576
	} else {
B
Borislav Petkov 已提交
577
		/* otherwise, we must wait for DRQ to get set */
L
Linus Torvalds 已提交
578 579 580 581 582
		if (ide_wait_stat(&startstop, drive, DRQ_STAT,
				BUSY_STAT, WAIT_READY))
			return startstop;
	}

B
Borislav Petkov 已提交
583
	/* arm the interrupt handler */
L
Linus Torvalds 已提交
584 585 586 587 588 589 590
	ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);

	/* ATAPI commands get padded out to 12 bytes minimum */
	cmd_len = COMMAND_SIZE(rq->cmd[0]);
	if (cmd_len < ATAPI_MIN_CDB_BYTES)
		cmd_len = ATAPI_MIN_CDB_BYTES;

B
Borislav Petkov 已提交
591
	/* send the command to the device */
592
	hwif->output_data(drive, NULL, rq->cmd, cmd_len);
L
Linus Torvalds 已提交
593

B
Borislav Petkov 已提交
594
	/* start the DMA if need be */
L
Linus Torvalds 已提交
595
	if (info->dma)
596
		hwif->dma_ops->dma_start(drive);
L
Linus Torvalds 已提交
597 598 599 600 601 602 603 604 605

	return ide_started;
}

/*
 * Check the contents of the interrupt reason register from the cdrom
 * and attempt to recover if there are problems.  Returns  0 if everything's
 * ok; nonzero if the request has been terminated.
 */
606 607
static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
				int len, int ireason, int rw)
L
Linus Torvalds 已提交
608
{
609 610 611 612 613
	/*
	 * ireason == 0: the drive wants to receive data from us
	 * ireason == 2: the drive is expecting to transfer data to us
	 */
	if (ireason == (!rw << 1))
L
Linus Torvalds 已提交
614
		return 0;
615
	else if (ireason == (rw << 1)) {
616

B
Borislav Petkov 已提交
617
		/* whoops... */
618
		printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
619
				drive->name, __func__);
L
Linus Torvalds 已提交
620

621
		ide_pad_transfer(drive, rw, len);
622
	} else  if (rw == 0 && ireason == 1) {
B
Borislav Petkov 已提交
623 624 625
		/*
		 * Some drives (ASUS) seem to tell us that status info is
		 * available.  Just get it and ignore.
L
Linus Torvalds 已提交
626
		 */
627
		(void)ide_read_status(drive);
L
Linus Torvalds 已提交
628 629
		return 0;
	} else {
B
Borislav Petkov 已提交
630
		/* drive wants a command packet, or invalid ireason... */
631
		printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
632
				drive->name, __func__, ireason);
L
Linus Torvalds 已提交
633 634
	}

635 636 637
	if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags |= REQ_FAILED;

L
Linus Torvalds 已提交
638 639 640 641
	cdrom_end_request(drive, 0);
	return -1;
}

642 643 644 645 646 647 648 649 650 651 652 653
/*
 * Assume that the drive will always provide data in multiples of at least
 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
 */
static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
{
	struct cdrom_info *cd = drive->driver_data;

	if ((len % SECTOR_SIZE) == 0)
		return 0;

	printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
654
			drive->name, __func__, len);
655 656 657 658 659 660 661 662 663 664 665 666

	if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
		printk(KERN_ERR "  This drive is not supported by "
				"this version of the driver\n");
	else {
		printk(KERN_ERR "  Trying to limit transfer sizes\n");
		cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
	}

	return 1;
}

667
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
668

L
Linus Torvalds 已提交
669
/*
B
Borislav Petkov 已提交
670 671 672 673
 * Routine to send a read/write packet command to the drive. This is usually
 * called directly from cdrom_start_{read,write}(). However, for drq_interrupt
 * devices, it is called from an interrupt when the drive is ready to accept
 * the command.
L
Linus Torvalds 已提交
674
 */
675
static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
L
Linus Torvalds 已提交
676 677 678
{
	struct request *rq = HWGROUP(drive)->rq;

679 680 681 682
	if (rq_data_dir(rq) == READ) {
		unsigned short sectors_per_frame =
			queue_hardsect_size(drive->queue) >> SECTOR_BITS;
		int nskip = rq->sector & (sectors_per_frame - 1);
L
Linus Torvalds 已提交
683

684 685 686 687 688 689 690 691 692 693 694
		/*
		 * If the requested sector doesn't start on a frame boundary,
		 * we must adjust the start of the transfer so that it does,
		 * and remember to skip the first few sectors.
		 *
		 * If the rq->current_nr_sectors field is larger than the size
		 * of the buffer, it will mean that we're to skip a number of
		 * sectors equal to the amount by which rq->current_nr_sectors
		 * is larger than the buffer size.
		 */
		if (nskip > 0) {
B
Borislav Petkov 已提交
695
			/* sanity check... */
696 697 698
			if (rq->current_nr_sectors !=
			    bio_cur_sectors(rq->bio)) {
				printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
699
						drive->name, __func__,
700 701 702 703 704
						rq->current_nr_sectors);
				cdrom_end_request(drive, 0);
				return ide_stopped;
			}
			rq->current_nr_sectors += nskip;
L
Linus Torvalds 已提交
705 706
		}
	}
707 708 709 710 711
#if 0
	else
		/* the immediate bit */
		rq->cmd[1] = 1 << 3;
#endif
B
Borislav Petkov 已提交
712
	/* set up the command */
L
Linus Torvalds 已提交
713 714
	rq->timeout = ATAPI_WAIT_PC;

B
Borislav Petkov 已提交
715
	/* send the command to the drive and return */
716
	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
L
Linus Torvalds 已提交
717 718 719 720 721 722
}

#define IDECD_SEEK_THRESHOLD	(1000)			/* 1000 blocks */
#define IDECD_SEEK_TIMER	(5 * WAIT_MIN_SLEEP)	/* 100 ms */
#define IDECD_SEEK_TIMEOUT	(2 * WAIT_CMD)		/* 20 sec */

723
static ide_startstop_t cdrom_seek_intr(ide_drive_t *drive)
L
Linus Torvalds 已提交
724 725 726 727 728 729 730
{
	struct cdrom_info *info = drive->driver_data;
	int stat;
	static int retry = 10;

	if (cdrom_decode_status(drive, 0, &stat))
		return ide_stopped;
731

732
	info->cd_flags |= IDE_CD_FLAG_SEEKING;
L
Linus Torvalds 已提交
733 734

	if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
B
Borislav Petkov 已提交
735
		if (--retry == 0)
L
Linus Torvalds 已提交
736 737 738 739 740
			drive->dsc_overlap = 0;
	}
	return ide_stopped;
}

741
static void ide_cd_prepare_seek_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
742 743 744 745 746
{
	sector_t frame = rq->sector;

	sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);

747
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
748 749 750 751
	rq->cmd[0] = GPCMD_SEEK;
	put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);

	rq->timeout = ATAPI_WAIT_PC;
752 753 754 755 756 757
}

static ide_startstop_t cdrom_start_seek_continuation(ide_drive_t *drive)
{
	struct request *rq = drive->hwif->hwgroup->rq;

L
Linus Torvalds 已提交
758 759 760
	return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
}

761
/*
B
Borislav Petkov 已提交
762 763
 * Fix up a possibly partially-processed request so that we can start it over
 * entirely, or even put it back on the request queue.
764 765
 */
static void restore_request(struct request *rq)
L
Linus Torvalds 已提交
766 767
{
	if (rq->buffer != bio_data(rq->bio)) {
768 769
		sector_t n =
			(rq->buffer - (char *)bio_data(rq->bio)) / SECTOR_SIZE;
L
Linus Torvalds 已提交
770 771 772 773 774

		rq->buffer = bio_data(rq->bio);
		rq->nr_sectors += n;
		rq->sector -= n;
	}
775 776
	rq->current_nr_sectors = bio_cur_sectors(rq->bio);
	rq->hard_cur_sectors = rq->current_nr_sectors;
L
Linus Torvalds 已提交
777 778 779 780 781
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
	rq->q->prep_rq_fn(rq->q, rq);
}

B
Borislav Petkov 已提交
782 783
/*
 * All other packet commands.
L
Linus Torvalds 已提交
784
 */
785 786 787 788 789 790 791 792 793 794 795 796 797 798
static void ide_cd_request_sense_fixup(struct request *rq)
{
	/*
	 * Some of the trailing request sense fields are optional,
	 * and some drives don't send them.  Sigh.
	 */
	if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
	    rq->data_len > 0 && rq->data_len <= 5)
		while (rq->data_len > 0) {
			*(u8 *)rq->data++ = 0;
			--rq->data_len;
		}
}

799 800 801 802
int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
		    int write, void *buffer, unsigned *bufflen,
		    struct request_sense *sense, int timeout,
		    unsigned int cmd_flags)
L
Linus Torvalds 已提交
803
{
804 805
	struct cdrom_info *info = drive->driver_data;
	struct request_sense local_sense;
L
Linus Torvalds 已提交
806
	int retries = 10;
807
	unsigned int flags = 0;
L
Linus Torvalds 已提交
808

809 810
	if (!sense)
		sense = &local_sense;
L
Linus Torvalds 已提交
811

B
Borislav Petkov 已提交
812
	/* start of retry loop */
L
Linus Torvalds 已提交
813
	do {
814
		struct request *rq;
L
Linus Torvalds 已提交
815 816
		int error;

817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
		rq = blk_get_request(drive->queue, write, __GFP_WAIT);

		memcpy(rq->cmd, cmd, BLK_MAX_CDB);
		rq->cmd_type = REQ_TYPE_ATA_PC;
		rq->sense = sense;
		rq->cmd_flags |= cmd_flags;
		rq->timeout = timeout;
		if (buffer) {
			rq->data = buffer;
			rq->data_len = *bufflen;
		}

		error = blk_execute_rq(drive->queue, info->disk, rq, 0);

		if (buffer)
			*bufflen = rq->data_len;

		flags = rq->cmd_flags;
		blk_put_request(rq);
L
Linus Torvalds 已提交
836

B
Borislav Petkov 已提交
837 838 839 840
		/*
		 * FIXME: we should probably abort/retry or something in case of
		 * failure.
		 */
841
		if (flags & REQ_FAILED) {
B
Borislav Petkov 已提交
842 843 844 845
			/*
			 * The request failed.  Retry if it was due to a unit
			 * attention status (usually means media was changed).
			 */
846
			struct request_sense *reqbuf = sense;
L
Linus Torvalds 已提交
847 848 849 850 851

			if (reqbuf->sense_key == UNIT_ATTENTION)
				cdrom_saw_media_change(drive);
			else if (reqbuf->sense_key == NOT_READY &&
				 reqbuf->asc == 4 && reqbuf->ascq != 4) {
B
Borislav Petkov 已提交
852 853 854 855 856
				/*
				 * The drive is in the process of loading
				 * a disk.  Retry, but wait a little to give
				 * the drive time to complete the load.
				 */
L
Linus Torvalds 已提交
857 858
				ssleep(2);
			} else {
B
Borislav Petkov 已提交
859
				/* otherwise, don't retry */
L
Linus Torvalds 已提交
860 861 862 863 864
				retries = 0;
			}
			--retries;
		}

B
Borislav Petkov 已提交
865
		/* end of retry loop */
866
	} while ((flags & REQ_FAILED) && retries >= 0);
L
Linus Torvalds 已提交
867

B
Borislav Petkov 已提交
868
	/* return an error if the command failed */
869
	return (flags & REQ_FAILED) ? -EIO : 0;
L
Linus Torvalds 已提交
870 871
}

872
/*
B
Borislav Petkov 已提交
873 874 875
 * Called from blk_end_request_callback() after the data of the request is
 * completed and before the request itself is completed. By returning value '1',
 * blk_end_request_callback() returns immediately without completing it.
876 877 878 879 880 881
 */
static int cdrom_newpc_intr_dummy_cb(struct request *rq)
{
	return 1;
}

L
Linus Torvalds 已提交
882 883
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
{
884
	ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
885 886 887
	struct cdrom_info *info = drive->driver_data;
	struct request *rq = HWGROUP(drive)->rq;
	xfer_func_t *xferfunc;
888
	ide_expiry_t *expiry = NULL;
889 890 891 892
	int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
	int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
	unsigned int timeout;
	u8 lowcyl, highcyl;
L
Linus Torvalds 已提交
893

B
Borislav Petkov 已提交
894
	/* check for errors */
L
Linus Torvalds 已提交
895 896 897
	dma = info->dma;
	if (dma) {
		info->dma = 0;
898
		dma_error = hwif->dma_ops->dma_end(drive);
899 900
		if (dma_error) {
			printk(KERN_ERR "%s: DMA %s error\n", drive->name,
901
					write ? "write" : "read");
902 903
			ide_dma_off(drive);
		}
L
Linus Torvalds 已提交
904 905 906 907 908
	}

	if (cdrom_decode_status(drive, 0, &stat))
		return ide_stopped;

B
Borislav Petkov 已提交
909
	/* using dma, transfer is complete now */
L
Linus Torvalds 已提交
910
	if (dma) {
911
		if (dma_error)
L
Linus Torvalds 已提交
912
			return ide_error(drive, "dma error", stat);
913 914 915 916
		if (blk_fs_request(rq)) {
			ide_end_request(drive, 1, rq->nr_sectors);
			return ide_stopped;
		}
917
		goto end_request;
L
Linus Torvalds 已提交
918 919
	}

B
Borislav Petkov 已提交
920
	/* ok we fall to pio :/ */
921 922 923
	ireason = hwif->INB(hwif->io_ports.nsect_addr) & 0x3;
	lowcyl  = hwif->INB(hwif->io_ports.lbam_addr);
	highcyl = hwif->INB(hwif->io_ports.lbah_addr);
L
Linus Torvalds 已提交
924 925

	len = lowcyl + (256 * highcyl);
926 927

	thislen = blk_fs_request(rq) ? len : rq->data_len;
L
Linus Torvalds 已提交
928 929 930
	if (thislen > len)
		thislen = len;

B
Borislav Petkov 已提交
931
	/* If DRQ is clear, the command has completed. */
932
	if ((stat & DRQ_STAT) == 0) {
933 934 935 936 937 938 939 940 941
		if (blk_fs_request(rq)) {
			/*
			 * If we're not done reading/writing, complain.
			 * Otherwise, complete the command normally.
			 */
			uptodate = 1;
			if (rq->current_nr_sectors > 0) {
				printk(KERN_ERR "%s: %s: data underrun "
						"(%d blocks)\n",
942
						drive->name, __func__,
943 944 945 946 947 948 949 950
						rq->current_nr_sectors);
				if (!write)
					rq->cmd_flags |= REQ_FAILED;
				uptodate = 0;
			}
			cdrom_end_request(drive, uptodate);
			return ide_stopped;
		} else if (!blk_pc_request(rq)) {
951
			ide_cd_request_sense_fixup(rq);
B
Borislav Petkov 已提交
952
			/* complain if we still have data left to transfer */
953 954 955
			uptodate = rq->data_len ? 0 : 1;
		}
		goto end_request;
956
	}
L
Linus Torvalds 已提交
957

B
Borislav Petkov 已提交
958
	/* check which way to transfer data */
959 960
	if (ide_cd_check_ireason(drive, rq, len, ireason, write))
		return ide_stopped;
961

962 963
	if (blk_fs_request(rq)) {
		if (write == 0) {
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
			int nskip;

			if (ide_cd_check_transfer_size(drive, len)) {
				cdrom_end_request(drive, 0);
				return ide_stopped;
			}

			/*
			 * First, figure out if we need to bit-bucket
			 * any of the leading sectors.
			 */
			nskip = min_t(int, rq->current_nr_sectors
					   - bio_cur_sectors(rq->bio),
					   thislen >> 9);
			if (nskip > 0) {
979
				ide_pad_transfer(drive, write, nskip << 9);
980 981 982 983
				rq->current_nr_sectors -= nskip;
				thislen -= (nskip << 9);
			}
		}
984
	}
L
Linus Torvalds 已提交
985

986 987
	if (ireason == 0) {
		write = 1;
988
		xferfunc = hwif->output_data;
989
	} else {
990
		write = 0;
991
		xferfunc = hwif->input_data;
L
Linus Torvalds 已提交
992 993
	}

B
Borislav Petkov 已提交
994
	/* transfer data */
L
Linus Torvalds 已提交
995
	while (thislen > 0) {
996
		u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
997
		int blen = rq->data_len;
L
Linus Torvalds 已提交
998

B
Borislav Petkov 已提交
999
		/* bio backed? */
L
Linus Torvalds 已提交
1000
		if (rq->bio) {
1001 1002 1003 1004 1005 1006 1007
			if (blk_fs_request(rq)) {
				ptr = rq->buffer;
				blen = rq->current_nr_sectors << 9;
			} else {
				ptr = bio_data(rq->bio);
				blen = bio_iovec(rq->bio)->bv_len;
			}
L
Linus Torvalds 已提交
1008 1009 1010
		}

		if (!ptr) {
1011 1012
			if (blk_fs_request(rq) && !write)
				/*
1013
				 * If the buffers are full, pipe the rest into
B
Borislav Petkov 已提交
1014 1015
				 * oblivion.
				 */
1016
				ide_pad_transfer(drive, 0, thislen);
1017 1018 1019 1020 1021 1022 1023
			else {
				printk(KERN_ERR "%s: confused, missing data\n",
						drive->name);
				blk_dump_rq_flags(rq, rq_data_dir(rq)
						  ? "cdrom_newpc_intr, write"
						  : "cdrom_newpc_intr, read");
			}
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029
			break;
		}

		if (blen > thislen)
			blen = thislen;

1030
		xferfunc(drive, NULL, ptr, blen);
L
Linus Torvalds 已提交
1031 1032 1033 1034

		thislen -= blen;
		len -= blen;

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
		if (blk_fs_request(rq)) {
			rq->buffer += blen;
			rq->nr_sectors -= (blen >> 9);
			rq->current_nr_sectors -= (blen >> 9);
			rq->sector += (blen >> 9);

			if (rq->current_nr_sectors == 0 && rq->nr_sectors)
				cdrom_end_request(drive, 1);
		} else {
			rq->data_len -= blen;

1046 1047 1048 1049 1050 1051
			/*
			 * The request can't be completed until DRQ is cleared.
			 * So complete the data, but don't complete the request
			 * using the dummy function for the callback feature
			 * of blk_end_request_callback().
			 */
1052 1053
			if (rq->bio)
				blk_end_request_callback(rq, 0, blen,
1054
						 cdrom_newpc_intr_dummy_cb);
1055 1056 1057
			else
				rq->data += blen;
		}
A
Andreas Schwab 已提交
1058 1059
		if (!write && blk_sense_request(rq))
			rq->sense_len += blen;
L
Linus Torvalds 已提交
1060 1061
	}

B
Borislav Petkov 已提交
1062
	/* pad, if necessary */
1063
	if (!blk_fs_request(rq) && len > 0)
1064
		ide_pad_transfer(drive, write, len);
L
Linus Torvalds 已提交
1065

1066 1067 1068 1069
	if (blk_pc_request(rq)) {
		timeout = rq->timeout;
	} else {
		timeout = ATAPI_WAIT_PC;
1070 1071
		if (!blk_fs_request(rq))
			expiry = cdrom_timer_expiry;
1072 1073 1074
	}

	ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
L
Linus Torvalds 已提交
1075
	return ide_started;
1076 1077 1078 1079

end_request:
	if (blk_pc_request(rq)) {
		unsigned long flags;
1080 1081 1082 1083
		unsigned int dlen = rq->data_len;

		if (dma)
			rq->data_len = 0;
1084 1085

		spin_lock_irqsave(&ide_lock, flags);
1086
		if (__blk_end_request(rq, 0, dlen))
1087 1088 1089 1090 1091 1092 1093 1094 1095
			BUG();
		HWGROUP(drive)->rq = NULL;
		spin_unlock_irqrestore(&ide_lock, flags);
	} else {
		if (!uptodate)
			rq->cmd_flags |= REQ_FAILED;
		cdrom_end_request(drive, uptodate);
	}
	return ide_stopped;
L
Linus Torvalds 已提交
1096 1097
}

1098
static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1099
{
1100 1101 1102 1103
	struct cdrom_info *cd = drive->driver_data;
	int write = rq_data_dir(rq) == WRITE;
	unsigned short sectors_per_frame =
		queue_hardsect_size(drive->queue) >> SECTOR_BITS;
L
Linus Torvalds 已提交
1104

1105
	if (write) {
B
Borislav Petkov 已提交
1106
		/* disk has become write protected */
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
		if (cd->disk->policy) {
			cdrom_end_request(drive, 0);
			return ide_stopped;
		}
	} else {
		/*
		 * We may be retrying this request after an error.  Fix up any
		 * weirdness which might be present in the request packet.
		 */
		restore_request(rq);
L
Linus Torvalds 已提交
1117 1118
	}

B
Borislav Petkov 已提交
1119
	/* use DMA, if possible / writes *must* be hardware frame aligned */
1120 1121 1122 1123 1124 1125 1126 1127 1128
	if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
	    (rq->sector & (sectors_per_frame - 1))) {
		if (write) {
			cdrom_end_request(drive, 0);
			return ide_stopped;
		}
		cd->dma = 0;
	} else
		cd->dma = drive->using_dma;
L
Linus Torvalds 已提交
1129

1130 1131
	if (write)
		cd->devinfo.media_written = 1;
L
Linus Torvalds 已提交
1132

1133
	return ide_started;
L
Linus Torvalds 已提交
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
}

static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
{
	struct request *rq = HWGROUP(drive)->rq;

	if (!rq->timeout)
		rq->timeout = ATAPI_WAIT_PC;

	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
}

1146
static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1147 1148 1149
{
	struct cdrom_info *info = drive->driver_data;

1150 1151 1152 1153
	if (blk_pc_request(rq))
		rq->cmd_flags |= REQ_QUIET;
	else
		rq->cmd_flags &= ~REQ_FAILED;
L
Linus Torvalds 已提交
1154 1155 1156

	info->dma = 0;

B
Borislav Petkov 已提交
1157
	/* sg request */
1158 1159 1160 1161
	if (rq->bio || ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
		struct request_queue *q = drive->queue;
		unsigned int alignment;
		unsigned long addr;
1162
		unsigned long stack_mask = ~(THREAD_SIZE - 1);
L
Linus Torvalds 已提交
1163

1164 1165 1166 1167 1168
		if (rq->bio)
			addr = (unsigned long)bio_data(rq->bio);
		else
			addr = (unsigned long)rq->data;

L
Linus Torvalds 已提交
1169 1170 1171 1172
		info->dma = drive->using_dma;

		/*
		 * check if dma is safe
1173 1174 1175
		 *
		 * NOTE! The "len" and "addr" checks should possibly have
		 * separate masks.
L
Linus Torvalds 已提交
1176
		 */
1177 1178
		alignment = queue_dma_alignment(q) | q->dma_pad_mask;
		if (addr & alignment || rq->data_len & alignment)
L
Linus Torvalds 已提交
1179
			info->dma = 0;
1180 1181 1182 1183

		if (!((addr & stack_mask) ^
		      ((unsigned long)current->stack & stack_mask)))
			info->dma = 0;
L
Linus Torvalds 已提交
1184 1185 1186
	}
}

B
Borislav Petkov 已提交
1187
/*
L
Linus Torvalds 已提交
1188 1189
 * cdrom driver request routine.
 */
1190
static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
1191
					sector_t block)
L
Linus Torvalds 已提交
1192 1193
{
	struct cdrom_info *info = drive->driver_data;
1194 1195
	ide_handler_t *fn;
	int xferlen;
L
Linus Torvalds 已提交
1196 1197

	if (blk_fs_request(rq)) {
1198
		if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
L
Linus Torvalds 已提交
1199
			unsigned long elapsed = jiffies - info->start_seek;
1200
			int stat = ide_read_status(drive);
L
Linus Torvalds 已提交
1201 1202 1203

			if ((stat & SEEK_STAT) != SEEK_STAT) {
				if (elapsed < IDECD_SEEK_TIMEOUT) {
1204 1205
					ide_stall_queue(drive,
							IDECD_SEEK_TIMER);
L
Linus Torvalds 已提交
1206 1207
					return ide_stopped;
				}
1208 1209
				printk(KERN_ERR "%s: DSC timeout\n",
						drive->name);
L
Linus Torvalds 已提交
1210
			}
1211
			info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
L
Linus Torvalds 已提交
1212
		}
1213 1214
		if (rq_data_dir(rq) == READ &&
		    IDE_LARGE_SEEK(info->last_block, block,
1215 1216 1217 1218
			    IDECD_SEEK_THRESHOLD) &&
		    drive->dsc_overlap) {
			xferlen = 0;
			fn = cdrom_start_seek_continuation;
1219

1220 1221
			info->dma = 0;
			info->start_seek = jiffies;
1222 1223

			ide_cd_prepare_seek_request(drive, rq);
1224 1225 1226 1227 1228 1229
		} else {
			xferlen = 32768;
			fn = cdrom_start_rw_cont;
			if (cdrom_start_rw(drive, rq) == ide_stopped)
				return ide_stopped;
		}
L
Linus Torvalds 已提交
1230
		info->last_block = block;
1231
	} else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1232
		   rq->cmd_type == REQ_TYPE_ATA_PC) {
1233 1234 1235
		xferlen = rq->data_len;
		fn = cdrom_do_newpc_cont;
		cdrom_do_block_pc(drive, rq);
1236
	} else if (blk_special_request(rq)) {
B
Borislav Petkov 已提交
1237
		/* right now this can only be a reset... */
L
Linus Torvalds 已提交
1238 1239
		cdrom_end_request(drive, 1);
		return ide_stopped;
1240 1241 1242 1243
	} else {
		blk_dump_rq_flags(rq, "ide-cd bad flags");
		cdrom_end_request(drive, 0);
		return ide_stopped;
L
Linus Torvalds 已提交
1244
	}
1245 1246

	return cdrom_start_packet_command(drive, xferlen, fn);
L
Linus Torvalds 已提交
1247 1248 1249 1250
}



B
Borislav Petkov 已提交
1251
/*
L
Linus Torvalds 已提交
1252 1253
 * Ioctl handling.
 *
B
Borislav Petkov 已提交
1254 1255 1256 1257 1258
 * Routines which queue packet commands take as a final argument a pointer to a
 * request_sense struct. If execution of the command results in an error with a
 * CHECK CONDITION status, this structure will be filled with the results of the
 * subsequent request sense command. The pointer can also be NULL, in which case
 * no sense information is returned.
L
Linus Torvalds 已提交
1259
 */
1260
static void msf_from_bcd(struct atapi_msf *msf)
L
Linus Torvalds 已提交
1261
{
1262 1263 1264
	msf->minute = BCD2BIN(msf->minute);
	msf->second = BCD2BIN(msf->second);
	msf->frame  = BCD2BIN(msf->frame);
L
Linus Torvalds 已提交
1265 1266
}

1267
int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1268 1269 1270
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
1271
	unsigned char cmd[BLK_MAX_CDB];
L
Linus Torvalds 已提交
1272

1273 1274
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_TEST_UNIT_READY;
L
Linus Torvalds 已提交
1275

1276
	/*
B
Borislav Petkov 已提交
1277 1278
	 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
	 * instead of supporting the LOAD_UNLOAD opcode.
1279
	 */
1280
	cmd[7] = cdi->sanyo_slot % 3;
L
Linus Torvalds 已提交
1281

1282
	return ide_cd_queue_pc(drive, cmd, 0, NULL, 0, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
}

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
			       unsigned long *sectors_per_frame,
			       struct request_sense *sense)
{
	struct {
		__u32 lba;
		__u32 blocklen;
	} capbuf;

	int stat;
1295 1296
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(capbuf);
L
Linus Torvalds 已提交
1297

1298 1299
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_READ_CDVD_CAPACITY;
L
Linus Torvalds 已提交
1300

1301 1302
	stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
			       REQ_QUIET);
L
Linus Torvalds 已提交
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
	if (stat == 0) {
		*capacity = 1 + be32_to_cpu(capbuf.lba);
		*sectors_per_frame =
			be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
	}

	return stat;
}

static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
				int format, char *buf, int buflen,
				struct request_sense *sense)
{
1316
	unsigned char cmd[BLK_MAX_CDB];
L
Linus Torvalds 已提交
1317

1318
	memset(cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1319

1320 1321 1322 1323 1324
	cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
	cmd[6] = trackno;
	cmd[7] = (buflen >> 8);
	cmd[8] = (buflen & 0xff);
	cmd[9] = (format << 6);
L
Linus Torvalds 已提交
1325 1326

	if (msf_flag)
1327
		cmd[1] = 2;
L
Linus Torvalds 已提交
1328

1329
	return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1330 1331 1332
}

/* Try to read the entire TOC for the disk into our internal buffer. */
1333
int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
{
	int stat, ntracks, i;
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
	struct atapi_toc *toc = info->toc;
	struct {
		struct atapi_toc_header hdr;
		struct atapi_toc_entry  ent;
	} ms_tmp;
	long last_written;
	unsigned long sectors_per_frame = SECTORS_PER_FRAME;

	if (toc == NULL) {
B
Borislav Petkov 已提交
1347
		/* try to allocate space */
J
Jesper Juhl 已提交
1348
		toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
L
Linus Torvalds 已提交
1349
		if (toc == NULL) {
1350 1351
			printk(KERN_ERR "%s: No cdrom TOC buffer!\n",
					drive->name);
L
Linus Torvalds 已提交
1352 1353
			return -ENOMEM;
		}
J
Jesper Juhl 已提交
1354
		info->toc = toc;
L
Linus Torvalds 已提交
1355 1356
	}

B
Borislav Petkov 已提交
1357 1358 1359 1360
	/*
	 * Check to see if the existing data is still valid. If it is,
	 * just return.
	 */
L
Linus Torvalds 已提交
1361 1362
	(void) cdrom_check_status(drive, sense);

1363
	if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
L
Linus Torvalds 已提交
1364 1365
		return 0;

B
Borislav Petkov 已提交
1366
	/* try to get the total cdrom capacity and sector size */
L
Linus Torvalds 已提交
1367 1368 1369 1370 1371 1372
	stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
				   sense);
	if (stat)
		toc->capacity = 0x1fffff;

	set_capacity(info->disk, toc->capacity * sectors_per_frame);
B
Borislav Petkov 已提交
1373
	/* save a private copy of the TOC capacity for error handling */
A
Alan Cox 已提交
1374 1375
	drive->probed_capacity = toc->capacity * sectors_per_frame;

L
Linus Torvalds 已提交
1376 1377 1378
	blk_queue_hardsect_size(drive->queue,
				sectors_per_frame << SECTOR_BITS);

B
Borislav Petkov 已提交
1379
	/* first read just the header, so we know how long the TOC is */
L
Linus Torvalds 已提交
1380 1381
	stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
				    sizeof(struct atapi_toc_header), sense);
J
Jesper Juhl 已提交
1382 1383
	if (stat)
		return stat;
L
Linus Torvalds 已提交
1384

1385
	if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1386 1387
		toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
		toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
L
Linus Torvalds 已提交
1388 1389 1390 1391 1392 1393 1394 1395
	}

	ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
	if (ntracks <= 0)
		return -EIO;
	if (ntracks > MAX_TRACKS)
		ntracks = MAX_TRACKS;

B
Borislav Petkov 已提交
1396
	/* now read the whole schmeer */
L
Linus Torvalds 已提交
1397 1398 1399 1400 1401 1402 1403
	stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
				  (char *)&toc->hdr,
				   sizeof(struct atapi_toc_header) +
				   (ntracks + 1) *
				   sizeof(struct atapi_toc_entry), sense);

	if (stat && toc->hdr.first_track > 1) {
B
Borislav Petkov 已提交
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
		/*
		 * Cds with CDI tracks only don't have any TOC entries, despite
		 * of this the returned values are
		 * first_track == last_track = number of CDI tracks + 1,
		 * so that this case is indistinguishable from the same layout
		 * plus an additional audio track. If we get an error for the
		 * regular case, we assume a CDI without additional audio
		 * tracks. In this case the readable TOC is empty (CDI tracks
		 * are not included) and only holds the Leadout entry.
		 *
		 * Heiko Eißfeldt.
		 */
L
Linus Torvalds 已提交
1416 1417 1418 1419 1420 1421 1422
		ntracks = 0;
		stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
					   (char *)&toc->hdr,
					   sizeof(struct atapi_toc_header) +
					   (ntracks + 1) *
					   sizeof(struct atapi_toc_entry),
					   sense);
1423
		if (stat)
L
Linus Torvalds 已提交
1424
			return stat;
1425

1426
		if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1427 1428
			toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
			toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1429
		} else {
L
Linus Torvalds 已提交
1430 1431 1432 1433 1434 1435 1436 1437
			toc->hdr.first_track = CDROM_LEADOUT;
			toc->hdr.last_track = CDROM_LEADOUT;
		}
	}

	if (stat)
		return stat;

1438
	toc->hdr.toc_length = be16_to_cpu(toc->hdr.toc_length);
L
Linus Torvalds 已提交
1439

1440
	if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1441 1442
		toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
		toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
L
Linus Torvalds 已提交
1443 1444
	}

1445
	for (i = 0; i <= ntracks; i++) {
1446 1447
		if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
			if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1448
				toc->ent[i].track = BCD2BIN(toc->ent[i].track);
L
Linus Torvalds 已提交
1449 1450
			msf_from_bcd(&toc->ent[i].addr.msf);
		}
1451 1452 1453
		toc->ent[i].addr.lba = msf_to_lba(toc->ent[i].addr.msf.minute,
						  toc->ent[i].addr.msf.second,
						  toc->ent[i].addr.msf.frame);
L
Linus Torvalds 已提交
1454 1455 1456
	}

	if (toc->hdr.first_track != CDROM_LEADOUT) {
B
Borislav Petkov 已提交
1457
		/* read the multisession information */
L
Linus Torvalds 已提交
1458 1459
		stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
J
Jesper Juhl 已提交
1460 1461
		if (stat)
			return stat;
L
Linus Torvalds 已提交
1462 1463 1464

		toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
	} else {
1465 1466
		ms_tmp.hdr.last_track = CDROM_LEADOUT;
		ms_tmp.hdr.first_track = ms_tmp.hdr.last_track;
L
Linus Torvalds 已提交
1467 1468 1469
		toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
	}

1470
	if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
B
Borislav Petkov 已提交
1471
		/* re-read multisession information using MSF format */
L
Linus Torvalds 已提交
1472 1473 1474 1475 1476
		stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
		if (stat)
			return stat;

1477
		msf_from_bcd(&ms_tmp.ent.addr.msf);
L
Linus Torvalds 已提交
1478
		toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1479
						   ms_tmp.ent.addr.msf.second,
L
Linus Torvalds 已提交
1480 1481 1482 1483 1484
						   ms_tmp.ent.addr.msf.frame);
	}

	toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);

B
Borislav Petkov 已提交
1485
	/* now try to get the total cdrom capacity */
L
Linus Torvalds 已提交
1486 1487 1488 1489
	stat = cdrom_get_last_written(cdi, &last_written);
	if (!stat && (last_written > toc->capacity)) {
		toc->capacity = last_written;
		set_capacity(info->disk, toc->capacity * sectors_per_frame);
A
Alan Cox 已提交
1490
		drive->probed_capacity = toc->capacity * sectors_per_frame;
L
Linus Torvalds 已提交
1491 1492 1493
	}

	/* Remember that we've read this stuff. */
1494
	info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
L
Linus Torvalds 已提交
1495 1496 1497 1498

	return 0;
}

1499
int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
E
Eric Piel 已提交
1500 1501 1502 1503
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
	struct packet_command cgc;
1504
	int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
E
Eric Piel 已提交
1505

1506
	if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1507
		size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
E
Eric Piel 已提交
1508

1509
	init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
B
Borislav Petkov 已提交
1510 1511
	do {
		/* we seem to get stat=0x01,err=0x00 the first time (??) */
E
Eric Piel 已提交
1512 1513 1514 1515 1516 1517 1518
		stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
		if (!stat)
			break;
	} while (--attempts);
	return stat;
}

1519
void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
E
Eric Piel 已提交
1520
{
1521
	struct cdrom_info *cd = drive->driver_data;
1522 1523
	u16 curspeed, maxspeed;

1524 1525 1526
	curspeed = *(u16 *)&buf[8 + 14];
	maxspeed = *(u16 *)&buf[8 +  8];

1527
	if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1528 1529
		curspeed = le16_to_cpu(curspeed);
		maxspeed = le16_to_cpu(maxspeed);
E
Eric Piel 已提交
1530
	} else {
1531 1532
		curspeed = be16_to_cpu(curspeed);
		maxspeed = be16_to_cpu(maxspeed);
E
Eric Piel 已提交
1533
	}
1534

1535 1536
	cd->current_speed = (curspeed + (176/2)) / 176;
	cd->max_speed = (maxspeed + (176/2)) / 176;
E
Eric Piel 已提交
1537 1538
}

1539 1540 1541 1542 1543 1544
#define IDE_CD_CAPABILITIES \
	(CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
	 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
	 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
	 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
	 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
L
Linus Torvalds 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557

static struct cdrom_device_ops ide_cdrom_dops = {
	.open			= ide_cdrom_open_real,
	.release		= ide_cdrom_release_real,
	.drive_status		= ide_cdrom_drive_status,
	.media_changed		= ide_cdrom_check_media_change_real,
	.tray_move		= ide_cdrom_tray_move,
	.lock_door		= ide_cdrom_lock_door,
	.select_speed		= ide_cdrom_select_speed,
	.get_last_session	= ide_cdrom_get_last_session,
	.get_mcn		= ide_cdrom_get_mcn,
	.reset			= ide_cdrom_reset,
	.audio_ioctl		= ide_cdrom_audio_ioctl,
1558
	.capability		= IDE_CD_CAPABILITIES,
L
Linus Torvalds 已提交
1559 1560 1561
	.generic_packet		= ide_cdrom_packet,
};

1562
static int ide_cdrom_register(ide_drive_t *drive, int nslots)
L
Linus Torvalds 已提交
1563 1564 1565 1566 1567
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *devinfo = &info->devinfo;

	devinfo->ops = &ide_cdrom_dops;
1568
	devinfo->speed = info->current_speed;
L
Linus Torvalds 已提交
1569
	devinfo->capacity = nslots;
J
Jesper Juhl 已提交
1570
	devinfo->handle = drive;
L
Linus Torvalds 已提交
1571 1572
	strcpy(devinfo->name, drive->name);

1573
	if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
1574 1575
		devinfo->mask |= CDC_SELECT_SPEED;

L
Linus Torvalds 已提交
1576 1577 1578 1579
	devinfo->disk = info->disk;
	return register_cdrom(devinfo);
}

1580
static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
L
Linus Torvalds 已提交
1581
{
1582 1583
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1584 1585
	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	mechtype_t mechtype;
L
Linus Torvalds 已提交
1586 1587
	int nslots = 1;

1588 1589 1590 1591
	cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
		     CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
		     CDC_MO_DRIVE | CDC_RAM);

L
Linus Torvalds 已提交
1592
	if (drive->media == ide_optical) {
1593
		cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1594 1595
		printk(KERN_ERR "%s: ATAPI magneto-optical drive\n",
				drive->name);
L
Linus Torvalds 已提交
1596 1597 1598
		return nslots;
	}

1599
	if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
1600
		cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1601
		cdi->mask &= ~CDC_PLAY_AUDIO;
L
Linus Torvalds 已提交
1602 1603 1604 1605
		return nslots;
	}

	/*
B
Borislav Petkov 已提交
1606 1607 1608 1609
	 * We have to cheat a little here. the packet will eventually be queued
	 * with ide_cdrom_packet(), which extracts the drive from cdi->handle.
	 * Since this device hasn't been registered with the Uniform layer yet,
	 * it can't do this. Same goes for cdi->ops.
L
Linus Torvalds 已提交
1610
	 */
J
Jesper Juhl 已提交
1611
	cdi->handle = drive;
L
Linus Torvalds 已提交
1612 1613
	cdi->ops = &ide_cdrom_dops;

1614
	if (ide_cdrom_get_capabilities(drive, buf))
L
Linus Torvalds 已提交
1615 1616
		return 0;

1617
	if ((buf[8 + 6] & 0x01) == 0)
1618
		cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1619
	if (buf[8 + 6] & 0x08)
1620
		cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1621
	if (buf[8 + 3] & 0x01)
1622
		cdi->mask &= ~CDC_CD_R;
1623
	if (buf[8 + 3] & 0x02)
1624
		cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1625
	if (buf[8 + 2] & 0x38)
1626
		cdi->mask &= ~CDC_DVD;
1627
	if (buf[8 + 3] & 0x20)
1628
		cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1629
	if (buf[8 + 3] & 0x10)
1630
		cdi->mask &= ~CDC_DVD_R;
1631
	if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
1632
		cdi->mask &= ~CDC_PLAY_AUDIO;
1633 1634 1635

	mechtype = buf[8 + 6] >> 5;
	if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
1636
		cdi->mask |= CDC_CLOSE_TRAY;
L
Linus Torvalds 已提交
1637 1638

	if (cdi->sanyo_slot > 0) {
1639
		cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1640
		nslots = 3;
1641 1642
	} else if (mechtype == mechtype_individual_changer ||
		   mechtype == mechtype_cartridge_changer) {
1643 1644
		nslots = cdrom_number_of_slots(cdi);
		if (nslots > 1)
1645
			cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1646 1647
	}

1648
	ide_cdrom_update_speed(drive, buf);
1649

L
Linus Torvalds 已提交
1650
	printk(KERN_INFO "%s: ATAPI", drive->name);
1651 1652

	/* don't print speed if the drive reported 0 */
1653 1654
	if (cd->max_speed)
		printk(KERN_CONT " %dX", cd->max_speed);
1655

1656
	printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
L
Linus Torvalds 已提交
1657

1658 1659 1660 1661
	if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
		printk(KERN_CONT " DVD%s%s",
				 (cdi->mask & CDC_DVD_R) ? "" : "-R",
				 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
L
Linus Torvalds 已提交
1662

1663 1664 1665 1666
	if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
		printk(KERN_CONT " CD%s%s",
				 (cdi->mask & CDC_CD_R) ? "" : "-R",
				 (cdi->mask & CDC_CD_RW) ? "" : "/RW");
L
Linus Torvalds 已提交
1667

1668 1669 1670 1671
	if ((cdi->mask & CDC_SELECT_DISC) == 0)
		printk(KERN_CONT " changer w/%d slots", nslots);
	else
		printk(KERN_CONT " drive");
L
Linus Torvalds 已提交
1672

1673
	printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
L
Linus Torvalds 已提交
1674 1675 1676 1677

	return nslots;
}

B
Borislav Petkov 已提交
1678
/* standard prep_rq_fn that builds 10 byte cmds */
1679
static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1680 1681 1682 1683 1684
{
	int hard_sect = queue_hardsect_size(q);
	long block = (long)rq->hard_sector / (hard_sect >> 9);
	unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);

1685
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716

	if (rq_data_dir(rq) == READ)
		rq->cmd[0] = GPCMD_READ_10;
	else
		rq->cmd[0] = GPCMD_WRITE_10;

	/*
	 * fill in lba
	 */
	rq->cmd[2] = (block >> 24) & 0xff;
	rq->cmd[3] = (block >> 16) & 0xff;
	rq->cmd[4] = (block >>  8) & 0xff;
	rq->cmd[5] = block & 0xff;

	/*
	 * and transfer length
	 */
	rq->cmd[7] = (blocks >> 8) & 0xff;
	rq->cmd[8] = blocks & 0xff;
	rq->cmd_len = 10;
	return BLKPREP_OK;
}

/*
 * Most of the SCSI commands are supported directly by ATAPI devices.
 * This transform handles the few exceptions.
 */
static int ide_cdrom_prep_pc(struct request *rq)
{
	u8 *c = rq->cmd;

B
Borislav Petkov 已提交
1717
	/* transform 6-byte read/write commands to the 10-byte version */
L
Linus Torvalds 已提交
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
	if (c[0] == READ_6 || c[0] == WRITE_6) {
		c[8] = c[4];
		c[5] = c[3];
		c[4] = c[2];
		c[3] = c[1] & 0x1f;
		c[2] = 0;
		c[1] &= 0xe0;
		c[0] += (READ_10 - READ_6);
		rq->cmd_len = 10;
		return BLKPREP_OK;
	}

	/*
	 * it's silly to pretend we understand 6-byte sense commands, just
	 * reject with ILLEGAL_REQUEST and the caller should take the
	 * appropriate action
	 */
	if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
		rq->errors = ILLEGAL_REQUEST;
		return BLKPREP_KILL;
	}
1739

L
Linus Torvalds 已提交
1740 1741 1742
	return BLKPREP_OK;
}

1743
static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1744
{
1745
	if (blk_fs_request(rq))
L
Linus Torvalds 已提交
1746
		return ide_cdrom_prep_fs(q, rq);
1747
	else if (blk_pc_request(rq))
L
Linus Torvalds 已提交
1748 1749 1750 1751 1752
		return ide_cdrom_prep_pc(rq);

	return 0;
}

1753 1754 1755 1756 1757 1758
struct cd_list_entry {
	const char	*id_model;
	const char	*id_firmware;
	unsigned int	cd_flags;
};

1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
#ifdef CONFIG_IDE_PROC_FS
static sector_t ide_cdrom_capacity(ide_drive_t *drive)
{
	unsigned long capacity, sectors_per_frame;

	if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
		return 0;

	return capacity * sectors_per_frame;
}

1770 1771
static int proc_idecd_read_capacity(char *page, char **start, off_t off,
					int count, int *eof, void *data)
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
{
	ide_drive_t *drive = data;
	int len;

	len = sprintf(page, "%llu\n", (long long)ide_cdrom_capacity(drive));
	PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
}

static ide_proc_entry_t idecd_proc[] = {
	{ "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
	{ NULL, 0, NULL, NULL }
};

static void ide_cdrom_add_settings(ide_drive_t *drive)
{
	ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
			&drive->dsc_overlap, NULL);
}
#else
static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
#endif

1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
static const struct cd_list_entry ide_cd_quirks_list[] = {
	/* Limit transfer size per interrupt. */
	{ "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES	    },
	{ "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES	    },
	/* SCR-3231 doesn't support the SET_CD_SPEED command. */
	{ "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
	/* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
	{ "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
					     IDE_CD_FLAG_PRE_ATAPI12,	    },
	/* Vertos 300, some versions of this drive like to talk BCD. */
	{ "V003S0DS",		     NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
	/* Vertos 600 ESD. */
	{ "V006E0DS",		     NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
	/*
	 * Sanyo 3 CD changer uses a non-standard command for CD changing
	 * (by default standard ATAPI support for CD changers is used).
	 */
	{ "CD-ROM CDR-C3 G",	     NULL,   IDE_CD_FLAG_SANYO_3CD	    },
	{ "CD-ROM CDR-C3G",	     NULL,   IDE_CD_FLAG_SANYO_3CD	    },
	{ "CD-ROM CDR_C36",	     NULL,   IDE_CD_FLAG_SANYO_3CD	    },
	/* Stingray 8X CD-ROM. */
	{ "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
	/*
	 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
	 * mode sense page capabilities size, but older drives break.
	 */
	{ "ATAPI CD ROM DRIVE 50X MAX",	NULL,	IDE_CD_FLAG_FULL_CAPS_PAGE  },
	{ "WPI CDS-32X",		NULL,	IDE_CD_FLAG_FULL_CAPS_PAGE  },
	/* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
	{ "",			     "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
	/*
	 * Some drives used by Apple don't advertise audio play
	 * but they do support reading TOC & audio datas.
	 */
	{ "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK	    },
	{ "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK	    },
	{ "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK	    },
	{ "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK	    },
1832
	{ "Optiarc DVD RW AD-5200A", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
	{ NULL, NULL, 0 }
};

static unsigned int ide_cd_flags(struct hd_driveid *id)
{
	const struct cd_list_entry *cle = ide_cd_quirks_list;

	while (cle->id_model) {
		if (strcmp(cle->id_model, id->model) == 0 &&
		    (cle->id_firmware == NULL ||
		     strstr(id->fw_rev, cle->id_firmware)))
			return cle->cd_flags;
		cle++;
	}

	return 0;
}

1851
static int ide_cdrom_setup(ide_drive_t *drive)
L
Linus Torvalds 已提交
1852
{
1853 1854
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1855
	struct hd_driveid *id = drive->id;
L
Linus Torvalds 已提交
1856 1857 1858 1859
	int nslots;

	blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
	blk_queue_dma_alignment(drive->queue, 31);
1860
	blk_queue_update_dma_pad(drive->queue, 15);
L
Linus Torvalds 已提交
1861 1862 1863 1864 1865 1866
	drive->queue->unplug_delay = (1 * HZ) / 1000;
	if (!drive->queue->unplug_delay)
		drive->queue->unplug_delay = 1;

	drive->special.all	= 0;

1867 1868
	cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
		       ide_cd_flags(id);
L
Linus Torvalds 已提交
1869

1870
	if ((id->config & 0x0060) == 0x20)
1871
		cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
1872 1873 1874

	if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
	    id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1875 1876
		cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
				 IDE_CD_FLAG_TOCADDR_AS_BCD);
1877 1878
	else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
		 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1879
		cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
1880
	else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
B
Borislav Petkov 已提交
1881 1882
		/* 3 => use CD in slot 0 */
		cdi->sanyo_slot = 3;
L
Linus Torvalds 已提交
1883

1884
	nslots = ide_cdrom_probe_capabilities(drive);
L
Linus Torvalds 已提交
1885

B
Borislav Petkov 已提交
1886
	/* set correct block size */
L
Linus Torvalds 已提交
1887 1888
	blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);

1889
	drive->dsc_overlap = (drive->next != drive);
L
Linus Torvalds 已提交
1890 1891

	if (ide_cdrom_register(drive, nslots)) {
1892 1893
		printk(KERN_ERR "%s: %s failed to register device with the"
				" cdrom driver.\n", drive->name, __func__);
1894
		cd->devinfo.handle = NULL;
L
Linus Torvalds 已提交
1895 1896 1897 1898 1899 1900
		return 1;
	}
	ide_cdrom_add_settings(drive);
	return 0;
}

1901
static void ide_cd_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
1902 1903 1904
{
	struct cdrom_info *info = drive->driver_data;

1905
	ide_proc_unregister_driver(drive, info->driver);
L
Linus Torvalds 已提交
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918

	del_gendisk(info->disk);

	ide_cd_put(info);
}

static void ide_cd_release(struct kref *kref)
{
	struct cdrom_info *info = to_ide_cd(kref);
	struct cdrom_device_info *devinfo = &info->devinfo;
	ide_drive_t *drive = info->drive;
	struct gendisk *g = info->disk;

1919
	kfree(info->toc);
1920 1921
	if (devinfo->handle == drive)
		unregister_cdrom(devinfo);
L
Linus Torvalds 已提交
1922 1923 1924 1925 1926 1927 1928 1929
	drive->dsc_overlap = 0;
	drive->driver_data = NULL;
	blk_queue_prep_rq(drive->queue, NULL);
	g->private_data = NULL;
	put_disk(g);
	kfree(info);
}

1930
static int ide_cd_probe(ide_drive_t *);
L
Linus Torvalds 已提交
1931 1932

static ide_driver_t ide_cdrom_driver = {
1933
	.gen_driver = {
1934
		.owner		= THIS_MODULE,
1935 1936 1937
		.name		= "ide-cdrom",
		.bus		= &ide_bus_type,
	},
1938 1939
	.probe			= ide_cd_probe,
	.remove			= ide_cd_remove,
L
Linus Torvalds 已提交
1940 1941 1942
	.version		= IDECD_VERSION,
	.media			= ide_cdrom,
	.supports_dsc_overlap	= 1,
1943
	.do_request		= ide_cd_do_request,
L
Linus Torvalds 已提交
1944 1945 1946
	.end_request		= ide_end_request,
	.error			= __ide_error,
	.abort			= __ide_abort,
1947
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
1948
	.proc			= idecd_proc,
1949
#endif
L
Linus Torvalds 已提交
1950 1951
};

1952
static int idecd_open(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1953 1954 1955 1956 1957
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct cdrom_info *info;
	int rc = -ENOMEM;

1958 1959
	info = ide_cd_get(disk);
	if (!info)
L
Linus Torvalds 已提交
1960 1961
		return -ENXIO;

1962
	rc = cdrom_open(&info->devinfo, inode, file);
L
Linus Torvalds 已提交
1963 1964 1965 1966 1967 1968 1969

	if (rc < 0)
		ide_cd_put(info);

	return rc;
}

1970
static int idecd_release(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1971 1972 1973 1974
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct cdrom_info *info = ide_cd_g(disk);

1975
	cdrom_release(&info->devinfo, file);
L
Linus Torvalds 已提交
1976 1977 1978 1979 1980 1981

	ide_cd_put(info);

	return 0;
}

1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
{
	struct packet_command cgc;
	char buffer[16];
	int stat;
	char spindown;

	if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
		return -EFAULT;

	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);

	stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
	if (stat)
		return stat;

	buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
	return cdrom_mode_select(cdi, &cgc);
}

static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
{
	struct packet_command cgc;
	char buffer[16];
	int stat;
2007
	char spindown;
2008 2009 2010 2011 2012 2013 2014 2015

	init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);

	stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
	if (stat)
		return stat;

	spindown = buffer[11] & 0x0f;
2016
	if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
2017 2018 2019 2020
		return -EFAULT;
	return 0;
}

2021
static int idecd_ioctl(struct inode *inode, struct file *file,
L
Linus Torvalds 已提交
2022 2023 2024 2025 2026 2027
			unsigned int cmd, unsigned long arg)
{
	struct block_device *bdev = inode->i_bdev;
	struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
	int err;

2028
	switch (cmd) {
2029
	case CDROMSETSPINDOWN:
2030
		return idecd_set_spindown(&info->devinfo, arg);
2031
	case CDROMGETSPINDOWN:
2032 2033 2034
		return idecd_get_spindown(&info->devinfo, arg);
	default:
		break;
2035
	}
2036 2037

	err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
L
Linus Torvalds 已提交
2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
	if (err == -EINVAL)
		err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);

	return err;
}

static int idecd_media_changed(struct gendisk *disk)
{
	struct cdrom_info *info = ide_cd_g(disk);
	return cdrom_media_changed(&info->devinfo);
}

static int idecd_revalidate_disk(struct gendisk *disk)
{
	struct cdrom_info *info = ide_cd_g(disk);
	struct request_sense sense;
2054 2055 2056

	ide_cd_read_toc(info->drive, &sense);

L
Linus Torvalds 已提交
2057 2058 2059 2060
	return  0;
}

static struct block_device_operations idecd_ops = {
2061 2062 2063 2064 2065 2066
	.owner			= THIS_MODULE,
	.open			= idecd_open,
	.release		= idecd_release,
	.ioctl			= idecd_ioctl,
	.media_changed		= idecd_media_changed,
	.revalidate_disk	= idecd_revalidate_disk
L
Linus Torvalds 已提交
2067 2068
};

B
Borislav Petkov 已提交
2069
/* module options */
2070
static char *ignore;
L
Linus Torvalds 已提交
2071 2072 2073 2074

module_param(ignore, charp, 0400);
MODULE_DESCRIPTION("ATAPI CD-ROM Driver");

2075
static int ide_cd_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
{
	struct cdrom_info *info;
	struct gendisk *g;
	struct request_sense sense;

	if (!strstr("ide-cdrom", drive->driver_req))
		goto failed;
	if (!drive->present)
		goto failed;
	if (drive->media != ide_cdrom && drive->media != ide_optical)
		goto failed;
	/* skip drives that we were told to ignore */
	if (ignore != NULL) {
		if (strstr(ignore, drive->name)) {
2090 2091
			printk(KERN_INFO "ide-cd: ignoring drive %s\n",
					 drive->name);
L
Linus Torvalds 已提交
2092 2093 2094
			goto failed;
		}
	}
2095
	info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
L
Linus Torvalds 已提交
2096
	if (info == NULL) {
2097 2098
		printk(KERN_ERR "%s: Can't allocate a cdrom structure\n",
				drive->name);
L
Linus Torvalds 已提交
2099 2100 2101 2102 2103 2104 2105 2106 2107
		goto failed;
	}

	g = alloc_disk(1 << PARTN_BITS);
	if (!g)
		goto out_free_cd;

	ide_init_disk(g, drive);

2108
	ide_proc_register_driver(drive, &ide_cdrom_driver);
2109

L
Linus Torvalds 已提交
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
	kref_init(&info->kref);

	info->drive = drive;
	info->driver = &ide_cdrom_driver;
	info->disk = g;

	g->private_data = &info->driver;

	drive->driver_data = info;

	g->minors = 1;
	g->driverfs_dev = &drive->gendev;
	g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
	if (ide_cdrom_setup(drive)) {
2124
		ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2125
		ide_cd_release(&info->kref);
L
Linus Torvalds 已提交
2126 2127 2128
		goto failed;
	}

2129
	ide_cd_read_toc(drive, &sense);
L
Linus Torvalds 已提交
2130 2131 2132 2133 2134 2135 2136 2137
	g->fops = &idecd_ops;
	g->flags |= GENHD_FL_REMOVABLE;
	add_disk(g);
	return 0;

out_free_cd:
	kfree(info);
failed:
2138
	return -ENODEV;
L
Linus Torvalds 已提交
2139 2140 2141 2142
}

static void __exit ide_cdrom_exit(void)
{
2143
	driver_unregister(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2144
}
2145 2146

static int __init ide_cdrom_init(void)
L
Linus Torvalds 已提交
2147
{
2148
	return driver_register(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2149 2150
}

2151
MODULE_ALIAS("ide:*m-cdrom*");
2152
MODULE_ALIAS("ide-cd");
L
Linus Torvalds 已提交
2153 2154 2155
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);
MODULE_LICENSE("GPL");