ide-atapi.c revision baf08f0be6d986521bb2fbdc7af51fc4847da734
1/* 2 * ATAPI support. 3 */ 4 5#include <linux/kernel.h> 6#include <linux/delay.h> 7#include <linux/ide.h> 8#include <scsi/scsi.h> 9 10#ifdef DEBUG 11#define debug_log(fmt, args...) \ 12 printk(KERN_INFO "ide: " fmt, ## args) 13#else 14#define debug_log(fmt, args...) do {} while (0) 15#endif 16 17/* 18 * Check whether we can support a device, 19 * based on the ATAPI IDENTIFY command results. 20 */ 21int ide_check_atapi_device(ide_drive_t *drive, const char *s) 22{ 23 u16 *id = drive->id; 24 u8 gcw[2], protocol, device_type, removable, drq_type, packet_size; 25 26 *((u16 *)&gcw) = id[ATA_ID_CONFIG]; 27 28 protocol = (gcw[1] & 0xC0) >> 6; 29 device_type = gcw[1] & 0x1F; 30 removable = (gcw[0] & 0x80) >> 7; 31 drq_type = (gcw[0] & 0x60) >> 5; 32 packet_size = gcw[0] & 0x03; 33 34#ifdef CONFIG_PPC 35 /* kludge for Apple PowerBook internal zip */ 36 if (drive->media == ide_floppy && device_type == 5 && 37 !strstr((char *)&id[ATA_ID_PROD], "CD-ROM") && 38 strstr((char *)&id[ATA_ID_PROD], "ZIP")) 39 device_type = 0; 40#endif 41 42 if (protocol != 2) 43 printk(KERN_ERR "%s: %s: protocol (0x%02x) is not ATAPI\n", 44 s, drive->name, protocol); 45 else if ((drive->media == ide_floppy && device_type != 0) || 46 (drive->media == ide_tape && device_type != 1)) 47 printk(KERN_ERR "%s: %s: invalid device type (0x%02x)\n", 48 s, drive->name, device_type); 49 else if (removable == 0) 50 printk(KERN_ERR "%s: %s: the removable flag is not set\n", 51 s, drive->name); 52 else if (drive->media == ide_floppy && drq_type == 3) 53 printk(KERN_ERR "%s: %s: sorry, DRQ type (0x%02x) not " 54 "supported\n", s, drive->name, drq_type); 55 else if (packet_size != 0) 56 printk(KERN_ERR "%s: %s: packet size (0x%02x) is not 12 " 57 "bytes\n", s, drive->name, packet_size); 58 else 59 return 1; 60 return 0; 61} 62EXPORT_SYMBOL_GPL(ide_check_atapi_device); 63 64/* PIO data transfer routine using the scatter gather table. */ 65int ide_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc, 66 unsigned int bcount, int write) 67{ 68 ide_hwif_t *hwif = drive->hwif; 69 const struct ide_tp_ops *tp_ops = hwif->tp_ops; 70 xfer_func_t *xf = write ? tp_ops->output_data : tp_ops->input_data; 71 struct scatterlist *sg = pc->sg; 72 char *buf; 73 int count, done = 0; 74 75 while (bcount) { 76 count = min(sg->length - pc->b_count, bcount); 77 78 if (PageHighMem(sg_page(sg))) { 79 unsigned long flags; 80 81 local_irq_save(flags); 82 buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset; 83 xf(drive, NULL, buf + pc->b_count, count); 84 kunmap_atomic(buf - sg->offset, KM_IRQ0); 85 local_irq_restore(flags); 86 } else { 87 buf = sg_virt(sg); 88 xf(drive, NULL, buf + pc->b_count, count); 89 } 90 91 bcount -= count; 92 pc->b_count += count; 93 done += count; 94 95 if (pc->b_count == sg->length) { 96 if (!--pc->sg_cnt) 97 break; 98 pc->sg = sg = sg_next(sg); 99 pc->b_count = 0; 100 } 101 } 102 103 if (bcount) { 104 printk(KERN_ERR "%s: %d leftover bytes, %s\n", drive->name, 105 bcount, write ? "padding with zeros" 106 : "discarding data"); 107 ide_pad_transfer(drive, write, bcount); 108 } 109 110 return done; 111} 112EXPORT_SYMBOL_GPL(ide_io_buffers); 113 114void ide_init_pc(struct ide_atapi_pc *pc) 115{ 116 memset(pc, 0, sizeof(*pc)); 117 pc->buf = pc->pc_buf; 118 pc->buf_size = IDE_PC_BUFFER_SIZE; 119} 120EXPORT_SYMBOL_GPL(ide_init_pc); 121 122/* 123 * Generate a new packet command request in front of the request queue, before 124 * the current request, so that it will be processed immediately, on the next 125 * pass through the driver. 126 */ 127static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk, 128 struct ide_atapi_pc *pc, struct request *rq) 129{ 130 blk_rq_init(NULL, rq); 131 rq->cmd_type = REQ_TYPE_SPECIAL; 132 rq->cmd_flags |= REQ_PREEMPT; 133 rq->buffer = (char *)pc; 134 rq->rq_disk = disk; 135 memcpy(rq->cmd, pc->c, 12); 136 if (drive->media == ide_tape) 137 rq->cmd[13] = REQ_IDETAPE_PC1; 138 ide_do_drive_cmd(drive, rq); 139} 140 141/* 142 * Add a special packet command request to the tail of the request queue, 143 * and wait for it to be serviced. 144 */ 145int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk, 146 struct ide_atapi_pc *pc) 147{ 148 struct request *rq; 149 int error; 150 151 rq = blk_get_request(drive->queue, READ, __GFP_WAIT); 152 rq->cmd_type = REQ_TYPE_SPECIAL; 153 rq->buffer = (char *)pc; 154 memcpy(rq->cmd, pc->c, 12); 155 if (drive->media == ide_tape) 156 rq->cmd[13] = REQ_IDETAPE_PC1; 157 error = blk_execute_rq(drive->queue, disk, rq, 0); 158 blk_put_request(rq); 159 160 return error; 161} 162EXPORT_SYMBOL_GPL(ide_queue_pc_tail); 163 164int ide_do_test_unit_ready(ide_drive_t *drive, struct gendisk *disk) 165{ 166 struct ide_atapi_pc pc; 167 168 ide_init_pc(&pc); 169 pc.c[0] = TEST_UNIT_READY; 170 171 return ide_queue_pc_tail(drive, disk, &pc); 172} 173EXPORT_SYMBOL_GPL(ide_do_test_unit_ready); 174 175int ide_do_start_stop(ide_drive_t *drive, struct gendisk *disk, int start) 176{ 177 struct ide_atapi_pc pc; 178 179 ide_init_pc(&pc); 180 pc.c[0] = START_STOP; 181 pc.c[4] = start; 182 183 if (drive->media == ide_tape) 184 pc.flags |= PC_FLAG_WAIT_FOR_DSC; 185 186 return ide_queue_pc_tail(drive, disk, &pc); 187} 188EXPORT_SYMBOL_GPL(ide_do_start_stop); 189 190int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on) 191{ 192 struct ide_atapi_pc pc; 193 194 if (drive->atapi_flags & IDE_AFLAG_NO_DOORLOCK) 195 return 0; 196 197 ide_init_pc(&pc); 198 pc.c[0] = ALLOW_MEDIUM_REMOVAL; 199 pc.c[4] = on; 200 201 return ide_queue_pc_tail(drive, disk, &pc); 202} 203EXPORT_SYMBOL_GPL(ide_set_media_lock); 204 205void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc) 206{ 207 ide_init_pc(pc); 208 pc->c[0] = REQUEST_SENSE; 209 if (drive->media == ide_floppy) { 210 pc->c[4] = 255; 211 pc->req_xfer = 18; 212 } else { 213 pc->c[4] = 20; 214 pc->req_xfer = 20; 215 } 216} 217EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd); 218 219/* 220 * Called when an error was detected during the last packet command. 221 * We queue a request sense packet command in the head of the request list. 222 */ 223void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk) 224{ 225 struct request *rq = &drive->request_sense_rq; 226 struct ide_atapi_pc *pc = &drive->request_sense_pc; 227 228 (void)ide_read_error(drive); 229 ide_create_request_sense_cmd(drive, pc); 230 if (drive->media == ide_tape) 231 set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags); 232 ide_queue_pc_head(drive, disk, pc, rq); 233} 234EXPORT_SYMBOL_GPL(ide_retry_pc); 235 236int ide_scsi_expiry(ide_drive_t *drive) 237{ 238 struct ide_atapi_pc *pc = drive->pc; 239 240 debug_log("%s called for %lu at %lu\n", __func__, 241 pc->scsi_cmd->serial_number, jiffies); 242 243 pc->flags |= PC_FLAG_TIMEDOUT; 244 245 return 0; /* we do not want the IDE subsystem to retry */ 246} 247EXPORT_SYMBOL_GPL(ide_scsi_expiry); 248 249/* 250 * This is the usual interrupt handler which will be called during a packet 251 * command. We will transfer some of the data (as requested by the drive) 252 * and will re-point interrupt handler to us. 253 */ 254static ide_startstop_t ide_pc_intr(ide_drive_t *drive) 255{ 256 struct ide_atapi_pc *pc = drive->pc; 257 ide_hwif_t *hwif = drive->hwif; 258 struct request *rq = hwif->hwgroup->rq; 259 const struct ide_tp_ops *tp_ops = hwif->tp_ops; 260 xfer_func_t *xferfunc; 261 ide_expiry_t *expiry; 262 unsigned int timeout, temp; 263 u16 bcount; 264 u8 stat, ireason, scsi = drive->scsi, dsc = 0; 265 266 debug_log("Enter %s - interrupt handler\n", __func__); 267 268 if (scsi) { 269 timeout = ide_scsi_get_timeout(pc); 270 expiry = ide_scsi_expiry; 271 } else { 272 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD 273 : WAIT_TAPE_CMD; 274 expiry = NULL; 275 } 276 277 if (pc->flags & PC_FLAG_TIMEDOUT) { 278 drive->pc_callback(drive, 0); 279 return ide_stopped; 280 } 281 282 /* Clear the interrupt */ 283 stat = tp_ops->read_status(hwif); 284 285 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 286 if (hwif->dma_ops->dma_end(drive) || 287 (drive->media == ide_tape && !scsi && (stat & ATA_ERR))) { 288 if (drive->media == ide_floppy && !scsi) 289 printk(KERN_ERR "%s: DMA %s error\n", 290 drive->name, rq_data_dir(pc->rq) 291 ? "write" : "read"); 292 pc->flags |= PC_FLAG_DMA_ERROR; 293 } else { 294 pc->xferred = pc->req_xfer; 295 if (drive->pc_update_buffers) 296 drive->pc_update_buffers(drive, pc); 297 } 298 debug_log("%s: DMA finished\n", drive->name); 299 } 300 301 /* No more interrupts */ 302 if ((stat & ATA_DRQ) == 0) { 303 debug_log("Packet command completed, %d bytes transferred\n", 304 pc->xferred); 305 306 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 307 308 local_irq_enable_in_hardirq(); 309 310 if (drive->media == ide_tape && !scsi && 311 (stat & ATA_ERR) && rq->cmd[0] == REQUEST_SENSE) 312 stat &= ~ATA_ERR; 313 314 if ((stat & ATA_ERR) || (pc->flags & PC_FLAG_DMA_ERROR)) { 315 /* Error detected */ 316 debug_log("%s: I/O error\n", drive->name); 317 318 if (drive->media != ide_tape || scsi) { 319 pc->rq->errors++; 320 if (scsi) 321 goto cmd_finished; 322 } 323 324 if (rq->cmd[0] == REQUEST_SENSE) { 325 printk(KERN_ERR "%s: I/O error in request sense" 326 " command\n", drive->name); 327 return ide_do_reset(drive); 328 } 329 330 debug_log("[cmd %x]: check condition\n", rq->cmd[0]); 331 332 /* Retry operation */ 333 ide_retry_pc(drive, rq->rq_disk); 334 335 /* queued, but not started */ 336 return ide_stopped; 337 } 338cmd_finished: 339 pc->error = 0; 340 341 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0) 342 dsc = 1; 343 344 /* Command finished - Call the callback function */ 345 drive->pc_callback(drive, dsc); 346 347 return ide_stopped; 348 } 349 350 if (pc->flags & PC_FLAG_DMA_IN_PROGRESS) { 351 pc->flags &= ~PC_FLAG_DMA_IN_PROGRESS; 352 printk(KERN_ERR "%s: The device wants to issue more interrupts " 353 "in DMA mode\n", drive->name); 354 ide_dma_off(drive); 355 return ide_do_reset(drive); 356 } 357 358 /* Get the number of bytes to transfer on this interrupt. */ 359 ide_read_bcount_and_ireason(drive, &bcount, &ireason); 360 361 if (ireason & ATAPI_COD) { 362 printk(KERN_ERR "%s: CoD != 0 in %s\n", drive->name, __func__); 363 return ide_do_reset(drive); 364 } 365 366 if (((ireason & ATAPI_IO) == ATAPI_IO) == 367 !!(pc->flags & PC_FLAG_WRITING)) { 368 /* Hopefully, we will never get here */ 369 printk(KERN_ERR "%s: We wanted to %s, but the device wants us " 370 "to %s!\n", drive->name, 371 (ireason & ATAPI_IO) ? "Write" : "Read", 372 (ireason & ATAPI_IO) ? "Read" : "Write"); 373 return ide_do_reset(drive); 374 } 375 376 if (!(pc->flags & PC_FLAG_WRITING)) { 377 /* Reading - Check that we have enough space */ 378 temp = pc->xferred + bcount; 379 if (temp > pc->req_xfer) { 380 if (temp > pc->buf_size) { 381 printk(KERN_ERR "%s: The device wants to send " 382 "us more data than expected - " 383 "discarding data\n", 384 drive->name); 385 if (scsi) 386 temp = pc->buf_size - pc->xferred; 387 else 388 temp = 0; 389 if (temp) { 390 if (pc->sg) 391 drive->pc_io_buffers(drive, pc, 392 temp, 0); 393 else 394 tp_ops->input_data(drive, NULL, 395 pc->cur_pos, temp); 396 printk(KERN_ERR "%s: transferred %d of " 397 "%d bytes\n", 398 drive->name, 399 temp, bcount); 400 } 401 pc->xferred += temp; 402 pc->cur_pos += temp; 403 ide_pad_transfer(drive, 0, bcount - temp); 404 goto next_irq; 405 } 406 debug_log("The device wants to send us more data than " 407 "expected - allowing transfer\n"); 408 } 409 xferfunc = tp_ops->input_data; 410 } else 411 xferfunc = tp_ops->output_data; 412 413 if ((drive->media == ide_floppy && !scsi && !pc->buf) || 414 (drive->media == ide_tape && !scsi && pc->bh) || 415 (scsi && pc->sg)) { 416 int done = drive->pc_io_buffers(drive, pc, bcount, 417 !!(pc->flags & PC_FLAG_WRITING)); 418 419 /* FIXME: don't do partial completions */ 420 if (drive->media == ide_floppy && !scsi) 421 ide_end_request(drive, 1, done >> 9); 422 } else 423 xferfunc(drive, NULL, pc->cur_pos, bcount); 424 425 /* Update the current position */ 426 pc->xferred += bcount; 427 pc->cur_pos += bcount; 428 429 debug_log("[cmd %x] transferred %d bytes on that intr.\n", 430 rq->cmd[0], bcount); 431next_irq: 432 /* And set the interrupt handler again */ 433 ide_set_handler(drive, ide_pc_intr, timeout, expiry); 434 return ide_started; 435} 436 437static u8 ide_read_ireason(ide_drive_t *drive) 438{ 439 ide_task_t task; 440 441 memset(&task, 0, sizeof(task)); 442 task.tf_flags = IDE_TFLAG_IN_NSECT; 443 444 drive->hwif->tp_ops->tf_read(drive, &task); 445 446 return task.tf.nsect & 3; 447} 448 449static u8 ide_wait_ireason(ide_drive_t *drive, u8 ireason) 450{ 451 int retries = 100; 452 453 while (retries-- && ((ireason & ATAPI_COD) == 0 || 454 (ireason & ATAPI_IO))) { 455 printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing " 456 "a packet command, retrying\n", drive->name); 457 udelay(100); 458 ireason = ide_read_ireason(drive); 459 if (retries == 0) { 460 printk(KERN_ERR "%s: (IO,CoD != (0,1) while issuing " 461 "a packet command, ignoring\n", 462 drive->name); 463 ireason |= ATAPI_COD; 464 ireason &= ~ATAPI_IO; 465 } 466 } 467 468 return ireason; 469} 470 471static int ide_delayed_transfer_pc(ide_drive_t *drive) 472{ 473 /* Send the actual packet */ 474 drive->hwif->tp_ops->output_data(drive, NULL, drive->pc->c, 12); 475 476 /* Timeout for the packet command */ 477 return WAIT_FLOPPY_CMD; 478} 479 480static ide_startstop_t ide_transfer_pc(ide_drive_t *drive) 481{ 482 struct ide_atapi_pc *pc = drive->pc; 483 ide_hwif_t *hwif = drive->hwif; 484 struct request *rq = hwif->hwgroup->rq; 485 ide_expiry_t *expiry; 486 unsigned int timeout; 487 ide_startstop_t startstop; 488 u8 ireason; 489 490 if (ide_wait_stat(&startstop, drive, ATA_DRQ, ATA_BUSY, WAIT_READY)) { 491 printk(KERN_ERR "%s: Strange, packet command initiated yet " 492 "DRQ isn't asserted\n", drive->name); 493 return startstop; 494 } 495 496 ireason = ide_read_ireason(drive); 497 if (drive->media == ide_tape && !drive->scsi) 498 ireason = ide_wait_ireason(drive, ireason); 499 500 if ((ireason & ATAPI_COD) == 0 || (ireason & ATAPI_IO)) { 501 printk(KERN_ERR "%s: (IO,CoD) != (0,1) while issuing " 502 "a packet command\n", drive->name); 503 return ide_do_reset(drive); 504 } 505 506 /* 507 * If necessary schedule the packet transfer to occur 'timeout' 508 * miliseconds later in ide_delayed_transfer_pc() after the device 509 * says it's ready for a packet. 510 */ 511 if (drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) { 512 timeout = drive->pc_delay; 513 expiry = &ide_delayed_transfer_pc; 514 } else { 515 if (drive->scsi) { 516 timeout = ide_scsi_get_timeout(pc); 517 expiry = ide_scsi_expiry; 518 } else { 519 timeout = (drive->media == ide_floppy) ? WAIT_FLOPPY_CMD 520 : WAIT_TAPE_CMD; 521 expiry = NULL; 522 } 523 } 524 525 /* Set the interrupt routine */ 526 ide_set_handler(drive, ide_pc_intr, timeout, expiry); 527 528 /* Begin DMA, if necessary */ 529 if (pc->flags & PC_FLAG_DMA_OK) { 530 pc->flags |= PC_FLAG_DMA_IN_PROGRESS; 531 hwif->dma_ops->dma_start(drive); 532 } 533 534 /* Send the actual packet */ 535 if ((drive->atapi_flags & IDE_AFLAG_ZIP_DRIVE) == 0) 536 hwif->tp_ops->output_data(drive, NULL, rq->cmd, 12); 537 538 return ide_started; 539} 540 541ide_startstop_t ide_issue_pc(ide_drive_t *drive, unsigned int timeout, 542 ide_expiry_t *expiry) 543{ 544 struct ide_atapi_pc *pc = drive->pc; 545 ide_hwif_t *hwif = drive->hwif; 546 u16 bcount; 547 u8 dma = 0; 548 549 /* We haven't transferred any data yet */ 550 pc->xferred = 0; 551 pc->cur_pos = pc->buf; 552 553 /* Request to transfer the entire buffer at once */ 554 if (drive->media == ide_tape && !drive->scsi) 555 bcount = pc->req_xfer; 556 else 557 bcount = min(pc->req_xfer, 63 * 1024); 558 559 if (pc->flags & PC_FLAG_DMA_ERROR) { 560 pc->flags &= ~PC_FLAG_DMA_ERROR; 561 ide_dma_off(drive); 562 } 563 564 if ((pc->flags & PC_FLAG_DMA_OK) && drive->using_dma) { 565 if (drive->scsi) 566 hwif->sg_mapped = 1; 567 dma = !hwif->dma_ops->dma_setup(drive); 568 if (drive->scsi) 569 hwif->sg_mapped = 0; 570 } 571 572 if (!dma) 573 pc->flags &= ~PC_FLAG_DMA_OK; 574 575 ide_pktcmd_tf_load(drive, drive->scsi ? 0 : IDE_TFLAG_OUT_DEVICE, 576 bcount, dma); 577 578 /* Issue the packet command */ 579 if (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT) { 580 ide_execute_command(drive, ATA_CMD_PACKET, ide_transfer_pc, 581 timeout, NULL); 582 return ide_started; 583 } else { 584 ide_execute_pkt_cmd(drive); 585 return ide_transfer_pc(drive); 586 } 587} 588EXPORT_SYMBOL_GPL(ide_issue_pc); 589