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

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

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

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

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

#include "ide-cd.h"

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

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

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

60 61
static void ide_cd_release(struct kref *);

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

66
	mutex_lock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
67
	cd = ide_cd_g(disk);
68
	if (cd) {
69
		if (ide_device_get(cd->drive))
70
			cd = NULL;
71 72 73
		else
			kref_get(&cd->kref);

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

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

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

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

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

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

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

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

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

L
Linus Torvalds 已提交
153 154 155 156
	if (!cdrom_log_sense(drive, failed_command, sense))
		return;

	/*
B
Borislav Petkov 已提交
157 158 159
	 * 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 已提交
160 161 162 163 164
	 */
	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
		if (sense->sense_key == 0x05 && sense->asc == 0x24)
			return;

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

			bio_sectors = max(bio_sectors(failed_command->bio), 4U);
186
			sector &= ~(bio_sectors - 1);
A
Alan Cox 已提交
187 188

			if (sector < get_capacity(info->disk) &&
189
			    drive->probed_capacity - sector < 4 * 75)
A
Alan Cox 已提交
190
				set_capacity(info->disk, sector);
191 192
		}
	}
L
Linus Torvalds 已提交
193

194
	ide_cd_log_error(drive->name, failed_command, sense);
L
Linus Torvalds 已提交
195 196 197 198 199 200 201 202 203 204 205 206
}

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 已提交
207 208 209
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_ATA_PC;
	rq->rq_disk = info->disk;
L
Linus Torvalds 已提交
210 211 212

	rq->data = sense;
	rq->cmd[0] = GPCMD_REQUEST_SENSE;
213 214
	rq->cmd[4] = 18;
	rq->data_len = 18;
L
Linus Torvalds 已提交
215

216
	rq->cmd_type = REQ_TYPE_SENSE;
217
	rq->cmd_flags |= REQ_PREEMPT;
L
Linus Torvalds 已提交
218 219 220 221

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

222
	ide_do_drive_cmd(drive, rq);
L
Linus Torvalds 已提交
223 224
}

225
static void cdrom_end_request(ide_drive_t *drive, int uptodate)
L
Linus Torvalds 已提交
226 227 228 229
{
	struct request *rq = HWGROUP(drive)->rq;
	int nsectors = rq->hard_cur_sectors;

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

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

275
static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 st)
A
Alan Cox 已提交
276
{
277
	if (st & 0x80)
A
Alan Cox 已提交
278
		return;
279
	ide_dump_status(drive, msg, st);
A
Alan Cox 已提交
280 281
}

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

B
Borislav Petkov 已提交
293
	/* check for errors */
294
	stat = hwif->tp_ops->read_status(hwif);
295

L
Linus Torvalds 已提交
296 297 298 299 300 301
	if (stat_ret)
		*stat_ret = stat;

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

B
Borislav Petkov 已提交
302
	/* get the IDE error register */
303
	err = ide_read_error(drive);
L
Linus Torvalds 已提交
304 305 306
	sense_key = err >> 4;

	if (rq == NULL) {
307 308
		printk(KERN_ERR "%s: missing rq in %s\n",
				drive->name, __func__);
L
Linus Torvalds 已提交
309 310 311
		return 1;
	}

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

323
	} else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
L
Linus Torvalds 已提交
324 325 326 327 328 329
		/* All other functions, except for READ. */

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

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

354
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
355 356 357 358 359 360

		/*
		 * instead of playing games with moving completions around,
		 * remove failed request completely and end it when the
		 * request sense has completed
		 */
361
		goto end_request;
L
Linus Torvalds 已提交
362 363 364 365

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

B
Borislav Petkov 已提交
366
		/* handle errors from READ and WRITE requests */
L
Linus Torvalds 已提交
367 368 369 370 371

		if (blk_noretry_request(rq))
			do_end_request = 1;

		if (sense_key == NOT_READY) {
B
Borislav Petkov 已提交
372
			/* tray open */
L
Linus Torvalds 已提交
373
			if (rq_data_dir(rq) == READ) {
374
				cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
375

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

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

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

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

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

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

B
Borislav Petkov 已提交
467
	/* retry, or handle the next request */
L
Linus Torvalds 已提交
468
	return 1;
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483

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

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

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

	return 1;
L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491
}

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

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

B
Borislav Petkov 已提交
515 516 517 518 519 520 521 522
/*
 * 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 已提交
523 524 525 526 527 528 529
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;

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

B
Borislav Petkov 已提交
534
	/* set up the controller registers */
535 536
	ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL,
			   xferlen, info->dma);
537

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

L
Linus Torvalds 已提交
543
		/* packet command */
544 545
		ide_execute_command(drive, WIN_PACKETCMD, handler,
				    ATAPI_WAIT_PC, cdrom_timer_expiry);
L
Linus Torvalds 已提交
546 547
		return ide_started;
	} else {
548
		ide_execute_pkt_cmd(drive);
L
Linus Torvalds 已提交
549 550 551 552 553

		return (*handler) (drive);
	}
}

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

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

B
Borislav Petkov 已提交
576
		/* check for errors */
L
Linus Torvalds 已提交
577 578
		if (cdrom_decode_status(drive, DRQ_STAT, NULL))
			return ide_stopped;
579

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

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

B
Borislav Petkov 已提交
601
	/* start the DMA if need be */
L
Linus Torvalds 已提交
602
	if (info->dma)
603
		hwif->dma_ops->dma_start(drive);
L
Linus Torvalds 已提交
604 605 606 607 608 609 610 611 612

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

618 619 620 621 622
	/*
	 * 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 已提交
623
		return 0;
624
	else if (ireason == (rw << 1)) {
625

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

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

644 645 646
	if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags |= REQ_FAILED;

L
Linus Torvalds 已提交
647 648 649 650
	cdrom_end_request(drive, 0);
	return -1;
}

651 652 653 654 655 656 657 658 659 660
/*
 * 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",
661
			drive->name, __func__, len);
662

663
	if (drive->atapi_flags & IDE_AFLAG_LIMIT_NFRAMES)
664 665 666 667
		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");
668
		drive->atapi_flags |= IDE_AFLAG_LIMIT_NFRAMES;
669 670 671 672 673
	}

	return 1;
}

674
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
675

676 677
static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
						 struct request *rq)
L
Linus Torvalds 已提交
678
{
679 680 681 682
	if (rq_data_dir(rq) == READ) {
		unsigned short sectors_per_frame =
			queue_hardsect_size(drive->queue) >> SECTOR_BITS;
		int nskip = rq->sector & (sectors_per_frame - 1);
L
Linus Torvalds 已提交
683

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

715 716 717 718 719 720 721 722 723 724 725 726 727
	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 已提交
728
	/* send the command to the drive and return */
729
	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
L
Linus Torvalds 已提交
730 731 732 733 734 735
}

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

736
static ide_startstop_t cdrom_seek_intr(ide_drive_t *drive)
L
Linus Torvalds 已提交
737 738 739 740 741 742 743
{
	struct cdrom_info *info = drive->driver_data;
	int stat;
	static int retry = 10;

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

745
	drive->atapi_flags |= IDE_AFLAG_SEEKING;
L
Linus Torvalds 已提交
746 747

	if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
B
Borislav Petkov 已提交
748
		if (--retry == 0)
L
Linus Torvalds 已提交
749 750 751 752 753
			drive->dsc_overlap = 0;
	}
	return ide_stopped;
}

754
static void ide_cd_prepare_seek_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
755 756 757 758 759
{
	sector_t frame = rq->sector;

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

760
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
761 762 763 764
	rq->cmd[0] = GPCMD_SEEK;
	put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);

	rq->timeout = ATAPI_WAIT_PC;
765 766 767 768 769 770
}

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

L
Linus Torvalds 已提交
771 772 773
	return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
}

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

		rq->buffer = bio_data(rq->bio);
		rq->nr_sectors += n;
		rq->sector -= n;
	}
788 789
	rq->current_nr_sectors = bio_cur_sectors(rq->bio);
	rq->hard_cur_sectors = rq->current_nr_sectors;
L
Linus Torvalds 已提交
790 791 792 793 794
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
	rq->q->prep_rq_fn(rq->q, rq);
}

B
Borislav Petkov 已提交
795 796
/*
 * All other packet commands.
L
Linus Torvalds 已提交
797
 */
798 799 800 801 802 803 804 805 806 807 808 809 810 811
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;
		}
}

812 813 814 815
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 已提交
816
{
817 818
	struct cdrom_info *info = drive->driver_data;
	struct request_sense local_sense;
L
Linus Torvalds 已提交
819
	int retries = 10;
820
	unsigned int flags = 0;
L
Linus Torvalds 已提交
821

822 823
	if (!sense)
		sense = &local_sense;
L
Linus Torvalds 已提交
824

B
Borislav Petkov 已提交
825
	/* start of retry loop */
L
Linus Torvalds 已提交
826
	do {
827
		struct request *rq;
L
Linus Torvalds 已提交
828 829
		int error;

830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
		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 已提交
849

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

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

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

B
Borislav Petkov 已提交
881
	/* return an error if the command failed */
882
	return (flags & REQ_FAILED) ? -EIO : 0;
L
Linus Torvalds 已提交
883 884
}

885
/*
B
Borislav Petkov 已提交
886 887 888
 * 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.
889 890 891 892 893 894
 */
static int cdrom_newpc_intr_dummy_cb(struct request *rq)
{
	return 1;
}

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

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

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

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

934
	ide_read_bcount_and_ireason(drive, &len, &ireason);
935 936

	thislen = blk_fs_request(rq) ? len : rq->data_len;
L
Linus Torvalds 已提交
937 938 939
	if (thislen > len)
		thislen = len;

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

B
Borislav Petkov 已提交
967
	/* check which way to transfer data */
968 969
	if (ide_cd_check_ireason(drive, rq, len, ireason, write))
		return ide_stopped;
970

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

995 996
	if (ireason == 0) {
		write = 1;
997
		xferfunc = hwif->tp_ops->output_data;
998
	} else {
999
		write = 0;
1000
		xferfunc = hwif->tp_ops->input_data;
L
Linus Torvalds 已提交
1001 1002
	}

B
Borislav Petkov 已提交
1003
	/* transfer data */
L
Linus Torvalds 已提交
1004
	while (thislen > 0) {
1005
		u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1006
		int blen = rq->data_len;
L
Linus Torvalds 已提交
1007

B
Borislav Petkov 已提交
1008
		/* bio backed? */
L
Linus Torvalds 已提交
1009
		if (rq->bio) {
1010 1011 1012 1013 1014 1015 1016
			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 已提交
1017 1018 1019
		}

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

		if (blen > thislen)
			blen = thislen;

1039
		xferfunc(drive, NULL, ptr, blen);
L
Linus Torvalds 已提交
1040 1041 1042 1043

		thislen -= blen;
		len -= blen;

1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
		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;

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

B
Borislav Petkov 已提交
1071
	/* pad, if necessary */
1072
	if (!blk_fs_request(rq) && len > 0)
1073
		ide_pad_transfer(drive, write, len);
L
Linus Torvalds 已提交
1074

1075 1076 1077 1078
	if (blk_pc_request(rq)) {
		timeout = rq->timeout;
	} else {
		timeout = ATAPI_WAIT_PC;
1079 1080
		if (!blk_fs_request(rq))
			expiry = cdrom_timer_expiry;
1081 1082 1083
	}

	ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
L
Linus Torvalds 已提交
1084
	return ide_started;
1085 1086 1087 1088

end_request:
	if (blk_pc_request(rq)) {
		unsigned long flags;
1089 1090 1091 1092
		unsigned int dlen = rq->data_len;

		if (dma)
			rq->data_len = 0;
1093 1094

		spin_lock_irqsave(&ide_lock, flags);
1095
		if (__blk_end_request(rq, 0, dlen))
1096 1097 1098 1099 1100 1101 1102 1103 1104
			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 已提交
1105 1106
}

1107
static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1108
{
1109 1110 1111 1112
	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 已提交
1113

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

B
Borislav Petkov 已提交
1128
	/* use DMA, if possible / writes *must* be hardware frame aligned */
1129 1130 1131 1132 1133 1134 1135 1136 1137
	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 已提交
1138

1139 1140
	if (write)
		cd->devinfo.media_written = 1;
L
Linus Torvalds 已提交
1141

1142
	return ide_started;
L
Linus Torvalds 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151
}

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

1152
static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1153 1154 1155
{
	struct cdrom_info *info = drive->driver_data;

1156 1157 1158 1159
	if (blk_pc_request(rq))
		rq->cmd_flags |= REQ_QUIET;
	else
		rq->cmd_flags &= ~REQ_FAILED;
L
Linus Torvalds 已提交
1160 1161 1162

	info->dma = 0;

B
Borislav Petkov 已提交
1163
	/* sg request */
1164 1165 1166 1167
	if (rq->bio || ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
		struct request_queue *q = drive->queue;
		unsigned int alignment;
		unsigned long addr;
1168
		unsigned long stack_mask = ~(THREAD_SIZE - 1);
L
Linus Torvalds 已提交
1169

1170 1171 1172 1173 1174
		if (rq->bio)
			addr = (unsigned long)bio_data(rq->bio);
		else
			addr = (unsigned long)rq->data;

L
Linus Torvalds 已提交
1175 1176 1177 1178
		info->dma = drive->using_dma;

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

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

B
Borislav Petkov 已提交
1193
/*
L
Linus Torvalds 已提交
1194 1195
 * cdrom driver request routine.
 */
1196
static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
1197
					sector_t block)
L
Linus Torvalds 已提交
1198 1199
{
	struct cdrom_info *info = drive->driver_data;
1200 1201
	ide_handler_t *fn;
	int xferlen;
L
Linus Torvalds 已提交
1202 1203

	if (blk_fs_request(rq)) {
1204
		if (drive->atapi_flags & IDE_AFLAG_SEEKING) {
1205
			ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
1206
			unsigned long elapsed = jiffies - info->start_seek;
1207
			int stat = hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
1208 1209 1210

			if ((stat & SEEK_STAT) != SEEK_STAT) {
				if (elapsed < IDECD_SEEK_TIMEOUT) {
1211 1212
					ide_stall_queue(drive,
							IDECD_SEEK_TIMER);
L
Linus Torvalds 已提交
1213 1214
					return ide_stopped;
				}
1215 1216
				printk(KERN_ERR "%s: DSC timeout\n",
						drive->name);
L
Linus Torvalds 已提交
1217
			}
1218
			drive->atapi_flags &= ~IDE_AFLAG_SEEKING;
L
Linus Torvalds 已提交
1219
		}
1220 1221
		if (rq_data_dir(rq) == READ &&
		    IDE_LARGE_SEEK(info->last_block, block,
1222 1223 1224 1225
			    IDECD_SEEK_THRESHOLD) &&
		    drive->dsc_overlap) {
			xferlen = 0;
			fn = cdrom_start_seek_continuation;
1226

1227 1228
			info->dma = 0;
			info->start_seek = jiffies;
1229 1230

			ide_cd_prepare_seek_request(drive, rq);
1231 1232 1233
		} else {
			xferlen = 32768;
			fn = cdrom_start_rw_cont;
1234

1235 1236
			if (cdrom_start_rw(drive, rq) == ide_stopped)
				return ide_stopped;
1237 1238 1239

			if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
				return ide_stopped;
1240
		}
L
Linus Torvalds 已提交
1241
		info->last_block = block;
1242
	} else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1243
		   rq->cmd_type == REQ_TYPE_ATA_PC) {
1244 1245
		xferlen = rq->data_len;
		fn = cdrom_do_newpc_cont;
1246 1247 1248 1249

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

1250
		cdrom_do_block_pc(drive, rq);
1251
	} else if (blk_special_request(rq)) {
B
Borislav Petkov 已提交
1252
		/* right now this can only be a reset... */
L
Linus Torvalds 已提交
1253 1254
		cdrom_end_request(drive, 1);
		return ide_stopped;
1255 1256 1257 1258
	} else {
		blk_dump_rq_flags(rq, "ide-cd bad flags");
		cdrom_end_request(drive, 0);
		return ide_stopped;
L
Linus Torvalds 已提交
1259
	}
1260 1261

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

B
Borislav Petkov 已提交
1264
/*
L
Linus Torvalds 已提交
1265 1266
 * Ioctl handling.
 *
B
Borislav Petkov 已提交
1267 1268 1269 1270 1271
 * 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 已提交
1272
 */
1273
static void msf_from_bcd(struct atapi_msf *msf)
L
Linus Torvalds 已提交
1274
{
A
Adrian Bunk 已提交
1275 1276 1277
	msf->minute = bcd2bin(msf->minute);
	msf->second = bcd2bin(msf->second);
	msf->frame  = bcd2bin(msf->frame);
L
Linus Torvalds 已提交
1278 1279
}

1280
int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1281 1282 1283
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
1284
	unsigned char cmd[BLK_MAX_CDB];
L
Linus Torvalds 已提交
1285

1286 1287
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_TEST_UNIT_READY;
L
Linus Torvalds 已提交
1288

1289
	/*
B
Borislav Petkov 已提交
1290 1291
	 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
	 * instead of supporting the LOAD_UNLOAD opcode.
1292
	 */
1293
	cmd[7] = cdi->sanyo_slot % 3;
L
Linus Torvalds 已提交
1294

1295
	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1296 1297 1298 1299 1300 1301 1302
}

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
			       unsigned long *sectors_per_frame,
			       struct request_sense *sense)
{
	struct {
1303 1304
		__be32 lba;
		__be32 blocklen;
L
Linus Torvalds 已提交
1305 1306 1307
	} capbuf;

	int stat;
1308 1309
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(capbuf);
1310
	u32 blocklen;
L
Linus Torvalds 已提交
1311

1312 1313
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_READ_CDVD_CAPACITY;
L
Linus Torvalds 已提交
1314

1315 1316
	stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
			       REQ_QUIET);
1317 1318 1319 1320 1321 1322
	if (stat)
		return stat;

	/*
	 * Sanity check the given block size
	 */
1323 1324 1325 1326 1327 1328
	blocklen = be32_to_cpu(capbuf.blocklen);
	switch (blocklen) {
	case 512:
	case 1024:
	case 2048:
	case 4096:
1329 1330 1331
		break;
	default:
		printk(KERN_ERR "%s: weird block size %u\n",
1332
			drive->name, blocklen);
1333 1334
		printk(KERN_ERR "%s: default to 2kb block size\n",
			drive->name);
1335
		blocklen = 2048;
1336
		break;
L
Linus Torvalds 已提交
1337 1338
	}

1339
	*capacity = 1 + be32_to_cpu(capbuf.lba);
1340
	*sectors_per_frame = blocklen >> SECTOR_BITS;
1341
	return 0;
L
Linus Torvalds 已提交
1342 1343 1344 1345 1346 1347
}

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

1350
	memset(cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1351

1352 1353 1354 1355 1356
	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 已提交
1357 1358

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

1361
	return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1362 1363 1364
}

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

B
Borislav Petkov 已提交
1389 1390 1391 1392
	/*
	 * Check to see if the existing data is still valid. If it is,
	 * just return.
	 */
L
Linus Torvalds 已提交
1393 1394
	(void) cdrom_check_status(drive, sense);

1395
	if (drive->atapi_flags & IDE_AFLAG_TOC_VALID)
L
Linus Torvalds 已提交
1396 1397
		return 0;

B
Borislav Petkov 已提交
1398
	/* try to get the total cdrom capacity and sector size */
L
Linus Torvalds 已提交
1399 1400 1401 1402 1403 1404
	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 已提交
1405
	/* save a private copy of the TOC capacity for error handling */
A
Alan Cox 已提交
1406 1407
	drive->probed_capacity = toc->capacity * sectors_per_frame;

L
Linus Torvalds 已提交
1408 1409 1410
	blk_queue_hardsect_size(drive->queue,
				sectors_per_frame << SECTOR_BITS);

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

1417
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1418 1419
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1420 1421 1422 1423 1424 1425 1426 1427
	}

	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 已提交
1428
	/* now read the whole schmeer */
L
Linus Torvalds 已提交
1429 1430 1431 1432 1433 1434 1435
	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 已提交
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
		/*
		 * 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 已提交
1448 1449 1450 1451 1452 1453 1454
		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);
1455
		if (stat)
L
Linus Torvalds 已提交
1456
			return stat;
1457

1458
		if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1459 1460
			toc->hdr.first_track = (u8)bin2bcd(CDROM_LEADOUT);
			toc->hdr.last_track = (u8)bin2bcd(CDROM_LEADOUT);
1461
		} else {
L
Linus Torvalds 已提交
1462 1463 1464 1465 1466 1467 1468 1469
			toc->hdr.first_track = CDROM_LEADOUT;
			toc->hdr.last_track = CDROM_LEADOUT;
		}
	}

	if (stat)
		return stat;

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

1472
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1473 1474
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1475 1476
	}

1477
	for (i = 0; i <= ntracks; i++) {
1478 1479
		if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
			if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD)
A
Adrian Bunk 已提交
1480
				toc->ent[i].track = bcd2bin(toc->ent[i].track);
L
Linus Torvalds 已提交
1481 1482
			msf_from_bcd(&toc->ent[i].addr.msf);
		}
1483 1484 1485
		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 已提交
1486 1487 1488
	}

	if (toc->hdr.first_track != CDROM_LEADOUT) {
B
Borislav Petkov 已提交
1489
		/* read the multisession information */
L
Linus Torvalds 已提交
1490 1491
		stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
J
Jesper Juhl 已提交
1492 1493
		if (stat)
			return stat;
L
Linus Torvalds 已提交
1494 1495 1496

		toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
	} else {
1497 1498
		ms_tmp.hdr.last_track = CDROM_LEADOUT;
		ms_tmp.hdr.first_track = ms_tmp.hdr.last_track;
L
Linus Torvalds 已提交
1499 1500 1501
		toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
	}

1502
	if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
B
Borislav Petkov 已提交
1503
		/* re-read multisession information using MSF format */
L
Linus Torvalds 已提交
1504 1505 1506 1507 1508
		stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
		if (stat)
			return stat;

1509
		msf_from_bcd(&ms_tmp.ent.addr.msf);
L
Linus Torvalds 已提交
1510
		toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1511
						   ms_tmp.ent.addr.msf.second,
L
Linus Torvalds 已提交
1512 1513 1514 1515 1516
						   ms_tmp.ent.addr.msf.frame);
	}

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

B
Borislav Petkov 已提交
1517
	/* now try to get the total cdrom capacity */
L
Linus Torvalds 已提交
1518 1519 1520 1521
	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 已提交
1522
		drive->probed_capacity = toc->capacity * sectors_per_frame;
L
Linus Torvalds 已提交
1523 1524 1525
	}

	/* Remember that we've read this stuff. */
1526
	drive->atapi_flags |= IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
1527 1528 1529 1530

	return 0;
}

1531
int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
E
Eric Piel 已提交
1532 1533 1534 1535
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
	struct packet_command cgc;
1536
	int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
E
Eric Piel 已提交
1537

1538
	if ((drive->atapi_flags & IDE_AFLAG_FULL_CAPS_PAGE) == 0)
1539
		size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
E
Eric Piel 已提交
1540

1541
	init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
B
Borislav Petkov 已提交
1542 1543
	do {
		/* we seem to get stat=0x01,err=0x00 the first time (??) */
E
Eric Piel 已提交
1544 1545 1546 1547 1548 1549 1550
		stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
		if (!stat)
			break;
	} while (--attempts);
	return stat;
}

1551
void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
E
Eric Piel 已提交
1552
{
1553
	struct cdrom_info *cd = drive->driver_data;
1554 1555
	u16 curspeed, maxspeed;

1556
	if (drive->atapi_flags & IDE_AFLAG_LE_SPEED_FIELDS) {
1557 1558
		curspeed = le16_to_cpup((__le16 *)&buf[8 + 14]);
		maxspeed = le16_to_cpup((__le16 *)&buf[8 + 8]);
E
Eric Piel 已提交
1559
	} else {
1560 1561
		curspeed = be16_to_cpup((__be16 *)&buf[8 + 14]);
		maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
E
Eric Piel 已提交
1562
	}
1563

1564 1565
	cd->current_speed = (curspeed + (176/2)) / 176;
	cd->max_speed = (maxspeed + (176/2)) / 176;
E
Eric Piel 已提交
1566 1567
}

1568 1569 1570 1571 1572 1573
#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 已提交
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586

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,
1587
	.capability		= IDE_CD_CAPABILITIES,
L
Linus Torvalds 已提交
1588 1589 1590
	.generic_packet		= ide_cdrom_packet,
};

1591
static int ide_cdrom_register(ide_drive_t *drive, int nslots)
L
Linus Torvalds 已提交
1592 1593 1594 1595 1596
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *devinfo = &info->devinfo;

	devinfo->ops = &ide_cdrom_dops;
1597
	devinfo->speed = info->current_speed;
L
Linus Torvalds 已提交
1598
	devinfo->capacity = nslots;
J
Jesper Juhl 已提交
1599
	devinfo->handle = drive;
L
Linus Torvalds 已提交
1600 1601
	strcpy(devinfo->name, drive->name);

1602
	if (drive->atapi_flags & IDE_AFLAG_NO_SPEED_SELECT)
1603 1604
		devinfo->mask |= CDC_SELECT_SPEED;

L
Linus Torvalds 已提交
1605 1606 1607 1608
	devinfo->disk = info->disk;
	return register_cdrom(devinfo);
}

1609
static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
L
Linus Torvalds 已提交
1610
{
1611 1612
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1613 1614
	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	mechtype_t mechtype;
L
Linus Torvalds 已提交
1615 1616
	int nslots = 1;

1617 1618 1619 1620
	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 已提交
1621
	if (drive->media == ide_optical) {
1622
		cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1623 1624
		printk(KERN_ERR "%s: ATAPI magneto-optical drive\n",
				drive->name);
L
Linus Torvalds 已提交
1625 1626 1627
		return nslots;
	}

1628 1629
	if (drive->atapi_flags & IDE_AFLAG_PRE_ATAPI12) {
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1630
		cdi->mask &= ~CDC_PLAY_AUDIO;
L
Linus Torvalds 已提交
1631 1632 1633 1634
		return nslots;
	}

	/*
B
Borislav Petkov 已提交
1635 1636 1637 1638
	 * 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 已提交
1639
	 */
J
Jesper Juhl 已提交
1640
	cdi->handle = drive;
L
Linus Torvalds 已提交
1641 1642
	cdi->ops = &ide_cdrom_dops;

1643
	if (ide_cdrom_get_capabilities(drive, buf))
L
Linus Torvalds 已提交
1644 1645
		return 0;

1646
	if ((buf[8 + 6] & 0x01) == 0)
1647
		drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
1648
	if (buf[8 + 6] & 0x08)
1649
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1650
	if (buf[8 + 3] & 0x01)
1651
		cdi->mask &= ~CDC_CD_R;
1652
	if (buf[8 + 3] & 0x02)
1653
		cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1654
	if (buf[8 + 2] & 0x38)
1655
		cdi->mask &= ~CDC_DVD;
1656
	if (buf[8 + 3] & 0x20)
1657
		cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1658
	if (buf[8 + 3] & 0x10)
1659
		cdi->mask &= ~CDC_DVD_R;
1660
	if ((buf[8 + 4] & 0x01) || (drive->atapi_flags & IDE_AFLAG_PLAY_AUDIO_OK))
1661
		cdi->mask &= ~CDC_PLAY_AUDIO;
1662 1663

	mechtype = buf[8 + 6] >> 5;
B
Borislav Petkov 已提交
1664 1665 1666
	if (mechtype == mechtype_caddy ||
	    mechtype == mechtype_popup ||
	    (drive->atapi_flags & IDE_AFLAG_NO_AUTOCLOSE))
1667
		cdi->mask |= CDC_CLOSE_TRAY;
L
Linus Torvalds 已提交
1668 1669

	if (cdi->sanyo_slot > 0) {
1670
		cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1671
		nslots = 3;
1672 1673
	} else if (mechtype == mechtype_individual_changer ||
		   mechtype == mechtype_cartridge_changer) {
1674 1675
		nslots = cdrom_number_of_slots(cdi);
		if (nslots > 1)
1676
			cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1677 1678
	}

1679
	ide_cdrom_update_speed(drive, buf);
1680

L
Linus Torvalds 已提交
1681
	printk(KERN_INFO "%s: ATAPI", drive->name);
1682 1683

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

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

1689 1690 1691 1692
	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 已提交
1693

1694 1695 1696 1697
	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 已提交
1698

1699 1700 1701 1702
	if ((cdi->mask & CDC_SELECT_DISC) == 0)
		printk(KERN_CONT " changer w/%d slots", nslots);
	else
		printk(KERN_CONT " drive");
L
Linus Torvalds 已提交
1703

1704
	printk(KERN_CONT ", %dkB Cache\n", be16_to_cpup((__be16 *)&buf[8 + 12]));
L
Linus Torvalds 已提交
1705 1706 1707 1708

	return nslots;
}

B
Borislav Petkov 已提交
1709
/* standard prep_rq_fn that builds 10 byte cmds */
1710
static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1711 1712 1713 1714 1715
{
	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);

1716
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747

	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 已提交
1748
	/* transform 6-byte read/write commands to the 10-byte version */
L
Linus Torvalds 已提交
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	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;
	}
1770

L
Linus Torvalds 已提交
1771 1772 1773
	return BLKPREP_OK;
}

1774
static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1775
{
1776
	if (blk_fs_request(rq))
L
Linus Torvalds 已提交
1777
		return ide_cdrom_prep_fs(q, rq);
1778
	else if (blk_pc_request(rq))
L
Linus Torvalds 已提交
1779 1780 1781 1782 1783
		return ide_cdrom_prep_pc(rq);

	return 0;
}

1784 1785 1786 1787 1788 1789
struct cd_list_entry {
	const char	*id_model;
	const char	*id_firmware;
	unsigned int	cd_flags;
};

1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
#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;
}

1801 1802
static int proc_idecd_read_capacity(char *page, char **start, off_t off,
					int count, int *eof, void *data)
1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824
{
	ide_drive_t *drive = data;
	int len;

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

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

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

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

1869
static unsigned int ide_cd_flags(u16 *id)
1870 1871 1872 1873
{
	const struct cd_list_entry *cle = ide_cd_quirks_list;

	while (cle->id_model) {
1874
		if (strcmp(cle->id_model, (char *)&id[ATA_ID_PROD]) == 0 &&
1875
		    (cle->id_firmware == NULL ||
1876
		     strstr((char *)&id[ATA_ID_FW_REV], cle->id_firmware)))
1877 1878 1879 1880 1881 1882 1883
			return cle->cd_flags;
		cle++;
	}

	return 0;
}

1884
static int ide_cdrom_setup(ide_drive_t *drive)
L
Linus Torvalds 已提交
1885
{
1886 1887
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1888 1889
	u16 *id = drive->id;
	char *fw_rev = (char *)&id[ATA_ID_FW_REV];
L
Linus Torvalds 已提交
1890 1891 1892 1893
	int nslots;

	blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
	blk_queue_dma_alignment(drive->queue, 31);
1894
	blk_queue_update_dma_pad(drive->queue, 15);
L
Linus Torvalds 已提交
1895 1896 1897 1898 1899 1900
	drive->queue->unplug_delay = (1 * HZ) / 1000;
	if (!drive->queue->unplug_delay)
		drive->queue->unplug_delay = 1;

	drive->special.all	= 0;

1901
	drive->atapi_flags = IDE_AFLAG_MEDIA_CHANGED | IDE_AFLAG_NO_EJECT |
1902
		       ide_cd_flags(id);
L
Linus Torvalds 已提交
1903

1904
	if ((id[ATA_ID_CONFIG] & 0x0060) == 0x20)
1905
		drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
1906

1907
	if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
1908
	    fw_rev[4] == '1' && fw_rev[6] <= '2')
1909 1910 1911
		drive->atapi_flags |= (IDE_AFLAG_TOCTRACKS_AS_BCD |
				     IDE_AFLAG_TOCADDR_AS_BCD);
	else if ((drive->atapi_flags & IDE_AFLAG_VERTOS_600_ESD) &&
1912
		 fw_rev[4] == '1' && fw_rev[6] <= '2')
1913 1914
		drive->atapi_flags |= IDE_AFLAG_TOCTRACKS_AS_BCD;
	else if (drive->atapi_flags & IDE_AFLAG_SANYO_3CD)
B
Borislav Petkov 已提交
1915 1916
		/* 3 => use CD in slot 0 */
		cdi->sanyo_slot = 3;
L
Linus Torvalds 已提交
1917

1918
	nslots = ide_cdrom_probe_capabilities(drive);
L
Linus Torvalds 已提交
1919

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

1923
	drive->dsc_overlap = (drive->next != drive);
L
Linus Torvalds 已提交
1924 1925

	if (ide_cdrom_register(drive, nslots)) {
1926 1927
		printk(KERN_ERR "%s: %s failed to register device with the"
				" cdrom driver.\n", drive->name, __func__);
1928
		cd->devinfo.handle = NULL;
L
Linus Torvalds 已提交
1929 1930 1931 1932 1933 1934
		return 1;
	}
	ide_cdrom_add_settings(drive);
	return 0;
}

1935
static void ide_cd_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
1936 1937 1938
{
	struct cdrom_info *info = drive->driver_data;

1939
	ide_proc_unregister_driver(drive, info->driver);
L
Linus Torvalds 已提交
1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952

	del_gendisk(info->disk);

	ide_cd_put(info);
}

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

1953
	kfree(info->toc);
1954 1955
	if (devinfo->handle == drive)
		unregister_cdrom(devinfo);
L
Linus Torvalds 已提交
1956 1957 1958 1959 1960 1961 1962 1963
	drive->dsc_overlap = 0;
	drive->driver_data = NULL;
	blk_queue_prep_rq(drive->queue, NULL);
	g->private_data = NULL;
	put_disk(g);
	kfree(info);
}

1964
static int ide_cd_probe(ide_drive_t *);
L
Linus Torvalds 已提交
1965 1966

static ide_driver_t ide_cdrom_driver = {
1967
	.gen_driver = {
1968
		.owner		= THIS_MODULE,
1969 1970 1971
		.name		= "ide-cdrom",
		.bus		= &ide_bus_type,
	},
1972 1973
	.probe			= ide_cd_probe,
	.remove			= ide_cd_remove,
L
Linus Torvalds 已提交
1974 1975 1976
	.version		= IDECD_VERSION,
	.media			= ide_cdrom,
	.supports_dsc_overlap	= 1,
1977
	.do_request		= ide_cd_do_request,
L
Linus Torvalds 已提交
1978 1979
	.end_request		= ide_end_request,
	.error			= __ide_error,
1980
#ifdef CONFIG_IDE_PROC_FS
L
Linus Torvalds 已提交
1981
	.proc			= idecd_proc,
1982
#endif
L
Linus Torvalds 已提交
1983 1984
};

1985
static int idecd_open(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
1986 1987 1988 1989 1990
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct cdrom_info *info;
	int rc = -ENOMEM;

1991 1992
	info = ide_cd_get(disk);
	if (!info)
L
Linus Torvalds 已提交
1993 1994
		return -ENXIO;

1995
	rc = cdrom_open(&info->devinfo, inode, file);
L
Linus Torvalds 已提交
1996 1997 1998 1999 2000 2001 2002

	if (rc < 0)
		ide_cd_put(info);

	return rc;
}

2003
static int idecd_release(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
2004 2005 2006 2007
{
	struct gendisk *disk = inode->i_bdev->bd_disk;
	struct cdrom_info *info = ide_cd_g(disk);

2008
	cdrom_release(&info->devinfo, file);
L
Linus Torvalds 已提交
2009 2010 2011 2012 2013 2014

	ide_cd_put(info);

	return 0;
}

2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
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;
2040
	char spindown;
2041 2042 2043 2044 2045 2046 2047 2048

	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;
2049
	if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
2050 2051 2052 2053
		return -EFAULT;
	return 0;
}

2054
static int idecd_ioctl(struct inode *inode, struct file *file,
L
Linus Torvalds 已提交
2055 2056 2057 2058 2059 2060
			unsigned int cmd, unsigned long arg)
{
	struct block_device *bdev = inode->i_bdev;
	struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
	int err;

2061
	switch (cmd) {
2062
	case CDROMSETSPINDOWN:
2063
		return idecd_set_spindown(&info->devinfo, arg);
2064
	case CDROMGETSPINDOWN:
2065 2066 2067
		return idecd_get_spindown(&info->devinfo, arg);
	default:
		break;
2068
	}
2069 2070

	err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
L
Linus Torvalds 已提交
2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
	if (err == -EINVAL)
		err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);

	return err;
}

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

static int idecd_revalidate_disk(struct gendisk *disk)
{
	struct cdrom_info *info = ide_cd_g(disk);
	struct request_sense sense;
2087 2088 2089

	ide_cd_read_toc(info->drive, &sense);

L
Linus Torvalds 已提交
2090 2091 2092 2093
	return  0;
}

static struct block_device_operations idecd_ops = {
2094 2095 2096 2097 2098 2099
	.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 已提交
2100 2101
};

B
Borislav Petkov 已提交
2102
/* module options */
2103
static char *ignore;
L
Linus Torvalds 已提交
2104 2105 2106 2107

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

2108
static int ide_cd_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122
{
	struct cdrom_info *info;
	struct gendisk *g;
	struct request_sense sense;

	if (!strstr("ide-cdrom", drive->driver_req))
		goto failed;
	if (!drive->present)
		goto failed;
	if (drive->media != ide_cdrom && drive->media != ide_optical)
		goto failed;
	/* skip drives that we were told to ignore */
	if (ignore != NULL) {
		if (strstr(ignore, drive->name)) {
2123 2124
			printk(KERN_INFO "ide-cd: ignoring drive %s\n",
					 drive->name);
L
Linus Torvalds 已提交
2125 2126 2127
			goto failed;
		}
	}
2128
	info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
L
Linus Torvalds 已提交
2129
	if (info == NULL) {
2130 2131
		printk(KERN_ERR "%s: Can't allocate a cdrom structure\n",
				drive->name);
L
Linus Torvalds 已提交
2132 2133 2134 2135 2136 2137 2138 2139 2140
		goto failed;
	}

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

	ide_init_disk(g, drive);

2141
	ide_proc_register_driver(drive, &ide_cdrom_driver);
2142

L
Linus Torvalds 已提交
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
	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)) {
2157
		ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2158
		ide_cd_release(&info->kref);
L
Linus Torvalds 已提交
2159 2160 2161
		goto failed;
	}

2162
	ide_cd_read_toc(drive, &sense);
L
Linus Torvalds 已提交
2163 2164 2165 2166 2167 2168 2169 2170
	g->fops = &idecd_ops;
	g->flags |= GENHD_FL_REMOVABLE;
	add_disk(g);
	return 0;

out_free_cd:
	kfree(info);
failed:
2171
	return -ENODEV;
L
Linus Torvalds 已提交
2172 2173 2174 2175
}

static void __exit ide_cdrom_exit(void)
{
2176
	driver_unregister(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2177
}
2178 2179

static int __init ide_cdrom_init(void)
L
Linus Torvalds 已提交
2180
{
2181
	return driver_register(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2182 2183
}

2184
MODULE_ALIAS("ide:*m-cdrom*");
2185
MODULE_ALIAS("ide-cd");
L
Linus Torvalds 已提交
2186 2187 2188
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);
MODULE_LICENSE("GPL");