ide-io.c revision ff2779b568e70822e0ef2cc7afeeefbe7c607652
1/* 2 * IDE I/O functions 3 * 4 * Basic PIO and command management functionality. 5 * 6 * This code was split off from ide.c. See ide.c for history and original 7 * copyrights. 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2, or (at your option) any 12 * later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * For the avoidance of doubt the "preferred form" of this code is one which 20 * is in an open non patent encumbered format. Where cryptographic key signing 21 * forms part of the process of creating an executable the information 22 * including keys needed to generate an equivalently functional executable 23 * are deemed to be part of the source code. 24 */ 25 26 27#include <linux/module.h> 28#include <linux/types.h> 29#include <linux/string.h> 30#include <linux/kernel.h> 31#include <linux/timer.h> 32#include <linux/mm.h> 33#include <linux/interrupt.h> 34#include <linux/major.h> 35#include <linux/errno.h> 36#include <linux/genhd.h> 37#include <linux/blkpg.h> 38#include <linux/slab.h> 39#include <linux/init.h> 40#include <linux/pci.h> 41#include <linux/delay.h> 42#include <linux/ide.h> 43#include <linux/hdreg.h> 44#include <linux/completion.h> 45#include <linux/reboot.h> 46#include <linux/cdrom.h> 47#include <linux/seq_file.h> 48#include <linux/device.h> 49#include <linux/kmod.h> 50#include <linux/scatterlist.h> 51#include <linux/bitops.h> 52 53#include <asm/byteorder.h> 54#include <asm/irq.h> 55#include <asm/uaccess.h> 56#include <asm/io.h> 57 58static int __ide_end_request(ide_drive_t *drive, struct request *rq, 59 int uptodate, unsigned int nr_bytes, int dequeue) 60{ 61 int ret = 1; 62 int error = 0; 63 64 if (uptodate <= 0) 65 error = uptodate ? uptodate : -EIO; 66 67 /* 68 * if failfast is set on a request, override number of sectors and 69 * complete the whole request right now 70 */ 71 if (blk_noretry_request(rq) && error) 72 nr_bytes = rq->hard_nr_sectors << 9; 73 74 if (!blk_fs_request(rq) && error && !rq->errors) 75 rq->errors = -EIO; 76 77 /* 78 * decide whether to reenable DMA -- 3 is a random magic for now, 79 * if we DMA timeout more than 3 times, just stay in PIO 80 */ 81 if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) { 82 drive->state = 0; 83 ide_dma_on(drive); 84 } 85 86 if (!__blk_end_request(rq, error, nr_bytes)) { 87 if (dequeue) 88 HWGROUP(drive)->rq = NULL; 89 ret = 0; 90 } 91 92 return ret; 93} 94 95/** 96 * ide_end_request - complete an IDE I/O 97 * @drive: IDE device for the I/O 98 * @uptodate: 99 * @nr_sectors: number of sectors completed 100 * 101 * This is our end_request wrapper function. We complete the I/O 102 * update random number input and dequeue the request, which if 103 * it was tagged may be out of order. 104 */ 105 106int ide_end_request (ide_drive_t *drive, int uptodate, int nr_sectors) 107{ 108 unsigned int nr_bytes = nr_sectors << 9; 109 struct request *rq; 110 unsigned long flags; 111 int ret = 1; 112 113 /* 114 * room for locking improvements here, the calls below don't 115 * need the queue lock held at all 116 */ 117 spin_lock_irqsave(&ide_lock, flags); 118 rq = HWGROUP(drive)->rq; 119 120 if (!nr_bytes) { 121 if (blk_pc_request(rq)) 122 nr_bytes = rq->data_len; 123 else 124 nr_bytes = rq->hard_cur_sectors << 9; 125 } 126 127 ret = __ide_end_request(drive, rq, uptodate, nr_bytes, 1); 128 129 spin_unlock_irqrestore(&ide_lock, flags); 130 return ret; 131} 132EXPORT_SYMBOL(ide_end_request); 133 134/* 135 * Power Management state machine. This one is rather trivial for now, 136 * we should probably add more, like switching back to PIO on suspend 137 * to help some BIOSes, re-do the door locking on resume, etc... 138 */ 139 140enum { 141 ide_pm_flush_cache = ide_pm_state_start_suspend, 142 idedisk_pm_standby, 143 144 idedisk_pm_restore_pio = ide_pm_state_start_resume, 145 idedisk_pm_idle, 146 ide_pm_restore_dma, 147}; 148 149static void ide_complete_power_step(ide_drive_t *drive, struct request *rq, u8 stat, u8 error) 150{ 151 struct request_pm_state *pm = rq->data; 152 153 if (drive->media != ide_disk) 154 return; 155 156 switch (pm->pm_step) { 157 case ide_pm_flush_cache: /* Suspend step 1 (flush cache) complete */ 158 if (pm->pm_state == PM_EVENT_FREEZE) 159 pm->pm_step = ide_pm_state_completed; 160 else 161 pm->pm_step = idedisk_pm_standby; 162 break; 163 case idedisk_pm_standby: /* Suspend step 2 (standby) complete */ 164 pm->pm_step = ide_pm_state_completed; 165 break; 166 case idedisk_pm_restore_pio: /* Resume step 1 complete */ 167 pm->pm_step = idedisk_pm_idle; 168 break; 169 case idedisk_pm_idle: /* Resume step 2 (idle) complete */ 170 pm->pm_step = ide_pm_restore_dma; 171 break; 172 } 173} 174 175static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq) 176{ 177 struct request_pm_state *pm = rq->data; 178 ide_task_t *args = rq->special; 179 180 memset(args, 0, sizeof(*args)); 181 182 switch (pm->pm_step) { 183 case ide_pm_flush_cache: /* Suspend step 1 (flush cache) */ 184 if (drive->media != ide_disk) 185 break; 186 /* Not supported? Switch to next step now. */ 187 if (!drive->wcache || ata_id_flush_enabled(drive->id) == 0) { 188 ide_complete_power_step(drive, rq, 0, 0); 189 return ide_stopped; 190 } 191 if (ata_id_flush_ext_enabled(drive->id)) 192 args->tf.command = ATA_CMD_FLUSH_EXT; 193 else 194 args->tf.command = ATA_CMD_FLUSH; 195 goto out_do_tf; 196 197 case idedisk_pm_standby: /* Suspend step 2 (standby) */ 198 args->tf.command = ATA_CMD_STANDBYNOW1; 199 goto out_do_tf; 200 201 case idedisk_pm_restore_pio: /* Resume step 1 (restore PIO) */ 202 ide_set_max_pio(drive); 203 /* 204 * skip idedisk_pm_idle for ATAPI devices 205 */ 206 if (drive->media != ide_disk) 207 pm->pm_step = ide_pm_restore_dma; 208 else 209 ide_complete_power_step(drive, rq, 0, 0); 210 return ide_stopped; 211 212 case idedisk_pm_idle: /* Resume step 2 (idle) */ 213 args->tf.command = ATA_CMD_IDLEIMMEDIATE; 214 goto out_do_tf; 215 216 case ide_pm_restore_dma: /* Resume step 3 (restore DMA) */ 217 /* 218 * Right now, all we do is call ide_set_dma(drive), 219 * we could be smarter and check for current xfer_speed 220 * in struct drive etc... 221 */ 222 if (drive->hwif->dma_ops == NULL) 223 break; 224 /* 225 * TODO: respect ->using_dma setting 226 */ 227 ide_set_dma(drive); 228 break; 229 } 230 pm->pm_step = ide_pm_state_completed; 231 return ide_stopped; 232 233out_do_tf: 234 args->tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE; 235 args->data_phase = TASKFILE_NO_DATA; 236 return do_rw_taskfile(drive, args); 237} 238 239/** 240 * ide_end_dequeued_request - complete an IDE I/O 241 * @drive: IDE device for the I/O 242 * @uptodate: 243 * @nr_sectors: number of sectors completed 244 * 245 * Complete an I/O that is no longer on the request queue. This 246 * typically occurs when we pull the request and issue a REQUEST_SENSE. 247 * We must still finish the old request but we must not tamper with the 248 * queue in the meantime. 249 * 250 * NOTE: This path does not handle barrier, but barrier is not supported 251 * on ide-cd anyway. 252 */ 253 254int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq, 255 int uptodate, int nr_sectors) 256{ 257 unsigned long flags; 258 int ret; 259 260 spin_lock_irqsave(&ide_lock, flags); 261 BUG_ON(!blk_rq_started(rq)); 262 ret = __ide_end_request(drive, rq, uptodate, nr_sectors << 9, 0); 263 spin_unlock_irqrestore(&ide_lock, flags); 264 265 return ret; 266} 267EXPORT_SYMBOL_GPL(ide_end_dequeued_request); 268 269 270/** 271 * ide_complete_pm_request - end the current Power Management request 272 * @drive: target drive 273 * @rq: request 274 * 275 * This function cleans up the current PM request and stops the queue 276 * if necessary. 277 */ 278static void ide_complete_pm_request (ide_drive_t *drive, struct request *rq) 279{ 280 unsigned long flags; 281 282#ifdef DEBUG_PM 283 printk("%s: completing PM request, %s\n", drive->name, 284 blk_pm_suspend_request(rq) ? "suspend" : "resume"); 285#endif 286 spin_lock_irqsave(&ide_lock, flags); 287 if (blk_pm_suspend_request(rq)) { 288 blk_stop_queue(drive->queue); 289 } else { 290 drive->blocked = 0; 291 blk_start_queue(drive->queue); 292 } 293 HWGROUP(drive)->rq = NULL; 294 if (__blk_end_request(rq, 0, 0)) 295 BUG(); 296 spin_unlock_irqrestore(&ide_lock, flags); 297} 298 299/** 300 * ide_end_drive_cmd - end an explicit drive command 301 * @drive: command 302 * @stat: status bits 303 * @err: error bits 304 * 305 * Clean up after success/failure of an explicit drive command. 306 * These get thrown onto the queue so they are synchronized with 307 * real I/O operations on the drive. 308 * 309 * In LBA48 mode we have to read the register set twice to get 310 * all the extra information out. 311 */ 312 313void ide_end_drive_cmd (ide_drive_t *drive, u8 stat, u8 err) 314{ 315 unsigned long flags; 316 struct request *rq; 317 318 spin_lock_irqsave(&ide_lock, flags); 319 rq = HWGROUP(drive)->rq; 320 spin_unlock_irqrestore(&ide_lock, flags); 321 322 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 323 ide_task_t *task = (ide_task_t *)rq->special; 324 325 if (rq->errors == 0) 326 rq->errors = !OK_STAT(stat, ATA_DRDY, BAD_STAT); 327 328 if (task) { 329 struct ide_taskfile *tf = &task->tf; 330 331 tf->error = err; 332 tf->status = stat; 333 334 drive->hwif->tp_ops->tf_read(drive, task); 335 336 if (task->tf_flags & IDE_TFLAG_DYN) 337 kfree(task); 338 } 339 } else if (blk_pm_request(rq)) { 340 struct request_pm_state *pm = rq->data; 341#ifdef DEBUG_PM 342 printk("%s: complete_power_step(step: %d, stat: %x, err: %x)\n", 343 drive->name, rq->pm->pm_step, stat, err); 344#endif 345 ide_complete_power_step(drive, rq, stat, err); 346 if (pm->pm_step == ide_pm_state_completed) 347 ide_complete_pm_request(drive, rq); 348 return; 349 } 350 351 spin_lock_irqsave(&ide_lock, flags); 352 HWGROUP(drive)->rq = NULL; 353 rq->errors = err; 354 if (unlikely(__blk_end_request(rq, (rq->errors ? -EIO : 0), 355 blk_rq_bytes(rq)))) 356 BUG(); 357 spin_unlock_irqrestore(&ide_lock, flags); 358} 359 360EXPORT_SYMBOL(ide_end_drive_cmd); 361 362static void ide_kill_rq(ide_drive_t *drive, struct request *rq) 363{ 364 if (rq->rq_disk) { 365 ide_driver_t *drv; 366 367 drv = *(ide_driver_t **)rq->rq_disk->private_data; 368 drv->end_request(drive, 0, 0); 369 } else 370 ide_end_request(drive, 0, 0); 371} 372 373static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 374{ 375 ide_hwif_t *hwif = drive->hwif; 376 377 if ((stat & ATA_BUSY) || ((stat & ATA_DF) && !drive->nowerr)) { 378 /* other bits are useless when BUSY */ 379 rq->errors |= ERROR_RESET; 380 } else if (stat & ATA_ERR) { 381 /* err has different meaning on cdrom and tape */ 382 if (err == ATA_ABORTED) { 383 if (drive->select.b.lba && 384 /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */ 385 hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS) 386 return ide_stopped; 387 } else if ((err & BAD_CRC) == BAD_CRC) { 388 /* UDMA crc error, just retry the operation */ 389 drive->crc_count++; 390 } else if (err & (ATA_BBK | ATA_UNC)) { 391 /* retries won't help these */ 392 rq->errors = ERROR_MAX; 393 } else if (err & ATA_TRK0NF) { 394 /* help it find track zero */ 395 rq->errors |= ERROR_RECAL; 396 } 397 } 398 399 if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ && 400 (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) { 401 int nsect = drive->mult_count ? drive->mult_count : 1; 402 403 ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE); 404 } 405 406 if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) { 407 ide_kill_rq(drive, rq); 408 return ide_stopped; 409 } 410 411 if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ)) 412 rq->errors |= ERROR_RESET; 413 414 if ((rq->errors & ERROR_RESET) == ERROR_RESET) { 415 ++rq->errors; 416 return ide_do_reset(drive); 417 } 418 419 if ((rq->errors & ERROR_RECAL) == ERROR_RECAL) 420 drive->special.b.recalibrate = 1; 421 422 ++rq->errors; 423 424 return ide_stopped; 425} 426 427static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 428{ 429 ide_hwif_t *hwif = drive->hwif; 430 431 if ((stat & ATA_BUSY) || ((stat & ATA_DF) && !drive->nowerr)) { 432 /* other bits are useless when BUSY */ 433 rq->errors |= ERROR_RESET; 434 } else { 435 /* add decoding error stuff */ 436 } 437 438 if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ)) 439 /* force an abort */ 440 hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE); 441 442 if (rq->errors >= ERROR_MAX) { 443 ide_kill_rq(drive, rq); 444 } else { 445 if ((rq->errors & ERROR_RESET) == ERROR_RESET) { 446 ++rq->errors; 447 return ide_do_reset(drive); 448 } 449 ++rq->errors; 450 } 451 452 return ide_stopped; 453} 454 455ide_startstop_t 456__ide_error(ide_drive_t *drive, struct request *rq, u8 stat, u8 err) 457{ 458 if (drive->media == ide_disk) 459 return ide_ata_error(drive, rq, stat, err); 460 return ide_atapi_error(drive, rq, stat, err); 461} 462 463EXPORT_SYMBOL_GPL(__ide_error); 464 465/** 466 * ide_error - handle an error on the IDE 467 * @drive: drive the error occurred on 468 * @msg: message to report 469 * @stat: status bits 470 * 471 * ide_error() takes action based on the error returned by the drive. 472 * For normal I/O that may well include retries. We deal with 473 * both new-style (taskfile) and old style command handling here. 474 * In the case of taskfile command handling there is work left to 475 * do 476 */ 477 478ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, u8 stat) 479{ 480 struct request *rq; 481 u8 err; 482 483 err = ide_dump_status(drive, msg, stat); 484 485 if ((rq = HWGROUP(drive)->rq) == NULL) 486 return ide_stopped; 487 488 /* retry only "normal" I/O: */ 489 if (!blk_fs_request(rq)) { 490 rq->errors = 1; 491 ide_end_drive_cmd(drive, stat, err); 492 return ide_stopped; 493 } 494 495 if (rq->rq_disk) { 496 ide_driver_t *drv; 497 498 drv = *(ide_driver_t **)rq->rq_disk->private_data; 499 return drv->error(drive, rq, stat, err); 500 } else 501 return __ide_error(drive, rq, stat, err); 502} 503 504EXPORT_SYMBOL_GPL(ide_error); 505 506static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 507{ 508 tf->nsect = drive->sect; 509 tf->lbal = drive->sect; 510 tf->lbam = drive->cyl; 511 tf->lbah = drive->cyl >> 8; 512 tf->device = ((drive->head - 1) | drive->select.all) & ~ATA_LBA; 513 tf->command = ATA_CMD_INIT_DEV_PARAMS; 514} 515 516static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 517{ 518 tf->nsect = drive->sect; 519 tf->command = ATA_CMD_RESTORE; 520} 521 522static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 523{ 524 tf->nsect = drive->mult_req; 525 tf->command = ATA_CMD_SET_MULTI; 526} 527 528static ide_startstop_t ide_disk_special(ide_drive_t *drive) 529{ 530 special_t *s = &drive->special; 531 ide_task_t args; 532 533 memset(&args, 0, sizeof(ide_task_t)); 534 args.data_phase = TASKFILE_NO_DATA; 535 536 if (s->b.set_geometry) { 537 s->b.set_geometry = 0; 538 ide_tf_set_specify_cmd(drive, &args.tf); 539 } else if (s->b.recalibrate) { 540 s->b.recalibrate = 0; 541 ide_tf_set_restore_cmd(drive, &args.tf); 542 } else if (s->b.set_multmode) { 543 s->b.set_multmode = 0; 544 ide_tf_set_setmult_cmd(drive, &args.tf); 545 } else if (s->all) { 546 int special = s->all; 547 s->all = 0; 548 printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special); 549 return ide_stopped; 550 } 551 552 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE | 553 IDE_TFLAG_CUSTOM_HANDLER; 554 555 do_rw_taskfile(drive, &args); 556 557 return ide_started; 558} 559 560/* 561 * handle HDIO_SET_PIO_MODE ioctl abusers here, eventually it will go away 562 */ 563static int set_pio_mode_abuse(ide_hwif_t *hwif, u8 req_pio) 564{ 565 switch (req_pio) { 566 case 202: 567 case 201: 568 case 200: 569 case 102: 570 case 101: 571 case 100: 572 return (hwif->host_flags & IDE_HFLAG_ABUSE_DMA_MODES) ? 1 : 0; 573 case 9: 574 case 8: 575 return (hwif->host_flags & IDE_HFLAG_ABUSE_PREFETCH) ? 1 : 0; 576 case 7: 577 case 6: 578 return (hwif->host_flags & IDE_HFLAG_ABUSE_FAST_DEVSEL) ? 1 : 0; 579 default: 580 return 0; 581 } 582} 583 584/** 585 * do_special - issue some special commands 586 * @drive: drive the command is for 587 * 588 * do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS, 589 * ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive. 590 * 591 * It used to do much more, but has been scaled back. 592 */ 593 594static ide_startstop_t do_special (ide_drive_t *drive) 595{ 596 special_t *s = &drive->special; 597 598#ifdef DEBUG 599 printk("%s: do_special: 0x%02x\n", drive->name, s->all); 600#endif 601 if (s->b.set_tune) { 602 ide_hwif_t *hwif = drive->hwif; 603 const struct ide_port_ops *port_ops = hwif->port_ops; 604 u8 req_pio = drive->tune_req; 605 606 s->b.set_tune = 0; 607 608 if (set_pio_mode_abuse(drive->hwif, req_pio)) { 609 /* 610 * take ide_lock for drive->[no_]unmask/[no_]io_32bit 611 */ 612 if (req_pio == 8 || req_pio == 9) { 613 unsigned long flags; 614 615 spin_lock_irqsave(&ide_lock, flags); 616 port_ops->set_pio_mode(drive, req_pio); 617 spin_unlock_irqrestore(&ide_lock, flags); 618 } else 619 port_ops->set_pio_mode(drive, req_pio); 620 } else { 621 int keep_dma = drive->using_dma; 622 623 ide_set_pio(drive, req_pio); 624 625 if (hwif->host_flags & IDE_HFLAG_SET_PIO_MODE_KEEP_DMA) { 626 if (keep_dma) 627 ide_dma_on(drive); 628 } 629 } 630 631 return ide_stopped; 632 } else { 633 if (drive->media == ide_disk) 634 return ide_disk_special(drive); 635 636 s->all = 0; 637 drive->mult_req = 0; 638 return ide_stopped; 639 } 640} 641 642void ide_map_sg(ide_drive_t *drive, struct request *rq) 643{ 644 ide_hwif_t *hwif = drive->hwif; 645 struct scatterlist *sg = hwif->sg_table; 646 647 if (hwif->sg_mapped) /* needed by ide-scsi */ 648 return; 649 650 if (rq->cmd_type != REQ_TYPE_ATA_TASKFILE) { 651 hwif->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); 652 } else { 653 sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE); 654 hwif->sg_nents = 1; 655 } 656} 657 658EXPORT_SYMBOL_GPL(ide_map_sg); 659 660void ide_init_sg_cmd(ide_drive_t *drive, struct request *rq) 661{ 662 ide_hwif_t *hwif = drive->hwif; 663 664 hwif->nsect = hwif->nleft = rq->nr_sectors; 665 hwif->cursg_ofs = 0; 666 hwif->cursg = NULL; 667} 668 669EXPORT_SYMBOL_GPL(ide_init_sg_cmd); 670 671/** 672 * execute_drive_command - issue special drive command 673 * @drive: the drive to issue the command on 674 * @rq: the request structure holding the command 675 * 676 * execute_drive_cmd() issues a special drive command, usually 677 * initiated by ioctl() from the external hdparm program. The 678 * command can be a drive command, drive task or taskfile 679 * operation. Weirdly you can call it with NULL to wait for 680 * all commands to finish. Don't do this as that is due to change 681 */ 682 683static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, 684 struct request *rq) 685{ 686 ide_hwif_t *hwif = HWIF(drive); 687 ide_task_t *task = rq->special; 688 689 if (task) { 690 hwif->data_phase = task->data_phase; 691 692 switch (hwif->data_phase) { 693 case TASKFILE_MULTI_OUT: 694 case TASKFILE_OUT: 695 case TASKFILE_MULTI_IN: 696 case TASKFILE_IN: 697 ide_init_sg_cmd(drive, rq); 698 ide_map_sg(drive, rq); 699 default: 700 break; 701 } 702 703 return do_rw_taskfile(drive, task); 704 } 705 706 /* 707 * NULL is actually a valid way of waiting for 708 * all current requests to be flushed from the queue. 709 */ 710#ifdef DEBUG 711 printk("%s: DRIVE_CMD (null)\n", drive->name); 712#endif 713 ide_end_drive_cmd(drive, hwif->tp_ops->read_status(hwif), 714 ide_read_error(drive)); 715 716 return ide_stopped; 717} 718 719static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 720{ 721 switch (rq->cmd[0]) { 722 case REQ_DRIVE_RESET: 723 return ide_do_reset(drive); 724 default: 725 blk_dump_rq_flags(rq, "ide_special_rq - bad request"); 726 ide_end_request(drive, 0, 0); 727 return ide_stopped; 728 } 729} 730 731static void ide_check_pm_state(ide_drive_t *drive, struct request *rq) 732{ 733 struct request_pm_state *pm = rq->data; 734 735 if (blk_pm_suspend_request(rq) && 736 pm->pm_step == ide_pm_state_start_suspend) 737 /* Mark drive blocked when starting the suspend sequence. */ 738 drive->blocked = 1; 739 else if (blk_pm_resume_request(rq) && 740 pm->pm_step == ide_pm_state_start_resume) { 741 /* 742 * The first thing we do on wakeup is to wait for BSY bit to 743 * go away (with a looong timeout) as a drive on this hwif may 744 * just be POSTing itself. 745 * We do that before even selecting as the "other" device on 746 * the bus may be broken enough to walk on our toes at this 747 * point. 748 */ 749 ide_hwif_t *hwif = drive->hwif; 750 int rc; 751#ifdef DEBUG_PM 752 printk("%s: Wakeup request inited, waiting for !BSY...\n", drive->name); 753#endif 754 rc = ide_wait_not_busy(hwif, 35000); 755 if (rc) 756 printk(KERN_WARNING "%s: bus not ready on wakeup\n", drive->name); 757 SELECT_DRIVE(drive); 758 hwif->tp_ops->set_irq(hwif, 1); 759 rc = ide_wait_not_busy(hwif, 100000); 760 if (rc) 761 printk(KERN_WARNING "%s: drive not ready on wakeup\n", drive->name); 762 } 763} 764 765/** 766 * start_request - start of I/O and command issuing for IDE 767 * 768 * start_request() initiates handling of a new I/O request. It 769 * accepts commands and I/O (read/write) requests. 770 * 771 * FIXME: this function needs a rename 772 */ 773 774static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq) 775{ 776 ide_startstop_t startstop; 777 778 BUG_ON(!blk_rq_started(rq)); 779 780#ifdef DEBUG 781 printk("%s: start_request: current=0x%08lx\n", 782 HWIF(drive)->name, (unsigned long) rq); 783#endif 784 785 /* bail early if we've exceeded max_failures */ 786 if (drive->max_failures && (drive->failures > drive->max_failures)) { 787 rq->cmd_flags |= REQ_FAILED; 788 goto kill_rq; 789 } 790 791 if (blk_pm_request(rq)) 792 ide_check_pm_state(drive, rq); 793 794 SELECT_DRIVE(drive); 795 if (ide_wait_stat(&startstop, drive, drive->ready_stat, 796 ATA_BUSY | ATA_DRQ, WAIT_READY)) { 797 printk(KERN_ERR "%s: drive not ready for command\n", drive->name); 798 return startstop; 799 } 800 if (!drive->special.all) { 801 ide_driver_t *drv; 802 803 /* 804 * We reset the drive so we need to issue a SETFEATURES. 805 * Do it _after_ do_special() restored device parameters. 806 */ 807 if (drive->current_speed == 0xff) 808 ide_config_drive_speed(drive, drive->desired_speed); 809 810 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 811 return execute_drive_cmd(drive, rq); 812 else if (blk_pm_request(rq)) { 813 struct request_pm_state *pm = rq->data; 814#ifdef DEBUG_PM 815 printk("%s: start_power_step(step: %d)\n", 816 drive->name, rq->pm->pm_step); 817#endif 818 startstop = ide_start_power_step(drive, rq); 819 if (startstop == ide_stopped && 820 pm->pm_step == ide_pm_state_completed) 821 ide_complete_pm_request(drive, rq); 822 return startstop; 823 } else if (!rq->rq_disk && blk_special_request(rq)) 824 /* 825 * TODO: Once all ULDs have been modified to 826 * check for specific op codes rather than 827 * blindly accepting any special request, the 828 * check for ->rq_disk above may be replaced 829 * by a more suitable mechanism or even 830 * dropped entirely. 831 */ 832 return ide_special_rq(drive, rq); 833 834 drv = *(ide_driver_t **)rq->rq_disk->private_data; 835 836 return drv->do_request(drive, rq, rq->sector); 837 } 838 return do_special(drive); 839kill_rq: 840 ide_kill_rq(drive, rq); 841 return ide_stopped; 842} 843 844/** 845 * ide_stall_queue - pause an IDE device 846 * @drive: drive to stall 847 * @timeout: time to stall for (jiffies) 848 * 849 * ide_stall_queue() can be used by a drive to give excess bandwidth back 850 * to the hwgroup by sleeping for timeout jiffies. 851 */ 852 853void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) 854{ 855 if (timeout > WAIT_WORSTCASE) 856 timeout = WAIT_WORSTCASE; 857 drive->sleep = timeout + jiffies; 858 drive->sleeping = 1; 859} 860 861EXPORT_SYMBOL(ide_stall_queue); 862 863#define WAKEUP(drive) ((drive)->service_start + 2 * (drive)->service_time) 864 865/** 866 * choose_drive - select a drive to service 867 * @hwgroup: hardware group to select on 868 * 869 * choose_drive() selects the next drive which will be serviced. 870 * This is necessary because the IDE layer can't issue commands 871 * to both drives on the same cable, unlike SCSI. 872 */ 873 874static inline ide_drive_t *choose_drive (ide_hwgroup_t *hwgroup) 875{ 876 ide_drive_t *drive, *best; 877 878repeat: 879 best = NULL; 880 drive = hwgroup->drive; 881 882 /* 883 * drive is doing pre-flush, ordered write, post-flush sequence. even 884 * though that is 3 requests, it must be seen as a single transaction. 885 * we must not preempt this drive until that is complete 886 */ 887 if (blk_queue_flushing(drive->queue)) { 888 /* 889 * small race where queue could get replugged during 890 * the 3-request flush cycle, just yank the plug since 891 * we want it to finish asap 892 */ 893 blk_remove_plug(drive->queue); 894 return drive; 895 } 896 897 do { 898 if ((!drive->sleeping || time_after_eq(jiffies, drive->sleep)) 899 && !elv_queue_empty(drive->queue)) { 900 if (!best 901 || (drive->sleeping && (!best->sleeping || time_before(drive->sleep, best->sleep))) 902 || (!best->sleeping && time_before(WAKEUP(drive), WAKEUP(best)))) 903 { 904 if (!blk_queue_plugged(drive->queue)) 905 best = drive; 906 } 907 } 908 } while ((drive = drive->next) != hwgroup->drive); 909 if (best && best->nice1 && !best->sleeping && best != hwgroup->drive && best->service_time > WAIT_MIN_SLEEP) { 910 long t = (signed long)(WAKEUP(best) - jiffies); 911 if (t >= WAIT_MIN_SLEEP) { 912 /* 913 * We *may* have some time to spare, but first let's see if 914 * someone can potentially benefit from our nice mood today.. 915 */ 916 drive = best->next; 917 do { 918 if (!drive->sleeping 919 && time_before(jiffies - best->service_time, WAKEUP(drive)) 920 && time_before(WAKEUP(drive), jiffies + t)) 921 { 922 ide_stall_queue(best, min_t(long, t, 10 * WAIT_MIN_SLEEP)); 923 goto repeat; 924 } 925 } while ((drive = drive->next) != best); 926 } 927 } 928 return best; 929} 930 931/* 932 * Issue a new request to a drive from hwgroup 933 * Caller must have already done spin_lock_irqsave(&ide_lock, ..); 934 * 935 * A hwgroup is a serialized group of IDE interfaces. Usually there is 936 * exactly one hwif (interface) per hwgroup, but buggy controllers (eg. CMD640) 937 * may have both interfaces in a single hwgroup to "serialize" access. 938 * Or possibly multiple ISA interfaces can share a common IRQ by being grouped 939 * together into one hwgroup for serialized access. 940 * 941 * Note also that several hwgroups can end up sharing a single IRQ, 942 * possibly along with many other devices. This is especially common in 943 * PCI-based systems with off-board IDE controller cards. 944 * 945 * The IDE driver uses the single global ide_lock spinlock to protect 946 * access to the request queues, and to protect the hwgroup->busy flag. 947 * 948 * The first thread into the driver for a particular hwgroup sets the 949 * hwgroup->busy flag to indicate that this hwgroup is now active, 950 * and then initiates processing of the top request from the request queue. 951 * 952 * Other threads attempting entry notice the busy setting, and will simply 953 * queue their new requests and exit immediately. Note that hwgroup->busy 954 * remains set even when the driver is merely awaiting the next interrupt. 955 * Thus, the meaning is "this hwgroup is busy processing a request". 956 * 957 * When processing of a request completes, the completing thread or IRQ-handler 958 * will start the next request from the queue. If no more work remains, 959 * the driver will clear the hwgroup->busy flag and exit. 960 * 961 * The ide_lock (spinlock) is used to protect all access to the 962 * hwgroup->busy flag, but is otherwise not needed for most processing in 963 * the driver. This makes the driver much more friendlier to shared IRQs 964 * than previous designs, while remaining 100% (?) SMP safe and capable. 965 */ 966static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq) 967{ 968 ide_drive_t *drive; 969 ide_hwif_t *hwif; 970 struct request *rq; 971 ide_startstop_t startstop; 972 int loops = 0; 973 974 /* for atari only: POSSIBLY BROKEN HERE(?) */ 975 ide_get_lock(ide_intr, hwgroup); 976 977 /* caller must own ide_lock */ 978 BUG_ON(!irqs_disabled()); 979 980 while (!hwgroup->busy) { 981 hwgroup->busy = 1; 982 drive = choose_drive(hwgroup); 983 if (drive == NULL) { 984 int sleeping = 0; 985 unsigned long sleep = 0; /* shut up, gcc */ 986 hwgroup->rq = NULL; 987 drive = hwgroup->drive; 988 do { 989 if (drive->sleeping && (!sleeping || time_before(drive->sleep, sleep))) { 990 sleeping = 1; 991 sleep = drive->sleep; 992 } 993 } while ((drive = drive->next) != hwgroup->drive); 994 if (sleeping) { 995 /* 996 * Take a short snooze, and then wake up this hwgroup again. 997 * This gives other hwgroups on the same a chance to 998 * play fairly with us, just in case there are big differences 999 * in relative throughputs.. don't want to hog the cpu too much. 1000 */ 1001 if (time_before(sleep, jiffies + WAIT_MIN_SLEEP)) 1002 sleep = jiffies + WAIT_MIN_SLEEP; 1003#if 1 1004 if (timer_pending(&hwgroup->timer)) 1005 printk(KERN_CRIT "ide_set_handler: timer already active\n"); 1006#endif 1007 /* so that ide_timer_expiry knows what to do */ 1008 hwgroup->sleeping = 1; 1009 hwgroup->req_gen_timer = hwgroup->req_gen; 1010 mod_timer(&hwgroup->timer, sleep); 1011 /* we purposely leave hwgroup->busy==1 1012 * while sleeping */ 1013 } else { 1014 /* Ugly, but how can we sleep for the lock 1015 * otherwise? perhaps from tq_disk? 1016 */ 1017 1018 /* for atari only */ 1019 ide_release_lock(); 1020 hwgroup->busy = 0; 1021 } 1022 1023 /* no more work for this hwgroup (for now) */ 1024 return; 1025 } 1026 again: 1027 hwif = HWIF(drive); 1028 if (hwgroup->hwif->sharing_irq && hwif != hwgroup->hwif) { 1029 /* 1030 * set nIEN for previous hwif, drives in the 1031 * quirk_list may not like intr setups/cleanups 1032 */ 1033 if (drive->quirk_list != 1) 1034 hwif->tp_ops->set_irq(hwif, 0); 1035 } 1036 hwgroup->hwif = hwif; 1037 hwgroup->drive = drive; 1038 drive->sleeping = 0; 1039 drive->service_start = jiffies; 1040 1041 if (blk_queue_plugged(drive->queue)) { 1042 printk(KERN_ERR "ide: huh? queue was plugged!\n"); 1043 break; 1044 } 1045 1046 /* 1047 * we know that the queue isn't empty, but this can happen 1048 * if the q->prep_rq_fn() decides to kill a request 1049 */ 1050 rq = elv_next_request(drive->queue); 1051 if (!rq) { 1052 hwgroup->busy = 0; 1053 break; 1054 } 1055 1056 /* 1057 * Sanity: don't accept a request that isn't a PM request 1058 * if we are currently power managed. This is very important as 1059 * blk_stop_queue() doesn't prevent the elv_next_request() 1060 * above to return us whatever is in the queue. Since we call 1061 * ide_do_request() ourselves, we end up taking requests while 1062 * the queue is blocked... 1063 * 1064 * We let requests forced at head of queue with ide-preempt 1065 * though. I hope that doesn't happen too much, hopefully not 1066 * unless the subdriver triggers such a thing in its own PM 1067 * state machine. 1068 * 1069 * We count how many times we loop here to make sure we service 1070 * all drives in the hwgroup without looping for ever 1071 */ 1072 if (drive->blocked && !blk_pm_request(rq) && !(rq->cmd_flags & REQ_PREEMPT)) { 1073 drive = drive->next ? drive->next : hwgroup->drive; 1074 if (loops++ < 4 && !blk_queue_plugged(drive->queue)) 1075 goto again; 1076 /* We clear busy, there should be no pending ATA command at this point. */ 1077 hwgroup->busy = 0; 1078 break; 1079 } 1080 1081 hwgroup->rq = rq; 1082 1083 /* 1084 * Some systems have trouble with IDE IRQs arriving while 1085 * the driver is still setting things up. So, here we disable 1086 * the IRQ used by this interface while the request is being started. 1087 * This may look bad at first, but pretty much the same thing 1088 * happens anyway when any interrupt comes in, IDE or otherwise 1089 * -- the kernel masks the IRQ while it is being handled. 1090 */ 1091 if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq) 1092 disable_irq_nosync(hwif->irq); 1093 spin_unlock(&ide_lock); 1094 local_irq_enable_in_hardirq(); 1095 /* allow other IRQs while we start this request */ 1096 startstop = start_request(drive, rq); 1097 spin_lock_irq(&ide_lock); 1098 if (masked_irq != IDE_NO_IRQ && hwif->irq != masked_irq) 1099 enable_irq(hwif->irq); 1100 if (startstop == ide_stopped) 1101 hwgroup->busy = 0; 1102 } 1103} 1104 1105/* 1106 * Passes the stuff to ide_do_request 1107 */ 1108void do_ide_request(struct request_queue *q) 1109{ 1110 ide_drive_t *drive = q->queuedata; 1111 1112 ide_do_request(HWGROUP(drive), IDE_NO_IRQ); 1113} 1114 1115/* 1116 * un-busy the hwgroup etc, and clear any pending DMA status. we want to 1117 * retry the current request in pio mode instead of risking tossing it 1118 * all away 1119 */ 1120static ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error) 1121{ 1122 ide_hwif_t *hwif = HWIF(drive); 1123 struct request *rq; 1124 ide_startstop_t ret = ide_stopped; 1125 1126 /* 1127 * end current dma transaction 1128 */ 1129 1130 if (error < 0) { 1131 printk(KERN_WARNING "%s: DMA timeout error\n", drive->name); 1132 (void)hwif->dma_ops->dma_end(drive); 1133 ret = ide_error(drive, "dma timeout error", 1134 hwif->tp_ops->read_status(hwif)); 1135 } else { 1136 printk(KERN_WARNING "%s: DMA timeout retry\n", drive->name); 1137 hwif->dma_ops->dma_timeout(drive); 1138 } 1139 1140 /* 1141 * disable dma for now, but remember that we did so because of 1142 * a timeout -- we'll reenable after we finish this next request 1143 * (or rather the first chunk of it) in pio. 1144 */ 1145 drive->retry_pio++; 1146 drive->state = DMA_PIO_RETRY; 1147 ide_dma_off_quietly(drive); 1148 1149 /* 1150 * un-busy drive etc (hwgroup->busy is cleared on return) and 1151 * make sure request is sane 1152 */ 1153 rq = HWGROUP(drive)->rq; 1154 1155 if (!rq) 1156 goto out; 1157 1158 HWGROUP(drive)->rq = NULL; 1159 1160 rq->errors = 0; 1161 1162 if (!rq->bio) 1163 goto out; 1164 1165 rq->sector = rq->bio->bi_sector; 1166 rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9; 1167 rq->hard_cur_sectors = rq->current_nr_sectors; 1168 rq->buffer = bio_data(rq->bio); 1169out: 1170 return ret; 1171} 1172 1173/** 1174 * ide_timer_expiry - handle lack of an IDE interrupt 1175 * @data: timer callback magic (hwgroup) 1176 * 1177 * An IDE command has timed out before the expected drive return 1178 * occurred. At this point we attempt to clean up the current 1179 * mess. If the current handler includes an expiry handler then 1180 * we invoke the expiry handler, and providing it is happy the 1181 * work is done. If that fails we apply generic recovery rules 1182 * invoking the handler and checking the drive DMA status. We 1183 * have an excessively incestuous relationship with the DMA 1184 * logic that wants cleaning up. 1185 */ 1186 1187void ide_timer_expiry (unsigned long data) 1188{ 1189 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data; 1190 ide_handler_t *handler; 1191 ide_expiry_t *expiry; 1192 unsigned long flags; 1193 unsigned long wait = -1; 1194 1195 spin_lock_irqsave(&ide_lock, flags); 1196 1197 if (((handler = hwgroup->handler) == NULL) || 1198 (hwgroup->req_gen != hwgroup->req_gen_timer)) { 1199 /* 1200 * Either a marginal timeout occurred 1201 * (got the interrupt just as timer expired), 1202 * or we were "sleeping" to give other devices a chance. 1203 * Either way, we don't really want to complain about anything. 1204 */ 1205 if (hwgroup->sleeping) { 1206 hwgroup->sleeping = 0; 1207 hwgroup->busy = 0; 1208 } 1209 } else { 1210 ide_drive_t *drive = hwgroup->drive; 1211 if (!drive) { 1212 printk(KERN_ERR "ide_timer_expiry: hwgroup->drive was NULL\n"); 1213 hwgroup->handler = NULL; 1214 } else { 1215 ide_hwif_t *hwif; 1216 ide_startstop_t startstop = ide_stopped; 1217 if (!hwgroup->busy) { 1218 hwgroup->busy = 1; /* paranoia */ 1219 printk(KERN_ERR "%s: ide_timer_expiry: hwgroup->busy was 0 ??\n", drive->name); 1220 } 1221 if ((expiry = hwgroup->expiry) != NULL) { 1222 /* continue */ 1223 if ((wait = expiry(drive)) > 0) { 1224 /* reset timer */ 1225 hwgroup->timer.expires = jiffies + wait; 1226 hwgroup->req_gen_timer = hwgroup->req_gen; 1227 add_timer(&hwgroup->timer); 1228 spin_unlock_irqrestore(&ide_lock, flags); 1229 return; 1230 } 1231 } 1232 hwgroup->handler = NULL; 1233 /* 1234 * We need to simulate a real interrupt when invoking 1235 * the handler() function, which means we need to 1236 * globally mask the specific IRQ: 1237 */ 1238 spin_unlock(&ide_lock); 1239 hwif = HWIF(drive); 1240 /* disable_irq_nosync ?? */ 1241 disable_irq(hwif->irq); 1242 /* local CPU only, 1243 * as if we were handling an interrupt */ 1244 local_irq_disable(); 1245 if (hwgroup->polling) { 1246 startstop = handler(drive); 1247 } else if (drive_is_ready(drive)) { 1248 if (drive->waiting_for_dma) 1249 hwif->dma_ops->dma_lost_irq(drive); 1250 (void)ide_ack_intr(hwif); 1251 printk(KERN_WARNING "%s: lost interrupt\n", drive->name); 1252 startstop = handler(drive); 1253 } else { 1254 if (drive->waiting_for_dma) { 1255 startstop = ide_dma_timeout_retry(drive, wait); 1256 } else 1257 startstop = 1258 ide_error(drive, "irq timeout", 1259 hwif->tp_ops->read_status(hwif)); 1260 } 1261 drive->service_time = jiffies - drive->service_start; 1262 spin_lock_irq(&ide_lock); 1263 enable_irq(hwif->irq); 1264 if (startstop == ide_stopped) 1265 hwgroup->busy = 0; 1266 } 1267 } 1268 ide_do_request(hwgroup, IDE_NO_IRQ); 1269 spin_unlock_irqrestore(&ide_lock, flags); 1270} 1271 1272/** 1273 * unexpected_intr - handle an unexpected IDE interrupt 1274 * @irq: interrupt line 1275 * @hwgroup: hwgroup being processed 1276 * 1277 * There's nothing really useful we can do with an unexpected interrupt, 1278 * other than reading the status register (to clear it), and logging it. 1279 * There should be no way that an irq can happen before we're ready for it, 1280 * so we needn't worry much about losing an "important" interrupt here. 1281 * 1282 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever 1283 * the drive enters "idle", "standby", or "sleep" mode, so if the status 1284 * looks "good", we just ignore the interrupt completely. 1285 * 1286 * This routine assumes __cli() is in effect when called. 1287 * 1288 * If an unexpected interrupt happens on irq15 while we are handling irq14 1289 * and if the two interfaces are "serialized" (CMD640), then it looks like 1290 * we could screw up by interfering with a new request being set up for 1291 * irq15. 1292 * 1293 * In reality, this is a non-issue. The new command is not sent unless 1294 * the drive is ready to accept one, in which case we know the drive is 1295 * not trying to interrupt us. And ide_set_handler() is always invoked 1296 * before completing the issuance of any new drive command, so we will not 1297 * be accidentally invoked as a result of any valid command completion 1298 * interrupt. 1299 * 1300 * Note that we must walk the entire hwgroup here. We know which hwif 1301 * is doing the current command, but we don't know which hwif burped 1302 * mysteriously. 1303 */ 1304 1305static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup) 1306{ 1307 u8 stat; 1308 ide_hwif_t *hwif = hwgroup->hwif; 1309 1310 /* 1311 * handle the unexpected interrupt 1312 */ 1313 do { 1314 if (hwif->irq == irq) { 1315 stat = hwif->tp_ops->read_status(hwif); 1316 1317 if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) { 1318 /* Try to not flood the console with msgs */ 1319 static unsigned long last_msgtime, count; 1320 ++count; 1321 if (time_after(jiffies, last_msgtime + HZ)) { 1322 last_msgtime = jiffies; 1323 printk(KERN_ERR "%s%s: unexpected interrupt, " 1324 "status=0x%02x, count=%ld\n", 1325 hwif->name, 1326 (hwif->next==hwgroup->hwif) ? "" : "(?)", stat, count); 1327 } 1328 } 1329 } 1330 } while ((hwif = hwif->next) != hwgroup->hwif); 1331} 1332 1333/** 1334 * ide_intr - default IDE interrupt handler 1335 * @irq: interrupt number 1336 * @dev_id: hwif group 1337 * @regs: unused weirdness from the kernel irq layer 1338 * 1339 * This is the default IRQ handler for the IDE layer. You should 1340 * not need to override it. If you do be aware it is subtle in 1341 * places 1342 * 1343 * hwgroup->hwif is the interface in the group currently performing 1344 * a command. hwgroup->drive is the drive and hwgroup->handler is 1345 * the IRQ handler to call. As we issue a command the handlers 1346 * step through multiple states, reassigning the handler to the 1347 * next step in the process. Unlike a smart SCSI controller IDE 1348 * expects the main processor to sequence the various transfer 1349 * stages. We also manage a poll timer to catch up with most 1350 * timeout situations. There are still a few where the handlers 1351 * don't ever decide to give up. 1352 * 1353 * The handler eventually returns ide_stopped to indicate the 1354 * request completed. At this point we issue the next request 1355 * on the hwgroup and the process begins again. 1356 */ 1357 1358irqreturn_t ide_intr (int irq, void *dev_id) 1359{ 1360 unsigned long flags; 1361 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id; 1362 ide_hwif_t *hwif; 1363 ide_drive_t *drive; 1364 ide_handler_t *handler; 1365 ide_startstop_t startstop; 1366 1367 spin_lock_irqsave(&ide_lock, flags); 1368 hwif = hwgroup->hwif; 1369 1370 if (!ide_ack_intr(hwif)) { 1371 spin_unlock_irqrestore(&ide_lock, flags); 1372 return IRQ_NONE; 1373 } 1374 1375 if ((handler = hwgroup->handler) == NULL || hwgroup->polling) { 1376 /* 1377 * Not expecting an interrupt from this drive. 1378 * That means this could be: 1379 * (1) an interrupt from another PCI device 1380 * sharing the same PCI INT# as us. 1381 * or (2) a drive just entered sleep or standby mode, 1382 * and is interrupting to let us know. 1383 * or (3) a spurious interrupt of unknown origin. 1384 * 1385 * For PCI, we cannot tell the difference, 1386 * so in that case we just ignore it and hope it goes away. 1387 * 1388 * FIXME: unexpected_intr should be hwif-> then we can 1389 * remove all the ifdef PCI crap 1390 */ 1391#ifdef CONFIG_BLK_DEV_IDEPCI 1392 if (hwif->chipset != ide_pci) 1393#endif /* CONFIG_BLK_DEV_IDEPCI */ 1394 { 1395 /* 1396 * Probably not a shared PCI interrupt, 1397 * so we can safely try to do something about it: 1398 */ 1399 unexpected_intr(irq, hwgroup); 1400#ifdef CONFIG_BLK_DEV_IDEPCI 1401 } else { 1402 /* 1403 * Whack the status register, just in case 1404 * we have a leftover pending IRQ. 1405 */ 1406 (void)hwif->tp_ops->read_status(hwif); 1407#endif /* CONFIG_BLK_DEV_IDEPCI */ 1408 } 1409 spin_unlock_irqrestore(&ide_lock, flags); 1410 return IRQ_NONE; 1411 } 1412 drive = hwgroup->drive; 1413 if (!drive) { 1414 /* 1415 * This should NEVER happen, and there isn't much 1416 * we could do about it here. 1417 * 1418 * [Note - this can occur if the drive is hot unplugged] 1419 */ 1420 spin_unlock_irqrestore(&ide_lock, flags); 1421 return IRQ_HANDLED; 1422 } 1423 if (!drive_is_ready(drive)) { 1424 /* 1425 * This happens regularly when we share a PCI IRQ with 1426 * another device. Unfortunately, it can also happen 1427 * with some buggy drives that trigger the IRQ before 1428 * their status register is up to date. Hopefully we have 1429 * enough advance overhead that the latter isn't a problem. 1430 */ 1431 spin_unlock_irqrestore(&ide_lock, flags); 1432 return IRQ_NONE; 1433 } 1434 if (!hwgroup->busy) { 1435 hwgroup->busy = 1; /* paranoia */ 1436 printk(KERN_ERR "%s: ide_intr: hwgroup->busy was 0 ??\n", drive->name); 1437 } 1438 hwgroup->handler = NULL; 1439 hwgroup->req_gen++; 1440 del_timer(&hwgroup->timer); 1441 spin_unlock(&ide_lock); 1442 1443 /* Some controllers might set DMA INTR no matter DMA or PIO; 1444 * bmdma status might need to be cleared even for 1445 * PIO interrupts to prevent spurious/lost irq. 1446 */ 1447 if (hwif->ide_dma_clear_irq && !(drive->waiting_for_dma)) 1448 /* ide_dma_end() needs bmdma status for error checking. 1449 * So, skip clearing bmdma status here and leave it 1450 * to ide_dma_end() if this is dma interrupt. 1451 */ 1452 hwif->ide_dma_clear_irq(drive); 1453 1454 if (drive->unmask) 1455 local_irq_enable_in_hardirq(); 1456 /* service this interrupt, may set handler for next interrupt */ 1457 startstop = handler(drive); 1458 spin_lock_irq(&ide_lock); 1459 1460 /* 1461 * Note that handler() may have set things up for another 1462 * interrupt to occur soon, but it cannot happen until 1463 * we exit from this routine, because it will be the 1464 * same irq as is currently being serviced here, and Linux 1465 * won't allow another of the same (on any CPU) until we return. 1466 */ 1467 drive->service_time = jiffies - drive->service_start; 1468 if (startstop == ide_stopped) { 1469 if (hwgroup->handler == NULL) { /* paranoia */ 1470 hwgroup->busy = 0; 1471 ide_do_request(hwgroup, hwif->irq); 1472 } else { 1473 printk(KERN_ERR "%s: ide_intr: huh? expected NULL handler " 1474 "on exit\n", drive->name); 1475 } 1476 } 1477 spin_unlock_irqrestore(&ide_lock, flags); 1478 return IRQ_HANDLED; 1479} 1480 1481/** 1482 * ide_do_drive_cmd - issue IDE special command 1483 * @drive: device to issue command 1484 * @rq: request to issue 1485 * 1486 * This function issues a special IDE device request 1487 * onto the request queue. 1488 * 1489 * the rq is queued at the head of the request queue, displacing 1490 * the currently-being-processed request and this function 1491 * returns immediately without waiting for the new rq to be 1492 * completed. This is VERY DANGEROUS, and is intended for 1493 * careful use by the ATAPI tape/cdrom driver code. 1494 */ 1495 1496void ide_do_drive_cmd(ide_drive_t *drive, struct request *rq) 1497{ 1498 unsigned long flags; 1499 ide_hwgroup_t *hwgroup = HWGROUP(drive); 1500 1501 spin_lock_irqsave(&ide_lock, flags); 1502 hwgroup->rq = NULL; 1503 __elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 1); 1504 __generic_unplug_device(drive->queue); 1505 spin_unlock_irqrestore(&ide_lock, flags); 1506} 1507 1508EXPORT_SYMBOL(ide_do_drive_cmd); 1509 1510void ide_pktcmd_tf_load(ide_drive_t *drive, u32 tf_flags, u16 bcount, u8 dma) 1511{ 1512 ide_hwif_t *hwif = drive->hwif; 1513 ide_task_t task; 1514 1515 memset(&task, 0, sizeof(task)); 1516 task.tf_flags = IDE_TFLAG_OUT_LBAH | IDE_TFLAG_OUT_LBAM | 1517 IDE_TFLAG_OUT_FEATURE | tf_flags; 1518 task.tf.feature = dma; /* Use PIO/DMA */ 1519 task.tf.lbam = bcount & 0xff; 1520 task.tf.lbah = (bcount >> 8) & 0xff; 1521 1522 ide_tf_dump(drive->name, &task.tf); 1523 hwif->tp_ops->set_irq(hwif, 1); 1524 SELECT_MASK(drive, 0); 1525 hwif->tp_ops->tf_load(drive, &task); 1526} 1527 1528EXPORT_SYMBOL_GPL(ide_pktcmd_tf_load); 1529 1530void ide_pad_transfer(ide_drive_t *drive, int write, int len) 1531{ 1532 ide_hwif_t *hwif = drive->hwif; 1533 u8 buf[4] = { 0 }; 1534 1535 while (len > 0) { 1536 if (write) 1537 hwif->tp_ops->output_data(drive, NULL, buf, min(4, len)); 1538 else 1539 hwif->tp_ops->input_data(drive, NULL, buf, min(4, len)); 1540 len -= 4; 1541 } 1542} 1543EXPORT_SYMBOL_GPL(ide_pad_transfer); 1544