ide-cd.c 56.7 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 27 28
#define DRV_NAME "ide-cd"
#define PFX DRV_NAME ": "

29
#define IDECD_VERSION "5.00"
L
Linus Torvalds 已提交
30 31 32 33 34 35 36 37 38 39 40 41

#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>
42
#include <linux/mutex.h>
43
#include <linux/bcd.h>
L
Linus Torvalds 已提交
44

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

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

#include "ide-cd.h"

56
static DEFINE_MUTEX(idecd_ref_mutex);
L
Linus Torvalds 已提交
57

58 59
static void ide_cd_release(struct kref *);

L
Linus Torvalds 已提交
60 61 62 63
static struct cdrom_info *ide_cd_get(struct gendisk *disk)
{
	struct cdrom_info *cd = NULL;

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

72
	}
73
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
74 75 76 77 78
	return cd;
}

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

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

B
Borislav Petkov 已提交
87
/*
L
Linus Torvalds 已提交
88 89 90
 * Generic packet command support and error handling routines.
 */

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

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

103 104 105
	ide_debug_log(IDE_DBG_SENSE, "Call %s, sense_key: 0x%x\n", __func__,
		      sense->sense_key);

106
	if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
L
Linus Torvalds 已提交
107 108 109
		return 0;

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

146
static void cdrom_analyze_sense_data(ide_drive_t *drive,
L
Linus Torvalds 已提交
147 148 149
			      struct request *failed_command,
			      struct request_sense *sense)
{
A
Alan Cox 已提交
150 151 152 153
	unsigned long sector;
	unsigned long bio_sectors;
	struct cdrom_info *info = drive->driver_data;

154 155 156 157 158 159 160 161
	ide_debug_log(IDE_DBG_SENSE, "Call %s, error_code: 0x%x, "
			"sense_key: 0x%x\n", __func__, sense->error_code,
			sense->sense_key);

	if (failed_command)
		ide_debug_log(IDE_DBG_SENSE, "%s: failed cmd: 0x%x\n",
				__func__, failed_command->cmd[0]);

L
Linus Torvalds 已提交
162 163 164 165
	if (!cdrom_log_sense(drive, failed_command, sense))
		return;

	/*
B
Borislav Petkov 已提交
166 167 168
	 * 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 已提交
169 170 171 172 173
	 */
	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
		if (sense->sense_key == 0x05 && sense->asc == 0x24)
			return;

B
Borislav Petkov 已提交
174 175
	/* current error */
	if (sense->error_code == 0x70) {
176
		switch (sense->sense_key) {
A
Alan Cox 已提交
177 178 179 180 181 182 183 184 185 186 187 188 189 190
		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 已提交
191 192
				/* device sector size is 2K */
				sector <<= 2;
193 194

			bio_sectors = max(bio_sectors(failed_command->bio), 4U);
195
			sector &= ~(bio_sectors - 1);
A
Alan Cox 已提交
196 197

			if (sector < get_capacity(info->disk) &&
198
			    drive->probed_capacity - sector < 4 * 75)
A
Alan Cox 已提交
199
				set_capacity(info->disk, sector);
200 201
		}
	}
L
Linus Torvalds 已提交
202

203
	ide_cd_log_error(drive->name, failed_command, sense);
L
Linus Torvalds 已提交
204 205 206 207 208 209 210 211
}

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;

212 213
	ide_debug_log(IDE_DBG_SENSE, "Call %s\n", __func__);

L
Linus Torvalds 已提交
214 215 216 217
	if (sense == NULL)
		sense = &info->sense_data;

	/* stuff the sense request in front of our current request */
F
FUJITA Tomonori 已提交
218 219 220
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_ATA_PC;
	rq->rq_disk = info->disk;
L
Linus Torvalds 已提交
221 222 223

	rq->data = sense;
	rq->cmd[0] = GPCMD_REQUEST_SENSE;
224 225
	rq->cmd[4] = 18;
	rq->data_len = 18;
L
Linus Torvalds 已提交
226

227
	rq->cmd_type = REQ_TYPE_SENSE;
228
	rq->cmd_flags |= REQ_PREEMPT;
L
Linus Torvalds 已提交
229 230 231 232

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

233 234 235 236
	if (failed_command)
		ide_debug_log(IDE_DBG_SENSE, "failed_cmd: 0x%x\n",
			      failed_command->cmd[0]);

237
	ide_do_drive_cmd(drive, rq);
L
Linus Torvalds 已提交
238 239
}

240
static void cdrom_end_request(ide_drive_t *drive, int uptodate)
L
Linus Torvalds 已提交
241 242 243 244
{
	struct request *rq = HWGROUP(drive)->rq;
	int nsectors = rq->hard_cur_sectors;

245 246 247 248
	ide_debug_log(IDE_DBG_FUNC, "Call %s, cmd: 0x%x, uptodate: 0x%x, "
		      "nsectors: %d\n", __func__, rq->cmd[0], uptodate,
		      nsectors);

249
	if (blk_sense_request(rq) && uptodate) {
L
Linus Torvalds 已提交
250
		/*
251 252
		 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
		 * failed request
L
Linus Torvalds 已提交
253 254 255 256 257 258 259 260 261 262
		 */
		struct request *failed = (struct request *) rq->buffer;
		struct cdrom_info *info = drive->driver_data;
		void *sense = &info->sense_data;

		if (failed) {
			if (failed->sense) {
				sense = failed->sense;
				failed->sense_len = rq->sense_len;
			}
A
Alan Cox 已提交
263
			cdrom_analyze_sense_data(drive, failed, sense);
L
Linus Torvalds 已提交
264
			/*
B
Borislav Petkov 已提交
265
			 * now end the failed request
L
Linus Torvalds 已提交
266
			 */
A
Alan Cox 已提交
267 268 269 270 271
			if (blk_fs_request(failed)) {
				if (ide_end_dequeued_request(drive, failed, 0,
						failed->hard_nr_sectors))
					BUG();
			} else {
272 273
				if (blk_end_request(failed, -EIO,
						    failed->data_len))
274
					BUG();
A
Alan Cox 已提交
275 276 277
			}
		} else
			cdrom_analyze_sense_data(drive, NULL, sense);
L
Linus Torvalds 已提交
278 279 280 281 282 283 284 285 286 287
	}

	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;

288 289 290
	ide_debug_log(IDE_DBG_FUNC, "Exit %s, uptodate: 0x%x, nsectors: %d\n",
		      __func__, uptodate, nsectors);

L
Linus Torvalds 已提交
291 292 293
	ide_end_request(drive, uptodate, nsectors);
}

294
static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 st)
A
Alan Cox 已提交
295
{
296
	if (st & 0x80)
A
Alan Cox 已提交
297
		return;
298
	ide_dump_status(drive, msg, st);
A
Alan Cox 已提交
299 300
}

B
Borislav Petkov 已提交
301 302 303 304 305
/*
 * Returns:
 * 0: if the request should be continued.
 * 1: if the request was ended.
 */
L
Linus Torvalds 已提交
306 307
static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
{
308
	ide_hwif_t *hwif = drive->hwif;
309 310
	ide_hwgroup_t *hwgroup = hwif->hwgroup;
	struct request *rq = hwgroup->rq;
L
Linus Torvalds 已提交
311
	int stat, err, sense_key;
312

B
Borislav Petkov 已提交
313
	/* check for errors */
314
	stat = hwif->tp_ops->read_status(hwif);
315

L
Linus Torvalds 已提交
316 317 318 319 320 321
	if (stat_ret)
		*stat_ret = stat;

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

B
Borislav Petkov 已提交
322
	/* get the IDE error register */
323
	err = ide_read_error(drive);
L
Linus Torvalds 已提交
324 325 326
	sense_key = err >> 4;

	if (rq == NULL) {
327
		printk(KERN_ERR PFX "%s: missing rq in %s\n",
328
				drive->name, __func__);
L
Linus Torvalds 已提交
329 330 331
		return 1;
	}

332
	ide_debug_log(IDE_DBG_RQ, "%s: stat: 0x%x, good_stat: 0x%x, "
B
Borislav Petkov 已提交
333 334
		      "rq->cmd[0]: 0x%x, rq->cmd_type: 0x%x, err: 0x%x\n",
		      __func__, stat, good_stat, rq->cmd[0], rq->cmd_type, err);
335

336
	if (blk_sense_request(rq)) {
B
Borislav Petkov 已提交
337 338 339 340 341
		/*
		 * We got an error trying to get sense info from the drive
		 * (probably while trying to recover from a former error).
		 * Just give up.
		 */
342
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
343 344 345 346
		cdrom_end_request(drive, 0);
		ide_error(drive, "request sense failure", stat);
		return 1;

347
	} else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
L
Linus Torvalds 已提交
348 349 350 351 352 353
		/* All other functions, except for READ. */

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

B
Borislav Petkov 已提交
357
		/* check for tray open */
L
Linus Torvalds 已提交
358
		if (sense_key == NOT_READY) {
359
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
360
		} else if (sense_key == UNIT_ATTENTION) {
B
Borislav Petkov 已提交
361
			/* check for media change */
362
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
363
			return 0;
364 365 366 367 368 369 370 371 372
		} 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!
			 */
373
		} else if (!(rq->cmd_flags & REQ_QUIET)) {
B
Borislav Petkov 已提交
374
			/* otherwise, print an error */
L
Linus Torvalds 已提交
375 376
			ide_dump_status(drive, "packet command error", stat);
		}
377

378
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
379 380 381 382 383 384

		/*
		 * instead of playing games with moving completions around,
		 * remove failed request completely and end it when the
		 * request sense has completed
		 */
385
		goto end_request;
L
Linus Torvalds 已提交
386 387 388 389

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

B
Borislav Petkov 已提交
390
		/* handle errors from READ and WRITE requests */
L
Linus Torvalds 已提交
391 392 393 394 395

		if (blk_noretry_request(rq))
			do_end_request = 1;

		if (sense_key == NOT_READY) {
B
Borislav Petkov 已提交
396
			/* tray open */
L
Linus Torvalds 已提交
397
			if (rq_data_dir(rq) == READ) {
398
				cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
399

B
Borislav Petkov 已提交
400
				/* fail the request */
401 402
				printk(KERN_ERR PFX "%s: tray open\n",
						drive->name);
L
Linus Torvalds 已提交
403 404 405 406
				do_end_request = 1;
			} else {
				struct cdrom_info *info = drive->driver_data;

B
Borislav Petkov 已提交
407 408
				/*
				 * Allow the drive 5 seconds to recover, some
L
Linus Torvalds 已提交
409
				 * devices will return this error while flushing
B
Borislav Petkov 已提交
410 411
				 * data from cache.
				 */
L
Linus Torvalds 已提交
412
				if (!rq->errors)
413 414
					info->write_timeout = jiffies +
							ATAPI_WAIT_WRITE_BUSY;
L
Linus Torvalds 已提交
415 416 417 418
				rq->errors = 1;
				if (time_after(jiffies, info->write_timeout))
					do_end_request = 1;
				else {
419
					struct request_queue *q = drive->queue;
L
Linus Torvalds 已提交
420 421 422
					unsigned long flags;

					/*
B
Borislav Petkov 已提交
423 424
					 * take a breather relying on the unplug
					 * timer to kick us again
L
Linus Torvalds 已提交
425
					 */
426 427 428 429
					spin_lock_irqsave(q->queue_lock, flags);
					blk_plug_device(q);
					spin_unlock_irqrestore(q->queue_lock, flags);

L
Linus Torvalds 已提交
430 431 432 433
					return 1;
				}
			}
		} else if (sense_key == UNIT_ATTENTION) {
B
Borislav Petkov 已提交
434
			/* media change */
435
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
436

437
			/*
B
Borislav Petkov 已提交
438 439
			 * Arrange to retry the request but be sure to give up
			 * if we've retried too many times.
440
			 */
L
Linus Torvalds 已提交
441 442 443 444
			if (++rq->errors > ERROR_MAX)
				do_end_request = 1;
		} else if (sense_key == ILLEGAL_REQUEST ||
			   sense_key == DATA_PROTECT) {
445
			/*
B
Borislav Petkov 已提交
446 447
			 * No point in retrying after an illegal request or data
			 * protect error.
448 449
			 */
			ide_dump_status_no_sense(drive, "command error", stat);
L
Linus Torvalds 已提交
450 451
			do_end_request = 1;
		} else if (sense_key == MEDIUM_ERROR) {
452 453
			/*
			 * No point in re-trying a zillion times on a bad
B
Borislav Petkov 已提交
454
			 * sector. If we got here the error is not correctable.
455
			 */
456 457 458
			ide_dump_status_no_sense(drive,
						 "media error (bad sector)",
						 stat);
L
Linus Torvalds 已提交
459 460
			do_end_request = 1;
		} else if (sense_key == BLANK_CHECK) {
B
Borislav Petkov 已提交
461
			/* disk appears blank ?? */
462 463
			ide_dump_status_no_sense(drive, "media error (blank)",
						 stat);
L
Linus Torvalds 已提交
464
			do_end_request = 1;
465
		} else if ((err & ~ATA_ABORTED) != 0) {
B
Borislav Petkov 已提交
466
			/* go to the default handler for other errors */
L
Linus Torvalds 已提交
467 468 469
			ide_error(drive, "cdrom_decode_status", stat);
			return 1;
		} else if ((++rq->errors > ERROR_MAX)) {
B
Borislav Petkov 已提交
470
			/* we've racked up too many retries, abort */
L
Linus Torvalds 已提交
471 472 473
			do_end_request = 1;
		}

B
Borislav Petkov 已提交
474 475 476 477 478
		/*
		 * End a request through request sense analysis when we have
		 * sense data. We need this in order to perform end of media
		 * processing.
		 */
479 480
		if (do_end_request)
			goto end_request;
A
Alan Cox 已提交
481

482
		/*
B
Borislav Petkov 已提交
483 484
		 * If we got a CHECK_CONDITION status, queue
		 * a request sense command.
485
		 */
486
		if (stat & ATA_ERR)
487
			cdrom_queue_request_sense(drive, NULL, NULL);
L
Linus Torvalds 已提交
488
	} else {
489
		blk_dump_rq_flags(rq, PFX "bad rq");
L
Linus Torvalds 已提交
490 491 492
		cdrom_end_request(drive, 0);
	}

B
Borislav Petkov 已提交
493
	/* retry, or handle the next request */
L
Linus Torvalds 已提交
494
	return 1;
495 496

end_request:
497
	if (stat & ATA_ERR) {
498
		struct request_queue *q = drive->queue;
499 500
		unsigned long flags;

501
		spin_lock_irqsave(q->queue_lock, flags);
502
		blkdev_dequeue_request(rq);
503
		spin_unlock_irqrestore(q->queue_lock, flags);
504

505 506
		hwgroup->rq = NULL;

507 508 509 510 511
		cdrom_queue_request_sense(drive, rq->sense, rq);
	} else
		cdrom_end_request(drive, 0);

	return 1;
L
Linus Torvalds 已提交
512 513
}

B
Borislav Petkov 已提交
514 515 516 517 518 519 520 521
/*
 * 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 已提交
522 523 524 525
static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
						  ide_handler_t *handler)
{
	ide_hwif_t *hwif = drive->hwif;
526 527 528 529
	struct request *rq = hwif->hwgroup->rq;
	int xferlen;

	xferlen = ide_cd_get_xferlen(rq);
L
Linus Torvalds 已提交
530

531 532
	ide_debug_log(IDE_DBG_PC, "Call %s, xferlen: %d\n", __func__, xferlen);

533
	/* FIXME: for Virtual DMA we must check harder */
534 535
	if (drive->dma)
		drive->dma = !hwif->dma_ops->dma_setup(drive);
L
Linus Torvalds 已提交
536

B
Borislav Petkov 已提交
537
	/* set up the controller registers */
538
	ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL,
539
			   xferlen, drive->dma);
540

541
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
542
		/* waiting for CDB interrupt, not DMA yet. */
543
		if (drive->dma)
544 545
			drive->waiting_for_dma = 0;

L
Linus Torvalds 已提交
546
		/* packet command */
547
		ide_execute_command(drive, ATA_CMD_PACKET, handler,
548
				    ATAPI_WAIT_PC, ide_cd_expiry);
L
Linus Torvalds 已提交
549 550
		return ide_started;
	} else {
551
		ide_execute_pkt_cmd(drive);
L
Linus Torvalds 已提交
552 553 554 555 556

		return (*handler) (drive);
	}
}

B
Borislav Petkov 已提交
557 558 559 560 561 562
/*
 * 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 已提交
563
#define ATAPI_MIN_CDB_BYTES 12
564
static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
L
Linus Torvalds 已提交
565 566 567 568 569 570 571
					  struct request *rq,
					  ide_handler_t *handler)
{
	ide_hwif_t *hwif = drive->hwif;
	int cmd_len;
	ide_startstop_t startstop;

572 573
	ide_debug_log(IDE_DBG_PC, "Call %s\n", __func__);

574
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
B
Borislav Petkov 已提交
575 576 577 578
		/*
		 * Here we should have been called after receiving an interrupt
		 * from the device.  DRQ should how be set.
		 */
L
Linus Torvalds 已提交
579

B
Borislav Petkov 已提交
580
		/* check for errors */
581
		if (cdrom_decode_status(drive, ATA_DRQ, NULL))
L
Linus Torvalds 已提交
582
			return ide_stopped;
583

B
Borislav Petkov 已提交
584
		/* ok, next interrupt will be DMA interrupt */
585
		if (drive->dma)
586
			drive->waiting_for_dma = 1;
L
Linus Torvalds 已提交
587
	} else {
B
Borislav Petkov 已提交
588
		/* otherwise, we must wait for DRQ to get set */
589 590
		if (ide_wait_stat(&startstop, drive, ATA_DRQ,
				  ATA_BUSY, WAIT_READY))
L
Linus Torvalds 已提交
591 592 593
			return startstop;
	}

B
Borislav Petkov 已提交
594
	/* arm the interrupt handler */
595
	ide_set_handler(drive, handler, rq->timeout, ide_cd_expiry);
L
Linus Torvalds 已提交
596 597 598 599 600 601

	/* 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 已提交
602
	/* send the command to the device */
603
	hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
L
Linus Torvalds 已提交
604

B
Borislav Petkov 已提交
605
	/* start the DMA if need be */
606
	if (drive->dma)
607
		hwif->dma_ops->dma_start(drive);
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615 616

	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.
 */
617 618
static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
				int len, int ireason, int rw)
L
Linus Torvalds 已提交
619
{
620 621
	ide_hwif_t *hwif = drive->hwif;

622 623 624
	ide_debug_log(IDE_DBG_FUNC, "Call %s, ireason: 0x%x, rw: 0x%x\n",
		      __func__, ireason, rw);

625 626 627 628 629
	/*
	 * 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 已提交
630
		return 0;
631
	else if (ireason == (rw << 1)) {
632

B
Borislav Petkov 已提交
633
		/* whoops... */
634
		printk(KERN_ERR PFX "%s: %s: wrong transfer direction!\n",
635
				drive->name, __func__);
L
Linus Torvalds 已提交
636

637
		ide_pad_transfer(drive, rw, len);
638
	} else  if (rw == 0 && ireason == 1) {
B
Borislav Petkov 已提交
639 640 641
		/*
		 * Some drives (ASUS) seem to tell us that status info is
		 * available.  Just get it and ignore.
L
Linus Torvalds 已提交
642
		 */
643
		(void)hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
644 645
		return 0;
	} else {
B
Borislav Petkov 已提交
646
		/* drive wants a command packet, or invalid ireason... */
647
		printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
648
				drive->name, __func__, ireason);
L
Linus Torvalds 已提交
649 650
	}

651 652 653
	if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags |= REQ_FAILED;

L
Linus Torvalds 已提交
654 655 656 657
	cdrom_end_request(drive, 0);
	return -1;
}

658 659 660 661 662 663
/*
 * 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)
{
664 665
	ide_debug_log(IDE_DBG_FUNC, "Call %s, len: %d\n", __func__, len);

666 667 668
	if ((len % SECTOR_SIZE) == 0)
		return 0;

669 670
	printk(KERN_ERR PFX "%s: %s: Bad transfer size %d\n", drive->name,
			__func__, len);
671

672
	if (drive->atapi_flags & IDE_AFLAG_LIMIT_NFRAMES)
673 674
		printk(KERN_ERR PFX "This drive is not supported by this "
				"version of the driver\n");
675
	else {
676
		printk(KERN_ERR PFX "Trying to limit transfer sizes\n");
677
		drive->atapi_flags |= IDE_AFLAG_LIMIT_NFRAMES;
678 679 680 681 682
	}

	return 1;
}

683
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
684

685 686
static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
						 struct request *rq)
L
Linus Torvalds 已提交
687
{
688 689 690
	ide_debug_log(IDE_DBG_RQ, "Call %s: rq->cmd_flags: 0x%x\n", __func__,
		      rq->cmd_flags);

691 692 693 694
	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 已提交
695

696 697 698 699 700 701 702 703 704 705 706
		/*
		 * 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 已提交
707
			/* sanity check... */
708 709
			if (rq->current_nr_sectors !=
			    bio_cur_sectors(rq->bio)) {
710
				printk(KERN_ERR PFX "%s: %s: buffer botch (%u)\n",
711
						drive->name, __func__,
712 713 714 715 716
						rq->current_nr_sectors);
				cdrom_end_request(drive, 0);
				return ide_stopped;
			}
			rq->current_nr_sectors += nskip;
L
Linus Torvalds 已提交
717 718
		}
	}
719

B
Borislav Petkov 已提交
720
	/* set up the command */
L
Linus Torvalds 已提交
721 722
	rq->timeout = ATAPI_WAIT_PC;

723 724 725 726 727 728 729 730 731 732 733 734 735
	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 已提交
736
	/* send the command to the drive and return */
737
	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
L
Linus Torvalds 已提交
738 739
}

740
/*
B
Borislav Petkov 已提交
741 742
 * Fix up a possibly partially-processed request so that we can start it over
 * entirely, or even put it back on the request queue.
743
 */
744
static void ide_cd_restore_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
745
{
746 747 748

	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

L
Linus Torvalds 已提交
749
	if (rq->buffer != bio_data(rq->bio)) {
750 751
		sector_t n =
			(rq->buffer - (char *)bio_data(rq->bio)) / SECTOR_SIZE;
L
Linus Torvalds 已提交
752 753 754 755 756

		rq->buffer = bio_data(rq->bio);
		rq->nr_sectors += n;
		rq->sector -= n;
	}
757 758
	rq->current_nr_sectors = bio_cur_sectors(rq->bio);
	rq->hard_cur_sectors = rq->current_nr_sectors;
L
Linus Torvalds 已提交
759 760 761 762 763
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
	rq->q->prep_rq_fn(rq->q, rq);
}

764
static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct request *rq)
765
{
B
Borislav Petkov 已提交
766 767
	ide_debug_log(IDE_DBG_FUNC, "Call %s, rq->cmd[0]: 0x%x\n",
		      __func__, rq->cmd[0]);
768

769 770 771 772 773 774 775 776 777 778 779 780
	/*
	 * 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;
		}
}

781 782 783 784
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 已提交
785
{
786 787
	struct cdrom_info *info = drive->driver_data;
	struct request_sense local_sense;
L
Linus Torvalds 已提交
788
	int retries = 10;
789
	unsigned int flags = 0;
L
Linus Torvalds 已提交
790

791 792
	if (!sense)
		sense = &local_sense;
L
Linus Torvalds 已提交
793

B
Borislav Petkov 已提交
794
	ide_debug_log(IDE_DBG_PC, "Call %s, cmd[0]: 0x%x, write: 0x%x, "
795 796 797
		      "timeout: %d, cmd_flags: 0x%x\n", __func__, cmd[0], write,
		      timeout, cmd_flags);

B
Borislav Petkov 已提交
798
	/* start of retry loop */
L
Linus Torvalds 已提交
799
	do {
800
		struct request *rq;
L
Linus Torvalds 已提交
801 802
		int error;

803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
		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 已提交
822

B
Borislav Petkov 已提交
823 824 825 826
		/*
		 * FIXME: we should probably abort/retry or something in case of
		 * failure.
		 */
827
		if (flags & REQ_FAILED) {
B
Borislav Petkov 已提交
828 829 830 831
			/*
			 * The request failed.  Retry if it was due to a unit
			 * attention status (usually means media was changed).
			 */
832
			struct request_sense *reqbuf = sense;
L
Linus Torvalds 已提交
833 834 835 836 837

			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 已提交
838 839 840 841 842
				/*
				 * 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 已提交
843 844
				ssleep(2);
			} else {
B
Borislav Petkov 已提交
845
				/* otherwise, don't retry */
L
Linus Torvalds 已提交
846 847 848 849 850
				retries = 0;
			}
			--retries;
		}

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

B
Borislav Petkov 已提交
854
	/* return an error if the command failed */
855
	return (flags & REQ_FAILED) ? -EIO : 0;
L
Linus Torvalds 已提交
856 857
}

858
/*
B
Borislav Petkov 已提交
859 860 861
 * 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.
862 863 864 865 866 867
 */
static int cdrom_newpc_intr_dummy_cb(struct request *rq)
{
	return 1;
}

L
Linus Torvalds 已提交
868 869
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
{
870
	ide_hwif_t *hwif = drive->hwif;
871 872
	ide_hwgroup_t *hwgroup = hwif->hwgroup;
	struct request *rq = hwgroup->rq;
L
Linus Torvalds 已提交
873
	xfer_func_t *xferfunc;
874
	ide_expiry_t *expiry = NULL;
875
	int dma_error = 0, dma, stat, thislen, uptodate = 0;
876 877
	int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
	unsigned int timeout;
878 879
	u16 len;
	u8 ireason;
L
Linus Torvalds 已提交
880

881 882 883
	ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, write: 0x%x\n",
		      __func__, rq->cmd[0], write);

B
Borislav Petkov 已提交
884
	/* check for errors */
885
	dma = drive->dma;
L
Linus Torvalds 已提交
886
	if (dma) {
887
		drive->dma = 0;
888
		dma_error = hwif->dma_ops->dma_end(drive);
889
		if (dma_error) {
890
			printk(KERN_ERR PFX "%s: DMA %s error\n", drive->name,
891
					write ? "write" : "read");
892 893
			ide_dma_off(drive);
		}
L
Linus Torvalds 已提交
894 895 896 897 898
	}

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

B
Borislav Petkov 已提交
899
	/* using dma, transfer is complete now */
L
Linus Torvalds 已提交
900
	if (dma) {
901
		if (dma_error)
L
Linus Torvalds 已提交
902
			return ide_error(drive, "dma error", stat);
903 904 905 906
		if (blk_fs_request(rq)) {
			ide_end_request(drive, 1, rq->nr_sectors);
			return ide_stopped;
		}
907
		goto end_request;
L
Linus Torvalds 已提交
908 909
	}

910
	ide_read_bcount_and_ireason(drive, &len, &ireason);
911 912

	thislen = blk_fs_request(rq) ? len : rq->data_len;
L
Linus Torvalds 已提交
913 914 915
	if (thislen > len)
		thislen = len;

916 917 918
	ide_debug_log(IDE_DBG_PC, "%s: DRQ: stat: 0x%x, thislen: %d\n",
		      __func__, stat, thislen);

B
Borislav Petkov 已提交
919
	/* If DRQ is clear, the command has completed. */
920
	if ((stat & ATA_DRQ) == 0) {
921 922 923 924 925 926 927
		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) {
928
				printk(KERN_ERR PFX "%s: %s: data underrun "
929
						"(%d blocks)\n",
930
						drive->name, __func__,
931 932 933 934 935 936 937 938
						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)) {
939
			ide_cd_request_sense_fixup(drive, rq);
B
Borislav Petkov 已提交
940
			/* complain if we still have data left to transfer */
941 942 943
			uptodate = rq->data_len ? 0 : 1;
		}
		goto end_request;
944
	}
L
Linus Torvalds 已提交
945

B
Borislav Petkov 已提交
946
	/* check which way to transfer data */
947 948
	if (ide_cd_check_ireason(drive, rq, len, ireason, write))
		return ide_stopped;
949

950 951
	if (blk_fs_request(rq)) {
		if (write == 0) {
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
			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) {
967
				ide_pad_transfer(drive, write, nskip << 9);
968 969 970 971
				rq->current_nr_sectors -= nskip;
				thislen -= (nskip << 9);
			}
		}
972
	}
L
Linus Torvalds 已提交
973

974 975
	if (ireason == 0) {
		write = 1;
976
		xferfunc = hwif->tp_ops->output_data;
977
	} else {
978
		write = 0;
979
		xferfunc = hwif->tp_ops->input_data;
L
Linus Torvalds 已提交
980 981
	}

982 983 984
	ide_debug_log(IDE_DBG_PC, "%s: data transfer, rq->cmd_type: 0x%x, "
		      "ireason: 0x%x\n", __func__, rq->cmd_type, ireason);

B
Borislav Petkov 已提交
985
	/* transfer data */
L
Linus Torvalds 已提交
986
	while (thislen > 0) {
987
		u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
988
		int blen = rq->data_len;
L
Linus Torvalds 已提交
989

B
Borislav Petkov 已提交
990
		/* bio backed? */
L
Linus Torvalds 已提交
991
		if (rq->bio) {
992 993 994 995 996 997 998
			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 已提交
999 1000 1001
		}

		if (!ptr) {
1002 1003
			if (blk_fs_request(rq) && !write)
				/*
1004
				 * If the buffers are full, pipe the rest into
B
Borislav Petkov 已提交
1005 1006
				 * oblivion.
				 */
1007
				ide_pad_transfer(drive, 0, thislen);
1008
			else {
1009
				printk(KERN_ERR PFX "%s: confused, missing data\n",
1010 1011 1012 1013 1014
						drive->name);
				blk_dump_rq_flags(rq, rq_data_dir(rq)
						  ? "cdrom_newpc_intr, write"
						  : "cdrom_newpc_intr, read");
			}
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020
			break;
		}

		if (blen > thislen)
			blen = thislen;

1021
		xferfunc(drive, NULL, ptr, blen);
L
Linus Torvalds 已提交
1022 1023 1024 1025

		thislen -= blen;
		len -= blen;

1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
		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;

1037 1038 1039 1040 1041 1042
			/*
			 * 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().
			 */
1043 1044
			if (rq->bio)
				blk_end_request_callback(rq, 0, blen,
1045
						 cdrom_newpc_intr_dummy_cb);
1046 1047 1048
			else
				rq->data += blen;
		}
A
Andreas Schwab 已提交
1049 1050
		if (!write && blk_sense_request(rq))
			rq->sense_len += blen;
L
Linus Torvalds 已提交
1051 1052
	}

B
Borislav Petkov 已提交
1053
	/* pad, if necessary */
1054
	if (!blk_fs_request(rq) && len > 0)
1055
		ide_pad_transfer(drive, write, len);
L
Linus Torvalds 已提交
1056

1057 1058 1059 1060
	if (blk_pc_request(rq)) {
		timeout = rq->timeout;
	} else {
		timeout = ATAPI_WAIT_PC;
1061
		if (!blk_fs_request(rq))
1062
			expiry = ide_cd_expiry;
1063 1064 1065
	}

	ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
L
Linus Torvalds 已提交
1066
	return ide_started;
1067 1068 1069

end_request:
	if (blk_pc_request(rq)) {
1070 1071 1072 1073
		unsigned int dlen = rq->data_len;

		if (dma)
			rq->data_len = 0;
1074

1075
		if (blk_end_request(rq, 0, dlen))
1076
			BUG();
1077 1078

		hwgroup->rq = NULL;
1079 1080 1081 1082 1083 1084
	} else {
		if (!uptodate)
			rq->cmd_flags |= REQ_FAILED;
		cdrom_end_request(drive, uptodate);
	}
	return ide_stopped;
L
Linus Torvalds 已提交
1085 1086
}

1087
static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1088
{
1089 1090 1091 1092
	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 已提交
1093

B
Borislav Petkov 已提交
1094 1095 1096
	ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, write: 0x%x, "
		      "secs_per_frame: %u\n",
		      __func__, rq->cmd[0], write, sectors_per_frame);
1097

1098
	if (write) {
B
Borislav Petkov 已提交
1099
		/* disk has become write protected */
T
Tejun Heo 已提交
1100
		if (get_disk_ro(cd->disk)) {
1101 1102 1103 1104 1105 1106 1107 1108
			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.
		 */
1109
		ide_cd_restore_request(drive, rq);
L
Linus Torvalds 已提交
1110 1111
	}

B
Borislav Petkov 已提交
1112
	/* use DMA, if possible / writes *must* be hardware frame aligned */
1113 1114 1115 1116 1117 1118
	if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
	    (rq->sector & (sectors_per_frame - 1))) {
		if (write) {
			cdrom_end_request(drive, 0);
			return ide_stopped;
		}
1119
		drive->dma = 0;
1120
	} else
1121
		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
L
Linus Torvalds 已提交
1122

1123 1124
	if (write)
		cd->devinfo.media_written = 1;
L
Linus Torvalds 已提交
1125

1126
	return ide_started;
L
Linus Torvalds 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135
}

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

1136
static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1137 1138
{

B
Borislav Petkov 已提交
1139 1140
	ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, "
		      "rq->cmd_type: 0x%x\n", __func__, rq->cmd[0],
1141 1142
		      rq->cmd_type);

1143 1144 1145 1146
	if (blk_pc_request(rq))
		rq->cmd_flags |= REQ_QUIET;
	else
		rq->cmd_flags &= ~REQ_FAILED;
L
Linus Torvalds 已提交
1147

1148
	drive->dma = 0;
L
Linus Torvalds 已提交
1149

B
Borislav Petkov 已提交
1150
	/* sg request */
1151 1152 1153
	if (rq->bio || ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
		struct request_queue *q = drive->queue;
		unsigned int alignment;
1154
		char *buf;
L
Linus Torvalds 已提交
1155

1156
		if (rq->bio)
1157
			buf = bio_data(rq->bio);
1158
		else
1159
			buf = rq->data;
1160

1161
		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
L
Linus Torvalds 已提交
1162 1163 1164

		/*
		 * check if dma is safe
1165 1166 1167
		 *
		 * NOTE! The "len" and "addr" checks should possibly have
		 * separate masks.
L
Linus Torvalds 已提交
1168
		 */
1169
		alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1170 1171
		if ((unsigned long)buf & alignment
		    || rq->data_len & q->dma_pad_mask
1172
		    || object_is_on_stack(buf))
1173
			drive->dma = 0;
L
Linus Torvalds 已提交
1174 1175 1176
	}
}

1177
static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
1178
					sector_t block)
L
Linus Torvalds 已提交
1179
{
1180
	ide_handler_t *fn;
L
Linus Torvalds 已提交
1181

B
Borislav Petkov 已提交
1182 1183 1184 1185
	ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, "
		      "rq->cmd_type: 0x%x, block: %llu\n",
		      __func__, rq->cmd[0], rq->cmd_type,
		      (unsigned long long)block);
1186

L
Linus Torvalds 已提交
1187
	if (blk_fs_request(rq)) {
1188
		fn = cdrom_start_rw_cont;
1189

1190 1191
		if (cdrom_start_rw(drive, rq) == ide_stopped)
			return ide_stopped;
1192

1193 1194
		if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
			return ide_stopped;
1195
	} else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1196
		   rq->cmd_type == REQ_TYPE_ATA_PC) {
1197
		fn = cdrom_do_newpc_cont;
1198 1199 1200 1201

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

1202
		cdrom_do_block_pc(drive, rq);
1203
	} else if (blk_special_request(rq)) {
B
Borislav Petkov 已提交
1204
		/* right now this can only be a reset... */
L
Linus Torvalds 已提交
1205 1206
		cdrom_end_request(drive, 1);
		return ide_stopped;
1207
	} else {
1208
		blk_dump_rq_flags(rq, DRV_NAME " bad flags");
1209 1210
		cdrom_end_request(drive, 0);
		return ide_stopped;
L
Linus Torvalds 已提交
1211
	}
1212

1213
	return cdrom_start_packet_command(drive, fn);
L
Linus Torvalds 已提交
1214 1215
}

B
Borislav Petkov 已提交
1216
/*
L
Linus Torvalds 已提交
1217 1218
 * Ioctl handling.
 *
B
Borislav Petkov 已提交
1219 1220 1221 1222 1223
 * 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 已提交
1224
 */
1225
static void msf_from_bcd(struct atapi_msf *msf)
L
Linus Torvalds 已提交
1226
{
A
Adrian Bunk 已提交
1227 1228 1229
	msf->minute = bcd2bin(msf->minute);
	msf->second = bcd2bin(msf->second);
	msf->frame  = bcd2bin(msf->frame);
L
Linus Torvalds 已提交
1230 1231
}

1232
int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1233 1234 1235
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
1236
	unsigned char cmd[BLK_MAX_CDB];
L
Linus Torvalds 已提交
1237

1238 1239
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1240 1241
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_TEST_UNIT_READY;
L
Linus Torvalds 已提交
1242

1243
	/*
B
Borislav Petkov 已提交
1244 1245
	 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
	 * instead of supporting the LOAD_UNLOAD opcode.
1246
	 */
1247
	cmd[7] = cdi->sanyo_slot % 3;
L
Linus Torvalds 已提交
1248

1249
	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1250 1251 1252 1253 1254 1255 1256
}

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
			       unsigned long *sectors_per_frame,
			       struct request_sense *sense)
{
	struct {
1257 1258
		__be32 lba;
		__be32 blocklen;
L
Linus Torvalds 已提交
1259 1260 1261
	} capbuf;

	int stat;
1262 1263
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(capbuf);
1264
	u32 blocklen;
L
Linus Torvalds 已提交
1265

1266 1267
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1268 1269
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_READ_CDVD_CAPACITY;
L
Linus Torvalds 已提交
1270

1271 1272
	stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
			       REQ_QUIET);
1273 1274 1275 1276 1277 1278
	if (stat)
		return stat;

	/*
	 * Sanity check the given block size
	 */
1279 1280 1281 1282 1283 1284
	blocklen = be32_to_cpu(capbuf.blocklen);
	switch (blocklen) {
	case 512:
	case 1024:
	case 2048:
	case 4096:
1285 1286
		break;
	default:
1287 1288 1289 1290
		printk(KERN_ERR PFX "%s: weird block size %u\n",
				drive->name, blocklen);
		printk(KERN_ERR PFX "%s: default to 2kb block size\n",
				drive->name);
1291
		blocklen = 2048;
1292
		break;
L
Linus Torvalds 已提交
1293 1294
	}

1295
	*capacity = 1 + be32_to_cpu(capbuf.lba);
1296
	*sectors_per_frame = blocklen >> SECTOR_BITS;
B
Borislav Petkov 已提交
1297 1298 1299 1300

	ide_debug_log(IDE_DBG_PROBE, "%s: cap: %lu, sectors_per_frame: %lu\n",
		      __func__, *capacity, *sectors_per_frame);

1301
	return 0;
L
Linus Torvalds 已提交
1302 1303 1304 1305 1306 1307
}

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

1310 1311
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1312
	memset(cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1313

1314 1315 1316 1317 1318
	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 已提交
1319 1320

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

1323
	return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1324 1325 1326
}

/* Try to read the entire TOC for the disk into our internal buffer. */
1327
int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
{
	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;

1340 1341
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

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

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

1359
	if (drive->atapi_flags & IDE_AFLAG_TOC_VALID)
L
Linus Torvalds 已提交
1360 1361
		return 0;

B
Borislav Petkov 已提交
1362
	/* try to get the total cdrom capacity and sector size */
L
Linus Torvalds 已提交
1363 1364 1365 1366 1367 1368
	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 已提交
1369
	/* save a private copy of the TOC capacity for error handling */
A
Alan Cox 已提交
1370 1371
	drive->probed_capacity = toc->capacity * sectors_per_frame;

L
Linus Torvalds 已提交
1372 1373 1374
	blk_queue_hardsect_size(drive->queue,
				sectors_per_frame << SECTOR_BITS);

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

1381
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1382 1383
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1384 1385 1386 1387 1388 1389 1390 1391
	}

	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 已提交
1392
	/* now read the whole schmeer */
L
Linus Torvalds 已提交
1393 1394 1395 1396 1397 1398 1399
	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 已提交
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
		/*
		 * 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 已提交
1412 1413 1414 1415 1416 1417 1418
		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);
1419
		if (stat)
L
Linus Torvalds 已提交
1420
			return stat;
1421

1422
		if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1423 1424
			toc->hdr.first_track = (u8)bin2bcd(CDROM_LEADOUT);
			toc->hdr.last_track = (u8)bin2bcd(CDROM_LEADOUT);
1425
		} else {
L
Linus Torvalds 已提交
1426 1427 1428 1429 1430 1431 1432 1433
			toc->hdr.first_track = CDROM_LEADOUT;
			toc->hdr.last_track = CDROM_LEADOUT;
		}
	}

	if (stat)
		return stat;

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

1436
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1437 1438
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1439 1440
	}

1441
	for (i = 0; i <= ntracks; i++) {
1442 1443
		if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
			if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD)
A
Adrian Bunk 已提交
1444
				toc->ent[i].track = bcd2bin(toc->ent[i].track);
L
Linus Torvalds 已提交
1445 1446
			msf_from_bcd(&toc->ent[i].addr.msf);
		}
1447 1448 1449
		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 已提交
1450 1451 1452
	}

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

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

1466
	if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
B
Borislav Petkov 已提交
1467
		/* re-read multisession information using MSF format */
L
Linus Torvalds 已提交
1468 1469 1470 1471 1472
		stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
		if (stat)
			return stat;

1473
		msf_from_bcd(&ms_tmp.ent.addr.msf);
L
Linus Torvalds 已提交
1474
		toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1475
						   ms_tmp.ent.addr.msf.second,
L
Linus Torvalds 已提交
1476 1477 1478 1479 1480
						   ms_tmp.ent.addr.msf.frame);
	}

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

B
Borislav Petkov 已提交
1481
	/* now try to get the total cdrom capacity */
L
Linus Torvalds 已提交
1482 1483 1484 1485
	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 已提交
1486
		drive->probed_capacity = toc->capacity * sectors_per_frame;
L
Linus Torvalds 已提交
1487 1488 1489
	}

	/* Remember that we've read this stuff. */
1490
	drive->atapi_flags |= IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
1491 1492 1493 1494

	return 0;
}

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

1502 1503
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1504
	if ((drive->atapi_flags & IDE_AFLAG_FULL_CAPS_PAGE) == 0)
1505
		size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
E
Eric Piel 已提交
1506

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

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

1522 1523
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1524
	if (drive->atapi_flags & IDE_AFLAG_LE_SPEED_FIELDS) {
1525 1526
		curspeed = le16_to_cpup((__le16 *)&buf[8 + 14]);
		maxspeed = le16_to_cpup((__le16 *)&buf[8 + 8]);
E
Eric Piel 已提交
1527
	} else {
1528 1529
		curspeed = be16_to_cpup((__be16 *)&buf[8 + 14]);
		maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
E
Eric Piel 已提交
1530
	}
1531

B
Borislav Petkov 已提交
1532 1533 1534
	ide_debug_log(IDE_DBG_PROBE, "%s: curspeed: %u, maxspeed: %u\n",
		      __func__, curspeed, maxspeed);

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
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *devinfo = &info->devinfo;

1567 1568
	ide_debug_log(IDE_DBG_PROBE, "Call %s, nslots: %d\n", __func__, nslots);

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

1575
	if (drive->atapi_flags & IDE_AFLAG_NO_SPEED_SELECT)
1576 1577
		devinfo->mask |= CDC_SELECT_SPEED;

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

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

1590 1591 1592 1593
	ide_debug_log(IDE_DBG_PROBE, "Call %s, drive->media: 0x%x, "
		      "drive->atapi_flags: 0x%lx\n", __func__, drive->media,
		      drive->atapi_flags);

1594 1595 1596 1597
	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 已提交
1598
	if (drive->media == ide_optical) {
1599
		cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1600
		printk(KERN_ERR PFX "%s: ATAPI magneto-optical drive\n",
1601
				drive->name);
L
Linus Torvalds 已提交
1602 1603 1604
		return nslots;
	}

1605 1606
	if (drive->atapi_flags & IDE_AFLAG_PRE_ATAPI12) {
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1607
		cdi->mask &= ~CDC_PLAY_AUDIO;
L
Linus Torvalds 已提交
1608 1609 1610 1611
		return nslots;
	}

	/*
B
Borislav Petkov 已提交
1612 1613 1614 1615
	 * 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 已提交
1616
	 */
J
Jesper Juhl 已提交
1617
	cdi->handle = drive;
L
Linus Torvalds 已提交
1618 1619
	cdi->ops = &ide_cdrom_dops;

1620
	if (ide_cdrom_get_capabilities(drive, buf))
L
Linus Torvalds 已提交
1621 1622
		return 0;

1623
	if ((buf[8 + 6] & 0x01) == 0)
1624
		drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
1625
	if (buf[8 + 6] & 0x08)
1626
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1627
	if (buf[8 + 3] & 0x01)
1628
		cdi->mask &= ~CDC_CD_R;
1629
	if (buf[8 + 3] & 0x02)
1630
		cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1631
	if (buf[8 + 2] & 0x38)
1632
		cdi->mask &= ~CDC_DVD;
1633
	if (buf[8 + 3] & 0x20)
1634
		cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1635
	if (buf[8 + 3] & 0x10)
1636
		cdi->mask &= ~CDC_DVD_R;
1637
	if ((buf[8 + 4] & 0x01) || (drive->atapi_flags & IDE_AFLAG_PLAY_AUDIO_OK))
1638
		cdi->mask &= ~CDC_PLAY_AUDIO;
1639 1640

	mechtype = buf[8 + 6] >> 5;
B
Borislav Petkov 已提交
1641 1642 1643
	if (mechtype == mechtype_caddy ||
	    mechtype == mechtype_popup ||
	    (drive->atapi_flags & IDE_AFLAG_NO_AUTOCLOSE))
1644
		cdi->mask |= CDC_CLOSE_TRAY;
L
Linus Torvalds 已提交
1645 1646

	if (cdi->sanyo_slot > 0) {
1647
		cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1648
		nslots = 3;
1649 1650
	} else if (mechtype == mechtype_individual_changer ||
		   mechtype == mechtype_cartridge_changer) {
1651 1652
		nslots = cdrom_number_of_slots(cdi);
		if (nslots > 1)
1653
			cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1654 1655
	}

1656
	ide_cdrom_update_speed(drive, buf);
1657

1658
	printk(KERN_INFO PFX "%s: ATAPI", drive->name);
1659 1660

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

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

1666 1667 1668
	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",
1669
				 (cdi->mask & CDC_DVD_RAM) ? "" : "/RAM");
L
Linus Torvalds 已提交
1670

1671 1672 1673 1674
	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 已提交
1675

1676 1677 1678 1679
	if ((cdi->mask & CDC_SELECT_DISC) == 0)
		printk(KERN_CONT " changer w/%d slots", nslots);
	else
		printk(KERN_CONT " drive");
L
Linus Torvalds 已提交
1680

1681 1682
	printk(KERN_CONT ", %dkB Cache\n",
			 be16_to_cpup((__be16 *)&buf[8 + 12]));
L
Linus Torvalds 已提交
1683 1684 1685 1686

	return nslots;
}

B
Borislav Petkov 已提交
1687
/* standard prep_rq_fn that builds 10 byte cmds */
1688
static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1689 1690 1691 1692 1693
{
	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);

1694
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725

	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 已提交
1726
	/* transform 6-byte read/write commands to the 10-byte version */
L
Linus Torvalds 已提交
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747
	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;
	}
1748

L
Linus Torvalds 已提交
1749 1750 1751
	return BLKPREP_OK;
}

1752
static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1753
{
1754
	if (blk_fs_request(rq))
L
Linus Torvalds 已提交
1755
		return ide_cdrom_prep_fs(q, rq);
1756
	else if (blk_pc_request(rq))
L
Linus Torvalds 已提交
1757 1758 1759 1760 1761
		return ide_cdrom_prep_pc(rq);

	return 0;
}

1762 1763 1764 1765 1766 1767
struct cd_list_entry {
	const char	*id_model;
	const char	*id_firmware;
	unsigned int	cd_flags;
};

1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
#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;
}

1779 1780
static int proc_idecd_read_capacity(char *page, char **start, off_t off,
					int count, int *eof, void *data)
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 }
};

1794 1795 1796 1797 1798 1799 1800
static ide_proc_entry_t *ide_cd_proc_entries(ide_drive_t *drive)
{
	return idecd_proc;
}

static const struct ide_proc_devset *ide_cd_proc_devsets(ide_drive_t *drive)
{
1801
	return NULL;
1802
}
1803 1804
#endif

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

1850
static unsigned int ide_cd_flags(u16 *id)
1851 1852 1853 1854
{
	const struct cd_list_entry *cle = ide_cd_quirks_list;

	while (cle->id_model) {
1855
		if (strcmp(cle->id_model, (char *)&id[ATA_ID_PROD]) == 0 &&
1856
		    (cle->id_firmware == NULL ||
1857
		     strstr((char *)&id[ATA_ID_FW_REV], cle->id_firmware)))
1858 1859 1860 1861 1862 1863 1864
			return cle->cd_flags;
		cle++;
	}

	return 0;
}

1865
static int ide_cdrom_setup(ide_drive_t *drive)
L
Linus Torvalds 已提交
1866
{
1867 1868
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1869 1870
	u16 *id = drive->id;
	char *fw_rev = (char *)&id[ATA_ID_FW_REV];
L
Linus Torvalds 已提交
1871 1872
	int nslots;

1873 1874
	ide_debug_log(IDE_DBG_PROBE, "Call %s\n", __func__);

L
Linus Torvalds 已提交
1875 1876
	blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
	blk_queue_dma_alignment(drive->queue, 31);
1877
	blk_queue_update_dma_pad(drive->queue, 15);
L
Linus Torvalds 已提交
1878 1879 1880 1881
	drive->queue->unplug_delay = (1 * HZ) / 1000;
	if (!drive->queue->unplug_delay)
		drive->queue->unplug_delay = 1;

1882 1883
	drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
	drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id);
L
Linus Torvalds 已提交
1884

1885
	if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
1886
	    fw_rev[4] == '1' && fw_rev[6] <= '2')
1887 1888 1889
		drive->atapi_flags |= (IDE_AFLAG_TOCTRACKS_AS_BCD |
				     IDE_AFLAG_TOCADDR_AS_BCD);
	else if ((drive->atapi_flags & IDE_AFLAG_VERTOS_600_ESD) &&
1890
		 fw_rev[4] == '1' && fw_rev[6] <= '2')
1891 1892
		drive->atapi_flags |= IDE_AFLAG_TOCTRACKS_AS_BCD;
	else if (drive->atapi_flags & IDE_AFLAG_SANYO_3CD)
B
Borislav Petkov 已提交
1893 1894
		/* 3 => use CD in slot 0 */
		cdi->sanyo_slot = 3;
L
Linus Torvalds 已提交
1895

1896
	nslots = ide_cdrom_probe_capabilities(drive);
L
Linus Torvalds 已提交
1897

B
Borislav Petkov 已提交
1898
	/* set correct block size */
L
Linus Torvalds 已提交
1899 1900 1901
	blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);

	if (ide_cdrom_register(drive, nslots)) {
1902
		printk(KERN_ERR PFX "%s: %s failed to register device with the"
1903
				" cdrom driver.\n", drive->name, __func__);
1904
		cd->devinfo.handle = NULL;
L
Linus Torvalds 已提交
1905 1906
		return 1;
	}
1907 1908

	ide_proc_register_driver(drive, cd->driver);
L
Linus Torvalds 已提交
1909 1910 1911
	return 0;
}

1912
static void ide_cd_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
1913 1914 1915
{
	struct cdrom_info *info = drive->driver_data;

1916 1917
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1918
	ide_proc_unregister_driver(drive, info->driver);
L
Linus Torvalds 已提交
1919 1920 1921 1922 1923 1924 1925 1926

	del_gendisk(info->disk);

	ide_cd_put(info);
}

static void ide_cd_release(struct kref *kref)
{
B
Borislav Petkov 已提交
1927
	struct cdrom_info *info = to_ide_drv(kref, cdrom_info);
L
Linus Torvalds 已提交
1928 1929 1930 1931
	struct cdrom_device_info *devinfo = &info->devinfo;
	ide_drive_t *drive = info->drive;
	struct gendisk *g = info->disk;

1932 1933
	ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);

1934
	kfree(info->toc);
1935 1936
	if (devinfo->handle == drive)
		unregister_cdrom(devinfo);
L
Linus Torvalds 已提交
1937 1938 1939 1940 1941 1942 1943
	drive->driver_data = NULL;
	blk_queue_prep_rq(drive->queue, NULL);
	g->private_data = NULL;
	put_disk(g);
	kfree(info);
}

1944
static int ide_cd_probe(ide_drive_t *);
L
Linus Torvalds 已提交
1945 1946

static ide_driver_t ide_cdrom_driver = {
1947
	.gen_driver = {
1948
		.owner		= THIS_MODULE,
1949 1950 1951
		.name		= "ide-cdrom",
		.bus		= &ide_bus_type,
	},
1952 1953
	.probe			= ide_cd_probe,
	.remove			= ide_cd_remove,
L
Linus Torvalds 已提交
1954
	.version		= IDECD_VERSION,
1955
	.do_request		= ide_cd_do_request,
L
Linus Torvalds 已提交
1956 1957
	.end_request		= ide_end_request,
	.error			= __ide_error,
1958
#ifdef CONFIG_IDE_PROC_FS
1959 1960
	.proc_entries		= ide_cd_proc_entries,
	.proc_devsets		= ide_cd_proc_devsets,
1961
#endif
L
Linus Torvalds 已提交
1962 1963
};

A
Al Viro 已提交
1964
static int idecd_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
1965
{
A
Al Viro 已提交
1966
	struct cdrom_info *info = ide_cd_get(bdev->bd_disk);
L
Linus Torvalds 已提交
1967 1968
	int rc = -ENOMEM;

1969
	if (!info)
L
Linus Torvalds 已提交
1970 1971
		return -ENXIO;

A
Al Viro 已提交
1972
	rc = cdrom_open(&info->devinfo, bdev, mode);
L
Linus Torvalds 已提交
1973 1974 1975 1976 1977 1978 1979

	if (rc < 0)
		ide_cd_put(info);

	return rc;
}

A
Al Viro 已提交
1980
static int idecd_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
1981
{
B
Borislav Petkov 已提交
1982
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
1983

A
Al Viro 已提交
1984
	cdrom_release(&info->devinfo, mode);
L
Linus Torvalds 已提交
1985 1986 1987 1988 1989 1990

	ide_cd_put(info);

	return 0;
}

1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015
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;
2016
	char spindown;
2017 2018 2019 2020 2021 2022 2023 2024

	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;
2025
	if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
2026 2027 2028 2029
		return -EFAULT;
	return 0;
}

A
Al Viro 已提交
2030
static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
2031 2032
			unsigned int cmd, unsigned long arg)
{
B
Borislav Petkov 已提交
2033
	struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info);
L
Linus Torvalds 已提交
2034 2035
	int err;

2036
	switch (cmd) {
2037
	case CDROMSETSPINDOWN:
2038
		return idecd_set_spindown(&info->devinfo, arg);
2039
	case CDROMGETSPINDOWN:
2040 2041 2042
		return idecd_get_spindown(&info->devinfo, arg);
	default:
		break;
2043
	}
2044

2045
	err = generic_ide_ioctl(info->drive, bdev, cmd, arg);
L
Linus Torvalds 已提交
2046
	if (err == -EINVAL)
A
Al Viro 已提交
2047
		err = cdrom_ioctl(&info->devinfo, bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
2048 2049 2050 2051 2052 2053

	return err;
}

static int idecd_media_changed(struct gendisk *disk)
{
B
Borislav Petkov 已提交
2054
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2055 2056 2057 2058 2059
	return cdrom_media_changed(&info->devinfo);
}

static int idecd_revalidate_disk(struct gendisk *disk)
{
B
Borislav Petkov 已提交
2060
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2061
	struct request_sense sense;
2062 2063 2064

	ide_cd_read_toc(info->drive, &sense);

L
Linus Torvalds 已提交
2065 2066 2067 2068
	return  0;
}

static struct block_device_operations idecd_ops = {
2069
	.owner			= THIS_MODULE,
A
Al Viro 已提交
2070 2071 2072
	.open			= idecd_open,
	.release		= idecd_release,
	.locked_ioctl		= idecd_ioctl,
2073 2074
	.media_changed		= idecd_media_changed,
	.revalidate_disk	= idecd_revalidate_disk
L
Linus Torvalds 已提交
2075 2076
};

B
Borislav Petkov 已提交
2077
/* module options */
2078
static char *ignore;
L
Linus Torvalds 已提交
2079
module_param(ignore, charp, 0400);
2080 2081 2082 2083

static unsigned long debug_mask;
module_param(debug_mask, ulong, 0644);

L
Linus Torvalds 已提交
2084 2085
MODULE_DESCRIPTION("ATAPI CD-ROM Driver");

2086
static int ide_cd_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
2087 2088 2089 2090 2091
{
	struct cdrom_info *info;
	struct gendisk *g;
	struct request_sense sense;

2092 2093 2094 2095
	ide_debug_log(IDE_DBG_PROBE, "Call %s, drive->driver_req: %s, "
		      "drive->media: 0x%x\n", __func__, drive->driver_req,
		      drive->media);

L
Linus Torvalds 已提交
2096 2097
	if (!strstr("ide-cdrom", drive->driver_req))
		goto failed;
2098

L
Linus Torvalds 已提交
2099 2100
	if (drive->media != ide_cdrom && drive->media != ide_optical)
		goto failed;
2101

L
Linus Torvalds 已提交
2102 2103 2104
	/* skip drives that we were told to ignore */
	if (ignore != NULL) {
		if (strstr(ignore, drive->name)) {
2105
			printk(KERN_INFO PFX "ignoring drive %s\n",
2106
					 drive->name);
L
Linus Torvalds 已提交
2107 2108 2109
			goto failed;
		}
	}
2110 2111 2112

	drive->debug_mask = debug_mask;

2113
	info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
L
Linus Torvalds 已提交
2114
	if (info == NULL) {
2115
		printk(KERN_ERR PFX "%s: Can't allocate a cdrom structure\n",
2116
				drive->name);
L
Linus Torvalds 已提交
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
		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)) {
2140
		ide_cd_release(&info->kref);
L
Linus Torvalds 已提交
2141 2142 2143
		goto failed;
	}

2144
	ide_cd_read_toc(drive, &sense);
L
Linus Torvalds 已提交
2145 2146 2147 2148 2149 2150 2151 2152
	g->fops = &idecd_ops;
	g->flags |= GENHD_FL_REMOVABLE;
	add_disk(g);
	return 0;

out_free_cd:
	kfree(info);
failed:
2153
	return -ENODEV;
L
Linus Torvalds 已提交
2154 2155 2156 2157
}

static void __exit ide_cdrom_exit(void)
{
2158
	driver_unregister(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2159
}
2160 2161

static int __init ide_cdrom_init(void)
L
Linus Torvalds 已提交
2162
{
2163
	printk(KERN_INFO DRV_NAME " driver " IDECD_VERSION "\n");
2164
	return driver_register(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2165 2166
}

2167
MODULE_ALIAS("ide:*m-cdrom*");
2168
MODULE_ALIAS("ide-cd");
L
Linus Torvalds 已提交
2169 2170 2171
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);
MODULE_LICENSE("GPL");