ide-cd.c 53.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 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
static DEFINE_MUTEX(idecd_ref_mutex);
L
Linus Torvalds 已提交
57

58 59
static void ide_cd_release(struct kref *);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/*
B
Borislav Petkov 已提交
166 167 168
	 * If a read toc is executed for a CD-R or CD-RW medium where the first
	 * toc has not been recorded yet, it will fail with 05/24/00 (which is a
	 * confusing error)
L
Linus Torvalds 已提交
169 170 171 172 173
	 */
	if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
		if (sense->sense_key == 0x05 && sense->asc == 0x24)
			return;

B
Borislav Petkov 已提交
174 175
	/* current error */
	if (sense->error_code == 0x70) {
176
		switch (sense->sense_key) {
177 178 179 180 181 182 183 184 185 186 187 188 189 190
		case MEDIUM_ERROR:
		case VOLUME_OVERFLOW:
		case ILLEGAL_REQUEST:
			if (!sense->valid)
				break;
			if (failed_command == NULL ||
					!blk_fs_request(failed_command))
				break;
			sector = (sense->information[0] << 24) |
				 (sense->information[1] << 16) |
				 (sense->information[2] <<  8) |
				 (sense->information[3]);

			if (drive->queue->hardsect_size == 2048)
B
Borislav Petkov 已提交
191 192
				/* device sector size is 2K */
				sector <<= 2;
193 194

			bio_sectors = max(bio_sectors(failed_command->bio), 4U);
195
			sector &= ~(bio_sectors - 1);
196

197 198 199 200 201 202 203 204
			/*
			 * The SCSI specification allows for the value
			 * returned by READ CAPACITY to be up to 75 2K
			 * sectors past the last readable block.
			 * Therefore, if we hit a medium error within the
			 * last 75 2K sectors, we decrease the saved size
			 * value.
			 */
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
	struct request *rq = drive->hwif->rq;
L
Linus Torvalds 已提交
251 252
	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
	struct request *rq = hwif->rq;
L
Linus Torvalds 已提交
318
	int stat, err, sense_key;
319

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		if (blk_noretry_request(rq))
			do_end_request = 1;

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

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

B
Borislav Petkov 已提交
414 415
				/*
				 * Allow the drive 5 seconds to recover, some
L
Linus Torvalds 已提交
416
				 * devices will return this error while flushing
B
Borislav Petkov 已提交
417 418
				 * data from cache.
				 */
L
Linus Torvalds 已提交
419
				if (!rq->errors)
420 421
					info->write_timeout = jiffies +
							ATAPI_WAIT_WRITE_BUSY;
L
Linus Torvalds 已提交
422 423 424 425
				rq->errors = 1;
				if (time_after(jiffies, info->write_timeout))
					do_end_request = 1;
				else {
426
					struct request_queue *q = drive->queue;
L
Linus Torvalds 已提交
427 428 429
					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 435 436
					spin_lock_irqsave(q->queue_lock, flags);
					blk_plug_device(q);
					spin_unlock_irqrestore(q->queue_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
		struct request_queue *q = drive->queue;
506 507
		unsigned long flags;

508
		spin_lock_irqsave(q->queue_lock, flags);
509
		blkdev_dequeue_request(rq);
510
		spin_unlock_irqrestore(q->queue_lock, flags);
511

512
		hwif->rq = NULL;
513

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

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

/*
 * 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.
 */
526 527
static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
				int len, int ireason, int rw)
L
Linus Torvalds 已提交
528
{
529 530
	ide_hwif_t *hwif = drive->hwif;

531 532 533
	ide_debug_log(IDE_DBG_FUNC, "Call %s, ireason: 0x%x, rw: 0x%x\n",
		      __func__, ireason, rw);

534 535 536 537 538
	/*
	 * 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 已提交
539
		return 0;
540
	else if (ireason == (rw << 1)) {
541

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

546
		ide_pad_transfer(drive, rw, len);
547
	} else  if (rw == 0 && ireason == 1) {
B
Borislav Petkov 已提交
548 549 550
		/*
		 * Some drives (ASUS) seem to tell us that status info is
		 * available.  Just get it and ignore.
L
Linus Torvalds 已提交
551
		 */
552
		(void)hwif->tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
553 554
		return 0;
	} else {
B
Borislav Petkov 已提交
555
		/* drive wants a command packet, or invalid ireason... */
556
		printk(KERN_ERR PFX "%s: %s: bad interrupt reason 0x%02x\n",
557
				drive->name, __func__, ireason);
L
Linus Torvalds 已提交
558 559
	}

560 561 562
	if (rq->cmd_type == REQ_TYPE_ATA_PC)
		rq->cmd_flags |= REQ_FAILED;

L
Linus Torvalds 已提交
563 564 565 566
	cdrom_end_request(drive, 0);
	return -1;
}

567 568 569 570 571 572
/*
 * 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)
{
573 574
	ide_debug_log(IDE_DBG_FUNC, "Call %s, len: %d\n", __func__, len);

575 576 577
	if ((len % SECTOR_SIZE) == 0)
		return 0;

578 579
	printk(KERN_ERR PFX "%s: %s: Bad transfer size %d\n", drive->name,
			__func__, len);
580

581
	if (drive->atapi_flags & IDE_AFLAG_LIMIT_NFRAMES)
582 583
		printk(KERN_ERR PFX "This drive is not supported by this "
				"version of the driver\n");
584
	else {
585
		printk(KERN_ERR PFX "Trying to limit transfer sizes\n");
586
		drive->atapi_flags |= IDE_AFLAG_LIMIT_NFRAMES;
587 588 589 590 591
	}

	return 1;
}

592 593
static ide_startstop_t ide_cd_prepare_rw_request(ide_drive_t *drive,
						 struct request *rq)
L
Linus Torvalds 已提交
594
{
595 596 597
	ide_debug_log(IDE_DBG_RQ, "Call %s: rq->cmd_flags: 0x%x\n", __func__,
		      rq->cmd_flags);

598 599 600 601
	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 已提交
602

603 604 605 606 607 608 609 610 611 612 613
		/*
		 * 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 已提交
614
			/* sanity check... */
615 616
			if (rq->current_nr_sectors !=
			    bio_cur_sectors(rq->bio)) {
617
				printk(KERN_ERR PFX "%s: %s: buffer botch (%u)\n",
618
						drive->name, __func__,
619 620 621 622 623
						rq->current_nr_sectors);
				cdrom_end_request(drive, 0);
				return ide_stopped;
			}
			rq->current_nr_sectors += nskip;
L
Linus Torvalds 已提交
624 625
		}
	}
626

B
Borislav Petkov 已提交
627
	/* set up the command */
L
Linus Torvalds 已提交
628 629
	rq->timeout = ATAPI_WAIT_PC;

630 631 632
	return ide_started;
}

633
/*
B
Borislav Petkov 已提交
634 635
 * Fix up a possibly partially-processed request so that we can start it over
 * entirely, or even put it back on the request queue.
636
 */
637
static void ide_cd_restore_request(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
638
{
639 640 641

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

L
Linus Torvalds 已提交
642
	if (rq->buffer != bio_data(rq->bio)) {
643 644
		sector_t n =
			(rq->buffer - (char *)bio_data(rq->bio)) / SECTOR_SIZE;
L
Linus Torvalds 已提交
645 646 647 648 649

		rq->buffer = bio_data(rq->bio);
		rq->nr_sectors += n;
		rq->sector -= n;
	}
650 651
	rq->current_nr_sectors = bio_cur_sectors(rq->bio);
	rq->hard_cur_sectors = rq->current_nr_sectors;
L
Linus Torvalds 已提交
652 653 654 655 656
	rq->hard_nr_sectors = rq->nr_sectors;
	rq->hard_sector = rq->sector;
	rq->q->prep_rq_fn(rq->q, rq);
}

657
static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct request *rq)
658
{
659 660
	ide_debug_log(IDE_DBG_FUNC, "Call %s, rq->cmd[0]: 0x%x\n",
		      __func__, rq->cmd[0]);
661

662 663 664 665 666 667 668 669 670 671 672 673
	/*
	 * 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;
		}
}

674 675 676 677
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 已提交
678
{
679 680
	struct cdrom_info *info = drive->driver_data;
	struct request_sense local_sense;
L
Linus Torvalds 已提交
681
	int retries = 10;
682
	unsigned int flags = 0;
L
Linus Torvalds 已提交
683

684 685
	if (!sense)
		sense = &local_sense;
L
Linus Torvalds 已提交
686

687
	ide_debug_log(IDE_DBG_PC, "Call %s, cmd[0]: 0x%x, write: 0x%x, "
688 689 690
		      "timeout: %d, cmd_flags: 0x%x\n", __func__, cmd[0], write,
		      timeout, cmd_flags);

B
Borislav Petkov 已提交
691
	/* start of retry loop */
L
Linus Torvalds 已提交
692
	do {
693
		struct request *rq;
L
Linus Torvalds 已提交
694 695
		int error;

696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
		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 已提交
715

B
Borislav Petkov 已提交
716 717 718 719
		/*
		 * FIXME: we should probably abort/retry or something in case of
		 * failure.
		 */
720
		if (flags & REQ_FAILED) {
B
Borislav Petkov 已提交
721 722 723 724
			/*
			 * The request failed.  Retry if it was due to a unit
			 * attention status (usually means media was changed).
			 */
725
			struct request_sense *reqbuf = sense;
L
Linus Torvalds 已提交
726 727 728 729 730

			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 已提交
731 732 733 734 735
				/*
				 * 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 已提交
736 737
				ssleep(2);
			} else {
B
Borislav Petkov 已提交
738
				/* otherwise, don't retry */
L
Linus Torvalds 已提交
739 740 741 742 743
				retries = 0;
			}
			--retries;
		}

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

B
Borislav Petkov 已提交
747
	/* return an error if the command failed */
748
	return (flags & REQ_FAILED) ? -EIO : 0;
L
Linus Torvalds 已提交
749 750
}

751
/*
B
Borislav Petkov 已提交
752 753 754
 * 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.
755 756 757 758 759 760
 */
static int cdrom_newpc_intr_dummy_cb(struct request *rq)
{
	return 1;
}

L
Linus Torvalds 已提交
761 762
static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
{
763
	ide_hwif_t *hwif = drive->hwif;
764
	struct request *rq = hwif->rq;
L
Linus Torvalds 已提交
765
	xfer_func_t *xferfunc;
766
	ide_expiry_t *expiry = NULL;
767
	int dma_error = 0, dma, stat, thislen, uptodate = 0;
768 769
	int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
	unsigned int timeout;
770 771
	u16 len;
	u8 ireason;
L
Linus Torvalds 已提交
772

773 774 775
	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 已提交
776
	/* check for errors */
777
	dma = drive->dma;
L
Linus Torvalds 已提交
778
	if (dma) {
779
		drive->dma = 0;
780
		dma_error = hwif->dma_ops->dma_end(drive);
781
		if (dma_error) {
782
			printk(KERN_ERR PFX "%s: DMA %s error\n", drive->name,
783
					write ? "write" : "read");
784 785
			ide_dma_off(drive);
		}
L
Linus Torvalds 已提交
786 787 788 789 790
	}

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

B
Borislav Petkov 已提交
791
	/* using dma, transfer is complete now */
L
Linus Torvalds 已提交
792
	if (dma) {
793
		if (dma_error)
L
Linus Torvalds 已提交
794
			return ide_error(drive, "dma error", stat);
795 796 797
		if (blk_fs_request(rq)) {
			ide_end_request(drive, 1, rq->nr_sectors);
			return ide_stopped;
798 799 800
		} else if (rq->cmd_type == REQ_TYPE_ATA_PC && !rq->bio) {
			ide_end_request(drive, 1, 1);
			return ide_stopped;
801
		}
802
		goto end_request;
L
Linus Torvalds 已提交
803 804
	}

805
	ide_read_bcount_and_ireason(drive, &len, &ireason);
806 807

	thislen = blk_fs_request(rq) ? len : rq->data_len;
L
Linus Torvalds 已提交
808 809 810
	if (thislen > len)
		thislen = len;

811 812 813
	ide_debug_log(IDE_DBG_PC, "%s: DRQ: stat: 0x%x, thislen: %d\n",
		      __func__, stat, thislen);

B
Borislav Petkov 已提交
814
	/* If DRQ is clear, the command has completed. */
815
	if ((stat & ATA_DRQ) == 0) {
816 817 818 819 820 821 822
		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) {
823
				printk(KERN_ERR PFX "%s: %s: data underrun "
824
						"(%d blocks)\n",
825
						drive->name, __func__,
826 827 828 829 830 831 832 833
						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)) {
834
			ide_cd_request_sense_fixup(drive, rq);
B
Borislav Petkov 已提交
835
			/* complain if we still have data left to transfer */
836 837 838
			uptodate = rq->data_len ? 0 : 1;
		}
		goto end_request;
839
	}
L
Linus Torvalds 已提交
840

B
Borislav Petkov 已提交
841
	/* check which way to transfer data */
842 843
	if (ide_cd_check_ireason(drive, rq, len, ireason, write))
		return ide_stopped;
844

845 846
	if (blk_fs_request(rq)) {
		if (write == 0) {
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
			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) {
862
				ide_pad_transfer(drive, write, nskip << 9);
863 864 865 866
				rq->current_nr_sectors -= nskip;
				thislen -= (nskip << 9);
			}
		}
867
	}
L
Linus Torvalds 已提交
868

869 870
	if (ireason == 0) {
		write = 1;
871
		xferfunc = hwif->tp_ops->output_data;
872
	} else {
873
		write = 0;
874
		xferfunc = hwif->tp_ops->input_data;
L
Linus Torvalds 已提交
875 876
	}

877 878 879
	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 已提交
880
	/* transfer data */
L
Linus Torvalds 已提交
881
	while (thislen > 0) {
882
		u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
883
		int blen = rq->data_len;
L
Linus Torvalds 已提交
884

B
Borislav Petkov 已提交
885
		/* bio backed? */
L
Linus Torvalds 已提交
886
		if (rq->bio) {
887 888 889 890 891 892 893
			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 已提交
894 895 896
		}

		if (!ptr) {
897 898
			if (blk_fs_request(rq) && !write)
				/*
899
				 * If the buffers are full, pipe the rest into
B
Borislav Petkov 已提交
900 901
				 * oblivion.
				 */
902
				ide_pad_transfer(drive, 0, thislen);
903
			else {
904
				printk(KERN_ERR PFX "%s: confused, missing data\n",
905 906 907 908 909
						drive->name);
				blk_dump_rq_flags(rq, rq_data_dir(rq)
						  ? "cdrom_newpc_intr, write"
						  : "cdrom_newpc_intr, read");
			}
L
Linus Torvalds 已提交
910 911 912 913 914 915
			break;
		}

		if (blen > thislen)
			blen = thislen;

916
		xferfunc(drive, NULL, ptr, blen);
L
Linus Torvalds 已提交
917 918 919 920

		thislen -= blen;
		len -= blen;

921 922 923 924 925 926 927 928 929 930 931
		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;

932 933 934 935 936 937
			/*
			 * 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().
			 */
938 939
			if (rq->bio)
				blk_end_request_callback(rq, 0, blen,
940
						 cdrom_newpc_intr_dummy_cb);
941 942 943
			else
				rq->data += blen;
		}
944 945
		if (!write && blk_sense_request(rq))
			rq->sense_len += blen;
L
Linus Torvalds 已提交
946 947
	}

B
Borislav Petkov 已提交
948
	/* pad, if necessary */
949
	if (!blk_fs_request(rq) && len > 0)
950
		ide_pad_transfer(drive, write, len);
L
Linus Torvalds 已提交
951

952 953 954 955
	if (blk_pc_request(rq)) {
		timeout = rq->timeout;
	} else {
		timeout = ATAPI_WAIT_PC;
956
		if (!blk_fs_request(rq))
957
			expiry = ide_cd_expiry;
958 959 960
	}

	ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
L
Linus Torvalds 已提交
961
	return ide_started;
962 963 964

end_request:
	if (blk_pc_request(rq)) {
965 966 967 968
		unsigned int dlen = rq->data_len;

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

970
		if (blk_end_request(rq, 0, dlen))
971
			BUG();
972

973
		hwif->rq = NULL;
974 975 976 977 978 979
	} else {
		if (!uptodate)
			rq->cmd_flags |= REQ_FAILED;
		cdrom_end_request(drive, uptodate);
	}
	return ide_stopped;
L
Linus Torvalds 已提交
980 981
}

982
static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
983
{
984 985 986 987
	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 已提交
988

989 990 991
	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);
992

993
	if (write) {
B
Borislav Petkov 已提交
994
		/* disk has become write protected */
995
		if (get_disk_ro(cd->disk)) {
996 997 998 999 1000 1001 1002 1003
			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.
		 */
1004
		ide_cd_restore_request(drive, rq);
L
Linus Torvalds 已提交
1005 1006
	}

B
Borislav Petkov 已提交
1007
	/* use DMA, if possible / writes *must* be hardware frame aligned */
1008 1009 1010 1011 1012 1013
	if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
	    (rq->sector & (sectors_per_frame - 1))) {
		if (write) {
			cdrom_end_request(drive, 0);
			return ide_stopped;
		}
1014
		drive->dma = 0;
1015
	} else
1016
		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
L
Linus Torvalds 已提交
1017

1018 1019
	if (write)
		cd->devinfo.media_written = 1;
L
Linus Torvalds 已提交
1020

1021
	return ide_started;
L
Linus Torvalds 已提交
1022 1023
}

1024
static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
L
Linus Torvalds 已提交
1025 1026
{

1027 1028
	ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, "
		      "rq->cmd_type: 0x%x\n", __func__, rq->cmd[0],
1029 1030
		      rq->cmd_type);

1031 1032 1033 1034
	if (blk_pc_request(rq))
		rq->cmd_flags |= REQ_QUIET;
	else
		rq->cmd_flags &= ~REQ_FAILED;
L
Linus Torvalds 已提交
1035

1036
	drive->dma = 0;
L
Linus Torvalds 已提交
1037

B
Borislav Petkov 已提交
1038
	/* sg request */
1039 1040 1041
	if (rq->bio || ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
		struct request_queue *q = drive->queue;
		unsigned int alignment;
1042
		char *buf;
L
Linus Torvalds 已提交
1043

1044
		if (rq->bio)
1045
			buf = bio_data(rq->bio);
1046
		else
1047
			buf = rq->data;
1048

1049
		drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
L
Linus Torvalds 已提交
1050 1051 1052

		/*
		 * check if dma is safe
1053 1054 1055
		 *
		 * NOTE! The "len" and "addr" checks should possibly have
		 * separate masks.
L
Linus Torvalds 已提交
1056
		 */
1057
		alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1058 1059
		if ((unsigned long)buf & alignment
		    || rq->data_len & q->dma_pad_mask
1060
		    || object_is_on_stack(buf))
1061
			drive->dma = 0;
L
Linus Torvalds 已提交
1062 1063 1064
	}
}

1065
static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
1066
					sector_t block)
L
Linus Torvalds 已提交
1067
{
1068 1069 1070 1071
	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);
1072

L
Linus Torvalds 已提交
1073
	if (blk_fs_request(rq)) {
1074 1075
		if (cdrom_start_rw(drive, rq) == ide_stopped)
			return ide_stopped;
1076

1077 1078
		if (ide_cd_prepare_rw_request(drive, rq) == ide_stopped)
			return ide_stopped;
1079
	} else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1080
		   rq->cmd_type == REQ_TYPE_ATA_PC) {
1081 1082 1083
		if (!rq->timeout)
			rq->timeout = ATAPI_WAIT_PC;

1084
		cdrom_do_block_pc(drive, rq);
1085
	} else if (blk_special_request(rq)) {
B
Borislav Petkov 已提交
1086
		/* right now this can only be a reset... */
L
Linus Torvalds 已提交
1087 1088
		cdrom_end_request(drive, 1);
		return ide_stopped;
1089
	} else {
1090
		blk_dump_rq_flags(rq, DRV_NAME " bad flags");
1091 1092
		cdrom_end_request(drive, 0);
		return ide_stopped;
L
Linus Torvalds 已提交
1093
	}
1094

1095
	return ide_issue_pc(drive);
L
Linus Torvalds 已提交
1096 1097
}

B
Borislav Petkov 已提交
1098
/*
L
Linus Torvalds 已提交
1099 1100
 * Ioctl handling.
 *
B
Borislav Petkov 已提交
1101 1102 1103 1104 1105
 * 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 已提交
1106
 */
1107
static void msf_from_bcd(struct atapi_msf *msf)
L
Linus Torvalds 已提交
1108
{
A
Adrian Bunk 已提交
1109 1110 1111
	msf->minute = bcd2bin(msf->minute);
	msf->second = bcd2bin(msf->second);
	msf->frame  = bcd2bin(msf->frame);
L
Linus Torvalds 已提交
1112 1113
}

1114
int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1115 1116 1117
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
1118
	unsigned char cmd[BLK_MAX_CDB];
L
Linus Torvalds 已提交
1119

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

1122 1123
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_TEST_UNIT_READY;
L
Linus Torvalds 已提交
1124

1125
	/*
B
Borislav Petkov 已提交
1126 1127
	 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to switch CDs
	 * instead of supporting the LOAD_UNLOAD opcode.
1128
	 */
1129
	cmd[7] = cdi->sanyo_slot % 3;
L
Linus Torvalds 已提交
1130

1131
	return ide_cd_queue_pc(drive, cmd, 0, NULL, NULL, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1132 1133 1134 1135 1136 1137 1138
}

static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
			       unsigned long *sectors_per_frame,
			       struct request_sense *sense)
{
	struct {
1139 1140
		__be32 lba;
		__be32 blocklen;
L
Linus Torvalds 已提交
1141 1142 1143
	} capbuf;

	int stat;
1144 1145
	unsigned char cmd[BLK_MAX_CDB];
	unsigned len = sizeof(capbuf);
1146
	u32 blocklen;
L
Linus Torvalds 已提交
1147

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

1150 1151
	memset(cmd, 0, BLK_MAX_CDB);
	cmd[0] = GPCMD_READ_CDVD_CAPACITY;
L
Linus Torvalds 已提交
1152

1153 1154
	stat = ide_cd_queue_pc(drive, cmd, 0, &capbuf, &len, sense, 0,
			       REQ_QUIET);
1155 1156 1157 1158 1159 1160
	if (stat)
		return stat;

	/*
	 * Sanity check the given block size
	 */
1161 1162 1163 1164 1165 1166
	blocklen = be32_to_cpu(capbuf.blocklen);
	switch (blocklen) {
	case 512:
	case 1024:
	case 2048:
	case 4096:
1167 1168
		break;
	default:
1169 1170 1171 1172
		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);
1173
		blocklen = 2048;
1174
		break;
L
Linus Torvalds 已提交
1175 1176
	}

1177
	*capacity = 1 + be32_to_cpu(capbuf.lba);
1178
	*sectors_per_frame = blocklen >> SECTOR_BITS;
1179 1180 1181 1182

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

1183
	return 0;
L
Linus Torvalds 已提交
1184 1185 1186 1187 1188 1189
}

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

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

1194
	memset(cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1195

1196 1197 1198 1199 1200
	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 已提交
1201 1202

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

1205
	return ide_cd_queue_pc(drive, cmd, 0, buf, &buflen, sense, 0, REQ_QUIET);
L
Linus Torvalds 已提交
1206 1207 1208
}

/* Try to read the entire TOC for the disk into our internal buffer. */
1209
int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
L
Linus Torvalds 已提交
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
{
	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;

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

L
Linus Torvalds 已提交
1224
	if (toc == NULL) {
B
Borislav Petkov 已提交
1225
		/* try to allocate space */
1226
		toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
L
Linus Torvalds 已提交
1227
		if (toc == NULL) {
1228
			printk(KERN_ERR PFX "%s: No cdrom TOC buffer!\n",
1229
					drive->name);
L
Linus Torvalds 已提交
1230 1231
			return -ENOMEM;
		}
1232
		info->toc = toc;
L
Linus Torvalds 已提交
1233 1234
	}

B
Borislav Petkov 已提交
1235 1236 1237 1238
	/*
	 * Check to see if the existing data is still valid. If it is,
	 * just return.
	 */
L
Linus Torvalds 已提交
1239 1240
	(void) cdrom_check_status(drive, sense);

1241
	if (drive->atapi_flags & IDE_AFLAG_TOC_VALID)
L
Linus Torvalds 已提交
1242 1243
		return 0;

B
Borislav Petkov 已提交
1244
	/* try to get the total cdrom capacity and sector size */
L
Linus Torvalds 已提交
1245 1246 1247 1248 1249 1250
	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 已提交
1251
	/* save a private copy of the TOC capacity for error handling */
1252 1253
	drive->probed_capacity = toc->capacity * sectors_per_frame;

L
Linus Torvalds 已提交
1254 1255 1256
	blk_queue_hardsect_size(drive->queue,
				sectors_per_frame << SECTOR_BITS);

B
Borislav Petkov 已提交
1257
	/* first read just the header, so we know how long the TOC is */
L
Linus Torvalds 已提交
1258 1259
	stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
				    sizeof(struct atapi_toc_header), sense);
1260 1261
	if (stat)
		return stat;
L
Linus Torvalds 已提交
1262

1263
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1264 1265
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1266 1267 1268 1269 1270 1271 1272 1273
	}

	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 已提交
1274
	/* now read the whole schmeer */
L
Linus Torvalds 已提交
1275 1276 1277 1278 1279 1280 1281
	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 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
		/*
		 * 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 已提交
1294 1295 1296 1297 1298 1299 1300
		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);
1301
		if (stat)
L
Linus Torvalds 已提交
1302
			return stat;
1303

1304
		if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1305 1306
			toc->hdr.first_track = (u8)bin2bcd(CDROM_LEADOUT);
			toc->hdr.last_track = (u8)bin2bcd(CDROM_LEADOUT);
1307
		} else {
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313 1314 1315
			toc->hdr.first_track = CDROM_LEADOUT;
			toc->hdr.last_track = CDROM_LEADOUT;
		}
	}

	if (stat)
		return stat;

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

1318
	if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD) {
A
Adrian Bunk 已提交
1319 1320
		toc->hdr.first_track = bcd2bin(toc->hdr.first_track);
		toc->hdr.last_track  = bcd2bin(toc->hdr.last_track);
L
Linus Torvalds 已提交
1321 1322
	}

1323
	for (i = 0; i <= ntracks; i++) {
1324 1325
		if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
			if (drive->atapi_flags & IDE_AFLAG_TOCTRACKS_AS_BCD)
A
Adrian Bunk 已提交
1326
				toc->ent[i].track = bcd2bin(toc->ent[i].track);
L
Linus Torvalds 已提交
1327 1328
			msf_from_bcd(&toc->ent[i].addr.msf);
		}
1329 1330 1331
		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 已提交
1332 1333 1334
	}

	if (toc->hdr.first_track != CDROM_LEADOUT) {
B
Borislav Petkov 已提交
1335
		/* read the multisession information */
L
Linus Torvalds 已提交
1336 1337
		stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
1338 1339
		if (stat)
			return stat;
L
Linus Torvalds 已提交
1340 1341 1342

		toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
	} else {
1343 1344
		ms_tmp.hdr.last_track = CDROM_LEADOUT;
		ms_tmp.hdr.first_track = ms_tmp.hdr.last_track;
L
Linus Torvalds 已提交
1345 1346 1347
		toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
	}

1348
	if (drive->atapi_flags & IDE_AFLAG_TOCADDR_AS_BCD) {
B
Borislav Petkov 已提交
1349
		/* re-read multisession information using MSF format */
L
Linus Torvalds 已提交
1350 1351 1352 1353 1354
		stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
					   sizeof(ms_tmp), sense);
		if (stat)
			return stat;

1355
		msf_from_bcd(&ms_tmp.ent.addr.msf);
L
Linus Torvalds 已提交
1356
		toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1357
						   ms_tmp.ent.addr.msf.second,
L
Linus Torvalds 已提交
1358 1359 1360 1361 1362
						   ms_tmp.ent.addr.msf.frame);
	}

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

B
Borislav Petkov 已提交
1363
	/* now try to get the total cdrom capacity */
L
Linus Torvalds 已提交
1364 1365 1366 1367
	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);
1368
		drive->probed_capacity = toc->capacity * sectors_per_frame;
L
Linus Torvalds 已提交
1369 1370 1371
	}

	/* Remember that we've read this stuff. */
1372
	drive->atapi_flags |= IDE_AFLAG_TOC_VALID;
L
Linus Torvalds 已提交
1373 1374 1375 1376

	return 0;
}

1377
int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1378 1379 1380 1381
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *cdi = &info->devinfo;
	struct packet_command cgc;
1382
	int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1383

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

1386
	if ((drive->atapi_flags & IDE_AFLAG_FULL_CAPS_PAGE) == 0)
1387
		size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1388

1389
	init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
B
Borislav Petkov 已提交
1390 1391
	do {
		/* we seem to get stat=0x01,err=0x00 the first time (??) */
1392 1393 1394 1395 1396 1397 1398
		stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
		if (!stat)
			break;
	} while (--attempts);
	return stat;
}

1399
void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1400
{
1401
	struct cdrom_info *cd = drive->driver_data;
1402 1403
	u16 curspeed, maxspeed;

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

1406
	if (drive->atapi_flags & IDE_AFLAG_LE_SPEED_FIELDS) {
1407 1408
		curspeed = le16_to_cpup((__le16 *)&buf[8 + 14]);
		maxspeed = le16_to_cpup((__le16 *)&buf[8 + 8]);
1409
	} else {
1410 1411
		curspeed = be16_to_cpup((__be16 *)&buf[8 + 14]);
		maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
1412
	}
1413

1414 1415 1416
	ide_debug_log(IDE_DBG_PROBE, "%s: curspeed: %u, maxspeed: %u\n",
		      __func__, curspeed, maxspeed);

1417 1418
	cd->current_speed = (curspeed + (176/2)) / 176;
	cd->max_speed = (maxspeed + (176/2)) / 176;
1419 1420
}

1421 1422 1423 1424 1425 1426
#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 已提交
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439

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,
1440
	.capability		= IDE_CD_CAPABILITIES,
L
Linus Torvalds 已提交
1441 1442 1443
	.generic_packet		= ide_cdrom_packet,
};

1444
static int ide_cdrom_register(ide_drive_t *drive, int nslots)
L
Linus Torvalds 已提交
1445 1446 1447 1448
{
	struct cdrom_info *info = drive->driver_data;
	struct cdrom_device_info *devinfo = &info->devinfo;

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

L
Linus Torvalds 已提交
1451
	devinfo->ops = &ide_cdrom_dops;
1452
	devinfo->speed = info->current_speed;
L
Linus Torvalds 已提交
1453
	devinfo->capacity = nslots;
1454
	devinfo->handle = drive;
L
Linus Torvalds 已提交
1455 1456
	strcpy(devinfo->name, drive->name);

1457
	if (drive->atapi_flags & IDE_AFLAG_NO_SPEED_SELECT)
1458 1459
		devinfo->mask |= CDC_SELECT_SPEED;

L
Linus Torvalds 已提交
1460 1461 1462 1463
	devinfo->disk = info->disk;
	return register_cdrom(devinfo);
}

1464
static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
L
Linus Torvalds 已提交
1465
{
1466 1467
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1468 1469
	u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
	mechtype_t mechtype;
L
Linus Torvalds 已提交
1470 1471
	int nslots = 1;

1472 1473 1474 1475
	ide_debug_log(IDE_DBG_PROBE, "Call %s, drive->media: 0x%x, "
		      "drive->atapi_flags: 0x%lx\n", __func__, drive->media,
		      drive->atapi_flags);

1476 1477 1478 1479
	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 已提交
1480
	if (drive->media == ide_optical) {
1481
		cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1482
		printk(KERN_ERR PFX "%s: ATAPI magneto-optical drive\n",
1483
				drive->name);
L
Linus Torvalds 已提交
1484 1485 1486
		return nslots;
	}

1487 1488
	if (drive->atapi_flags & IDE_AFLAG_PRE_ATAPI12) {
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1489
		cdi->mask &= ~CDC_PLAY_AUDIO;
L
Linus Torvalds 已提交
1490 1491 1492 1493
		return nslots;
	}

	/*
B
Borislav Petkov 已提交
1494 1495 1496 1497
	 * 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 已提交
1498
	 */
1499
	cdi->handle = drive;
L
Linus Torvalds 已提交
1500 1501
	cdi->ops = &ide_cdrom_dops;

1502
	if (ide_cdrom_get_capabilities(drive, buf))
L
Linus Torvalds 已提交
1503 1504
		return 0;

1505
	if ((buf[8 + 6] & 0x01) == 0)
1506
		drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
1507
	if (buf[8 + 6] & 0x08)
1508
		drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
1509
	if (buf[8 + 3] & 0x01)
1510
		cdi->mask &= ~CDC_CD_R;
1511
	if (buf[8 + 3] & 0x02)
1512
		cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1513
	if (buf[8 + 2] & 0x38)
1514
		cdi->mask &= ~CDC_DVD;
1515
	if (buf[8 + 3] & 0x20)
1516
		cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1517
	if (buf[8 + 3] & 0x10)
1518
		cdi->mask &= ~CDC_DVD_R;
1519
	if ((buf[8 + 4] & 0x01) || (drive->atapi_flags & IDE_AFLAG_PLAY_AUDIO_OK))
1520
		cdi->mask &= ~CDC_PLAY_AUDIO;
1521 1522

	mechtype = buf[8 + 6] >> 5;
1523 1524 1525
	if (mechtype == mechtype_caddy ||
	    mechtype == mechtype_popup ||
	    (drive->atapi_flags & IDE_AFLAG_NO_AUTOCLOSE))
1526
		cdi->mask |= CDC_CLOSE_TRAY;
L
Linus Torvalds 已提交
1527 1528

	if (cdi->sanyo_slot > 0) {
1529
		cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1530
		nslots = 3;
1531 1532
	} else if (mechtype == mechtype_individual_changer ||
		   mechtype == mechtype_cartridge_changer) {
1533 1534
		nslots = cdrom_number_of_slots(cdi);
		if (nslots > 1)
1535
			cdi->mask &= ~CDC_SELECT_DISC;
L
Linus Torvalds 已提交
1536 1537
	}

1538
	ide_cdrom_update_speed(drive, buf);
1539

1540
	printk(KERN_INFO PFX "%s: ATAPI", drive->name);
1541 1542

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

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

1548 1549 1550
	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",
1551
				 (cdi->mask & CDC_DVD_RAM) ? "" : "/RAM");
L
Linus Torvalds 已提交
1552

1553 1554 1555 1556
	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 已提交
1557

1558 1559 1560 1561
	if ((cdi->mask & CDC_SELECT_DISC) == 0)
		printk(KERN_CONT " changer w/%d slots", nslots);
	else
		printk(KERN_CONT " drive");
L
Linus Torvalds 已提交
1562

1563 1564
	printk(KERN_CONT ", %dkB Cache\n",
			 be16_to_cpup((__be16 *)&buf[8 + 12]));
L
Linus Torvalds 已提交
1565 1566 1567 1568

	return nslots;
}

B
Borislav Petkov 已提交
1569
/* standard prep_rq_fn that builds 10 byte cmds */
1570
static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1571 1572 1573 1574 1575
{
	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);

1576
	memset(rq->cmd, 0, BLK_MAX_CDB);
L
Linus Torvalds 已提交
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607

	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 已提交
1608
	/* transform 6-byte read/write commands to the 10-byte version */
L
Linus Torvalds 已提交
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
	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;
	}
1630

L
Linus Torvalds 已提交
1631 1632 1633
	return BLKPREP_OK;
}

1634
static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
L
Linus Torvalds 已提交
1635
{
1636
	if (blk_fs_request(rq))
L
Linus Torvalds 已提交
1637
		return ide_cdrom_prep_fs(q, rq);
1638
	else if (blk_pc_request(rq))
L
Linus Torvalds 已提交
1639 1640 1641 1642 1643
		return ide_cdrom_prep_pc(rq);

	return 0;
}

1644 1645 1646 1647 1648 1649
struct cd_list_entry {
	const char	*id_model;
	const char	*id_firmware;
	unsigned int	cd_flags;
};

1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
#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;
}

1661 1662
static int proc_idecd_read_capacity(char *page, char **start, off_t off,
					int count, int *eof, void *data)
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
{
	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 }
};

1676 1677 1678 1679 1680 1681 1682
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)
{
1683
	return NULL;
1684
}
1685 1686
#endif

1687 1688
static const struct cd_list_entry ide_cd_quirks_list[] = {
	/* Limit transfer size per interrupt. */
1689 1690
	{ "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_AFLAG_LIMIT_NFRAMES	     },
	{ "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_AFLAG_LIMIT_NFRAMES	     },
1691
	/* SCR-3231 doesn't support the SET_CD_SPEED command. */
1692
	{ "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_AFLAG_NO_SPEED_SELECT	     },
1693
	/* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1694 1695
	{ "NEC CD-ROM DRIVE:260",    "1.01", IDE_AFLAG_TOCADDR_AS_BCD |
					     IDE_AFLAG_PRE_ATAPI12,	     },
1696
	/* Vertos 300, some versions of this drive like to talk BCD. */
1697
	{ "V003S0DS",		     NULL,   IDE_AFLAG_VERTOS_300_SSD,	     },
1698
	/* Vertos 600 ESD. */
1699
	{ "V006E0DS",		     NULL,   IDE_AFLAG_VERTOS_600_ESD,	     },
1700 1701 1702 1703
	/*
	 * Sanyo 3 CD changer uses a non-standard command for CD changing
	 * (by default standard ATAPI support for CD changers is used).
	 */
1704 1705 1706
	{ "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	     },
1707
	/* Stingray 8X CD-ROM. */
1708
	{ "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_AFLAG_PRE_ATAPI12 },
1709 1710 1711 1712
	/*
	 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
	 * mode sense page capabilities size, but older drives break.
	 */
1713 1714
	{ "ATAPI CD ROM DRIVE 50X MAX",	NULL,	IDE_AFLAG_FULL_CAPS_PAGE     },
	{ "WPI CDS-32X",		NULL,	IDE_AFLAG_FULL_CAPS_PAGE     },
1715
	/* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1716
	{ "",			     "241N", IDE_AFLAG_LE_SPEED_FIELDS       },
1717 1718 1719 1720
	/*
	 * Some drives used by Apple don't advertise audio play
	 * but they do support reading TOC & audio datas.
	 */
1721 1722 1723 1724 1725
	{ "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	     },
1726
	{ "Optiarc DVD RW AD-7200A", NULL,   IDE_AFLAG_PLAY_AUDIO_OK	     },
1727
	{ "Optiarc DVD RW AD-7543A", NULL,   IDE_AFLAG_NO_AUTOCLOSE	     },
1728
	{ "TEAC CD-ROM CD-224E",     NULL,   IDE_AFLAG_NO_AUTOCLOSE	     },
1729 1730 1731
	{ NULL, NULL, 0 }
};

1732
static unsigned int ide_cd_flags(u16 *id)
1733 1734 1735 1736
{
	const struct cd_list_entry *cle = ide_cd_quirks_list;

	while (cle->id_model) {
1737
		if (strcmp(cle->id_model, (char *)&id[ATA_ID_PROD]) == 0 &&
1738
		    (cle->id_firmware == NULL ||
1739
		     strstr((char *)&id[ATA_ID_FW_REV], cle->id_firmware)))
1740 1741 1742 1743 1744 1745 1746
			return cle->cd_flags;
		cle++;
	}

	return 0;
}

1747
static int ide_cdrom_setup(ide_drive_t *drive)
L
Linus Torvalds 已提交
1748
{
1749 1750
	struct cdrom_info *cd = drive->driver_data;
	struct cdrom_device_info *cdi = &cd->devinfo;
1751 1752
	u16 *id = drive->id;
	char *fw_rev = (char *)&id[ATA_ID_FW_REV];
L
Linus Torvalds 已提交
1753 1754
	int nslots;

1755 1756
	ide_debug_log(IDE_DBG_PROBE, "Call %s\n", __func__);

L
Linus Torvalds 已提交
1757 1758
	blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
	blk_queue_dma_alignment(drive->queue, 31);
1759
	blk_queue_update_dma_pad(drive->queue, 15);
L
Linus Torvalds 已提交
1760 1761 1762 1763
	drive->queue->unplug_delay = (1 * HZ) / 1000;
	if (!drive->queue->unplug_delay)
		drive->queue->unplug_delay = 1;

1764 1765
	drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
	drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id);
L
Linus Torvalds 已提交
1766

1767
	if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
1768
	    fw_rev[4] == '1' && fw_rev[6] <= '2')
1769 1770 1771
		drive->atapi_flags |= (IDE_AFLAG_TOCTRACKS_AS_BCD |
				     IDE_AFLAG_TOCADDR_AS_BCD);
	else if ((drive->atapi_flags & IDE_AFLAG_VERTOS_600_ESD) &&
1772
		 fw_rev[4] == '1' && fw_rev[6] <= '2')
1773 1774
		drive->atapi_flags |= IDE_AFLAG_TOCTRACKS_AS_BCD;
	else if (drive->atapi_flags & IDE_AFLAG_SANYO_3CD)
B
Borislav Petkov 已提交
1775 1776
		/* 3 => use CD in slot 0 */
		cdi->sanyo_slot = 3;
L
Linus Torvalds 已提交
1777

1778
	nslots = ide_cdrom_probe_capabilities(drive);
L
Linus Torvalds 已提交
1779

B
Borislav Petkov 已提交
1780
	/* set correct block size */
L
Linus Torvalds 已提交
1781 1782 1783
	blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);

	if (ide_cdrom_register(drive, nslots)) {
1784
		printk(KERN_ERR PFX "%s: %s failed to register device with the"
1785
				" cdrom driver.\n", drive->name, __func__);
1786
		cd->devinfo.handle = NULL;
L
Linus Torvalds 已提交
1787 1788
		return 1;
	}
1789 1790

	ide_proc_register_driver(drive, cd->driver);
L
Linus Torvalds 已提交
1791 1792 1793
	return 0;
}

1794
static void ide_cd_remove(ide_drive_t *drive)
L
Linus Torvalds 已提交
1795 1796 1797
{
	struct cdrom_info *info = drive->driver_data;

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

1800
	ide_proc_unregister_driver(drive, info->driver);
L
Linus Torvalds 已提交
1801 1802 1803 1804 1805 1806 1807 1808

	del_gendisk(info->disk);

	ide_cd_put(info);
}

static void ide_cd_release(struct kref *kref)
{
1809
	struct cdrom_info *info = to_ide_drv(kref, cdrom_info);
L
Linus Torvalds 已提交
1810 1811 1812 1813
	struct cdrom_device_info *devinfo = &info->devinfo;
	ide_drive_t *drive = info->drive;
	struct gendisk *g = info->disk;

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

1816
	kfree(info->toc);
1817 1818
	if (devinfo->handle == drive)
		unregister_cdrom(devinfo);
L
Linus Torvalds 已提交
1819 1820 1821 1822 1823 1824 1825
	drive->driver_data = NULL;
	blk_queue_prep_rq(drive->queue, NULL);
	g->private_data = NULL;
	put_disk(g);
	kfree(info);
}

1826
static int ide_cd_probe(ide_drive_t *);
L
Linus Torvalds 已提交
1827

1828
static struct ide_driver ide_cdrom_driver = {
1829
	.gen_driver = {
1830
		.owner		= THIS_MODULE,
1831 1832 1833
		.name		= "ide-cdrom",
		.bus		= &ide_bus_type,
	},
1834 1835
	.probe			= ide_cd_probe,
	.remove			= ide_cd_remove,
L
Linus Torvalds 已提交
1836
	.version		= IDECD_VERSION,
1837
	.do_request		= ide_cd_do_request,
L
Linus Torvalds 已提交
1838
	.end_request		= ide_end_request,
1839
#ifdef CONFIG_IDE_PROC_FS
1840 1841
	.proc_entries		= ide_cd_proc_entries,
	.proc_devsets		= ide_cd_proc_devsets,
1842
#endif
L
Linus Torvalds 已提交
1843 1844
};

A
Al Viro 已提交
1845
static int idecd_open(struct block_device *bdev, fmode_t mode)
L
Linus Torvalds 已提交
1846
{
A
Al Viro 已提交
1847
	struct cdrom_info *info = ide_cd_get(bdev->bd_disk);
L
Linus Torvalds 已提交
1848 1849
	int rc = -ENOMEM;

1850
	if (!info)
L
Linus Torvalds 已提交
1851 1852
		return -ENXIO;

A
Al Viro 已提交
1853
	rc = cdrom_open(&info->devinfo, bdev, mode);
L
Linus Torvalds 已提交
1854 1855 1856 1857 1858 1859 1860

	if (rc < 0)
		ide_cd_put(info);

	return rc;
}

A
Al Viro 已提交
1861
static int idecd_release(struct gendisk *disk, fmode_t mode)
L
Linus Torvalds 已提交
1862
{
1863
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
1864

A
Al Viro 已提交
1865
	cdrom_release(&info->devinfo, mode);
L
Linus Torvalds 已提交
1866 1867 1868 1869 1870 1871

	ide_cd_put(info);

	return 0;
}

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
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;
1897
	char spindown;
1898 1899 1900 1901 1902 1903 1904 1905

	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;
1906
	if (copy_to_user((void __user *)arg, &spindown, sizeof(char)))
1907 1908 1909 1910
		return -EFAULT;
	return 0;
}

A
Al Viro 已提交
1911
static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
L
Linus Torvalds 已提交
1912 1913
			unsigned int cmd, unsigned long arg)
{
1914
	struct cdrom_info *info = ide_drv_g(bdev->bd_disk, cdrom_info);
L
Linus Torvalds 已提交
1915 1916
	int err;

1917
	switch (cmd) {
1918
	case CDROMSETSPINDOWN:
1919
		return idecd_set_spindown(&info->devinfo, arg);
1920
	case CDROMGETSPINDOWN:
1921 1922 1923
		return idecd_get_spindown(&info->devinfo, arg);
	default:
		break;
1924
	}
1925

1926
	err = generic_ide_ioctl(info->drive, bdev, cmd, arg);
L
Linus Torvalds 已提交
1927
	if (err == -EINVAL)
A
Al Viro 已提交
1928
		err = cdrom_ioctl(&info->devinfo, bdev, mode, cmd, arg);
L
Linus Torvalds 已提交
1929 1930 1931 1932 1933 1934

	return err;
}

static int idecd_media_changed(struct gendisk *disk)
{
1935
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
1936 1937 1938 1939 1940
	return cdrom_media_changed(&info->devinfo);
}

static int idecd_revalidate_disk(struct gendisk *disk)
{
1941
	struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
L
Linus Torvalds 已提交
1942
	struct request_sense sense;
1943 1944 1945

	ide_cd_read_toc(info->drive, &sense);

L
Linus Torvalds 已提交
1946 1947 1948 1949
	return  0;
}

static struct block_device_operations idecd_ops = {
1950
	.owner			= THIS_MODULE,
A
Al Viro 已提交
1951 1952 1953
	.open			= idecd_open,
	.release		= idecd_release,
	.locked_ioctl		= idecd_ioctl,
1954 1955
	.media_changed		= idecd_media_changed,
	.revalidate_disk	= idecd_revalidate_disk
L
Linus Torvalds 已提交
1956 1957
};

B
Borislav Petkov 已提交
1958
/* module options */
1959
static char *ignore;
L
Linus Torvalds 已提交
1960
module_param(ignore, charp, 0400);
1961 1962 1963 1964

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

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

1967
static int ide_cd_probe(ide_drive_t *drive)
L
Linus Torvalds 已提交
1968 1969 1970 1971 1972
{
	struct cdrom_info *info;
	struct gendisk *g;
	struct request_sense sense;

1973 1974 1975 1976
	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 已提交
1977 1978
	if (!strstr("ide-cdrom", drive->driver_req))
		goto failed;
1979

L
Linus Torvalds 已提交
1980 1981
	if (drive->media != ide_cdrom && drive->media != ide_optical)
		goto failed;
1982

L
Linus Torvalds 已提交
1983 1984 1985
	/* skip drives that we were told to ignore */
	if (ignore != NULL) {
		if (strstr(ignore, drive->name)) {
1986
			printk(KERN_INFO PFX "ignoring drive %s\n",
1987
					 drive->name);
L
Linus Torvalds 已提交
1988 1989 1990
			goto failed;
		}
	}
1991 1992

	drive->debug_mask = debug_mask;
1993
	drive->irq_handler = cdrom_newpc_intr;
1994

1995
	info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
L
Linus Torvalds 已提交
1996
	if (info == NULL) {
1997
		printk(KERN_ERR PFX "%s: Can't allocate a cdrom structure\n",
1998
				drive->name);
L
Linus Torvalds 已提交
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
		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)) {
2022
		ide_cd_release(&info->kref);
L
Linus Torvalds 已提交
2023 2024 2025
		goto failed;
	}

2026
	ide_cd_read_toc(drive, &sense);
L
Linus Torvalds 已提交
2027 2028 2029 2030 2031 2032 2033 2034
	g->fops = &idecd_ops;
	g->flags |= GENHD_FL_REMOVABLE;
	add_disk(g);
	return 0;

out_free_cd:
	kfree(info);
failed:
2035
	return -ENODEV;
L
Linus Torvalds 已提交
2036 2037 2038 2039
}

static void __exit ide_cdrom_exit(void)
{
2040
	driver_unregister(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2041
}
2042 2043

static int __init ide_cdrom_init(void)
L
Linus Torvalds 已提交
2044
{
2045
	printk(KERN_INFO DRV_NAME " driver " IDECD_VERSION "\n");
2046
	return driver_register(&ide_cdrom_driver.gen_driver);
L
Linus Torvalds 已提交
2047 2048
}

2049
MODULE_ALIAS("ide:*m-cdrom*");
2050
MODULE_ALIAS("ide-cd");
L
Linus Torvalds 已提交
2051 2052 2053
module_init(ide_cdrom_init);
module_exit(ide_cdrom_exit);
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部