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

26 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

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

#include "ide-cd.h"

56 57 58 59 60 61 62 63
#define IDECD_DEBUG_LOG		1

#if IDECD_DEBUG_LOG
#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
#else
#define ide_debug_log(lvl, fmt, args...) do {} while (0)
#endif

64
static DEFINE_MUTEX(idecd_ref_mutex);
L
Linus Torvalds 已提交
65

66 67
static void ide_cd_release(struct kref *);

L
Linus Torvalds 已提交
68 69 70 71
static struct cdrom_info *ide_cd_get(struct gendisk *disk)
{
	struct cdrom_info *cd = NULL;

72
	mutex_lock(&idecd_ref_mutex);
73
	cd = ide_drv_g(disk, cdrom_info);
74
	if (cd) {
75
		if (ide_device_get(cd->drive))
76
			cd = NULL;
77 78 79
		else
			kref_get(&cd->kref);

80
	}
81
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
82 83 84 85 86
	return cd;
}

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

89
	mutex_lock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
90
	kref_put(&cd->kref, ide_cd_release);
91
	ide_device_put(drive);
92
	mutex_unlock(&idecd_ref_mutex);
L
Linus Torvalds 已提交
93 94
}

B
Borislav Petkov 已提交
95
/*
L
Linus Torvalds 已提交
96 97 98
 * Generic packet command support and error handling routines.
 */

B
Borislav Petkov 已提交
99
/* Mark that we've seen a media change and invalidate our internal buffers. */
100
static void cdrom_saw_media_change(ide_drive_t *drive)
L
Linus Torvalds 已提交
101
{
102
	drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
103
	drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
104 105 106 107 108 109 110
}

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

111 112 113
	ide_debug_log(IDE_DBG_SENSE, "Call %s, sense_key: 0x%x\n", __func__,
		      sense->sense_key);

114
	if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
L
Linus Torvalds 已提交
115 116 117
		return 0;

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

154
static void cdrom_analyze_sense_data(ide_drive_t *drive,
L
Linus Torvalds 已提交
155 156 157
			      struct request *failed_command,
			      struct request_sense *sense)
{
158 159 160 161
	unsigned long sector;
	unsigned long bio_sectors;
	struct cdrom_info *info = drive->driver_data;

162 163 164 165 166 167 168 169
	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 已提交
170 171 172 173
	if (!cdrom_log_sense(drive, failed_command, sense))
		return;

	/*
B
Borislav Petkov 已提交
174 175 176
	 * 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 已提交
177 178 179 180 181
	 */
	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
		if (sense->sense_key == 0x05 && sense->asc == 0x24)
			return;

B
Borislav Petkov 已提交
182 183
	/* current error */
	if (sense->error_code == 0x70) {
184
		switch (sense->sense_key) {
185 186 187 188 189 190 191 192 193 194 195 196 197 198
		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 已提交
199 200
				/* device sector size is 2K */
				sector <<= 2;
201 202

			bio_sectors = max(bio_sectors(failed_command->bio), 4U);
203
			sector &= ~(bio_sectors - 1);
204 205

			if (sector < get_capacity(info->disk) &&
206
			    drive->probed_capacity - sector < 4 * 75)
207
				set_capacity(info->disk, sector);
208 209
		}
	}
L
Linus Torvalds 已提交
210

211
	ide_cd_log_error(drive->name, failed_command, sense);
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219
}

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;

220 221
	ide_debug_log(IDE_DBG_SENSE, "Call %s\n", __func__);

L
Linus Torvalds 已提交
222 223 224 225
	if (sense == NULL)
		sense = &info->sense_data;

	/* stuff the sense request in front of our current request */
226 227 228
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_ATA_PC;
	rq->rq_disk = info->disk;
L
Linus Torvalds 已提交
229 230 231

	rq->data = sense;
	rq->cmd[0] = GPCMD_REQUEST_SENSE;
232 233
	rq->cmd[4] = 18;
	rq->data_len = 18;
L
Linus Torvalds 已提交
234

235
	rq->cmd_type = REQ_TYPE_SENSE;
236
	rq->cmd_flags |= REQ_PREEMPT;
L
Linus Torvalds 已提交
237 238 239 240

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

241 242 243 244
	if (failed_command)
		ide_debug_log(IDE_DBG_SENSE, "failed_cmd: 0x%x\n",
			      failed_command->cmd[0]);

245
	ide_do_drive_cmd(drive, rq);
L
Linus Torvalds 已提交
246 247
}

248
static void cdrom_end_request(ide_drive_t *drive, int uptodate)
L
Linus Torvalds 已提交
249 250 251 252
{
	struct request *rq = HWGROUP(drive)->rq;
	int nsectors = rq->hard_cur_sectors;

253 254 255 256
	ide_debug_log(IDE_DBG_FUNC, "Call %s, cmd: 0x%x, uptodate: 0x%x, "
		      "nsectors: %d\n", __func__, rq->cmd[0], uptodate,
		      nsectors);

257
	if (blk_sense_request(rq) && uptodate) {
L
Linus Torvalds 已提交
258
		/*
259 260
		 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
		 * failed request
L
Linus Torvalds 已提交
261 262 263 264 265 266 267 268 269 270
		 */
		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;
			}
271
			cdrom_analyze_sense_data(drive, failed, sense);
L
Linus Torvalds 已提交
272
			/*
B
Borislav Petkov 已提交
273
			 * now end the failed request
L
Linus Torvalds 已提交
274
			 */
275 276 277 278 279
			if (blk_fs_request(failed)) {
				if (ide_end_dequeued_request(drive, failed, 0,
						failed->hard_nr_sectors))
					BUG();
			} else {
280 281
				if (blk_end_request(failed, -EIO,
						    failed->data_len))
282
					BUG();
283 284 285
			}
		} else
			cdrom_analyze_sense_data(drive, NULL, sense);
L
Linus Torvalds 已提交
286 287 288 289 290 291 292 293 294 295
	}

	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;

296 297 298
	ide_debug_log(IDE_DBG_FUNC, "Exit %s, uptodate: 0x%x, nsectors: %d\n",
		      __func__, uptodate, nsectors);

L
Linus Torvalds 已提交
299 300 301
	ide_end_request(drive, uptodate, nsectors);
}

302
static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 st)
303
{
304
	if (st & 0x80)
305
		return;
306
	ide_dump_status(drive, msg, st);
307 308
}

B
Borislav Petkov 已提交
309 310 311 312 313
/*
 * Returns:
 * 0: if the request should be continued.
 * 1: if the request was ended.
 */
L
Linus Torvalds 已提交
314 315
static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
{
316
	ide_hwif_t *hwif = drive->hwif;
317 318
	ide_hwgroup_t *hwgroup = hwif->hwgroup;
	struct request *rq = hwgroup->rq;
L
Linus Torvalds 已提交
319
	int stat, err, sense_key;
320

B
Borislav Petkov 已提交
321
	/* check for errors */
322
	stat = hwif->tp_ops->read_status(hwif);
323

L
Linus Torvalds 已提交
324 325 326 327 328 329
	if (stat_ret)
		*stat_ret = stat;

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

B
Borislav Petkov 已提交
330
	/* get the IDE error register */
331
	err = ide_read_error(drive);
L
Linus Torvalds 已提交
332 333 334
	sense_key = err >> 4;

	if (rq == NULL) {
335
		printk(KERN_ERR PFX "%s: missing rq in %s\n",
336
				drive->name, __func__);
L
Linus Torvalds 已提交
337 338 339
		return 1;
	}

340
	ide_debug_log(IDE_DBG_RQ, "%s: stat: 0x%x, good_stat: 0x%x, "
341 342
		      "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);
343

344
	if (blk_sense_request(rq)) {
B
Borislav Petkov 已提交
345 346 347 348 349
		/*
		 * We got an error trying to get sense info from the drive
		 * (probably while trying to recover from a former error).
		 * Just give up.
		 */
350
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
351 352 353 354
		cdrom_end_request(drive, 0);
		ide_error(drive, "request sense failure", stat);
		return 1;

355
	} else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
L
Linus Torvalds 已提交
356 357 358 359 360 361
		/* All other functions, except for READ. */

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

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

386
		rq->cmd_flags |= REQ_FAILED;
L
Linus Torvalds 已提交
387 388 389 390 391 392

		/*
		 * instead of playing games with moving completions around,
		 * remove failed request completely and end it when the
		 * request sense has completed
		 */
393
		goto end_request;
L
Linus Torvalds 已提交
394 395 396 397

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

B
Borislav Petkov 已提交
398
		/* handle errors from READ and WRITE requests */
L
Linus Torvalds 已提交
399 400 401 402 403

		if (blk_noretry_request(rq))
			do_end_request = 1;

		if (sense_key == NOT_READY) {
B
Borislav Petkov 已提交
404
			/* tray open */
L
Linus Torvalds 已提交
405
			if (rq_data_dir(rq) == READ) {
406
				cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
407

B
Borislav Petkov 已提交
408
				/* fail the request */
409 410
				printk(KERN_ERR PFX "%s: tray open\n",
						drive->name);
L
Linus Torvalds 已提交
411 412 413 414
				do_end_request = 1;
			} else {
				struct cdrom_info *info = drive->driver_data;

B
Borislav Petkov 已提交
415 416
				/*
				 * Allow the drive 5 seconds to recover, some
L
Linus Torvalds 已提交
417
				 * devices will return this error while flushing
B
Borislav Petkov 已提交
418 419
				 * data from cache.
				 */
L
Linus Torvalds 已提交
420
				if (!rq->errors)
421 422
					info->write_timeout = jiffies +
							ATAPI_WAIT_WRITE_BUSY;
L
Linus Torvalds 已提交
423 424 425 426 427 428 429
				rq->errors = 1;
				if (time_after(jiffies, info->write_timeout))
					do_end_request = 1;
				else {
					unsigned long flags;

					/*
B
Borislav Petkov 已提交
430 431
					 * take a breather relying on the unplug
					 * timer to kick us again
L
Linus Torvalds 已提交
432 433 434
					 */
					spin_lock_irqsave(&ide_lock, flags);
					blk_plug_device(drive->queue);
435 436
					spin_unlock_irqrestore(&ide_lock,
								flags);
L
Linus Torvalds 已提交
437 438 439 440
					return 1;
				}
			}
		} else if (sense_key == UNIT_ATTENTION) {
B
Borislav Petkov 已提交
441
			/* media change */
442
			cdrom_saw_media_change(drive);
L
Linus Torvalds 已提交
443

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

B
Borislav Petkov 已提交
481 482 483 484 485
		/*
		 * End a request through request sense analysis when we have
		 * sense data. We need this in order to perform end of media
		 * processing.
		 */
486 487
		if (do_end_request)
			goto end_request;
488

489
		/*
B
Borislav Petkov 已提交
490 491
		 * If we got a CHECK_CONDITION status, queue
		 * a request sense command.
492
		 */
493
		if (stat & ATA_ERR)
494
			cdrom_queue_request_sense(drive, NULL, NULL);
L
Linus Torvalds 已提交
495
	} else {
496
		blk_dump_rq_flags(rq, PFX "bad rq");
L
Linus Torvalds 已提交
497 498 499
		cdrom_end_request(drive, 0);
	}

B
Borislav Petkov 已提交
500
	/* retry, or handle the next request */
L
Linus Torvalds 已提交
501
	return 1;
502 503

end_request:
504
	if (stat & ATA_ERR) {
505 506 507 508 509 510
		unsigned long flags;

		spin_lock_irqsave(&ide_lock, flags);
		blkdev_dequeue_request(rq);
		spin_unlock_irqrestore(&ide_lock, flags);

511 512
		hwgroup->rq = NULL;

513 514 515 516 517
		cdrom_queue_request_sense(drive, rq->sense, rq);
	} else
		cdrom_end_request(drive, 0);

	return 1;
L
Linus Torvalds 已提交
518 519 520 521 522 523 524
}

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

525 526 527
	ide_debug_log(IDE_DBG_RQ, "Call %s: rq->cmd[0]: 0x%x\n", __func__,
		      rq->cmd[0]);

L
Linus Torvalds 已提交
528
	/*
B
Borislav Petkov 已提交
529 530 531 532
	 * 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 已提交
533 534
	 */
	switch (rq->cmd[0]) {
535 536 537 538 539 540 541 542 543
	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))
544
			printk(KERN_INFO PFX "cmd 0x%x timed out\n",
545
					 rq->cmd[0]);
546 547
		wait = 0;
		break;
L
Linus Torvalds 已提交
548 549 550 551
	}
	return wait;
}

B
Borislav Petkov 已提交
552 553 554 555 556 557 558 559
/*
 * 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 已提交
560 561 562 563 564 565
static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
						  int xferlen,
						  ide_handler_t *handler)
{
	ide_hwif_t *hwif = drive->hwif;

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

568
	/* FIXME: for Virtual DMA we must check harder */
569 570
	if (drive->dma)
		drive->dma = !hwif->dma_ops->dma_setup(drive);
L
Linus Torvalds 已提交
571

B
Borislav Petkov 已提交
572
	/* set up the controller registers */
573
	ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL,
574
			   xferlen, drive->dma);
575

576
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
577
		/* waiting for CDB interrupt, not DMA yet. */
578
		if (drive->dma)
579 580
			drive->waiting_for_dma = 0;

L
Linus Torvalds 已提交
581
		/* packet command */
582
		ide_execute_command(drive, ATA_CMD_PACKET, handler,
583
				    ATAPI_WAIT_PC, cdrom_timer_expiry);
L
Linus Torvalds 已提交
584 585
		return ide_started;
	} else {
586
		ide_execute_pkt_cmd(drive);
L
Linus Torvalds 已提交
587 588 589 590 591

		return (*handler) (drive);
	}
}

B
Borislav Petkov 已提交
592 593 594 595 596 597
/*
 * 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 已提交
598
#define ATAPI_MIN_CDB_BYTES 12
599
static ide_startstop_t cdrom_transfer_packet_command(ide_drive_t *drive,
L
Linus Torvalds 已提交
600 601 602 603 604 605 606
					  struct request *rq,
					  ide_handler_t *handler)
{
	ide_hwif_t *hwif = drive->hwif;
	int cmd_len;
	ide_startstop_t startstop;

607 608
	ide_debug_log(IDE_DBG_PC, "Call %s\n", __func__);

609
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
B
Borislav Petkov 已提交
610 611 612 613
		/*
		 * Here we should have been called after receiving an interrupt
		 * from the device.  DRQ should how be set.
		 */
L
Linus Torvalds 已提交
614

B
Borislav Petkov 已提交
615
		/* check for errors */
616
		if (cdrom_decode_status(drive, ATA_DRQ, NULL))
L
Linus Torvalds 已提交
617
			return ide_stopped;
618

B
Borislav Petkov 已提交
619
		/* ok, next interrupt will be DMA interrupt */
620
		if (drive->dma)
621
			drive->waiting_for_dma = 1;
L
Linus Torvalds 已提交
622
	} else {
B
Borislav Petkov 已提交
623
		/* otherwise, we must wait for DRQ to get set */
624 625
		if (ide_wait_stat(&startstop, drive, ATA_DRQ,
				  ATA_BUSY, WAIT_READY))
L
Linus Torvalds 已提交
626 627 628
			return startstop;
	}

B
Borislav Petkov 已提交
629
	/* arm the interrupt handler */
L
Linus Torvalds 已提交
630 631 632 633 634 635 636
	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 已提交
637
	/* send the command to the device */
638
	hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
L
Linus Torvalds 已提交
639

B
Borislav Petkov 已提交
640
	/* start the DMA if need be */
641
	if (drive->dma)
642
		hwif->dma_ops->dma_start(drive);
L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651

	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.
 */
652 653
static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
				int len, int ireason, int rw)
L
Linus Torvalds 已提交
654
{
655 656
	ide_hwif_t *hwif = drive->hwif;

657 658 659
	ide_debug_log(IDE_DBG_FUNC, "Call %s, ireason: 0x%x, rw: 0x%x\n",
		      __func__, ireason, rw);

660 661 662 663 664
	/*
	 * 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 已提交
665
		return 0;
666
	else if (ireason == (rw << 1)) {
667

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

672
		ide_pad_transfer(drive, rw, len);
673
	} else  if (rw == 0 && ireason == 1) {
B
Borislav Petkov 已提交
674 675 676
		/*
		 * Some drives (ASUS) seem to tell us that status info is
		 * available.  Just get it and ignore.
L
Linus Torvalds 已提交
677
		 */
678
		(void)hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
679 680
		return 0;
	} else {
B
Borislav Petkov 已提交
681
		/* drive wants a command packet, or invalid ireason... */
682
		printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
683
				drive->name, __func__, ireason);
L
Linus Torvalds 已提交
684 685
	}

686 687 688
	if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags |= REQ_FAILED;

L
Linus Torvalds 已提交
689 690 691 692
	cdrom_end_request(drive, 0);
	return -1;
}

693 694 695 696 697 698
/*
 * 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)
{
699 700
	ide_debug_log(IDE_DBG_FUNC, "Call %s, len: %d\n", __func__, len);

701 702 703
	if ((len % SECTOR_SIZE) == 0)
		return 0;

704 705
	printk(KERN_ERR PFX "%s: %s: Bad transfer size %d\n", drive->name,
			__func__, len);
706

707
	if (drive->atapi_flags & IDE_AFLAG_LIMIT_NFRAMES)
708 709
		printk(KERN_ERR PFX "This drive is not supported by this "
				"version of the driver\n");
710
	else {
711
		printk(KERN_ERR PFX "Trying to limit transfer sizes\n");
712
		drive->atapi_flags |= IDE_AFLAG_LIMIT_NFRAMES;
713 714 715 716 717
	}

	return 1;
}

718
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
719

720 721
static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
						 struct request *rq)
L
Linus Torvalds 已提交
722
{
723 724 725
	ide_debug_log(IDE_DBG_RQ, "Call %s: rq->cmd_flags: 0x%x\n", __func__,
		      rq->cmd_flags);

726 727 728 729
	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 已提交
730

731 732 733 734 735 736 737 738 739 740 741
		/*
		 * 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 已提交
742
			/* sanity check... */
743 744
			if (rq->current_nr_sectors !=
			    bio_cur_sectors(rq->bio)) {
745
				printk(KERN_ERR PFX "%s: %s: buffer botch (%u)\n",
746
						drive->name, __func__,
747 748 749 750 751
						rq->current_nr_sectors);
				cdrom_end_request(drive, 0);
				return ide_stopped;
			}
			rq->current_nr_sectors += nskip;
L
Linus Torvalds 已提交
752 753
		}
	}
754

B
Borislav Petkov 已提交
755
	/* set up the command */
L
Linus Torvalds 已提交
756 757
	rq->timeout = ATAPI_WAIT_PC;

758 759 760 761 762 763 764 765 766 767 768 769 770
	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 已提交
771
	/* send the command to the drive and return */
772
	return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
L
Linus Torvalds 已提交
773 774 775 776 777 778
}

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

779
static ide_startstop_t cdrom_seek_intr(ide_drive_t *drive)
L
Linus Torvalds 已提交
780 781 782 783 784
{
	struct cdrom_info *info = drive->driver_data;
	int stat;
	static int retry = 10;

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

L
Linus Torvalds 已提交
787 788
	if (cdrom_decode_status(drive, 0, &stat))
		return ide_stopped;
789

790
	drive->atapi_flags |= IDE_AFLAG_SEEKING;
L
Linus Torvalds 已提交
791 792

	if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
B
Borislav Petkov 已提交
793
		if (--retry == 0)
794
			drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
L
Linus Torvalds 已提交
795 796 797 798
	}
	return ide_stopped;
}

799
static void ide_cd_prepare_seek_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
800 801 802
{
	sector_t frame = rq->sector;

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

L
Linus Torvalds 已提交
805 806
	sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);

807
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
808 809 810 811
	rq->cmd[0] = GPCMD_SEEK;
	put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);

	rq->timeout = ATAPI_WAIT_PC;
812 813 814 815 816 817
}

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

L
Linus Torvalds 已提交
818 819 820
	return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
}

821
/*
B
Borislav Petkov 已提交
822 823
 * Fix up a possibly partially-processed request so that we can start it over
 * entirely, or even put it back on the request queue.
824
 */
825
static void ide_cd_restore_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
826
{
827 828 829

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

L
Linus Torvalds 已提交
830
	if (rq->buffer != bio_data(rq->bio)) {
831 832
		sector_t n =
			(rq->buffer - (char *)bio_data(rq->bio)) / SECTOR_SIZE;
L
Linus Torvalds 已提交
833 834 835 836 837

		rq->buffer = bio_data(rq->bio);
		rq->nr_sectors += n;
		rq->sector -= n;
	}
838 839
	rq->current_nr_sectors = bio_cur_sectors(rq->bio);
	rq->hard_cur_sectors = rq->current_nr_sectors;
L
Linus Torvalds 已提交
840 841 842 843 844
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
	rq->q->prep_rq_fn(rq->q, rq);
}

845
static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct request *rq)
846
{
847 848
	ide_debug_log(IDE_DBG_FUNC, "Call %s, rq->cmd[0]: 0x%x\n",
		      __func__, rq->cmd[0]);
849

850 851 852 853 854 855 856 857 858 859 860 861
	/*
	 * 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;
		}
}

862 863 864 865
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 已提交
866
{
867 868
	struct cdrom_info *info = drive->driver_data;
	struct request_sense local_sense;
L
Linus Torvalds 已提交
869
	int retries = 10;
870
	unsigned int flags = 0;
L
Linus Torvalds 已提交
871

872 873
	if (!sense)
		sense = &local_sense;
L
Linus Torvalds 已提交
874

875
	ide_debug_log(IDE_DBG_PC, "Call %s, cmd[0]: 0x%x, write: 0x%x, "
876 877 878
		      "timeout: %d, cmd_flags: 0x%x\n", __func__, cmd[0], write,
		      timeout, cmd_flags);

B
Borislav Petkov 已提交
879
	/* start of retry loop */
L
Linus Torvalds 已提交
880
	do {
881
		struct request *rq;
L
Linus Torvalds 已提交
882 883
		int error;

884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
		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 已提交
903

B
Borislav Petkov 已提交
904 905 906 907
		/*
		 * FIXME: we should probably abort/retry or something in case of
		 * failure.
		 */
908
		if (flags & REQ_FAILED) {
B
Borislav Petkov 已提交
909 910 911 912
			/*
			 * The request failed.  Retry if it was due to a unit
			 * attention status (usually means media was changed).
			 */
913
			struct request_sense *reqbuf = sense;
L
Linus Torvalds 已提交
914 915 916 917 918

			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 已提交
919 920 921 922 923
				/*
				 * 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 已提交
924 925
				ssleep(2);
			} else {
B
Borislav Petkov 已提交
926
				/* otherwise, don't retry */
L
Linus Torvalds 已提交
927 928 929 930 931
				retries = 0;
			}
			--retries;
		}

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

B
Borislav Petkov 已提交
935
	/* return an error if the command failed */
936
	return (flags & REQ_FAILED) ? -EIO : 0;
L
Linus Torvalds 已提交
937 938
}

939
/*
B
Borislav Petkov 已提交
940 941 942
 * 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.
943 944 945 946 947 948
 */
static int cdrom_newpc_intr_dummy_cb(struct request *rq)
{
	return 1;
}

L
Linus Torvalds 已提交
949 950
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
{
951
	ide_hwif_t *hwif = drive->hwif;
952 953
	ide_hwgroup_t *hwgroup = hwif->hwgroup;
	struct request *rq = hwgroup->rq;
L
Linus Torvalds 已提交
954
	xfer_func_t *xferfunc;
955
	ide_expiry_t *expiry = NULL;
956
	int dma_error = 0, dma, stat, thislen, uptodate = 0;
957 958
	int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
	unsigned int timeout;
959 960
	u16 len;
	u8 ireason;
L
Linus Torvalds 已提交
961

962 963 964
	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 已提交
965
	/* check for errors */
966
	dma = drive->dma;
L
Linus Torvalds 已提交
967
	if (dma) {
968
		drive->dma = 0;
969
		dma_error = hwif->dma_ops->dma_end(drive);
970
		if (dma_error) {
971
			printk(KERN_ERR PFX "%s: DMA %s error\n", drive->name,
972
					write ? "write" : "read");
973 974
			ide_dma_off(drive);
		}
L
Linus Torvalds 已提交
975 976 977 978 979
	}

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

B
Borislav Petkov 已提交
980
	/* using dma, transfer is complete now */
L
Linus Torvalds 已提交
981
	if (dma) {
982
		if (dma_error)
L
Linus Torvalds 已提交
983
			return ide_error(drive, "dma error", stat);
984 985 986 987
		if (blk_fs_request(rq)) {
			ide_end_request(drive, 1, rq->nr_sectors);
			return ide_stopped;
		}
988
		goto end_request;
L
Linus Torvalds 已提交
989 990
	}

991
	ide_read_bcount_and_ireason(drive, &len, &ireason);
992 993

	thislen = blk_fs_request(rq) ? len : rq->data_len;
L
Linus Torvalds 已提交
994 995 996
	if (thislen > len)
		thislen = len;

997 998 999
	ide_debug_log(IDE_DBG_PC, "%s: DRQ: stat: 0x%x, thislen: %d\n",
		      __func__, stat, thislen);

B
Borislav Petkov 已提交
1000
	/* If DRQ is clear, the command has completed. */
1001
	if ((stat & ATA_DRQ) == 0) {
1002 1003 1004 1005 1006 1007 1008
		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) {
1009
				printk(KERN_ERR PFX "%s: %s: data underrun "
1010
						"(%d blocks)\n",
1011
						drive->name, __func__,
1012 1013 1014 1015 1016 1017 1018 1019
						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)) {
1020
			ide_cd_request_sense_fixup(drive, rq);
B
Borislav Petkov 已提交
1021
			/* complain if we still have data left to transfer */
1022 1023 1024
			uptodate = rq->data_len ? 0 : 1;
		}
		goto end_request;
1025
	}
L
Linus Torvalds 已提交
1026

B
Borislav Petkov 已提交
1027
	/* check which way to transfer data */
1028 1029
	if (ide_cd_check_ireason(drive, rq, len, ireason, write))
		return ide_stopped;
1030

1031 1032
	if (blk_fs_request(rq)) {
		if (write == 0) {
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
			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) {
1048
				ide_pad_transfer(drive, write, nskip << 9);
1049 1050 1051 1052
				rq->current_nr_sectors -= nskip;
				thislen -= (nskip << 9);
			}
		}
1053
	}
L
Linus Torvalds 已提交
1054

1055 1056
	if (ireason == 0) {
		write = 1;
1057
		xferfunc = hwif->tp_ops->output_data;
1058
	} else {
1059
		write = 0;
1060
		xferfunc = hwif->tp_ops->input_data;
L
Linus Torvalds 已提交
1061 1062
	}

1063 1064 1065
	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 已提交
1066
	/* transfer data */
L
Linus Torvalds 已提交
1067
	while (thislen > 0) {
1068
		u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1069
		int blen = rq->data_len;
L
Linus Torvalds 已提交
1070

B
Borislav Petkov 已提交
1071
		/* bio backed? */
L
Linus Torvalds 已提交
1072
		if (rq->bio) {
1073 1074 1075 1076 1077 1078 1079
			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 已提交
1080 1081 1082
		}

		if (!ptr) {
1083 1084
			if (blk_fs_request(rq) && !write)
				/*
1085
				 * If the buffers are full, pipe the rest into
B
Borislav Petkov 已提交
1086 1087
				 * oblivion.
				 */
1088
				ide_pad_transfer(drive, 0, thislen);
1089
			else {
1090
				printk(KERN_ERR PFX "%s: confused, missing data\n",
1091 1092 1093 1094 1095
						drive->name);
				blk_dump_rq_flags(rq, rq_data_dir(rq)
						  ? "cdrom_newpc_intr, write"
						  : "cdrom_newpc_intr, read");
			}
L
Linus Torvalds 已提交
1096 1097 1098 1099 1100 1101
			break;
		}

		if (blen > thislen)
			blen = thislen;

1102
		xferfunc(drive, NULL, ptr, blen);
L
Linus Torvalds 已提交
1103 1104 1105 1106

		thislen -= blen;
		len -= blen;

1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
		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;

1118 1119 1120 1121 1122 1123
			/*
			 * 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().
			 */
1124 1125
			if (rq->bio)
				blk_end_request_callback(rq, 0, blen,
1126
						 cdrom_newpc_intr_dummy_cb);
1127 1128 1129
			else
				rq->data += blen;
		}
1130 1131
		if (!write && blk_sense_request(rq))
			rq->sense_len += blen;
L
Linus Torvalds 已提交
1132 1133
	}

B
Borislav Petkov 已提交
1134
	/* pad, if necessary */
1135
	if (!blk_fs_request(rq) && len > 0)
1136
		ide_pad_transfer(drive, write, len);
L
Linus Torvalds 已提交
1137

1138 1139 1140 1141
	if (blk_pc_request(rq)) {
		timeout = rq->timeout;
	} else {
		timeout = ATAPI_WAIT_PC;
1142 1143
		if (!blk_fs_request(rq))
			expiry = cdrom_timer_expiry;
1144 1145 1146
	}

	ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
L
Linus Torvalds 已提交
1147
	return ide_started;
1148 1149 1150

end_request:
	if (blk_pc_request(rq)) {
1151 1152 1153 1154
		unsigned int dlen = rq->data_len;

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

1156
		if (blk_end_request(rq, 0, dlen))
1157
			BUG();
1158 1159

		hwgroup->rq = NULL;
1160 1161 1162 1163 1164 1165
	} else {
		if (!uptodate)
			rq->cmd_flags |= REQ_FAILED;
		cdrom_end_request(drive, uptodate);
	}
	return ide_stopped;
L
Linus Torvalds 已提交
1166 1167
}

1168
static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1169
{
1170 1171 1172 1173
	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 已提交
1174

1175 1176 1177
	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);
1178

1179
	if (write) {
B
Borislav Petkov 已提交
1180
		/* disk has become write protected */
1181
		if (get_disk_ro(cd->disk)) {
1182 1183 1184 1185 1186 1187 1188 1189
			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.
		 */
1190
		ide_cd_restore_request(drive, rq);
L
Linus Torvalds 已提交
1191 1192
	}

B
Borislav Petkov 已提交
1193
	/* use DMA, if possible / writes *must* be hardware frame aligned */
1194 1195 1196 1197 1198 1199
	if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
	    (rq->sector & (sectors_per_frame - 1))) {
		if (write) {
			cdrom_end_request(drive, 0);
			return ide_stopped;
		}
1200
		drive->dma = 0;
1201
	} else
1202
		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
L
Linus Torvalds 已提交
1203

1204 1205
	if (write)
		cd->devinfo.media_written = 1;
L
Linus Torvalds 已提交
1206

1207
	return ide_started;
L
Linus Torvalds 已提交
1208 1209 1210 1211 1212 1213 1214 1215 1216
}

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

1217
static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1218 1219
{

1220 1221
	ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, "
		      "rq->cmd_type: 0x%x\n", __func__, rq->cmd[0],
1222 1223
		      rq->cmd_type);

1224 1225 1226 1227
	if (blk_pc_request(rq))
		rq->cmd_flags |= REQ_QUIET;
	else
		rq->cmd_flags &= ~REQ_FAILED;
L
Linus Torvalds 已提交
1228

1229
	drive->dma = 0;
L
Linus Torvalds 已提交
1230

B
Borislav Petkov 已提交
1231
	/* sg request */
1232 1233 1234
	if (rq->bio || ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
		struct request_queue *q = drive->queue;
		unsigned int alignment;
1235
		char *buf;
L
Linus Torvalds 已提交
1236

1237
		if (rq->bio)
1238
			buf = bio_data(rq->bio);
1239
		else
1240
			buf = rq->data;
1241

1242
		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
L
Linus Torvalds 已提交
1243 1244 1245

		/*
		 * check if dma is safe
1246 1247 1248
		 *
		 * NOTE! The "len" and "addr" checks should possibly have
		 * separate masks.
L
Linus Torvalds 已提交
1249
		 */
1250
		alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1251 1252
		if ((unsigned long)buf & alignment
		    || rq->data_len & q->dma_pad_mask
1253
		    || object_is_on_stack(buf))
1254
			drive->dma = 0;
L
Linus Torvalds 已提交
1255 1256 1257
	}
}

1258
static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
1259
					sector_t block)
L
Linus Torvalds 已提交
1260 1261
{
	struct cdrom_info *info = drive->driver_data;
1262 1263
	ide_handler_t *fn;
	int xferlen;
L
Linus Torvalds 已提交
1264

1265 1266 1267 1268
	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);
1269

L
Linus Torvalds 已提交
1270
	if (blk_fs_request(rq)) {
1271
		if (drive->atapi_flags & IDE_AFLAG_SEEKING) {
1272
			ide_hwif_t *hwif = drive->hwif;
L
Linus Torvalds 已提交
1273
			unsigned long elapsed = jiffies - info->start_seek;
1274
			int stat = hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
1275

1276
			if ((stat & ATA_DSC) != ATA_DSC) {
L
Linus Torvalds 已提交
1277
				if (elapsed < IDECD_SEEK_TIMEOUT) {
1278 1279
					ide_stall_queue(drive,
							IDECD_SEEK_TIMER);
L
Linus Torvalds 已提交
1280 1281
					return ide_stopped;
				}
1282
				printk(KERN_ERR PFX "%s: DSC timeout\n",
1283
						drive->name);
L
Linus Torvalds 已提交
1284
			}
1285
			drive->atapi_flags &= ~IDE_AFLAG_SEEKING;
L
Linus Torvalds 已提交
1286
		}
1287 1288
		if (rq_data_dir(rq) == READ &&
		    IDE_LARGE_SEEK(info->last_block, block,
1289
			    IDECD_SEEK_THRESHOLD) &&
1290
		    (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP)) {
1291 1292
			xferlen = 0;
			fn = cdrom_start_seek_continuation;
1293

1294
			drive->dma = 0;
1295
			info->start_seek = jiffies;
1296 1297

			ide_cd_prepare_seek_request(drive, rq);
1298 1299 1300
		} else {
			xferlen = 32768;
			fn = cdrom_start_rw_cont;
1301

1302 1303
			if (cdrom_start_rw(drive, rq) == ide_stopped)
				return ide_stopped;
1304 1305 1306

			if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
				return ide_stopped;
1307
		}
L
Linus Torvalds 已提交
1308
		info->last_block = block;
1309
	} else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1310
		   rq->cmd_type == REQ_TYPE_ATA_PC) {
1311 1312
		xferlen = rq->data_len;
		fn = cdrom_do_newpc_cont;
1313 1314 1315 1316

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

1317
		cdrom_do_block_pc(drive, rq);
1318
	} else if (blk_special_request(rq)) {
B
Borislav Petkov 已提交
1319
		/* right now this can only be a reset... */
L
Linus Torvalds 已提交
1320 1321
		cdrom_end_request(drive, 1);
		return ide_stopped;
1322
	} else {
1323
		blk_dump_rq_flags(rq, DRV_NAME " bad flags");
1324 1325
		cdrom_end_request(drive, 0);
		return ide_stopped;
L
Linus Torvalds 已提交
1326
	}
1327 1328

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

B
Borislav Petkov 已提交
1331
/*
L
Linus Torvalds 已提交
1332 1333
 * Ioctl handling.
 *
B
Borislav Petkov 已提交
1334 1335 1336 1337 1338
 * 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 已提交
1339
 */
1340
static void msf_from_bcd(struct atapi_msf *msf)
L
Linus Torvalds 已提交
1341
{
A
Adrian Bunk 已提交
1342 1343 1344
	msf->minute = bcd2bin(msf->minute);
	msf->second = bcd2bin(msf->second);
	msf->frame  = bcd2bin(msf->frame);
L
Linus Torvalds 已提交
1345 1346
}

1347
int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1348 1349 1350
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
1351
	unsigned char cmd[BLK_MAX_CDB];
L
Linus Torvalds 已提交
1352

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

1355 1356
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_TEST_UNIT_READY;
L
Linus Torvalds 已提交
1357

1358
	/*
B
Borislav Petkov 已提交
1359 1360
	 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
	 * instead of supporting the LOAD_UNLOAD opcode.
1361
	 */
1362
	cmd[7] = cdi->sanyo_slot % 3;
L
Linus Torvalds 已提交
1363

1364
	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1365 1366 1367 1368 1369 1370 1371
}

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
			       unsigned long *sectors_per_frame,
			       struct request_sense *sense)
{
	struct {
1372 1373
		__be32 lba;
		__be32 blocklen;
L
Linus Torvalds 已提交
1374 1375 1376
	} capbuf;

	int stat;
1377 1378
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(capbuf);
1379
	u32 blocklen;
L
Linus Torvalds 已提交
1380

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

1383 1384
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_READ_CDVD_CAPACITY;
L
Linus Torvalds 已提交
1385

1386 1387
	stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
			       REQ_QUIET);
1388 1389 1390 1391 1392 1393
	if (stat)
		return stat;

	/*
	 * Sanity check the given block size
	 */
1394 1395 1396 1397 1398 1399
	blocklen = be32_to_cpu(capbuf.blocklen);
	switch (blocklen) {
	case 512:
	case 1024:
	case 2048:
	case 4096:
1400 1401
		break;
	default:
1402 1403 1404 1405
		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);
1406
		blocklen = 2048;
1407
		break;
L
Linus Torvalds 已提交
1408 1409
	}

1410
	*capacity = 1 + be32_to_cpu(capbuf.lba);
1411
	*sectors_per_frame = blocklen >> SECTOR_BITS;
1412 1413 1414 1415

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

1416
	return 0;
L
Linus Torvalds 已提交
1417 1418 1419 1420 1421 1422
}

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

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

1427
	memset(cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1428

1429 1430 1431 1432 1433
	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 已提交
1434 1435

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

1438
	return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1439 1440 1441
}

/* Try to read the entire TOC for the disk into our internal buffer. */
1442
int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
{
	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;

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

L
Linus Torvalds 已提交
1457
	if (toc == NULL) {
B
Borislav Petkov 已提交
1458
		/* try to allocate space */
1459
		toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
L
Linus Torvalds 已提交
1460
		if (toc == NULL) {
1461
			printk(KERN_ERR PFX "%s: No cdrom TOC buffer!\n",
1462
					drive->name);
L
Linus Torvalds 已提交
1463 1464
			return -ENOMEM;
		}
1465
		info->toc = toc;
L
Linus Torvalds 已提交
1466 1467
	}

B
Borislav Petkov 已提交
1468 1469 1470 1471
	/*
	 * Check to see if the existing data is still valid. If it is,
	 * just return.
	 */
L
Linus Torvalds 已提交
1472 1473
	(void) cdrom_check_status(drive, sense);

1474
	if (drive->atapi_flags & IDE_AFLAG_TOC_VALID)
L
Linus Torvalds 已提交
1475 1476
		return 0;

B
Borislav Petkov 已提交
1477
	/* try to get the total cdrom capacity and sector size */
L
Linus Torvalds 已提交
1478 1479 1480 1481 1482 1483
	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 已提交
1484
	/* save a private copy of the TOC capacity for error handling */
1485 1486
	drive->probed_capacity = toc->capacity * sectors_per_frame;

L
Linus Torvalds 已提交
1487 1488 1489
	blk_queue_hardsect_size(drive->queue,
				sectors_per_frame << SECTOR_BITS);

B
Borislav Petkov 已提交
1490
	/* first read just the header, so we know how long the TOC is */
L
Linus Torvalds 已提交
1491 1492
	stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
				    sizeof(struct atapi_toc_header), sense);
1493 1494
	if (stat)
		return stat;
L
Linus Torvalds 已提交
1495

1496
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1497 1498
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1499 1500 1501 1502 1503 1504 1505 1506
	}

	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 已提交
1507
	/* now read the whole schmeer */
L
Linus Torvalds 已提交
1508 1509 1510 1511 1512 1513 1514
	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 已提交
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
		/*
		 * 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 已提交
1527 1528 1529 1530 1531 1532 1533
		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);
1534
		if (stat)
L
Linus Torvalds 已提交
1535
			return stat;
1536

1537
		if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1538 1539
			toc->hdr.first_track = (u8)bin2bcd(CDROM_LEADOUT);
			toc->hdr.last_track = (u8)bin2bcd(CDROM_LEADOUT);
1540
		} else {
L
Linus Torvalds 已提交
1541 1542 1543 1544 1545 1546 1547 1548
			toc->hdr.first_track = CDROM_LEADOUT;
			toc->hdr.last_track = CDROM_LEADOUT;
		}
	}

	if (stat)
		return stat;

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

1551
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1552 1553
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1554 1555
	}

1556
	for (i = 0; i <= ntracks; i++) {
1557 1558
		if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
			if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD)
A
Adrian Bunk 已提交
1559
				toc->ent[i].track = bcd2bin(toc->ent[i].track);
L
Linus Torvalds 已提交
1560 1561
			msf_from_bcd(&toc->ent[i].addr.msf);
		}
1562 1563 1564
		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 已提交
1565 1566 1567
	}

	if (toc->hdr.first_track != CDROM_LEADOUT) {
B
Borislav Petkov 已提交
1568
		/* read the multisession information */
L
Linus Torvalds 已提交
1569 1570
		stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
1571 1572
		if (stat)
			return stat;
L
Linus Torvalds 已提交
1573 1574 1575

		toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
	} else {
1576 1577
		ms_tmp.hdr.last_track = CDROM_LEADOUT;
		ms_tmp.hdr.first_track = ms_tmp.hdr.last_track;
L
Linus Torvalds 已提交
1578 1579 1580
		toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
	}

1581
	if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
B
Borislav Petkov 已提交
1582
		/* re-read multisession information using MSF format */
L
Linus Torvalds 已提交
1583 1584 1585 1586 1587
		stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
		if (stat)
			return stat;

1588
		msf_from_bcd(&ms_tmp.ent.addr.msf);
L
Linus Torvalds 已提交
1589
		toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1590
						   ms_tmp.ent.addr.msf.second,
L
Linus Torvalds 已提交
1591 1592 1593 1594 1595
						   ms_tmp.ent.addr.msf.frame);
	}

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

B
Borislav Petkov 已提交
1596
	/* now try to get the total cdrom capacity */
L
Linus Torvalds 已提交
1597 1598 1599 1600
	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);
1601
		drive->probed_capacity = toc->capacity * sectors_per_frame;
L
Linus Torvalds 已提交
1602 1603 1604
	}

	/* Remember that we've read this stuff. */
1605
	drive->atapi_flags |= IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
1606 1607 1608 1609

	return 0;
}

1610
int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1611 1612 1613 1614
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
	struct packet_command cgc;
1615
	int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1616

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

1619
	if ((drive->atapi_flags & IDE_AFLAG_FULL_CAPS_PAGE) == 0)
1620
		size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1621

1622
	init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
B
Borislav Petkov 已提交
1623 1624
	do {
		/* we seem to get stat=0x01,err=0x00 the first time (??) */
1625 1626 1627 1628 1629 1630 1631
		stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
		if (!stat)
			break;
	} while (--attempts);
	return stat;
}

1632
void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1633
{
1634
	struct cdrom_info *cd = drive->driver_data;
1635 1636
	u16 curspeed, maxspeed;

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

1639
	if (drive->atapi_flags & IDE_AFLAG_LE_SPEED_FIELDS) {
1640 1641
		curspeed = le16_to_cpup((__le16 *)&buf[8 + 14]);
		maxspeed = le16_to_cpup((__le16 *)&buf[8 + 8]);
1642
	} else {
1643 1644
		curspeed = be16_to_cpup((__be16 *)&buf[8 + 14]);
		maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
1645
	}
1646

1647 1648 1649
	ide_debug_log(IDE_DBG_PROBE, "%s: curspeed: %u, maxspeed: %u\n",
		      __func__, curspeed, maxspeed);

1650 1651
	cd->current_speed = (curspeed + (176/2)) / 176;
	cd->max_speed = (maxspeed + (176/2)) / 176;
1652 1653
}

1654 1655 1656 1657 1658 1659
#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 已提交
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672

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,
1673
	.capability		= IDE_CD_CAPABILITIES,
L
Linus Torvalds 已提交
1674 1675 1676
	.generic_packet		= ide_cdrom_packet,
};

1677
static int ide_cdrom_register(ide_drive_t *drive, int nslots)
L
Linus Torvalds 已提交
1678 1679 1680 1681
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *devinfo = &info->devinfo;

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

L
Linus Torvalds 已提交
1684
	devinfo->ops = &ide_cdrom_dops;
1685
	devinfo->speed = info->current_speed;
L
Linus Torvalds 已提交
1686
	devinfo->capacity = nslots;
1687
	devinfo->handle = drive;
L
Linus Torvalds 已提交
1688 1689
	strcpy(devinfo->name, drive->name);

1690
	if (drive->atapi_flags & IDE_AFLAG_NO_SPEED_SELECT)
1691 1692
		devinfo->mask |= CDC_SELECT_SPEED;

L
Linus Torvalds 已提交
1693 1694 1695 1696
	devinfo->disk = info->disk;
	return register_cdrom(devinfo);
}

1697
static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
L
Linus Torvalds 已提交
1698
{
1699 1700
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1701 1702
	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	mechtype_t mechtype;
L
Linus Torvalds 已提交
1703 1704
	int nslots = 1;

1705 1706 1707 1708
	ide_debug_log(IDE_DBG_PROBE, "Call %s, drive->media: 0x%x, "
		      "drive->atapi_flags: 0x%lx\n", __func__, drive->media,
		      drive->atapi_flags);

1709 1710 1711 1712
	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 已提交
1713
	if (drive->media == ide_optical) {
1714
		cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1715
		printk(KERN_ERR PFX "%s: ATAPI magneto-optical drive\n",
1716
				drive->name);
L
Linus Torvalds 已提交
1717 1718 1719
		return nslots;
	}

1720 1721
	if (drive->atapi_flags & IDE_AFLAG_PRE_ATAPI12) {
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1722
		cdi->mask &= ~CDC_PLAY_AUDIO;
L
Linus Torvalds 已提交
1723 1724 1725 1726
		return nslots;
	}

	/*
B
Borislav Petkov 已提交
1727 1728 1729 1730
	 * 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 已提交
1731
	 */
1732
	cdi->handle = drive;
L
Linus Torvalds 已提交
1733 1734
	cdi->ops = &ide_cdrom_dops;

1735
	if (ide_cdrom_get_capabilities(drive, buf))
L
Linus Torvalds 已提交
1736 1737
		return 0;

1738
	if ((buf[8 + 6] & 0x01) == 0)
1739
		drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
1740
	if (buf[8 + 6] & 0x08)
1741
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1742
	if (buf[8 + 3] & 0x01)
1743
		cdi->mask &= ~CDC_CD_R;
1744
	if (buf[8 + 3] & 0x02)
1745
		cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1746
	if (buf[8 + 2] & 0x38)
1747
		cdi->mask &= ~CDC_DVD;
1748
	if (buf[8 + 3] & 0x20)
1749
		cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1750
	if (buf[8 + 3] & 0x10)
1751
		cdi->mask &= ~CDC_DVD_R;
1752
	if ((buf[8 + 4] & 0x01) || (drive->atapi_flags & IDE_AFLAG_PLAY_AUDIO_OK))
1753
		cdi->mask &= ~CDC_PLAY_AUDIO;
1754 1755

	mechtype = buf[8 + 6] >> 5;
1756 1757 1758
	if (mechtype == mechtype_caddy ||
	    mechtype == mechtype_popup ||
	    (drive->atapi_flags & IDE_AFLAG_NO_AUTOCLOSE))
1759
		cdi->mask |= CDC_CLOSE_TRAY;
L
Linus Torvalds 已提交
1760 1761

	if (cdi->sanyo_slot > 0) {
1762
		cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1763
		nslots = 3;
1764 1765
	} else if (mechtype == mechtype_individual_changer ||
		   mechtype == mechtype_cartridge_changer) {
1766 1767
		nslots = cdrom_number_of_slots(cdi);
		if (nslots > 1)
1768
			cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1769 1770
	}

1771
	ide_cdrom_update_speed(drive, buf);
1772

1773
	printk(KERN_INFO PFX "%s: ATAPI", drive->name);
1774 1775

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

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

1781 1782 1783
	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",
1784
				 (cdi->mask & CDC_DVD_RAM) ? "" : "/RAM");
L
Linus Torvalds 已提交
1785

1786 1787 1788 1789
	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 已提交
1790

1791 1792 1793 1794
	if ((cdi->mask & CDC_SELECT_DISC) == 0)
		printk(KERN_CONT " changer w/%d slots", nslots);
	else
		printk(KERN_CONT " drive");
L
Linus Torvalds 已提交
1795

1796 1797
	printk(KERN_CONT ", %dkB Cache\n",
			 be16_to_cpup((__be16 *)&buf[8 + 12]));
L
Linus Torvalds 已提交
1798 1799 1800 1801

	return nslots;
}

B
Borislav Petkov 已提交
1802
/* standard prep_rq_fn that builds 10 byte cmds */
1803
static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1804 1805 1806 1807 1808
{
	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);

1809
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840

	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 已提交
1841
	/* transform 6-byte read/write commands to the 10-byte version */
L
Linus Torvalds 已提交
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
	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;
	}
1863

L
Linus Torvalds 已提交
1864 1865 1866
	return BLKPREP_OK;
}

1867
static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1868
{
1869
	if (blk_fs_request(rq))
L
Linus Torvalds 已提交
1870
		return ide_cdrom_prep_fs(q, rq);
1871
	else if (blk_pc_request(rq))
L
Linus Torvalds 已提交
1872 1873 1874 1875 1876
		return ide_cdrom_prep_pc(rq);

	return 0;
}

1877 1878 1879 1880 1881 1882
struct cd_list_entry {
	const char	*id_model;
	const char	*id_firmware;
	unsigned int	cd_flags;
};

1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
#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;
}

1894 1895
static int proc_idecd_read_capacity(char *page, char **start, off_t off,
					int count, int *eof, void *data)
1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
{
	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 }
};

1909
ide_devset_rw_flag(dsc_overlap, IDE_DFLAG_DSC_OVERLAP);
1910

1911 1912 1913
static const struct ide_proc_devset idecd_settings[] = {
	IDE_PROC_DEVSET(dsc_overlap, 0, 1),
	{ 0 },
1914
};
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924

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)
{
	return idecd_settings;
}
1925 1926
#endif

1927 1928
static const struct cd_list_entry ide_cd_quirks_list[] = {
	/* Limit transfer size per interrupt. */
1929 1930
	{ "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_AFLAG_LIMIT_NFRAMES	     },
	{ "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_AFLAG_LIMIT_NFRAMES	     },
1931
	/* SCR-3231 doesn't support the SET_CD_SPEED command. */
1932
	{ "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_AFLAG_NO_SPEED_SELECT	     },
1933
	/* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1934 1935
	{ "NEC CD-ROM DRIVE:260",    "1.01", IDE_AFLAG_TOCADDR_AS_BCD |
					     IDE_AFLAG_PRE_ATAPI12,	     },
1936
	/* Vertos 300, some versions of this drive like to talk BCD. */
1937
	{ "V003S0DS",		     NULL,   IDE_AFLAG_VERTOS_300_SSD,	     },
1938
	/* Vertos 600 ESD. */
1939
	{ "V006E0DS",		     NULL,   IDE_AFLAG_VERTOS_600_ESD,	     },
1940 1941 1942 1943
	/*
	 * Sanyo 3 CD changer uses a non-standard command for CD changing
	 * (by default standard ATAPI support for CD changers is used).
	 */
1944 1945 1946
	{ "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	     },
1947
	/* Stingray 8X CD-ROM. */
1948
	{ "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_AFLAG_PRE_ATAPI12 },
1949 1950 1951 1952
	/*
	 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
	 * mode sense page capabilities size, but older drives break.
	 */
1953 1954
	{ "ATAPI CD ROM DRIVE 50X MAX",	NULL,	IDE_AFLAG_FULL_CAPS_PAGE     },
	{ "WPI CDS-32X",		NULL,	IDE_AFLAG_FULL_CAPS_PAGE     },
1955
	/* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1956
	{ "",			     "241N", IDE_AFLAG_LE_SPEED_FIELDS       },
1957 1958 1959 1960
	/*
	 * Some drives used by Apple don't advertise audio play
	 * but they do support reading TOC & audio datas.
	 */
1961 1962 1963 1964 1965
	{ "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	     },
1966
	{ "Optiarc DVD RW AD-7200A", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
1967
	{ "Optiarc DVD RW AD-7543A", NULL,   IDE_AFLAG_NO_AUTOCLOSE	     },
1968
	{ "TEAC CD-ROM CD-224E",     NULL,   IDE_AFLAG_NO_AUTOCLOSE	     },
1969 1970 1971
	{ NULL, NULL, 0 }
};

1972
static unsigned int ide_cd_flags(u16 *id)
1973 1974 1975 1976
{
	const struct cd_list_entry *cle = ide_cd_quirks_list;

	while (cle->id_model) {
1977
		if (strcmp(cle->id_model, (char *)&id[ATA_ID_PROD]) == 0 &&
1978
		    (cle->id_firmware == NULL ||
1979
		     strstr((char *)&id[ATA_ID_FW_REV], cle->id_firmware)))
1980 1981 1982 1983 1984 1985 1986
			return cle->cd_flags;
		cle++;
	}

	return 0;
}

1987
static int ide_cdrom_setup(ide_drive_t *drive)
L
Linus Torvalds 已提交
1988
{
1989 1990
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1991 1992
	u16 *id = drive->id;
	char *fw_rev = (char *)&id[ATA_ID_FW_REV];
L
Linus Torvalds 已提交
1993 1994
	int nslots;

1995 1996
	ide_debug_log(IDE_DBG_PROBE, "Call %s\n", __func__);

L
Linus Torvalds 已提交
1997 1998
	blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
	blk_queue_dma_alignment(drive->queue, 31);
1999
	blk_queue_update_dma_pad(drive->queue, 15);
L
Linus Torvalds 已提交
2000 2001 2002 2003
	drive->queue->unplug_delay = (1 * HZ) / 1000;
	if (!drive->queue->unplug_delay)
		drive->queue->unplug_delay = 1;

2004 2005
	drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
	drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id);
L
Linus Torvalds 已提交
2006

2007
	if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
2008
	    fw_rev[4] == '1' && fw_rev[6] <= '2')
2009 2010 2011
		drive->atapi_flags |= (IDE_AFLAG_TOCTRACKS_AS_BCD |
				     IDE_AFLAG_TOCADDR_AS_BCD);
	else if ((drive->atapi_flags & IDE_AFLAG_VERTOS_600_ESD) &&
2012
		 fw_rev[4] == '1' && fw_rev[6] <= '2')
2013 2014
		drive->atapi_flags |= IDE_AFLAG_TOCTRACKS_AS_BCD;
	else if (drive->atapi_flags & IDE_AFLAG_SANYO_3CD)
B
Borislav Petkov 已提交
2015 2016
		/* 3 => use CD in slot 0 */
		cdi->sanyo_slot = 3;
L
Linus Torvalds 已提交
2017

2018
	nslots = ide_cdrom_probe_capabilities(drive);
L
Linus Torvalds 已提交
2019

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

2023 2024 2025 2026
	if (drive->next != drive)
		drive->dev_flags |= IDE_DFLAG_DSC_OVERLAP;
	else
		drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
L
Linus Torvalds 已提交
2027 2028

	if (ide_cdrom_register(drive, nslots)) {
2029
		printk(KERN_ERR PFX "%s: %s failed to register device with the"
2030
				" cdrom driver.\n", drive->name, __func__);
2031
		cd->devinfo.handle = NULL;
L
Linus Torvalds 已提交
2032 2033
		return 1;
	}
2034 2035

	ide_proc_register_driver(drive, cd->driver);
L
Linus Torvalds 已提交
2036 2037 2038
	return 0;
}

2039
static void ide_cd_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
2040 2041 2042
{
	struct cdrom_info *info = drive->driver_data;

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

2045
	ide_proc_unregister_driver(drive, info->driver);
L
Linus Torvalds 已提交
2046 2047 2048 2049 2050 2051 2052 2053

	del_gendisk(info->disk);

	ide_cd_put(info);
}

static void ide_cd_release(struct kref *kref)
{
2054
	struct cdrom_info *info = to_ide_drv(kref, cdrom_info);
L
Linus Torvalds 已提交
2055 2056 2057 2058
	struct cdrom_device_info *devinfo = &info->devinfo;
	ide_drive_t *drive = info->drive;
	struct gendisk *g = info->disk;

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

2061
	kfree(info->toc);
2062 2063
	if (devinfo->handle == drive)
		unregister_cdrom(devinfo);
2064
	drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
L
Linus Torvalds 已提交
2065 2066 2067 2068 2069 2070 2071
	drive->driver_data = NULL;
	blk_queue_prep_rq(drive->queue, NULL);
	g->private_data = NULL;
	put_disk(g);
	kfree(info);
}

2072
static int ide_cd_probe(ide_drive_t *);
L
Linus Torvalds 已提交
2073 2074

static ide_driver_t ide_cdrom_driver = {
2075
	.gen_driver = {
2076
		.owner		= THIS_MODULE,
2077 2078 2079
		.name		= "ide-cdrom",
		.bus		= &ide_bus_type,
	},
2080 2081
	.probe			= ide_cd_probe,
	.remove			= ide_cd_remove,
L
Linus Torvalds 已提交
2082
	.version		= IDECD_VERSION,
2083
	.do_request		= ide_cd_do_request,
L
Linus Torvalds 已提交
2084 2085
	.end_request		= ide_end_request,
	.error			= __ide_error,
2086
#ifdef CONFIG_IDE_PROC_FS
2087 2088
	.proc_entries		= ide_cd_proc_entries,
	.proc_devsets		= ide_cd_proc_devsets,
2089
#endif
L
Linus Torvalds 已提交
2090 2091
};

A
Al Viro 已提交
2092
static int idecd_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
2093
{
A
Al Viro 已提交
2094
	struct cdrom_info *info = ide_cd_get(bdev->bd_disk);
L
Linus Torvalds 已提交
2095 2096
	int rc = -ENOMEM;

2097
	if (!info)
L
Linus Torvalds 已提交
2098 2099
		return -ENXIO;

A
Al Viro 已提交
2100
	rc = cdrom_open(&info->devinfo, bdev, mode);
L
Linus Torvalds 已提交
2101 2102 2103 2104 2105 2106 2107

	if (rc < 0)
		ide_cd_put(info);

	return rc;
}

A
Al Viro 已提交
2108
static int idecd_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
2109
{
2110
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2111

A
Al Viro 已提交
2112
	cdrom_release(&info->devinfo, mode);
L
Linus Torvalds 已提交
2113 2114 2115 2116 2117 2118

	ide_cd_put(info);

	return 0;
}

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
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;
2144
	char spindown;
2145 2146 2147 2148 2149 2150 2151 2152

	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;
2153
	if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
2154 2155 2156 2157
		return -EFAULT;
	return 0;
}

A
Al Viro 已提交
2158
static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
2159 2160
			unsigned int cmd, unsigned long arg)
{
2161
	struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info);
L
Linus Torvalds 已提交
2162 2163
	int err;

2164
	switch (cmd) {
2165
	case CDROMSETSPINDOWN:
2166
		return idecd_set_spindown(&info->devinfo, arg);
2167
	case CDROMGETSPINDOWN:
2168 2169 2170
		return idecd_get_spindown(&info->devinfo, arg);
	default:
		break;
2171
	}
2172

2173
	err = generic_ide_ioctl(info->drive, bdev, cmd, arg);
L
Linus Torvalds 已提交
2174
	if (err == -EINVAL)
A
Al Viro 已提交
2175
		err = cdrom_ioctl(&info->devinfo, bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
2176 2177 2178 2179 2180 2181

	return err;
}

static int idecd_media_changed(struct gendisk *disk)
{
2182
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2183 2184 2185 2186 2187
	return cdrom_media_changed(&info->devinfo);
}

static int idecd_revalidate_disk(struct gendisk *disk)
{
2188
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
2189
	struct request_sense sense;
2190 2191 2192

	ide_cd_read_toc(info->drive, &sense);

L
Linus Torvalds 已提交
2193 2194 2195 2196
	return  0;
}

static struct block_device_operations idecd_ops = {
2197
	.owner			= THIS_MODULE,
A
Al Viro 已提交
2198 2199 2200
	.open			= idecd_open,
	.release		= idecd_release,
	.locked_ioctl		= idecd_ioctl,
2201 2202
	.media_changed		= idecd_media_changed,
	.revalidate_disk	= idecd_revalidate_disk
L
Linus Torvalds 已提交
2203 2204
};

B
Borislav Petkov 已提交
2205
/* module options */
2206
static char *ignore;
L
Linus Torvalds 已提交
2207
module_param(ignore, charp, 0400);
2208 2209 2210 2211

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

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

2214
static int ide_cd_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
2215 2216 2217 2218 2219
{
	struct cdrom_info *info;
	struct gendisk *g;
	struct request_sense sense;

2220 2221 2222 2223
	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 已提交
2224 2225
	if (!strstr("ide-cdrom", drive->driver_req))
		goto failed;
2226

L
Linus Torvalds 已提交
2227 2228
	if (drive->media != ide_cdrom && drive->media != ide_optical)
		goto failed;
2229

L
Linus Torvalds 已提交
2230 2231 2232
	/* skip drives that we were told to ignore */
	if (ignore != NULL) {
		if (strstr(ignore, drive->name)) {
2233
			printk(KERN_INFO PFX "ignoring drive %s\n",
2234
					 drive->name);
L
Linus Torvalds 已提交
2235 2236 2237
			goto failed;
		}
	}
2238 2239 2240

	drive->debug_mask = debug_mask;

2241
	info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
L
Linus Torvalds 已提交
2242
	if (info == NULL) {
2243
		printk(KERN_ERR PFX "%s: Can't allocate a cdrom structure\n",
2244
				drive->name);
L
Linus Torvalds 已提交
2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
		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)) {
2268
		ide_cd_release(&info->kref);
L
Linus Torvalds 已提交
2269 2270 2271
		goto failed;
	}

2272
	ide_cd_read_toc(drive, &sense);
L
Linus Torvalds 已提交
2273 2274 2275 2276 2277 2278 2279 2280
	g->fops = &idecd_ops;
	g->flags |= GENHD_FL_REMOVABLE;
	add_disk(g);
	return 0;

out_free_cd:
	kfree(info);
failed:
2281
	return -ENODEV;
L
Linus Torvalds 已提交
2282 2283 2284 2285
}

static void __exit ide_cdrom_exit(void)
{
2286
	driver_unregister(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2287
}
2288 2289

static int __init ide_cdrom_init(void)
L
Linus Torvalds 已提交
2290
{
2291
	printk(KERN_INFO DRV_NAME " driver " IDECD_VERSION "\n");
2292
	return driver_register(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2293 2294
}

2295
MODULE_ALIAS("ide:*m-cdrom*");
2296
MODULE_ALIAS("ide-cd");
L
Linus Torvalds 已提交
2297 2298 2299
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部