ide-cd.c 56.0 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 56
static void ide_cd_release(struct kref *);

L
Linus Torvalds 已提交
57 58 59 60
static struct cdrom_info *ide_cd_get(struct gendisk *disk)
{
	struct cdrom_info *cd = NULL;

61
	mutex_lock(&idecd_ref_mutex);
B
Borislav Petkov 已提交
62
	cd = ide_drv_g(disk, cdrom_info);
63
	if (cd) {
64
		if (ide_device_get(cd->drive))
65
			cd = NULL;
66 67 68
		else
			kref_get(&cd->kref);

69
	}
70
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
71 72 73 74 75
	return cd;
}

static void ide_cd_put(struct cdrom_info *cd)
{
76 77
	ide_drive_t *drive = cd->drive;

78
	mutex_lock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
79
	kref_put(&cd->kref, ide_cd_release);
80
	ide_device_put(drive);
81
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
82 83
}

B
Borislav Petkov 已提交
84
/*
L
Linus Torvalds 已提交
85 86 87
 * Generic packet command support and error handling routines.
 */

B
Borislav Petkov 已提交
88
/* Mark that we've seen a media change and invalidate our internal buffers. */
89
static void cdrom_saw_media_change(ide_drive_t *drive)
L
Linus Torvalds 已提交
90
{
91 92
	drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
	drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
93 94 95 96 97 98 99
}

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

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

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

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

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

	/*
B
Borislav Petkov 已提交
152 153 154
	 * 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 已提交
155 156 157 158 159
	 */
	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
		if (sense->sense_key == 0x05 && sense->asc == 0x24)
			return;

B
Borislav Petkov 已提交
160 161
	/* current error */
	if (sense->error_code == 0x70) {
162
		switch (sense->sense_key) {
A
Alan Cox 已提交
163 164 165 166 167 168 169 170 171 172 173 174 175 176
		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 已提交
177 178
				/* device sector size is 2K */
				sector <<= 2;
179 180

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

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

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

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 已提交
202 203 204
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_ATA_PC;
	rq->rq_disk = info->disk;
L
Linus Torvalds 已提交
205 206 207

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

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

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

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

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

225
	if (blk_sense_request(rq) && uptodate) {
L
Linus Torvalds 已提交
226
		/*
227 228
		 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
		 * failed request
L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236 237 238 239
		 */
		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 已提交
240
			cdrom_analyze_sense_data(drive, failed, sense);
L
Linus Torvalds 已提交
241
			/*
B
Borislav Petkov 已提交
242
			 * now end the failed request
L
Linus Torvalds 已提交
243
			 */
A
Alan Cox 已提交
244 245 246 247 248 249
			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);
250 251 252
				if (__blk_end_request(failed, -EIO,
						      failed->data_len))
					BUG();
A
Alan Cox 已提交
253 254 255 256
				spin_unlock_irqrestore(&ide_lock, flags);
			}
		} else
			cdrom_analyze_sense_data(drive, NULL, sense);
L
Linus Torvalds 已提交
257 258 259 260 261 262 263 264 265 266 267 268 269
	}

	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);
}

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

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

B
Borislav Petkov 已提交
288
	/* check for errors */
289
	stat = hwif->tp_ops->read_status(hwif);
290

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

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

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

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

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

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

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

B
Borislav Petkov 已提交
328
		/* check for tray open */
L
Linus Torvalds 已提交
329
		if (sense_key == NOT_READY) {
330
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
331
		} else if (sense_key == UNIT_ATTENTION) {
B
Borislav Petkov 已提交
332
			/* check for media change */
333
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
334
			return 0;
335 336 337 338 339 340 341 342 343
		} 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!
			 */
344
		} else if (!(rq->cmd_flags & REQ_QUIET)) {
B
Borislav Petkov 已提交
345
			/* otherwise, print an error */
L
Linus Torvalds 已提交
346 347
			ide_dump_status(drive, "packet command error", stat);
		}
348

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

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

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

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

		if (blk_noretry_request(rq))
			do_end_request = 1;

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

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

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

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

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

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

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

B
Borislav Petkov 已提交
462
	/* retry, or handle the next request */
L
Linus Torvalds 已提交
463
	return 1;
464 465

end_request:
466
	if (stat & ATA_ERR) {
467 468 469 470 471 472 473 474 475 476 477 478
		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 已提交
479 480 481 482 483 484 485 486
}

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

	/*
B
Borislav Petkov 已提交
487 488 489 490
	 * 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 已提交
491 492
	 */
	switch (rq->cmd[0]) {
493 494 495 496 497 498 499 500 501
	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))
502 503
			printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n",
					 rq->cmd[0]);
504 505
		wait = 0;
		break;
L
Linus Torvalds 已提交
506 507 508 509
	}
	return wait;
}

B
Borislav Petkov 已提交
510 511 512 513 514 515 516 517
/*
 * 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 已提交
518 519 520 521 522 523 524
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;

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

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

533
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
534 535 536 537
		/* waiting for CDB interrupt, not DMA yet. */
		if (info->dma)
			drive->waiting_for_dma = 0;

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

		return (*handler) (drive);
	}
}

B
Borislav Petkov 已提交
549 550 551 552 553 554
/*
 * 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 已提交
555
#define ATAPI_MIN_CDB_BYTES 12
556
static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564
					  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;

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

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

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

B
Borislav Petkov 已提交
585
	/* arm the interrupt handler */
L
Linus Torvalds 已提交
586 587 588 589 590 591 592
	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 已提交
593
	/* send the command to the device */
594
	hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
L
Linus Torvalds 已提交
595

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

	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.
 */
608 609
static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
				int len, int ireason, int rw)
L
Linus Torvalds 已提交
610
{
611 612
	ide_hwif_t *hwif = drive->hwif;

613 614 615 616 617
	/*
	 * 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 已提交
618
		return 0;
619
	else if (ireason == (rw << 1)) {
620

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

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

639 640 641
	if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags |= REQ_FAILED;

L
Linus Torvalds 已提交
642 643 644 645
	cdrom_end_request(drive, 0);
	return -1;
}

646 647 648 649 650 651 652 653 654 655
/*
 * 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)
{
	if ((len % SECTOR_SIZE) == 0)
		return 0;

	printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
656
			drive->name, __func__, len);
657

658
	if (drive->atapi_flags & IDE_AFLAG_LIMIT_NFRAMES)
659 660 661 662
		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");
663
		drive->atapi_flags |= IDE_AFLAG_LIMIT_NFRAMES;
664 665 666 667 668
	}

	return 1;
}

669
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
670

671 672
static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
						 struct request *rq)
L
Linus Torvalds 已提交
673
{
674 675 676 677
	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 已提交
678

679 680 681 682 683 684 685 686 687 688 689
		/*
		 * 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 已提交
690
			/* sanity check... */
691 692 693
			if (rq->current_nr_sectors !=
			    bio_cur_sectors(rq->bio)) {
				printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
694
						drive->name, __func__,
695 696 697 698 699
						rq->current_nr_sectors);
				cdrom_end_request(drive, 0);
				return ide_stopped;
			}
			rq->current_nr_sectors += nskip;
L
Linus Torvalds 已提交
700 701
		}
	}
702 703 704 705 706
#if 0
	else
		/* the immediate bit */
		rq->cmd[1] = 1 << 3;
#endif
B
Borislav Petkov 已提交
707
	/* set up the command */
L
Linus Torvalds 已提交
708 709
	rq->timeout = ATAPI_WAIT_PC;

710 711 712 713 714 715 716 717 718 719 720 721 722
	return ide_started;
}

/*
 * 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.
 */
static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
{
	struct request *rq = drive->hwif->hwgroup->rq;

B
Borislav Petkov 已提交
723
	/* send the command to the drive and return */
724
	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
L
Linus Torvalds 已提交
725 726 727 728 729 730
}

#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 */

731
static ide_startstop_t cdrom_seek_intr(ide_drive_t *drive)
L
Linus Torvalds 已提交
732 733 734 735 736 737 738
{
	struct cdrom_info *info = drive->driver_data;
	int stat;
	static int retry = 10;

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

740
	drive->atapi_flags |= IDE_AFLAG_SEEKING;
L
Linus Torvalds 已提交
741 742

	if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
B
Borislav Petkov 已提交
743
		if (--retry == 0)
L
Linus Torvalds 已提交
744 745 746 747 748
			drive->dsc_overlap = 0;
	}
	return ide_stopped;
}

749
static void ide_cd_prepare_seek_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
750 751 752 753 754
{
	sector_t frame = rq->sector;

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

755
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
756 757 758 759
	rq->cmd[0] = GPCMD_SEEK;
	put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);

	rq->timeout = ATAPI_WAIT_PC;
760 761 762 763 764 765
}

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

L
Linus Torvalds 已提交
766 767 768
	return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
}

769
/*
B
Borislav Petkov 已提交
770 771
 * Fix up a possibly partially-processed request so that we can start it over
 * entirely, or even put it back on the request queue.
772 773
 */
static void restore_request(struct request *rq)
L
Linus Torvalds 已提交
774 775
{
	if (rq->buffer != bio_data(rq->bio)) {
776 777
		sector_t n =
			(rq->buffer - (char *)bio_data(rq->bio)) / SECTOR_SIZE;
L
Linus Torvalds 已提交
778 779 780 781 782

		rq->buffer = bio_data(rq->bio);
		rq->nr_sectors += n;
		rq->sector -= n;
	}
783 784
	rq->current_nr_sectors = bio_cur_sectors(rq->bio);
	rq->hard_cur_sectors = rq->current_nr_sectors;
L
Linus Torvalds 已提交
785 786 787 788 789
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
	rq->q->prep_rq_fn(rq->q, rq);
}

B
Borislav Petkov 已提交
790 791
/*
 * All other packet commands.
L
Linus Torvalds 已提交
792
 */
793 794 795 796 797 798 799 800 801 802 803 804 805 806
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;
		}
}

807 808 809 810
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 已提交
811
{
812 813
	struct cdrom_info *info = drive->driver_data;
	struct request_sense local_sense;
L
Linus Torvalds 已提交
814
	int retries = 10;
815
	unsigned int flags = 0;
L
Linus Torvalds 已提交
816

817 818
	if (!sense)
		sense = &local_sense;
L
Linus Torvalds 已提交
819

B
Borislav Petkov 已提交
820
	/* start of retry loop */
L
Linus Torvalds 已提交
821
	do {
822
		struct request *rq;
L
Linus Torvalds 已提交
823 824
		int error;

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
		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 已提交
844

B
Borislav Petkov 已提交
845 846 847 848
		/*
		 * FIXME: we should probably abort/retry or something in case of
		 * failure.
		 */
849
		if (flags & REQ_FAILED) {
B
Borislav Petkov 已提交
850 851 852 853
			/*
			 * The request failed.  Retry if it was due to a unit
			 * attention status (usually means media was changed).
			 */
854
			struct request_sense *reqbuf = sense;
L
Linus Torvalds 已提交
855 856 857 858 859

			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 已提交
860 861 862 863 864
				/*
				 * 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 已提交
865 866
				ssleep(2);
			} else {
B
Borislav Petkov 已提交
867
				/* otherwise, don't retry */
L
Linus Torvalds 已提交
868 869 870 871 872
				retries = 0;
			}
			--retries;
		}

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

B
Borislav Petkov 已提交
876
	/* return an error if the command failed */
877
	return (flags & REQ_FAILED) ? -EIO : 0;
L
Linus Torvalds 已提交
878 879
}

880
/*
B
Borislav Petkov 已提交
881 882 883
 * 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.
884 885 886 887 888 889
 */
static int cdrom_newpc_intr_dummy_cb(struct request *rq)
{
	return 1;
}

L
Linus Torvalds 已提交
890 891
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
{
892
	ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
893 894 895
	struct cdrom_info *info = drive->driver_data;
	struct request *rq = HWGROUP(drive)->rq;
	xfer_func_t *xferfunc;
896
	ide_expiry_t *expiry = NULL;
897
	int dma_error = 0, dma, stat, thislen, uptodate = 0;
898 899
	int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
	unsigned int timeout;
900 901
	u16 len;
	u8 ireason;
L
Linus Torvalds 已提交
902

B
Borislav Petkov 已提交
903
	/* check for errors */
L
Linus Torvalds 已提交
904 905 906
	dma = info->dma;
	if (dma) {
		info->dma = 0;
907
		dma_error = hwif->dma_ops->dma_end(drive);
908 909
		if (dma_error) {
			printk(KERN_ERR "%s: DMA %s error\n", drive->name,
910
					write ? "write" : "read");
911 912
			ide_dma_off(drive);
		}
L
Linus Torvalds 已提交
913 914 915 916 917
	}

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

B
Borislav Petkov 已提交
918
	/* using dma, transfer is complete now */
L
Linus Torvalds 已提交
919
	if (dma) {
920
		if (dma_error)
L
Linus Torvalds 已提交
921
			return ide_error(drive, "dma error", stat);
922 923 924 925
		if (blk_fs_request(rq)) {
			ide_end_request(drive, 1, rq->nr_sectors);
			return ide_stopped;
		}
926
		goto end_request;
L
Linus Torvalds 已提交
927 928
	}

929
	ide_read_bcount_and_ireason(drive, &len, &ireason);
930 931

	thislen = blk_fs_request(rq) ? len : rq->data_len;
L
Linus Torvalds 已提交
932 933 934
	if (thislen > len)
		thislen = len;

B
Borislav Petkov 已提交
935
	/* If DRQ is clear, the command has completed. */
936
	if ((stat & ATA_DRQ) == 0) {
937 938 939 940 941 942 943 944 945
		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",
946
						drive->name, __func__,
947 948 949 950 951 952 953 954
						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)) {
955
			ide_cd_request_sense_fixup(rq);
B
Borislav Petkov 已提交
956
			/* complain if we still have data left to transfer */
957 958 959
			uptodate = rq->data_len ? 0 : 1;
		}
		goto end_request;
960
	}
L
Linus Torvalds 已提交
961

B
Borislav Petkov 已提交
962
	/* check which way to transfer data */
963 964
	if (ide_cd_check_ireason(drive, rq, len, ireason, write))
		return ide_stopped;
965

966 967
	if (blk_fs_request(rq)) {
		if (write == 0) {
968 969 970 971 972 973 974 975 976 977 978 979 980 981 982
			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) {
983
				ide_pad_transfer(drive, write, nskip << 9);
984 985 986 987
				rq->current_nr_sectors -= nskip;
				thislen -= (nskip << 9);
			}
		}
988
	}
L
Linus Torvalds 已提交
989

990 991
	if (ireason == 0) {
		write = 1;
992
		xferfunc = hwif->tp_ops->output_data;
993
	} else {
994
		write = 0;
995
		xferfunc = hwif->tp_ops->input_data;
L
Linus Torvalds 已提交
996 997
	}

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

B
Borislav Petkov 已提交
1003
		/* bio backed? */
L
Linus Torvalds 已提交
1004
		if (rq->bio) {
1005 1006 1007 1008 1009 1010 1011
			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 已提交
1012 1013 1014
		}

		if (!ptr) {
1015 1016
			if (blk_fs_request(rq) && !write)
				/*
1017
				 * If the buffers are full, pipe the rest into
B
Borislav Petkov 已提交
1018 1019
				 * oblivion.
				 */
1020
				ide_pad_transfer(drive, 0, thislen);
1021 1022 1023 1024 1025 1026 1027
			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 已提交
1028 1029 1030 1031 1032 1033
			break;
		}

		if (blen > thislen)
			blen = thislen;

1034
		xferfunc(drive, NULL, ptr, blen);
L
Linus Torvalds 已提交
1035 1036 1037 1038

		thislen -= blen;
		len -= blen;

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
		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;

1050 1051 1052 1053 1054 1055
			/*
			 * 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().
			 */
1056 1057
			if (rq->bio)
				blk_end_request_callback(rq, 0, blen,
1058
						 cdrom_newpc_intr_dummy_cb);
1059 1060 1061
			else
				rq->data += blen;
		}
A
Andreas Schwab 已提交
1062 1063
		if (!write && blk_sense_request(rq))
			rq->sense_len += blen;
L
Linus Torvalds 已提交
1064 1065
	}

B
Borislav Petkov 已提交
1066
	/* pad, if necessary */
1067
	if (!blk_fs_request(rq) && len > 0)
1068
		ide_pad_transfer(drive, write, len);
L
Linus Torvalds 已提交
1069

1070 1071 1072 1073
	if (blk_pc_request(rq)) {
		timeout = rq->timeout;
	} else {
		timeout = ATAPI_WAIT_PC;
1074 1075
		if (!blk_fs_request(rq))
			expiry = cdrom_timer_expiry;
1076 1077 1078
	}

	ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
L
Linus Torvalds 已提交
1079
	return ide_started;
1080 1081 1082 1083

end_request:
	if (blk_pc_request(rq)) {
		unsigned long flags;
1084 1085 1086 1087
		unsigned int dlen = rq->data_len;

		if (dma)
			rq->data_len = 0;
1088 1089

		spin_lock_irqsave(&ide_lock, flags);
1090
		if (__blk_end_request(rq, 0, dlen))
1091 1092 1093 1094 1095 1096 1097 1098 1099
			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 已提交
1100 1101
}

1102
static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1103
{
1104 1105 1106 1107
	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 已提交
1108

1109
	if (write) {
B
Borislav Petkov 已提交
1110
		/* disk has become write protected */
T
Tejun Heo 已提交
1111
		if (get_disk_ro(cd->disk)) {
1112 1113 1114 1115 1116 1117 1118 1119 1120
			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 已提交
1121 1122
	}

B
Borislav Petkov 已提交
1123
	/* use DMA, if possible / writes *must* be hardware frame aligned */
1124 1125 1126 1127 1128 1129 1130 1131 1132
	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 已提交
1133

1134 1135
	if (write)
		cd->devinfo.media_written = 1;
L
Linus Torvalds 已提交
1136

1137
	return ide_started;
L
Linus Torvalds 已提交
1138 1139 1140 1141 1142 1143 1144 1145 1146
}

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

	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
}

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

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

	info->dma = 0;

B
Borislav Petkov 已提交
1158
	/* sg request */
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;
1162
		char *buf;
L
Linus Torvalds 已提交
1163

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

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
		alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1178 1179
		if ((unsigned long)buf & alignment || rq->data_len & alignment
		    || object_is_on_stack(buf))
1180
			info->dma = 0;
L
Linus Torvalds 已提交
1181 1182 1183
	}
}

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

	if (blk_fs_request(rq)) {
1195
		if (drive->atapi_flags & IDE_AFLAG_SEEKING) {
1196
			ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
1197
			unsigned long elapsed = jiffies - info->start_seek;
1198
			int stat = hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
1199

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

1218 1219
			info->dma = 0;
			info->start_seek = jiffies;
1220 1221

			ide_cd_prepare_seek_request(drive, rq);
1222 1223 1224
		} else {
			xferlen = 32768;
			fn = cdrom_start_rw_cont;
1225

1226 1227
			if (cdrom_start_rw(drive, rq) == ide_stopped)
				return ide_stopped;
1228 1229 1230

			if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
				return ide_stopped;
1231
		}
L
Linus Torvalds 已提交
1232
		info->last_block = block;
1233
	} else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1234
		   rq->cmd_type == REQ_TYPE_ATA_PC) {
1235 1236
		xferlen = rq->data_len;
		fn = cdrom_do_newpc_cont;
1237 1238 1239 1240

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

1241
		cdrom_do_block_pc(drive, rq);
1242
	} else if (blk_special_request(rq)) {
B
Borislav Petkov 已提交
1243
		/* right now this can only be a reset... */
L
Linus Torvalds 已提交
1244 1245
		cdrom_end_request(drive, 1);
		return ide_stopped;
1246 1247 1248 1249
	} else {
		blk_dump_rq_flags(rq, "ide-cd bad flags");
		cdrom_end_request(drive, 0);
		return ide_stopped;
L
Linus Torvalds 已提交
1250
	}
1251 1252

	return cdrom_start_packet_command(drive, xferlen, fn);
L
Linus Torvalds 已提交
1253 1254
}

B
Borislav Petkov 已提交
1255
/*
L
Linus Torvalds 已提交
1256 1257
 * Ioctl handling.
 *
B
Borislav Petkov 已提交
1258 1259 1260 1261 1262
 * 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 已提交
1263
 */
1264
static void msf_from_bcd(struct atapi_msf *msf)
L
Linus Torvalds 已提交
1265
{
A
Adrian Bunk 已提交
1266 1267 1268
	msf->minute = bcd2bin(msf->minute);
	msf->second = bcd2bin(msf->second);
	msf->frame  = bcd2bin(msf->frame);
L
Linus Torvalds 已提交
1269 1270
}

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

1277 1278
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_TEST_UNIT_READY;
L
Linus Torvalds 已提交
1279

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

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

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
			       unsigned long *sectors_per_frame,
			       struct request_sense *sense)
{
	struct {
1294 1295
		__be32 lba;
		__be32 blocklen;
L
Linus Torvalds 已提交
1296 1297 1298
	} capbuf;

	int stat;
1299 1300
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(capbuf);
1301
	u32 blocklen;
L
Linus Torvalds 已提交
1302

1303 1304
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_READ_CDVD_CAPACITY;
L
Linus Torvalds 已提交
1305

1306 1307
	stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
			       REQ_QUIET);
1308 1309 1310 1311 1312 1313
	if (stat)
		return stat;

	/*
	 * Sanity check the given block size
	 */
1314 1315 1316 1317 1318 1319
	blocklen = be32_to_cpu(capbuf.blocklen);
	switch (blocklen) {
	case 512:
	case 1024:
	case 2048:
	case 4096:
1320 1321 1322
		break;
	default:
		printk(KERN_ERR "%s: weird block size %u\n",
1323
			drive->name, blocklen);
1324 1325
		printk(KERN_ERR "%s: default to 2kb block size\n",
			drive->name);
1326
		blocklen = 2048;
1327
		break;
L
Linus Torvalds 已提交
1328 1329
	}

1330
	*capacity = 1 + be32_to_cpu(capbuf.lba);
1331
	*sectors_per_frame = blocklen >> SECTOR_BITS;
1332
	return 0;
L
Linus Torvalds 已提交
1333 1334 1335 1336 1337 1338
}

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

1341
	memset(cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1342

1343 1344 1345 1346 1347
	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 已提交
1348 1349

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

1352
	return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1353 1354 1355
}

/* Try to read the entire TOC for the disk into our internal buffer. */
1356
int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
{
	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 已提交
1370
		/* try to allocate space */
J
Jesper Juhl 已提交
1371
		toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
L
Linus Torvalds 已提交
1372
		if (toc == NULL) {
1373 1374
			printk(KERN_ERR "%s: No cdrom TOC buffer!\n",
					drive->name);
L
Linus Torvalds 已提交
1375 1376
			return -ENOMEM;
		}
J
Jesper Juhl 已提交
1377
		info->toc = toc;
L
Linus Torvalds 已提交
1378 1379
	}

B
Borislav Petkov 已提交
1380 1381 1382 1383
	/*
	 * Check to see if the existing data is still valid. If it is,
	 * just return.
	 */
L
Linus Torvalds 已提交
1384 1385
	(void) cdrom_check_status(drive, sense);

1386
	if (drive->atapi_flags & IDE_AFLAG_TOC_VALID)
L
Linus Torvalds 已提交
1387 1388
		return 0;

B
Borislav Petkov 已提交
1389
	/* try to get the total cdrom capacity and sector size */
L
Linus Torvalds 已提交
1390 1391 1392 1393 1394 1395
	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 已提交
1396
	/* save a private copy of the TOC capacity for error handling */
A
Alan Cox 已提交
1397 1398
	drive->probed_capacity = toc->capacity * sectors_per_frame;

L
Linus Torvalds 已提交
1399 1400 1401
	blk_queue_hardsect_size(drive->queue,
				sectors_per_frame << SECTOR_BITS);

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

1408
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1409 1410
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1411 1412 1413 1414 1415 1416 1417 1418
	}

	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 已提交
1419
	/* now read the whole schmeer */
L
Linus Torvalds 已提交
1420 1421 1422 1423 1424 1425 1426
	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 已提交
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
		/*
		 * 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 已提交
1439 1440 1441 1442 1443 1444 1445
		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);
1446
		if (stat)
L
Linus Torvalds 已提交
1447
			return stat;
1448

1449
		if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1450 1451
			toc->hdr.first_track = (u8)bin2bcd(CDROM_LEADOUT);
			toc->hdr.last_track = (u8)bin2bcd(CDROM_LEADOUT);
1452
		} else {
L
Linus Torvalds 已提交
1453 1454 1455 1456 1457 1458 1459 1460
			toc->hdr.first_track = CDROM_LEADOUT;
			toc->hdr.last_track = CDROM_LEADOUT;
		}
	}

	if (stat)
		return stat;

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

1463
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1464 1465
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1466 1467
	}

1468
	for (i = 0; i <= ntracks; i++) {
1469 1470
		if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
			if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD)
A
Adrian Bunk 已提交
1471
				toc->ent[i].track = bcd2bin(toc->ent[i].track);
L
Linus Torvalds 已提交
1472 1473
			msf_from_bcd(&toc->ent[i].addr.msf);
		}
1474 1475 1476
		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 已提交
1477 1478 1479
	}

	if (toc->hdr.first_track != CDROM_LEADOUT) {
B
Borislav Petkov 已提交
1480
		/* read the multisession information */
L
Linus Torvalds 已提交
1481 1482
		stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
J
Jesper Juhl 已提交
1483 1484
		if (stat)
			return stat;
L
Linus Torvalds 已提交
1485 1486 1487

		toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
	} else {
1488 1489
		ms_tmp.hdr.last_track = CDROM_LEADOUT;
		ms_tmp.hdr.first_track = ms_tmp.hdr.last_track;
L
Linus Torvalds 已提交
1490 1491 1492
		toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
	}

1493
	if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
B
Borislav Petkov 已提交
1494
		/* re-read multisession information using MSF format */
L
Linus Torvalds 已提交
1495 1496 1497 1498 1499
		stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
		if (stat)
			return stat;

1500
		msf_from_bcd(&ms_tmp.ent.addr.msf);
L
Linus Torvalds 已提交
1501
		toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1502
						   ms_tmp.ent.addr.msf.second,
L
Linus Torvalds 已提交
1503 1504 1505 1506 1507
						   ms_tmp.ent.addr.msf.frame);
	}

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

B
Borislav Petkov 已提交
1508
	/* now try to get the total cdrom capacity */
L
Linus Torvalds 已提交
1509 1510 1511 1512
	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 已提交
1513
		drive->probed_capacity = toc->capacity * sectors_per_frame;
L
Linus Torvalds 已提交
1514 1515 1516
	}

	/* Remember that we've read this stuff. */
1517
	drive->atapi_flags |= IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
1518 1519 1520 1521

	return 0;
}

1522
int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
E
Eric Piel 已提交
1523 1524 1525 1526
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
	struct packet_command cgc;
1527
	int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
E
Eric Piel 已提交
1528

1529
	if ((drive->atapi_flags & IDE_AFLAG_FULL_CAPS_PAGE) == 0)
1530
		size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
E
Eric Piel 已提交
1531

1532
	init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
B
Borislav Petkov 已提交
1533 1534
	do {
		/* we seem to get stat=0x01,err=0x00 the first time (??) */
E
Eric Piel 已提交
1535 1536 1537 1538 1539 1540 1541
		stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
		if (!stat)
			break;
	} while (--attempts);
	return stat;
}

1542
void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
E
Eric Piel 已提交
1543
{
1544
	struct cdrom_info *cd = drive->driver_data;
1545 1546
	u16 curspeed, maxspeed;

1547
	if (drive->atapi_flags & IDE_AFLAG_LE_SPEED_FIELDS) {
1548 1549
		curspeed = le16_to_cpup((__le16 *)&buf[8 + 14]);
		maxspeed = le16_to_cpup((__le16 *)&buf[8 + 8]);
E
Eric Piel 已提交
1550
	} else {
1551 1552
		curspeed = be16_to_cpup((__be16 *)&buf[8 + 14]);
		maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
E
Eric Piel 已提交
1553
	}
1554

1555 1556
	cd->current_speed = (curspeed + (176/2)) / 176;
	cd->max_speed = (maxspeed + (176/2)) / 176;
E
Eric Piel 已提交
1557 1558
}

1559 1560 1561 1562 1563 1564
#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 已提交
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577

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,
1578
	.capability		= IDE_CD_CAPABILITIES,
L
Linus Torvalds 已提交
1579 1580 1581
	.generic_packet		= ide_cdrom_packet,
};

1582
static int ide_cdrom_register(ide_drive_t *drive, int nslots)
L
Linus Torvalds 已提交
1583 1584 1585 1586 1587
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *devinfo = &info->devinfo;

	devinfo->ops = &ide_cdrom_dops;
1588
	devinfo->speed = info->current_speed;
L
Linus Torvalds 已提交
1589
	devinfo->capacity = nslots;
J
Jesper Juhl 已提交
1590
	devinfo->handle = drive;
L
Linus Torvalds 已提交
1591 1592
	strcpy(devinfo->name, drive->name);

1593
	if (drive->atapi_flags & IDE_AFLAG_NO_SPEED_SELECT)
1594 1595
		devinfo->mask |= CDC_SELECT_SPEED;

L
Linus Torvalds 已提交
1596 1597 1598 1599
	devinfo->disk = info->disk;
	return register_cdrom(devinfo);
}

1600
static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
L
Linus Torvalds 已提交
1601
{
1602 1603
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1604 1605
	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	mechtype_t mechtype;
L
Linus Torvalds 已提交
1606 1607
	int nslots = 1;

1608 1609 1610 1611
	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 已提交
1612
	if (drive->media == ide_optical) {
1613
		cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1614 1615
		printk(KERN_ERR "%s: ATAPI magneto-optical drive\n",
				drive->name);
L
Linus Torvalds 已提交
1616 1617 1618
		return nslots;
	}

1619 1620
	if (drive->atapi_flags & IDE_AFLAG_PRE_ATAPI12) {
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1621
		cdi->mask &= ~CDC_PLAY_AUDIO;
L
Linus Torvalds 已提交
1622 1623 1624 1625
		return nslots;
	}

	/*
B
Borislav Petkov 已提交
1626 1627 1628 1629
	 * 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 已提交
1630
	 */
J
Jesper Juhl 已提交
1631
	cdi->handle = drive;
L
Linus Torvalds 已提交
1632 1633
	cdi->ops = &ide_cdrom_dops;

1634
	if (ide_cdrom_get_capabilities(drive, buf))
L
Linus Torvalds 已提交
1635 1636
		return 0;

1637
	if ((buf[8 + 6] & 0x01) == 0)
1638
		drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
1639
	if (buf[8 + 6] & 0x08)
1640
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1641
	if (buf[8 + 3] & 0x01)
1642
		cdi->mask &= ~CDC_CD_R;
1643
	if (buf[8 + 3] & 0x02)
1644
		cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1645
	if (buf[8 + 2] & 0x38)
1646
		cdi->mask &= ~CDC_DVD;
1647
	if (buf[8 + 3] & 0x20)
1648
		cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1649
	if (buf[8 + 3] & 0x10)
1650
		cdi->mask &= ~CDC_DVD_R;
1651
	if ((buf[8 + 4] & 0x01) || (drive->atapi_flags & IDE_AFLAG_PLAY_AUDIO_OK))
1652
		cdi->mask &= ~CDC_PLAY_AUDIO;
1653 1654

	mechtype = buf[8 + 6] >> 5;
B
Borislav Petkov 已提交
1655 1656 1657
	if (mechtype == mechtype_caddy ||
	    mechtype == mechtype_popup ||
	    (drive->atapi_flags & IDE_AFLAG_NO_AUTOCLOSE))
1658
		cdi->mask |= CDC_CLOSE_TRAY;
L
Linus Torvalds 已提交
1659 1660

	if (cdi->sanyo_slot > 0) {
1661
		cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1662
		nslots = 3;
1663 1664
	} else if (mechtype == mechtype_individual_changer ||
		   mechtype == mechtype_cartridge_changer) {
1665 1666
		nslots = cdrom_number_of_slots(cdi);
		if (nslots > 1)
1667
			cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1668 1669
	}

1670
	ide_cdrom_update_speed(drive, buf);
1671

L
Linus Torvalds 已提交
1672
	printk(KERN_INFO "%s: ATAPI", drive->name);
1673 1674

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

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

1680 1681 1682 1683
	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 已提交
1684

1685 1686 1687 1688
	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 已提交
1689

1690 1691 1692 1693
	if ((cdi->mask & CDC_SELECT_DISC) == 0)
		printk(KERN_CONT " changer w/%d slots", nslots);
	else
		printk(KERN_CONT " drive");
L
Linus Torvalds 已提交
1694

1695
	printk(KERN_CONT ", %dkB Cache\n", be16_to_cpup((__be16 *)&buf[8 + 12]));
L
Linus Torvalds 已提交
1696 1697 1698 1699

	return nslots;
}

B
Borislav Petkov 已提交
1700
/* standard prep_rq_fn that builds 10 byte cmds */
1701
static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1702 1703 1704 1705 1706
{
	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);

1707
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738

	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 已提交
1739
	/* transform 6-byte read/write commands to the 10-byte version */
L
Linus Torvalds 已提交
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
	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;
	}
1761

L
Linus Torvalds 已提交
1762 1763 1764
	return BLKPREP_OK;
}

1765
static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1766
{
1767
	if (blk_fs_request(rq))
L
Linus Torvalds 已提交
1768
		return ide_cdrom_prep_fs(q, rq);
1769
	else if (blk_pc_request(rq))
L
Linus Torvalds 已提交
1770 1771 1772 1773 1774
		return ide_cdrom_prep_pc(rq);

	return 0;
}

1775 1776 1777 1778 1779 1780
struct cd_list_entry {
	const char	*id_model;
	const char	*id_firmware;
	unsigned int	cd_flags;
};

1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
#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;
}

1792 1793
static int proc_idecd_read_capacity(char *page, char **start, off_t off,
					int count, int *eof, void *data)
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
{
	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 }
};

1807
ide_devset_rw_field(dsc_overlap, dsc_overlap);
1808

1809 1810 1811
static const struct ide_proc_devset idecd_settings[] = {
	IDE_PROC_DEVSET(dsc_overlap, 0, 1),
	{ 0 },
1812
};
1813 1814
#endif

1815 1816
static const struct cd_list_entry ide_cd_quirks_list[] = {
	/* Limit transfer size per interrupt. */
1817 1818
	{ "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_AFLAG_LIMIT_NFRAMES	     },
	{ "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_AFLAG_LIMIT_NFRAMES	     },
1819
	/* SCR-3231 doesn't support the SET_CD_SPEED command. */
1820
	{ "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_AFLAG_NO_SPEED_SELECT	     },
1821
	/* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1822 1823
	{ "NEC CD-ROM DRIVE:260",    "1.01", IDE_AFLAG_TOCADDR_AS_BCD |
					     IDE_AFLAG_PRE_ATAPI12,	     },
1824
	/* Vertos 300, some versions of this drive like to talk BCD. */
1825
	{ "V003S0DS",		     NULL,   IDE_AFLAG_VERTOS_300_SSD,	     },
1826
	/* Vertos 600 ESD. */
1827
	{ "V006E0DS",		     NULL,   IDE_AFLAG_VERTOS_600_ESD,	     },
1828 1829 1830 1831
	/*
	 * Sanyo 3 CD changer uses a non-standard command for CD changing
	 * (by default standard ATAPI support for CD changers is used).
	 */
1832 1833 1834
	{ "CD-ROM CDR-C3 G",	     NULL,   IDE_AFLAG_SANYO_3CD	     },
	{ "CD-ROM CDR-C3G",	     NULL,   IDE_AFLAG_SANYO_3CD	     },
	{ "CD-ROM CDR_C36",	     NULL,   IDE_AFLAG_SANYO_3CD	     },
1835
	/* Stingray 8X CD-ROM. */
1836
	{ "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_AFLAG_PRE_ATAPI12 },
1837 1838 1839 1840
	/*
	 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
	 * mode sense page capabilities size, but older drives break.
	 */
1841 1842
	{ "ATAPI CD ROM DRIVE 50X MAX",	NULL,	IDE_AFLAG_FULL_CAPS_PAGE     },
	{ "WPI CDS-32X",		NULL,	IDE_AFLAG_FULL_CAPS_PAGE     },
1843
	/* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1844
	{ "",			     "241N", IDE_AFLAG_LE_SPEED_FIELDS       },
1845 1846 1847 1848
	/*
	 * Some drives used by Apple don't advertise audio play
	 * but they do support reading TOC & audio datas.
	 */
1849 1850 1851 1852 1853
	{ "MATSHITADVD-ROM SR-8187", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
	{ "MATSHITADVD-ROM SR-8186", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
	{ "MATSHITADVD-ROM SR-8176", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
	{ "MATSHITADVD-ROM SR-8174", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
	{ "Optiarc DVD RW AD-5200A", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
1854
	{ "Optiarc DVD RW AD-7200A", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
B
Borislav Petkov 已提交
1855
	{ "Optiarc DVD RW AD-7543A", NULL,   IDE_AFLAG_NO_AUTOCLOSE	     },
1856 1857 1858
	{ NULL, NULL, 0 }
};

1859
static unsigned int ide_cd_flags(u16 *id)
1860 1861 1862 1863
{
	const struct cd_list_entry *cle = ide_cd_quirks_list;

	while (cle->id_model) {
1864
		if (strcmp(cle->id_model, (char *)&id[ATA_ID_PROD]) == 0 &&
1865
		    (cle->id_firmware == NULL ||
1866
		     strstr((char *)&id[ATA_ID_FW_REV], cle->id_firmware)))
1867 1868 1869 1870 1871 1872 1873
			return cle->cd_flags;
		cle++;
	}

	return 0;
}

1874
static int ide_cdrom_setup(ide_drive_t *drive)
L
Linus Torvalds 已提交
1875
{
1876 1877
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1878 1879
	u16 *id = drive->id;
	char *fw_rev = (char *)&id[ATA_ID_FW_REV];
L
Linus Torvalds 已提交
1880 1881 1882 1883
	int nslots;

	blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
	blk_queue_dma_alignment(drive->queue, 31);
1884
	blk_queue_update_dma_pad(drive->queue, 15);
L
Linus Torvalds 已提交
1885 1886 1887 1888 1889 1890
	drive->queue->unplug_delay = (1 * HZ) / 1000;
	if (!drive->queue->unplug_delay)
		drive->queue->unplug_delay = 1;

	drive->special.all	= 0;

1891
	drive->atapi_flags = IDE_AFLAG_MEDIA_CHANGED | IDE_AFLAG_NO_EJECT |
1892
		       ide_cd_flags(id);
L
Linus Torvalds 已提交
1893

1894
	if ((id[ATA_ID_CONFIG] & 0x0060) == 0x20)
1895
		drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
1896

1897
	if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
1898
	    fw_rev[4] == '1' && fw_rev[6] <= '2')
1899 1900 1901
		drive->atapi_flags |= (IDE_AFLAG_TOCTRACKS_AS_BCD |
				     IDE_AFLAG_TOCADDR_AS_BCD);
	else if ((drive->atapi_flags & IDE_AFLAG_VERTOS_600_ESD) &&
1902
		 fw_rev[4] == '1' && fw_rev[6] <= '2')
1903 1904
		drive->atapi_flags |= IDE_AFLAG_TOCTRACKS_AS_BCD;
	else if (drive->atapi_flags & IDE_AFLAG_SANYO_3CD)
B
Borislav Petkov 已提交
1905 1906
		/* 3 => use CD in slot 0 */
		cdi->sanyo_slot = 3;
L
Linus Torvalds 已提交
1907

1908
	nslots = ide_cdrom_probe_capabilities(drive);
L
Linus Torvalds 已提交
1909

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

1913
	drive->dsc_overlap = (drive->next != drive);
L
Linus Torvalds 已提交
1914 1915

	if (ide_cdrom_register(drive, nslots)) {
1916 1917
		printk(KERN_ERR "%s: %s failed to register device with the"
				" cdrom driver.\n", drive->name, __func__);
1918
		cd->devinfo.handle = NULL;
L
Linus Torvalds 已提交
1919 1920
		return 1;
	}
1921 1922

	ide_proc_register_driver(drive, cd->driver);
L
Linus Torvalds 已提交
1923 1924 1925
	return 0;
}

1926
static void ide_cd_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
1927 1928 1929
{
	struct cdrom_info *info = drive->driver_data;

1930
	ide_proc_unregister_driver(drive, info->driver);
L
Linus Torvalds 已提交
1931 1932 1933 1934 1935 1936 1937 1938

	del_gendisk(info->disk);

	ide_cd_put(info);
}

static void ide_cd_release(struct kref *kref)
{
B
Borislav Petkov 已提交
1939
	struct cdrom_info *info = to_ide_drv(kref, cdrom_info);
L
Linus Torvalds 已提交
1940 1941 1942 1943
	struct cdrom_device_info *devinfo = &info->devinfo;
	ide_drive_t *drive = info->drive;
	struct gendisk *g = info->disk;

1944
	kfree(info->toc);
1945 1946
	if (devinfo->handle == drive)
		unregister_cdrom(devinfo);
L
Linus Torvalds 已提交
1947 1948 1949 1950 1951 1952 1953 1954
	drive->dsc_overlap = 0;
	drive->driver_data = NULL;
	blk_queue_prep_rq(drive->queue, NULL);
	g->private_data = NULL;
	put_disk(g);
	kfree(info);
}

1955
static int ide_cd_probe(ide_drive_t *);
L
Linus Torvalds 已提交
1956 1957

static ide_driver_t ide_cdrom_driver = {
1958
	.gen_driver = {
1959
		.owner		= THIS_MODULE,
1960 1961 1962
		.name		= "ide-cdrom",
		.bus		= &ide_bus_type,
	},
1963 1964
	.probe			= ide_cd_probe,
	.remove			= ide_cd_remove,
L
Linus Torvalds 已提交
1965 1966
	.version		= IDECD_VERSION,
	.media			= ide_cdrom,
1967
	.do_request		= ide_cd_do_request,
L
Linus Torvalds 已提交
1968 1969
	.end_request		= ide_end_request,
	.error			= __ide_error,
1970
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
1971
	.proc			= idecd_proc,
1972
	.settings		= idecd_settings,
1973
#endif
L
Linus Torvalds 已提交
1974 1975
};

1976
static int idecd_open(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1977 1978 1979 1980 1981
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct cdrom_info *info;
	int rc = -ENOMEM;

1982 1983
	info = ide_cd_get(disk);
	if (!info)
L
Linus Torvalds 已提交
1984 1985
		return -ENXIO;

1986
	rc = cdrom_open(&info->devinfo, inode, file);
L
Linus Torvalds 已提交
1987 1988 1989 1990 1991 1992 1993

	if (rc < 0)
		ide_cd_put(info);

	return rc;
}

1994
static int idecd_release(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1995 1996
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
B
Borislav Petkov 已提交
1997
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
1998

1999
	cdrom_release(&info->devinfo, file);
L
Linus Torvalds 已提交
2000 2001 2002 2003 2004 2005

	ide_cd_put(info);

	return 0;
}

2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
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;
2031
	char spindown;
2032 2033 2034 2035 2036 2037 2038 2039

	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;
2040
	if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
2041 2042 2043 2044
		return -EFAULT;
	return 0;
}

2045
static int idecd_ioctl(struct inode *inode, struct file *file,
L
Linus Torvalds 已提交
2046 2047 2048
			unsigned int cmd, unsigned long arg)
{
	struct block_device *bdev = inode->i_bdev;
B
Borislav Petkov 已提交
2049
	struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info);
L
Linus Torvalds 已提交
2050 2051
	int err;

2052
	switch (cmd) {
2053
	case CDROMSETSPINDOWN:
2054
		return idecd_set_spindown(&info->devinfo, arg);
2055
	case CDROMGETSPINDOWN:
2056 2057 2058
		return idecd_get_spindown(&info->devinfo, arg);
	default:
		break;
2059
	}
2060 2061

	err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
L
Linus Torvalds 已提交
2062 2063 2064 2065 2066 2067 2068 2069
	if (err == -EINVAL)
		err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);

	return err;
}

static int idecd_media_changed(struct gendisk *disk)
{
B
Borislav Petkov 已提交
2070
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2071 2072 2073 2074 2075
	return cdrom_media_changed(&info->devinfo);
}

static int idecd_revalidate_disk(struct gendisk *disk)
{
B
Borislav Petkov 已提交
2076
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2077
	struct request_sense sense;
2078 2079 2080

	ide_cd_read_toc(info->drive, &sense);

L
Linus Torvalds 已提交
2081 2082 2083 2084
	return  0;
}

static struct block_device_operations idecd_ops = {
2085 2086 2087 2088 2089 2090
	.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 已提交
2091 2092
};

B
Borislav Petkov 已提交
2093
/* module options */
2094
static char *ignore;
L
Linus Torvalds 已提交
2095 2096 2097 2098

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

2099
static int ide_cd_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
2100 2101 2102 2103 2104 2105 2106
{
	struct cdrom_info *info;
	struct gendisk *g;
	struct request_sense sense;

	if (!strstr("ide-cdrom", drive->driver_req))
		goto failed;
2107

L
Linus Torvalds 已提交
2108 2109
	if (drive->media != ide_cdrom && drive->media != ide_optical)
		goto failed;
2110

L
Linus Torvalds 已提交
2111 2112 2113
	/* skip drives that we were told to ignore */
	if (ignore != NULL) {
		if (strstr(ignore, drive->name)) {
2114 2115
			printk(KERN_INFO "ide-cd: ignoring drive %s\n",
					 drive->name);
L
Linus Torvalds 已提交
2116 2117 2118
			goto failed;
		}
	}
2119
	info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
L
Linus Torvalds 已提交
2120
	if (info == NULL) {
2121 2122
		printk(KERN_ERR "%s: Can't allocate a cdrom structure\n",
				drive->name);
L
Linus Torvalds 已提交
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
		goto failed;
	}

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

	ide_init_disk(g, drive);

	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)) {
2146
		ide_cd_release(&info->kref);
L
Linus Torvalds 已提交
2147 2148 2149
		goto failed;
	}

2150
	ide_cd_read_toc(drive, &sense);
L
Linus Torvalds 已提交
2151 2152 2153 2154 2155 2156 2157 2158
	g->fops = &idecd_ops;
	g->flags |= GENHD_FL_REMOVABLE;
	add_disk(g);
	return 0;

out_free_cd:
	kfree(info);
failed:
2159
	return -ENODEV;
L
Linus Torvalds 已提交
2160 2161 2162 2163
}

static void __exit ide_cdrom_exit(void)
{
2164
	driver_unregister(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2165
}
2166 2167

static int __init ide_cdrom_init(void)
L
Linus Torvalds 已提交
2168
{
2169
	return driver_register(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2170 2171
}

2172
MODULE_ALIAS("ide:*m-cdrom*");
2173
MODULE_ALIAS("ide-cd");
L
Linus Torvalds 已提交
2174 2175 2176
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);
MODULE_LICENSE("GPL");