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

#include <linux/kernel.h>
6
#include <linux/cdrom.h>
7 8
#include <linux/delay.h>
#include <linux/ide.h>
9 10 11 12 13 14 15 16 17
#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

18 19
#define ATAPI_MIN_CDB_BYTES	12

20 21
static inline int dev_is_idecd(ide_drive_t *drive)
{
22
	return drive->media == ide_cdrom || drive->media == ide_optical;
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 70 71
/*
 * 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);

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 120 121
/* 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);

122 123 124 125 126 127 128 129
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);

130 131 132 133 134
/*
 * 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.
 */
135 136
static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
			      struct ide_atapi_pc *pc, struct request *rq)
137 138 139 140 141 142
{
	blk_rq_init(NULL, rq);
	rq->cmd_type = REQ_TYPE_SPECIAL;
	rq->cmd_flags |= REQ_PREEMPT;
	rq->buffer = (char *)pc;
	rq->rq_disk = disk;
143 144 145 146 147 148

	if (pc->req_xfer) {
		rq->data = pc->buf;
		rq->data_len = pc->req_xfer;
	}

149 150 151
	memcpy(rq->cmd, pc->c, 12);
	if (drive->media == ide_tape)
		rq->cmd[13] = REQ_IDETAPE_PC1;
152 153 154 155

	drive->hwif->rq = NULL;

	elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
156 157
}

158 159 160 161 162 163 164 165 166 167 168 169 170
/*
 * 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;
171 172 173 174 175 176

	if (pc->req_xfer) {
		rq->data = pc->buf;
		rq->data_len = pc->req_xfer;
	}

177 178 179 180 181 182 183 184 185 186
	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);

187 188 189 190 191 192 193 194 195 196 197
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);

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
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);

213 214 215 216
int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
{
	struct ide_atapi_pc pc;

217
	if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
218 219 220 221 222 223 224 225 226 227
		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);

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
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);

259 260
int ide_cd_expiry(ide_drive_t *drive)
{
261
	struct request *rq = drive->hwif->rq;
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
	unsigned long wait = 0;

	debug_log("%s: rq->cmd[0]: 0x%x\n", __func__, rq->cmd[0]);

	/*
	 * 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.
	 */
	switch (rq->cmd[0]) {
	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))
			printk(KERN_INFO "cmd 0x%x timed out\n",
					 rq->cmd[0]);
		wait = 0;
		break;
	}
	return wait;
}
EXPORT_SYMBOL_GPL(ide_cd_expiry);

291 292 293 294 295 296 297 298 299 300 301 302
int ide_cd_get_xferlen(struct request *rq)
{
	if (blk_fs_request(rq))
		return 32768;
	else if (blk_sense_request(rq) || blk_pc_request(rq) ||
			 rq->cmd_type == REQ_TYPE_ATA_PC)
		return rq->data_len;
	else
		return 0;
}
EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);

303 304
void ide_read_bcount_and_ireason(ide_drive_t *drive, u16 *bcount, u8 *ireason)
{
305
	struct ide_cmd cmd;
306

307 308 309
	memset(&cmd, 0, sizeof(cmd));
	cmd.tf_flags = IDE_TFLAG_IN_LBAH | IDE_TFLAG_IN_LBAM |
		       IDE_TFLAG_IN_NSECT;
310

311
	drive->hwif->tp_ops->tf_read(drive, &cmd);
312

313 314
	*bcount = (cmd.tf.lbah << 8) | cmd.tf.lbam;
	*ireason = cmd.tf.nsect & 3;
315 316 317
}
EXPORT_SYMBOL_GPL(ide_read_bcount_and_ireason);

318 319 320 321 322 323
/*
 * 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)
324
{
325
	struct ide_atapi_pc *pc = drive->pc;
326
	ide_hwif_t *hwif = drive->hwif;
327
	struct request *rq = hwif->rq;
328
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
329
	xfer_func_t *xferfunc;
330
	unsigned int timeout, temp;
331
	u16 bcount;
332
	u8 stat, ireason, dsc = 0;
333 334 335

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

336 337
	timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
					       : WAIT_TAPE_CMD;
338

339
	/* Clear the interrupt */
340
	stat = tp_ops->read_status(hwif);
341 342 343

	if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
		if (hwif->dma_ops->dma_end(drive) ||
344 345
		    (drive->media == ide_tape && (stat & ATA_ERR))) {
			if (drive->media == ide_floppy)
346 347 348 349 350 351
				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;
352 353
			if (drive->pc_update_buffers)
				drive->pc_update_buffers(drive, pc);
354 355 356 357 358
		}
		debug_log("%s: DMA finished\n", drive->name);
	}

	/* No more interrupts */
359
	if ((stat & ATA_DRQ) == 0) {
360 361
		int uptodate;

362 363 364 365 366 367 368
		debug_log("Packet command completed, %d bytes transferred\n",
			  pc->xferred);

		pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;

		local_irq_enable_in_hardirq();

369
		if (drive->media == ide_tape &&
370 371
		    (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
			stat &= ~ATA_ERR;
372

373
		if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
374 375 376
			/* Error detected */
			debug_log("%s: I/O error\n", drive->name);

377
			if (drive->media != ide_tape)
378 379
				pc->rq->errors++;

380
			if (rq->cmd[0] == REQUEST_SENSE) {
381 382 383 384 385
				printk(KERN_ERR "%s: I/O error in request sense"
						" command\n", drive->name);
				return ide_do_reset(drive);
			}

386
			debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
387 388

			/* Retry operation */
389
			ide_retry_pc(drive, rq->rq_disk);
390

391 392 393 394
			/* queued, but not started */
			return ide_stopped;
		}
		pc->error = 0;
395 396 397

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

399
		/* Command finished - Call the callback function */
400 401 402 403 404
		uptodate = drive->pc_callback(drive, dsc);

		if (uptodate == 0)
			drive->failed_pc = NULL;

405 406
		if (blk_special_request(rq)) {
			rq->errors = 0;
407
			ide_complete_rq(drive, 0, blk_rq_bytes(rq));
408 409 410 411 412
		} else {
			if (blk_fs_request(rq) == 0 && uptodate <= 0) {
				if (rq->errors == 0)
					rq->errors = -EIO;
			}
413
			ide_end_request(drive, uptodate, 0);
414
		}
415

416 417 418 419 420 421 422 423 424 425 426
		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);
	}

427 428
	/* Get the number of bytes to transfer on this interrupt. */
	ide_read_bcount_and_ireason(drive, &bcount, &ireason);
429

430
	if (ireason & ATAPI_COD) {
431 432 433
		printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__);
		return ide_do_reset(drive);
	}
434

435 436
	if (((ireason & ATAPI_IO) == ATAPI_IO) ==
		!!(pc->flags & PC_FLAG_WRITING)) {
437 438 439
		/* Hopefully, we will never get here */
		printk(KERN_ERR "%s: We wanted to %s, but the device wants us "
				"to %s!\n", drive->name,
440 441
				(ireason & ATAPI_IO) ? "Write" : "Read",
				(ireason & ATAPI_IO) ? "Read" : "Write");
442 443
		return ide_do_reset(drive);
	}
444

445 446 447 448 449 450 451 452 453
	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);
454 455

				ide_pad_transfer(drive, 0, bcount);
456
				goto next_irq;
457 458 459 460
			}
			debug_log("The device wants to send us more data than "
				  "expected - allowing transfer\n");
		}
461
		xferfunc = tp_ops->input_data;
462
	} else
463
		xferfunc = tp_ops->output_data;
464

465 466
	if ((drive->media == ide_floppy && !pc->buf) ||
	    (drive->media == ide_tape && pc->bh)) {
467
		int done = drive->pc_io_buffers(drive, pc, bcount,
468 469 470
				  !!(pc->flags & PC_FLAG_WRITING));

		/* FIXME: don't do partial completions */
471
		if (drive->media == ide_floppy)
472 473
			ide_end_request(drive, 1, done >> 9);
	} else
474 475 476 477 478 479 480
		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",
481
		  rq->cmd[0], bcount);
482
next_irq:
483
	/* And set the interrupt handler again */
484
	ide_set_handler(drive, ide_pc_intr, timeout, NULL);
485 486
	return ide_started;
}
487

488 489 490
static void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount)
{
	ide_hwif_t *hwif = drive->hwif;
491
	struct ide_cmd cmd;
492 493
	u8 dma = drive->dma;

494 495 496 497 498 499
	memset(&cmd, 0, sizeof(cmd));
	cmd.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM |
		       IDE_TFLAG_OUT_FEATURE | tf_flags;
	cmd.tf.feature = dma;		/* Use PIO/DMA */
	cmd.tf.lbam    = bcount & 0xff;
	cmd.tf.lbah    = (bcount >> 8) & 0xff;
500

501
	ide_tf_dump(drive->name, &cmd.tf);
502 503
	hwif->tp_ops->set_irq(hwif, 1);
	SELECT_MASK(drive, 0);
504
	hwif->tp_ops->tf_load(drive, &cmd);
505 506
}

507 508
static u8 ide_read_ireason(ide_drive_t *drive)
{
509
	struct ide_cmd cmd;
510

511 512
	memset(&cmd, 0, sizeof(cmd));
	cmd.tf_flags = IDE_TFLAG_IN_NSECT;
513

514
	drive->hwif->tp_ops->tf_read(drive, &cmd);
515

516
	return cmd.tf.nsect & 3;
517 518
}

519 520 521 522
static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
{
	int retries = 100;

523 524
	while (retries-- && ((ireason & ATAPI_COD) == 0 ||
		(ireason & ATAPI_IO))) {
525 526 527
		printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
				"a packet command, retrying\n", drive->name);
		udelay(100);
528
		ireason = ide_read_ireason(drive);
529 530 531 532
		if (retries == 0) {
			printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
					"a packet command, ignoring\n",
					drive->name);
533 534
			ireason |= ATAPI_COD;
			ireason &= ~ATAPI_IO;
535 536 537 538 539 540
		}
	}

	return ireason;
}

541 542 543 544 545 546 547 548 549 550
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)
551
{
552
	struct ide_atapi_pc *uninitialized_var(pc);
553
	ide_hwif_t *hwif = drive->hwif;
554
	struct request *rq = hwif->rq;
555 556
	ide_expiry_t *expiry;
	unsigned int timeout;
557
	int cmd_len;
558 559 560
	ide_startstop_t startstop;
	u8 ireason;

561
	if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
562 563 564 565 566
		printk(KERN_ERR "%s: Strange, packet command initiated yet "
				"DRQ isn't asserted\n", drive->name);
		return startstop;
	}

567 568 569 570 571
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
		if (drive->dma)
			drive->waiting_for_dma = 1;
	}

572 573 574 575 576 577
	if (dev_is_idecd(drive)) {
		/* 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;

578 579
		timeout = rq->timeout;
		expiry  = ide_cd_expiry;
580
	} else {
581 582
		pc = drive->pc;

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
		cmd_len = ATAPI_MIN_CDB_BYTES;

		/*
		 * 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 {
			timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
							       : WAIT_TAPE_CMD;
			expiry = NULL;
		}
598 599 600 601 602 603 604 605 606 607 608

		ireason = ide_read_ireason(drive);
		if (drive->media == ide_tape)
			ireason = ide_wait_ireason(drive, ireason);

		if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
			printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
					"a packet command\n", drive->name);

			return ide_do_reset(drive);
		}
609 610
	}

611
	/* Set the interrupt routine */
612 613 614 615
	ide_set_handler(drive,
			(dev_is_idecd(drive) ? drive->irq_handler
					     : ide_pc_intr),
			timeout, expiry);
616 617

	/* Begin DMA, if necessary */
618 619 620 621 622 623 624 625
	if (dev_is_idecd(drive)) {
		if (drive->dma)
			hwif->dma_ops->dma_start(drive);
	} else {
		if (pc->flags & PC_FLAG_DMA_OK) {
			pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
			hwif->dma_ops->dma_start(drive);
		}
626 627 628
	}

	/* Send the actual packet */
629
	if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
630
		hwif->tp_ops->output_data(drive, NULL, rq->cmd, cmd_len);
631 632 633

	return ide_started;
}
634

635
ide_startstop_t ide_issue_pc(ide_drive_t *drive)
636
{
637
	struct ide_atapi_pc *pc;
638
	ide_hwif_t *hwif = drive->hwif;
639
	ide_expiry_t *expiry = NULL;
640
	struct request *rq = hwif->rq;
641
	unsigned int timeout;
642
	u32 tf_flags;
643
	u16 bcount;
644

645 646
	if (dev_is_idecd(drive)) {
		tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;
647
		bcount = ide_cd_get_xferlen(rq);
648
		expiry = ide_cd_expiry;
649
		timeout = ATAPI_WAIT_PC;
650

651 652 653 654 655 656
		if (drive->dma) {
			if (ide_build_sglist(drive, rq))
				drive->dma = !hwif->dma_ops->dma_setup(drive);
			else
				drive->dma = 0;
		}
657
	} else {
658 659 660 661 662 663
		pc = drive->pc;

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

664 665 666 667
		tf_flags = IDE_TFLAG_OUT_DEVICE;
		bcount = ((drive->media == ide_tape) ?
				pc->req_xfer :
				min(pc->req_xfer, 63 * 1024));
668

669 670 671 672
		if (pc->flags & PC_FLAG_DMA_ERROR) {
			pc->flags &= ~PC_FLAG_DMA_ERROR;
			ide_dma_off(drive);
		}
673

674
		if ((pc->flags & PC_FLAG_DMA_OK) &&
675 676 677 678 679 680
		     (drive->dev_flags & IDE_DFLAG_USING_DMA)) {
			if (ide_build_sglist(drive, rq))
				drive->dma = !hwif->dma_ops->dma_setup(drive);
			else
				drive->dma = 0;
		}
681

682 683
		if (!drive->dma)
			pc->flags &= ~PC_FLAG_DMA_OK;
684 685 686

		timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
						       : WAIT_TAPE_CMD;
687
	}
688

689
	ide_pktcmd_tf_load(drive, tf_flags, bcount);
690 691

	/* Issue the packet command */
692
	if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
693 694
		if (drive->dma)
			drive->waiting_for_dma = 0;
695
		ide_execute_command(drive, ATA_CMD_PACKET, ide_transfer_pc,
696
				    timeout, expiry);
697 698 699
		return ide_started;
	} else {
		ide_execute_pkt_cmd(drive);
700
		return ide_transfer_pc(drive);
701 702 703
	}
}
EXPORT_SYMBOL_GPL(ide_issue_pc);