5 #include <linux/kernel.h>
6 #include <linux/delay.h>
11 #define debug_log(fmt, args...) \
12 printk(KERN_INFO "ide: " fmt, ## args)
14 #define debug_log(fmt, args...) do {} while (0)
17 static inline int dev_is_idecd(ide_drive_t *drive)
19 return (drive->media == ide_cdrom || drive->media == ide_optical) &&
20 !(drive->dev_flags & IDE_DFLAG_SCSI);
24 * Check whether we can support a device,
25 * based on the ATAPI IDENTIFY command results.
27 int ide_check_atapi_device(ide_drive_t *drive, const char *s)
30 u8 gcw[2], protocol, device_type, removable, drq_type, packet_size;
32 *((u16 *)&gcw) = id[ATA_ID_CONFIG];
34 protocol = (gcw[1] & 0xC0) >> 6;
35 device_type = gcw[1] & 0x1F;
36 removable = (gcw[0] & 0x80) >> 7;
37 drq_type = (gcw[0] & 0x60) >> 5;
38 packet_size = gcw[0] & 0x03;
41 /* kludge for Apple PowerBook internal zip */
42 if (drive->media == ide_floppy && device_type == 5 &&
43 !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") &&
44 strstr((char *)&id[ATA_ID_PROD], "ZIP"))
49 printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n",
50 s, drive->name, protocol);
51 else if ((drive->media == ide_floppy && device_type != 0) ||
52 (drive->media == ide_tape && device_type != 1))
53 printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n",
54 s, drive->name, device_type);
55 else if (removable == 0)
56 printk(KERN_ERR "%s: %s: the removable flag is not set\n",
58 else if (drive->media == ide_floppy && drq_type == 3)
59 printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not "
60 "supported\n", s, drive->name, drq_type);
61 else if (packet_size != 0)
62 printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 "
63 "bytes\n", s, drive->name, packet_size);
68 EXPORT_SYMBOL_GPL(ide_check_atapi_device);
70 /* PIO data transfer routine using the scatter gather table. */
71 int ide_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
72 unsigned int bcount, int write)
74 ide_hwif_t *hwif = drive->hwif;
75 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
76 xfer_func_t *xf = write ? tp_ops->output_data : tp_ops->input_data;
77 struct scatterlist *sg = pc->sg;
82 count = min(sg->length - pc->b_count, bcount);
84 if (PageHighMem(sg_page(sg))) {
87 local_irq_save(flags);
88 buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset;
89 xf(drive, NULL, buf + pc->b_count, count);
90 kunmap_atomic(buf - sg->offset, KM_IRQ0);
91 local_irq_restore(flags);
94 xf(drive, NULL, buf + pc->b_count, count);
101 if (pc->b_count == sg->length) {
104 pc->sg = sg = sg_next(sg);
110 printk(KERN_ERR "%s: %d leftover bytes, %s\n", drive->name,
111 bcount, write ? "padding with zeros"
112 : "discarding data");
113 ide_pad_transfer(drive, write, bcount);
118 EXPORT_SYMBOL_GPL(ide_io_buffers);
120 void ide_init_pc(struct ide_atapi_pc *pc)
122 memset(pc, 0, sizeof(*pc));
123 pc->buf = pc->pc_buf;
124 pc->buf_size = IDE_PC_BUFFER_SIZE;
126 EXPORT_SYMBOL_GPL(ide_init_pc);
129 * Generate a new packet command request in front of the request queue, before
130 * the current request, so that it will be processed immediately, on the next
131 * pass through the driver.
133 static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
134 struct ide_atapi_pc *pc, struct request *rq)
136 blk_rq_init(NULL, rq);
137 rq->cmd_type = REQ_TYPE_SPECIAL;
138 rq->cmd_flags |= REQ_PREEMPT;
139 rq->buffer = (char *)pc;
141 memcpy(rq->cmd, pc->c, 12);
142 if (drive->media == ide_tape)
143 rq->cmd[13] = REQ_IDETAPE_PC1;
144 ide_do_drive_cmd(drive, rq);
148 * Add a special packet command request to the tail of the request queue,
149 * and wait for it to be serviced.
151 int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
152 struct ide_atapi_pc *pc)
157 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
158 rq->cmd_type = REQ_TYPE_SPECIAL;
159 rq->buffer = (char *)pc;
160 memcpy(rq->cmd, pc->c, 12);
161 if (drive->media == ide_tape)
162 rq->cmd[13] = REQ_IDETAPE_PC1;
163 error = blk_execute_rq(drive->queue, disk, rq, 0);
168 EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
170 int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk)
172 struct ide_atapi_pc pc;
175 pc.c[0] = TEST_UNIT_READY;
177 return ide_queue_pc_tail(drive, disk, &pc);
179 EXPORT_SYMBOL_GPL(ide_do_test_unit_ready);
181 int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start)
183 struct ide_atapi_pc pc;
186 pc.c[0] = START_STOP;
189 if (drive->media == ide_tape)
190 pc.flags |= PC_FLAG_WAIT_FOR_DSC;
192 return ide_queue_pc_tail(drive, disk, &pc);
194 EXPORT_SYMBOL_GPL(ide_do_start_stop);
196 int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
198 struct ide_atapi_pc pc;
200 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
204 pc.c[0] = ALLOW_MEDIUM_REMOVAL;
207 return ide_queue_pc_tail(drive, disk, &pc);
209 EXPORT_SYMBOL_GPL(ide_set_media_lock);
211 void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
214 pc->c[0] = REQUEST_SENSE;
215 if (drive->media == ide_floppy) {
223 EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
226 * Called when an error was detected during the last packet command.
227 * We queue a request sense packet command in the head of the request list.
229 void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk)
231 struct request *rq = &drive->request_sense_rq;
232 struct ide_atapi_pc *pc = &drive->request_sense_pc;
234 (void)ide_read_error(drive);
235 ide_create_request_sense_cmd(drive, pc);
236 if (drive->media == ide_tape)
237 set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
238 ide_queue_pc_head(drive, disk, pc, rq);
240 EXPORT_SYMBOL_GPL(ide_retry_pc);
242 int ide_scsi_expiry(ide_drive_t *drive)
244 struct ide_atapi_pc *pc = drive->pc;
246 debug_log("%s called for %lu at %lu\n", __func__,
247 pc->scsi_cmd->serial_number, jiffies);
249 pc->flags |= PC_FLAG_TIMEDOUT;
251 return 0; /* we do not want the IDE subsystem to retry */
253 EXPORT_SYMBOL_GPL(ide_scsi_expiry);
255 int ide_cd_get_xferlen(struct request *rq)
257 if (blk_fs_request(rq))
259 else if (blk_sense_request(rq) || blk_pc_request(rq) ||
260 rq->cmd_type == REQ_TYPE_ATA_PC)
265 EXPORT_SYMBOL_GPL(ide_cd_get_xferlen);
268 * This is the usual interrupt handler which will be called during a packet
269 * command. We will transfer some of the data (as requested by the drive)
270 * and will re-point interrupt handler to us.
272 static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
274 struct ide_atapi_pc *pc = drive->pc;
275 ide_hwif_t *hwif = drive->hwif;
276 struct request *rq = hwif->hwgroup->rq;
277 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
278 xfer_func_t *xferfunc;
279 ide_expiry_t *expiry;
280 unsigned int timeout, temp;
282 u8 stat, ireason, scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI), dsc = 0;
284 debug_log("Enter %s - interrupt handler\n", __func__);
287 timeout = ide_scsi_get_timeout(pc);
288 expiry = ide_scsi_expiry;
290 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
295 if (pc->flags & PC_FLAG_TIMEDOUT) {
296 drive->pc_callback(drive, 0);
300 /* Clear the interrupt */
301 stat = tp_ops->read_status(hwif);
303 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
304 if (hwif->dma_ops->dma_end(drive) ||
305 (drive->media == ide_tape && !scsi && (stat & ATA_ERR))) {
306 if (drive->media == ide_floppy && !scsi)
307 printk(KERN_ERR "%s: DMA %s error\n",
308 drive->name, rq_data_dir(pc->rq)
310 pc->flags |= PC_FLAG_DMA_ERROR;
312 pc->xferred = pc->req_xfer;
313 if (drive->pc_update_buffers)
314 drive->pc_update_buffers(drive, pc);
316 debug_log("%s: DMA finished\n", drive->name);
319 /* No more interrupts */
320 if ((stat & ATA_DRQ) == 0) {
321 debug_log("Packet command completed, %d bytes transferred\n",
324 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
326 local_irq_enable_in_hardirq();
328 if (drive->media == ide_tape && !scsi &&
329 (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE)
332 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) {
334 debug_log("%s: I/O error\n", drive->name);
336 if (drive->media != ide_tape || scsi) {
342 if (rq->cmd[0] == REQUEST_SENSE) {
343 printk(KERN_ERR "%s: I/O error in request sense"
344 " command\n", drive->name);
345 return ide_do_reset(drive);
348 debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
350 /* Retry operation */
351 ide_retry_pc(drive, rq->rq_disk);
353 /* queued, but not started */
359 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
362 /* Command finished - Call the callback function */
363 drive->pc_callback(drive, dsc);
368 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) {
369 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS;
370 printk(KERN_ERR "%s: The device wants to issue more interrupts "
371 "in DMA mode\n", drive->name);
373 return ide_do_reset(drive);
376 /* Get the number of bytes to transfer on this interrupt. */
377 ide_read_bcount_and_ireason(drive, &bcount, &ireason);
379 if (ireason & ATAPI_COD) {
380 printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__);
381 return ide_do_reset(drive);
384 if (((ireason & ATAPI_IO) == ATAPI_IO) ==
385 !!(pc->flags & PC_FLAG_WRITING)) {
386 /* Hopefully, we will never get here */
387 printk(KERN_ERR "%s: We wanted to %s, but the device wants us "
388 "to %s!\n", drive->name,
389 (ireason & ATAPI_IO) ? "Write" : "Read",
390 (ireason & ATAPI_IO) ? "Read" : "Write");
391 return ide_do_reset(drive);
394 if (!(pc->flags & PC_FLAG_WRITING)) {
395 /* Reading - Check that we have enough space */
396 temp = pc->xferred + bcount;
397 if (temp > pc->req_xfer) {
398 if (temp > pc->buf_size) {
399 printk(KERN_ERR "%s: The device wants to send "
400 "us more data than expected - "
404 temp = pc->buf_size - pc->xferred;
409 drive->pc_io_buffers(drive, pc,
412 tp_ops->input_data(drive, NULL,
414 printk(KERN_ERR "%s: transferred %d of "
421 ide_pad_transfer(drive, 0, bcount - temp);
424 debug_log("The device wants to send us more data than "
425 "expected - allowing transfer\n");
427 xferfunc = tp_ops->input_data;
429 xferfunc = tp_ops->output_data;
431 if ((drive->media == ide_floppy && !scsi && !pc->buf) ||
432 (drive->media == ide_tape && !scsi && pc->bh) ||
434 int done = drive->pc_io_buffers(drive, pc, bcount,
435 !!(pc->flags & PC_FLAG_WRITING));
437 /* FIXME: don't do partial completions */
438 if (drive->media == ide_floppy && !scsi)
439 ide_end_request(drive, 1, done >> 9);
441 xferfunc(drive, NULL, pc->cur_pos, bcount);
443 /* Update the current position */
444 pc->xferred += bcount;
445 pc->cur_pos += bcount;
447 debug_log("[cmd %x] transferred %d bytes on that intr.\n",
450 /* And set the interrupt handler again */
451 ide_set_handler(drive, ide_pc_intr, timeout, expiry);
455 static u8 ide_read_ireason(ide_drive_t *drive)
459 memset(&task, 0, sizeof(task));
460 task.tf_flags = IDE_TFLAG_IN_NSECT;
462 drive->hwif->tp_ops->tf_read(drive, &task);
464 return task.tf.nsect & 3;
467 static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason)
471 while (retries-- && ((ireason & ATAPI_COD) == 0 ||
472 (ireason & ATAPI_IO))) {
473 printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
474 "a packet command, retrying\n", drive->name);
476 ireason = ide_read_ireason(drive);
478 printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing "
479 "a packet command, ignoring\n",
481 ireason |= ATAPI_COD;
482 ireason &= ~ATAPI_IO;
489 static int ide_delayed_transfer_pc(ide_drive_t *drive)
491 /* Send the actual packet */
492 drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12);
494 /* Timeout for the packet command */
495 return WAIT_FLOPPY_CMD;
498 static ide_startstop_t ide_transfer_pc(ide_drive_t *drive)
500 struct ide_atapi_pc *pc = drive->pc;
501 ide_hwif_t *hwif = drive->hwif;
502 struct request *rq = hwif->hwgroup->rq;
503 ide_expiry_t *expiry;
504 unsigned int timeout;
505 ide_startstop_t startstop;
508 if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) {
509 printk(KERN_ERR "%s: Strange, packet command initiated yet "
510 "DRQ isn't asserted\n", drive->name);
514 ireason = ide_read_ireason(drive);
515 if (drive->media == ide_tape &&
516 (drive->dev_flags & IDE_DFLAG_SCSI) == 0)
517 ireason = ide_wait_ireason(drive, ireason);
519 if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) {
520 printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing "
521 "a packet command\n", drive->name);
522 return ide_do_reset(drive);
526 * If necessary schedule the packet transfer to occur 'timeout'
527 * miliseconds later in ide_delayed_transfer_pc() after the device
528 * says it's ready for a packet.
530 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) {
531 timeout = drive->pc_delay;
532 expiry = &ide_delayed_transfer_pc;
534 if (drive->dev_flags & IDE_DFLAG_SCSI) {
535 timeout = ide_scsi_get_timeout(pc);
536 expiry = ide_scsi_expiry;
538 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD
544 /* Set the interrupt routine */
545 ide_set_handler(drive, ide_pc_intr, timeout, expiry);
547 /* Begin DMA, if necessary */
548 if (pc->flags & PC_FLAG_DMA_OK) {
549 pc->flags |= PC_FLAG_DMA_IN_PROGRESS;
550 hwif->dma_ops->dma_start(drive);
553 /* Send the actual packet */
554 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0)
555 hwif->tp_ops->output_data(drive, NULL, rq->cmd, 12);
560 ide_startstop_t ide_issue_pc(ide_drive_t *drive, unsigned int timeout,
561 ide_expiry_t *expiry)
563 struct ide_atapi_pc *pc = drive->pc;
564 ide_hwif_t *hwif = drive->hwif;
567 u8 scsi = !!(drive->dev_flags & IDE_DFLAG_SCSI);
569 /* We haven't transferred any data yet */
571 pc->cur_pos = pc->buf;
573 if (dev_is_idecd(drive)) {
574 tf_flags = IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL;
575 bcount = ide_cd_get_xferlen(hwif->hwgroup->rq);
578 bcount = min(pc->req_xfer, 63 * 1024);
580 tf_flags = IDE_TFLAG_OUT_DEVICE;
581 bcount = ((drive->media == ide_tape) ?
583 min(pc->req_xfer, 63 * 1024));
586 if (pc->flags & PC_FLAG_DMA_ERROR) {
587 pc->flags &= ~PC_FLAG_DMA_ERROR;
591 if (((pc->flags & PC_FLAG_DMA_OK) &&
592 (drive->dev_flags & IDE_DFLAG_USING_DMA)) ||
596 drive->dma = !hwif->dma_ops->dma_setup(drive);
602 pc->flags &= ~PC_FLAG_DMA_OK;
604 ide_pktcmd_tf_load(drive, tf_flags, bcount, drive->dma);
606 /* Issue the packet command */
607 if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) {
608 ide_execute_command(drive, ATA_CMD_PACKET, ide_transfer_pc,
612 ide_execute_pkt_cmd(drive);
613 return ide_transfer_pc(drive);
616 EXPORT_SYMBOL_GPL(ide_issue_pc);