ide-atapi.c 15.5 KB
Newer Older
1 2 3 4 5 6 7
/*
 * ATAPI support.
 */

#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
8 9 10 11 12 13 14 15 16
#include <scsi/scsi.h>

#ifdef DEBUG
#define debug_log(fmt, args...) \
	printk(KERN_INFO "ide: " fmt, ## args)
#else
#define debug_log(fmt, args...) do {} while (0)
#endif

17 18 19 20 21 22
static inline int dev_is_idecd(ide_drive_t *drive)
{
	return (drive->media == ide_cdrom || drive->media == ide_optical) &&
		!(drive->dev_flags & IDE_DFLAG_SCSI);
}

23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
/*
 * Check whether we can support a device,
 * based on the ATAPI IDENTIFY command results.
 */
int ide_check_atapi_device(ide_drive_t *drive, const char *s)
{
	u16 *id = drive->id;
	u8 gcw[2], protocol, device_type, removable, drq_type, packet_size;

	*((u16 *)&gcw) = id[ATA_ID_CONFIG];

	protocol    = (gcw[1] & 0xC0) >> 6;
	device_type =  gcw[1] & 0x1F;
	removable   = (gcw[0] & 0x80) >> 7;
	drq_type    = (gcw[0] & 0x60) >> 5;
	packet_size =  gcw[0] & 0x03;

#ifdef CONFIG_PPC
	/* kludge for Apple PowerBook internal zip */
	if (drive->media == ide_floppy && device_type == 5 &&
	    !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") &&
	    strstr((char *)&id[ATA_ID_PROD], "ZIP"))
		device_type = 0;
#endif

	if (protocol != 2)
		printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n",
			s, drive->name, protocol);
	else if ((drive->media == ide_floppy && device_type != 0) ||
		 (drive->media == ide_tape && device_type != 1))
		printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n",
			s, drive->name, device_type);
	else if (removable == 0)
		printk(KERN_ERR "%s: %s: the removable flag is not set\n",
			s, drive->name);
	else if (drive->media == ide_floppy && drq_type == 3)
		printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not "
			"supported\n", s, drive->name, drq_type);
	else if (packet_size != 0)
		printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 "
			"bytes\n", s, drive->name, packet_size);
	else
		return 1;
	return 0;
}
EXPORT_SYMBOL_GPL(ide_check_atapi_device);

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
/* PIO data transfer routine using the scatter gather table. */
int ide_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
		    unsigned int bcount, int write)
{
	ide_hwif_t *hwif = drive->hwif;
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
	xfer_func_t *xf = write ? tp_ops->output_data : tp_ops->input_data;
	struct scatterlist *sg = pc->sg;
	char *buf;
	int count, done = 0;

	while (bcount) {
		count = min(sg->length - pc->b_count, bcount);

		if (PageHighMem(sg_page(sg))) {
			unsigned long flags;

			local_irq_save(flags);
			buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset;
			xf(drive, NULL, buf + pc->b_count, count);
			kunmap_atomic(buf - sg->offset, KM_IRQ0);
			local_irq_restore(flags);
		} else {
			buf = sg_virt(sg);
			xf(drive, NULL, buf + pc->b_count, count);
		}

		bcount -= count;
		pc->b_count += count;
		done += count;

		if (pc->b_count == sg->length) {
			if (!--pc->sg_cnt)
				break;
			pc->sg = sg = sg_next(sg);
			pc->b_count = 0;
		}
	}

	if (bcount) {
		printk(KERN_ERR "%s: %d leftover bytes, %s\n", drive->name,
			bcount, write ? "padding with zeros"
				      : "discarding data");
		ide_pad_transfer(drive, write, bcount);
	}

	return done;
}
EXPORT_SYMBOL_GPL(ide_io_buffers);

120 121 122 123 124 125 126 127
void ide_init_pc(struct ide_atapi_pc *pc)
{
	memset(pc, 0, sizeof(*pc));
	pc->buf = pc->pc_buf;
	pc->buf_size = IDE_PC_BUFFER_SIZE;
}
EXPORT_SYMBOL_GPL(ide_init_pc);

128 129 130 131 132
/*
 * Generate a new packet command request in front of the request queue, before
 * the current request, so that it will be processed immediately, on the next
 * pass through the driver.
 */
133 134
static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
			      struct ide_atapi_pc *pc, struct request *rq)
135 136 137 138 139 140 141 142 143 144 145 146
{
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_SPECIAL;
	rq->cmd_flags |= REQ_PREEMPT;
	rq->buffer = (char *)pc;
	rq->rq_disk = disk;
	memcpy(rq->cmd, pc->c, 12);
	if (drive->media == ide_tape)
		rq->cmd[13] = REQ_IDETAPE_PC1;
	ide_do_drive_cmd(drive, rq);
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
/*
 * Add a special packet command request to the tail of the request queue,
 * and wait for it to be serviced.
 */
int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
		      struct ide_atapi_pc *pc)
{
	struct request *rq;
	int error;

	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->cmd_type = REQ_TYPE_SPECIAL;
	rq->buffer = (char *)pc;
	memcpy(rq->cmd, pc->c, 12);
	if (drive->media == ide_tape)
		rq->cmd[13] = REQ_IDETAPE_PC1;
	error = blk_execute_rq(drive->queue, disk, rq, 0);
	blk_put_request(rq);

	return error;
}
EXPORT_SYMBOL_GPL(ide_queue_pc_tail);

170 171 172 173 174 175 176 177 178 179 180
int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
{
	struct ide_atapi_pc pc;

	ide_init_pc(&pc);
	pc.c[0] = TEST_UNIT_READY;

	return ide_queue_pc_tail(drive, disk, &pc);
}
EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
{
	struct ide_atapi_pc pc;

	ide_init_pc(&pc);
	pc.c[0] = START_STOP;
	pc.c[4] = start;

	if (drive->media == ide_tape)
		pc.flags |= PC_FLAG_WAIT_FOR_DSC;

	return ide_queue_pc_tail(drive, disk, &pc);
}
EXPORT_SYMBOL_GPL(ide_do_start_stop);

196 197 198 199
int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
{
	struct ide_atapi_pc pc;

200
	if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
201 202 203 204 205 206 207 208 209 210
		return 0;

	ide_init_pc(&pc);
	pc.c[0] = ALLOW_MEDIUM_REMOVAL;
	pc.c[4] = on;

	return ide_queue_pc_tail(drive, disk, &pc);
}
EXPORT_SYMBOL_GPL(ide_set_media_lock);

211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
{
	ide_init_pc(pc);
	pc->c[0] = REQUEST_SENSE;
	if (drive->media == ide_floppy) {
		pc->c[4] = 255;
		pc->req_xfer = 18;
	} else {
		pc->c[4] = 20;
		pc->req_xfer = 20;
	}
}
EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);

/*
 * Called when an error was detected during the last packet command.
 * We queue a request sense packet command in the head of the request list.
 */
void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk)
{
	struct request *rq = &drive->request_sense_rq;
	struct ide_atapi_pc *pc = &drive->request_sense_pc;

	(void)ide_read_error(drive);
	ide_create_request_sense_cmd(drive, pc);
	if (drive->media == ide_tape)
		set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
	ide_queue_pc_head(drive, disk, pc, rq);
}
EXPORT_SYMBOL_GPL(ide_retry_pc);

242 243 244 245 246 247 248 249 250 251 252 253 254
int ide_scsi_expiry(ide_drive_t *drive)
{
	struct ide_atapi_pc *pc = drive->pc;

	debug_log("%s called for %lu at %lu\n", __func__,
		  pc->scsi_cmd->serial_number, jiffies);

	pc->flags |= PC_FLAG_TIMEDOUT;

	return 0; /* we do not want the IDE subsystem to retry */
}
EXPORT_SYMBOL_GPL(ide_scsi_expiry);

255 256 257 258 259 260
/*
 * This is the usual interrupt handler which will be called during a packet
 * command.  We will transfer some of the data (as requested by the drive)
 * and will re-point interrupt handler to us.
 */
static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
261
{
262
	struct ide_atapi_pc *pc = drive->pc;
263
	ide_hwif_t *hwif = drive->hwif;
264
	struct request *rq = hwif->hwgroup->rq;
265
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
266
	xfer_func_t *xferfunc;
267 268
	ide_expiry_t *expiry;
	unsigned int timeout, temp;
269
	u16 bcount;
B
Bartlomiej Zolnierkiewicz 已提交
270
	u8 stat, ireason, scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI), dsc = 0;
271 272 273

	debug_log("Enter %s - interrupt handler\n", __func__);

274 275 276 277 278 279 280 281 282
	if (scsi) {
		timeout = ide_scsi_get_timeout(pc);
		expiry = ide_scsi_expiry;
	} else {
		timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
						       : WAIT_TAPE_CMD;
		expiry = NULL;
	}

283
	if (pc->flags & PC_FLAG_TIMEDOUT) {
284
		drive->pc_callback(drive, 0);
285 286 287 288
		return ide_stopped;
	}

	/* Clear the interrupt */
289
	stat = tp_ops->read_status(hwif);
290 291 292

	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
		if (hwif->dma_ops->dma_end(drive) ||
293
		    (drive->media == ide_tape && !scsi && (stat & ATA_ERR))) {
294 295 296 297 298 299 300
			if (drive->media == ide_floppy && !scsi)
				printk(KERN_ERR "%s: DMA %s error\n",
					drive->name, rq_data_dir(pc->rq)
						     ? "write" : "read");
			pc->flags |= PC_FLAG_DMA_ERROR;
		} else {
			pc->xferred = pc->req_xfer;
301 302
			if (drive->pc_update_buffers)
				drive->pc_update_buffers(drive, pc);
303 304 305 306 307
		}
		debug_log("%s: DMA finished\n", drive->name);
	}

	/* No more interrupts */
308
	if ((stat & ATA_DRQ) == 0) {
309 310 311 312 313 314 315 316
		debug_log("Packet command completed, %d bytes transferred\n",
			  pc->xferred);

		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;

		local_irq_enable_in_hardirq();

		if (drive->media == ide_tape && !scsi &&
317 318
		    (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
			stat &= ~ATA_ERR;
319

320
		if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
321 322 323 324 325 326 327 328 329
			/* Error detected */
			debug_log("%s: I/O error\n", drive->name);

			if (drive->media != ide_tape || scsi) {
				pc->rq->errors++;
				if (scsi)
					goto cmd_finished;
			}

330
			if (rq->cmd[0] == REQUEST_SENSE) {
331 332 333 334 335
				printk(KERN_ERR "%s: I/O error in request sense"
						" command\n", drive->name);
				return ide_do_reset(drive);
			}

336
			debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
337 338

			/* Retry operation */
339
			ide_retry_pc(drive, rq->rq_disk);
340

341 342 343 344 345
			/* queued, but not started */
			return ide_stopped;
		}
cmd_finished:
		pc->error = 0;
346 347 348

		if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
			dsc = 1;
349

350
		/* Command finished - Call the callback function */
351
		drive->pc_callback(drive, dsc);
352

353 354 355 356 357 358 359 360 361 362 363
		return ide_stopped;
	}

	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
		printk(KERN_ERR "%s: The device wants to issue more interrupts "
				"in DMA mode\n", drive->name);
		ide_dma_off(drive);
		return ide_do_reset(drive);
	}

364 365
	/* Get the number of bytes to transfer on this interrupt. */
	ide_read_bcount_and_ireason(drive, &bcount, &ireason);
366

367
	if (ireason & ATAPI_COD) {
368 369 370
		printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__);
		return ide_do_reset(drive);
	}
371

372 373
	if (((ireason & ATAPI_IO) == ATAPI_IO) ==
		!!(pc->flags & PC_FLAG_WRITING)) {
374 375 376
		/* Hopefully, we will never get here */
		printk(KERN_ERR "%s: We wanted to %s, but the device wants us "
				"to %s!\n", drive->name,
377 378
				(ireason & ATAPI_IO) ? "Write" : "Read",
				(ireason & ATAPI_IO) ? "Read" : "Write");
379 380
		return ide_do_reset(drive);
	}
381

382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	if (!(pc->flags & PC_FLAG_WRITING)) {
		/* Reading - Check that we have enough space */
		temp = pc->xferred + bcount;
		if (temp > pc->req_xfer) {
			if (temp > pc->buf_size) {
				printk(KERN_ERR "%s: The device wants to send "
						"us more data than expected - "
						"discarding data\n",
						drive->name);
				if (scsi)
					temp = pc->buf_size - pc->xferred;
				else
					temp = 0;
				if (temp) {
					if (pc->sg)
397 398
						drive->pc_io_buffers(drive, pc,
								     temp, 0);
399
					else
400
						tp_ops->input_data(drive, NULL,
401 402 403 404 405 406 407 408 409
							pc->cur_pos, temp);
					printk(KERN_ERR "%s: transferred %d of "
							"%d bytes\n",
							drive->name,
							temp, bcount);
				}
				pc->xferred += temp;
				pc->cur_pos += temp;
				ide_pad_transfer(drive, 0, bcount - temp);
410
				goto next_irq;
411 412 413 414
			}
			debug_log("The device wants to send us more data than "
				  "expected - allowing transfer\n");
		}
415
		xferfunc = tp_ops->input_data;
416
	} else
417
		xferfunc = tp_ops->output_data;
418 419 420

	if ((drive->media == ide_floppy && !scsi && !pc->buf) ||
	    (drive->media == ide_tape && !scsi && pc->bh) ||
421
	    (scsi && pc->sg)) {
422
		int done = drive->pc_io_buffers(drive, pc, bcount,
423 424 425 426 427 428
				  !!(pc->flags & PC_FLAG_WRITING));

		/* FIXME: don't do partial completions */
		if (drive->media == ide_floppy && !scsi)
			ide_end_request(drive, 1, done >> 9);
	} else
429 430 431 432 433 434 435
		xferfunc(drive, NULL, pc->cur_pos, bcount);

	/* Update the current position */
	pc->xferred += bcount;
	pc->cur_pos += bcount;

	debug_log("[cmd %x] transferred %d bytes on that intr.\n",
436
		  rq->cmd[0], bcount);
437
next_irq:
438
	/* And set the interrupt handler again */
439
	ide_set_handler(drive, ide_pc_intr, timeout, expiry);
440 441
	return ide_started;
}
442

443 444 445 446 447 448 449
static u8 ide_read_ireason(ide_drive_t *drive)
{
	ide_task_t task;

	memset(&task, 0, sizeof(task));
	task.tf_flags = IDE_TFLAG_IN_NSECT;

450
	drive->hwif->tp_ops->tf_read(drive, &task);
451 452 453 454

	return task.tf.nsect & 3;
}

455 456 457 458
static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
{
	int retries = 100;

459 460
	while (retries-- && ((ireason & ATAPI_COD) == 0 ||
		(ireason & ATAPI_IO))) {
461 462 463
		printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
				"a packet command, retrying\n", drive->name);
		udelay(100);
464
		ireason = ide_read_ireason(drive);
465 466 467 468
		if (retries == 0) {
			printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
					"a packet command, ignoring\n",
					drive->name);
469 470
			ireason |= ATAPI_COD;
			ireason &= ~ATAPI_IO;
471 472 473 474 475 476
		}
	}

	return ireason;
}

477 478 479 480 481 482 483 484 485 486
static int ide_delayed_transfer_pc(ide_drive_t *drive)
{
	/* Send the actual packet */
	drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12);

	/* Timeout for the packet command */
	return WAIT_FLOPPY_CMD;
}

static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
487
{
488
	struct ide_atapi_pc *pc = drive->pc;
489
	ide_hwif_t *hwif = drive->hwif;
490
	struct request *rq = hwif->hwgroup->rq;
491 492
	ide_expiry_t *expiry;
	unsigned int timeout;
493 494 495
	ide_startstop_t startstop;
	u8 ireason;

496
	if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
497 498 499 500 501
		printk(KERN_ERR "%s: Strange, packet command initiated yet "
				"DRQ isn't asserted\n", drive->name);
		return startstop;
	}

502
	ireason = ide_read_ireason(drive);
B
Bartlomiej Zolnierkiewicz 已提交
503 504
	if (drive->media == ide_tape &&
	    (drive->dev_flags & IDE_DFLAG_SCSI) == 0)
505 506
		ireason = ide_wait_ireason(drive, ireason);

507
	if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
508 509 510 511 512
		printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
				"a packet command\n", drive->name);
		return ide_do_reset(drive);
	}

513 514 515 516 517 518 519 520 521
	/*
	 * If necessary schedule the packet transfer to occur 'timeout'
	 * miliseconds later in ide_delayed_transfer_pc() after the device
	 * says it's ready for a packet.
	 */
	if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
		timeout = drive->pc_delay;
		expiry = &ide_delayed_transfer_pc;
	} else {
B
Bartlomiej Zolnierkiewicz 已提交
522
		if (drive->dev_flags & IDE_DFLAG_SCSI) {
523 524 525 526 527 528 529 530 531
			timeout = ide_scsi_get_timeout(pc);
			expiry = ide_scsi_expiry;
		} else {
			timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
							       : WAIT_TAPE_CMD;
			expiry = NULL;
		}
	}

532
	/* Set the interrupt routine */
533
	ide_set_handler(drive, ide_pc_intr, timeout, expiry);
534 535 536 537 538 539 540 541

	/* Begin DMA, if necessary */
	if (pc->flags & PC_FLAG_DMA_OK) {
		pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
		hwif->dma_ops->dma_start(drive);
	}

	/* Send the actual packet */
542
	if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
543
		hwif->tp_ops->output_data(drive, NULL, rq->cmd, 12);
544 545 546

	return ide_started;
}
547

548
ide_startstop_t ide_issue_pc(ide_drive_t *drive, unsigned int timeout,
549 550
			     ide_expiry_t *expiry)
{
551
	struct ide_atapi_pc *pc = drive->pc;
552
	ide_hwif_t *hwif = drive->hwif;
553
	u32 tf_flags;
554
	u16 bcount;
B
Borislav Petkov 已提交
555
	u8 scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI);
556 557 558 559 560 561

	/* We haven't transferred any data yet */
	pc->xferred = 0;
	pc->cur_pos = pc->buf;

	/* Request to transfer the entire buffer at once */
B
Bartlomiej Zolnierkiewicz 已提交
562
	if (drive->media == ide_tape && scsi == 0)
563 564 565 566 567 568 569 570 571
		bcount = pc->req_xfer;
	else
		bcount = min(pc->req_xfer, 63 * 1024);

	if (pc->flags & PC_FLAG_DMA_ERROR) {
		pc->flags &= ~PC_FLAG_DMA_ERROR;
		ide_dma_off(drive);
	}

B
Bartlomiej Zolnierkiewicz 已提交
572 573 574
	if ((pc->flags & PC_FLAG_DMA_OK) &&
	    (drive->dev_flags & IDE_DFLAG_USING_DMA)) {
		if (scsi)
575
			hwif->sg_mapped = 1;
B
Borislav Petkov 已提交
576
		drive->dma = !hwif->dma_ops->dma_setup(drive);
B
Bartlomiej Zolnierkiewicz 已提交
577
		if (scsi)
578 579 580
			hwif->sg_mapped = 0;
	}

B
Borislav Petkov 已提交
581
	if (!drive->dma)
582 583
		pc->flags &= ~PC_FLAG_DMA_OK;

584 585
	if (scsi)
		tf_flags = 0;
586
	else if (dev_is_idecd(drive))
587 588 589 590 591
		tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;
	else
		tf_flags = IDE_TFLAG_OUT_DEVICE;

	ide_pktcmd_tf_load(drive, tf_flags, bcount, drive->dma);
592 593

	/* Issue the packet command */
594
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
595
		ide_execute_command(drive, ATA_CMD_PACKET, ide_transfer_pc,
596 597 598 599
				    timeout, NULL);
		return ide_started;
	} else {
		ide_execute_pkt_cmd(drive);
600
		return ide_transfer_pc(drive);
601 602 603
	}
}
EXPORT_SYMBOL_GPL(ide_issue_pc);