ide-io.c revision 789547508f22e482825f52f813b59680408ec2c7
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/completion.h> 44#include <linux/reboot.h> 45#include <linux/cdrom.h> 46#include <linux/seq_file.h> 47#include <linux/device.h> 48#include <linux/kmod.h> 49#include <linux/scatterlist.h> 50#include <linux/bitops.h> 51 52#include <asm/byteorder.h> 53#include <asm/irq.h> 54#include <asm/uaccess.h> 55#include <asm/io.h> 56 57int ide_end_rq(ide_drive_t *drive, struct request *rq, int error, 58 unsigned int nr_bytes) 59{ 60 /* 61 * decide whether to reenable DMA -- 3 is a random magic for now, 62 * if we DMA timeout more than 3 times, just stay in PIO 63 */ 64 if ((drive->dev_flags & IDE_DFLAG_DMA_PIO_RETRY) && 65 drive->retry_pio <= 3) { 66 drive->dev_flags &= ~IDE_DFLAG_DMA_PIO_RETRY; 67 ide_dma_on(drive); 68 } 69 70 return blk_end_request(rq, error, nr_bytes); 71} 72EXPORT_SYMBOL_GPL(ide_end_rq); 73 74void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err) 75{ 76 const struct ide_tp_ops *tp_ops = drive->hwif->tp_ops; 77 struct ide_taskfile *tf = &cmd->tf; 78 struct request *rq = cmd->rq; 79 u8 tf_cmd = tf->command; 80 81 tf->error = err; 82 tf->status = stat; 83 84 if (cmd->ftf_flags & IDE_FTFLAG_IN_DATA) { 85 u8 data[2]; 86 87 tp_ops->input_data(drive, cmd, data, 2); 88 89 cmd->tf.data = data[0]; 90 cmd->hob.data = data[1]; 91 } 92 93 ide_tf_readback(drive, cmd); 94 95 if ((cmd->tf_flags & IDE_TFLAG_CUSTOM_HANDLER) && 96 tf_cmd == ATA_CMD_IDLEIMMEDIATE) { 97 if (tf->lbal != 0xc4) { 98 printk(KERN_ERR "%s: head unload failed!\n", 99 drive->name); 100 ide_tf_dump(drive->name, cmd); 101 } else 102 drive->dev_flags |= IDE_DFLAG_PARKED; 103 } 104 105 if (rq && rq->cmd_type == REQ_TYPE_ATA_TASKFILE) { 106 struct ide_cmd *orig_cmd = rq->special; 107 108 if (cmd->tf_flags & IDE_TFLAG_DYN) 109 kfree(orig_cmd); 110 else 111 memcpy(orig_cmd, cmd, sizeof(*cmd)); 112 } 113} 114 115/* obsolete, blk_rq_bytes() should be used instead */ 116unsigned int ide_rq_bytes(struct request *rq) 117{ 118 if (blk_pc_request(rq)) 119 return blk_rq_bytes(rq); 120 else 121 return blk_rq_cur_sectors(rq) << 9; 122} 123EXPORT_SYMBOL_GPL(ide_rq_bytes); 124 125int ide_complete_rq(ide_drive_t *drive, int error, unsigned int nr_bytes) 126{ 127 ide_hwif_t *hwif = drive->hwif; 128 struct request *rq = hwif->rq; 129 int rc; 130 131 /* 132 * if failfast is set on a request, override number of sectors 133 * and complete the whole request right now 134 */ 135 if (blk_noretry_request(rq) && error <= 0) 136 nr_bytes = blk_rq_sectors(rq) << 9; 137 138 rc = ide_end_rq(drive, rq, error, nr_bytes); 139 if (rc == 0) 140 hwif->rq = NULL; 141 142 return rc; 143} 144EXPORT_SYMBOL(ide_complete_rq); 145 146void ide_kill_rq(ide_drive_t *drive, struct request *rq) 147{ 148 u8 drv_req = blk_special_request(rq) && rq->rq_disk; 149 u8 media = drive->media; 150 151 drive->failed_pc = NULL; 152 153 if ((media == ide_floppy || media == ide_tape) && drv_req) { 154 rq->errors = 0; 155 ide_complete_rq(drive, -EIO, blk_rq_bytes(rq)); 156 } else { 157 if (media == ide_tape) 158 rq->errors = IDE_DRV_ERROR_GENERAL; 159 else if (blk_fs_request(rq) == 0 && rq->errors == 0) 160 rq->errors = -EIO; 161 ide_complete_rq(drive, -EIO, ide_rq_bytes(rq)); 162 } 163} 164 165static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 166{ 167 tf->nsect = drive->sect; 168 tf->lbal = drive->sect; 169 tf->lbam = drive->cyl; 170 tf->lbah = drive->cyl >> 8; 171 tf->device = (drive->head - 1) | drive->select; 172 tf->command = ATA_CMD_INIT_DEV_PARAMS; 173} 174 175static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 176{ 177 tf->nsect = drive->sect; 178 tf->command = ATA_CMD_RESTORE; 179} 180 181static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 182{ 183 tf->nsect = drive->mult_req; 184 tf->command = ATA_CMD_SET_MULTI; 185} 186 187/** 188 * do_special - issue some special commands 189 * @drive: drive the command is for 190 * 191 * do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS, 192 * ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive. 193 */ 194 195static ide_startstop_t do_special(ide_drive_t *drive) 196{ 197 struct ide_cmd cmd; 198 199#ifdef DEBUG 200 printk(KERN_DEBUG "%s: %s: 0x%02x\n", drive->name, __func__, 201 drive->special_flags); 202#endif 203 if (drive->media != ide_disk) { 204 drive->special_flags = 0; 205 drive->mult_req = 0; 206 return ide_stopped; 207 } 208 209 memset(&cmd, 0, sizeof(cmd)); 210 cmd.protocol = ATA_PROT_NODATA; 211 212 if (drive->special_flags & IDE_SFLAG_SET_GEOMETRY) { 213 drive->special_flags &= ~IDE_SFLAG_SET_GEOMETRY; 214 ide_tf_set_specify_cmd(drive, &cmd.tf); 215 } else if (drive->special_flags & IDE_SFLAG_RECALIBRATE) { 216 drive->special_flags &= ~IDE_SFLAG_RECALIBRATE; 217 ide_tf_set_restore_cmd(drive, &cmd.tf); 218 } else if (drive->special_flags & IDE_SFLAG_SET_MULTMODE) { 219 drive->special_flags &= ~IDE_SFLAG_SET_MULTMODE; 220 ide_tf_set_setmult_cmd(drive, &cmd.tf); 221 } else 222 BUG(); 223 224 cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE; 225 cmd.valid.in.tf = IDE_VALID_IN_TF | IDE_VALID_DEVICE; 226 cmd.tf_flags = IDE_TFLAG_CUSTOM_HANDLER; 227 228 do_rw_taskfile(drive, &cmd); 229 230 return ide_started; 231} 232 233void ide_map_sg(ide_drive_t *drive, struct ide_cmd *cmd) 234{ 235 ide_hwif_t *hwif = drive->hwif; 236 struct scatterlist *sg = hwif->sg_table; 237 struct request *rq = cmd->rq; 238 239 cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); 240} 241EXPORT_SYMBOL_GPL(ide_map_sg); 242 243void ide_init_sg_cmd(struct ide_cmd *cmd, unsigned int nr_bytes) 244{ 245 cmd->nbytes = cmd->nleft = nr_bytes; 246 cmd->cursg_ofs = 0; 247 cmd->cursg = NULL; 248} 249EXPORT_SYMBOL_GPL(ide_init_sg_cmd); 250 251/** 252 * execute_drive_command - issue special drive command 253 * @drive: the drive to issue the command on 254 * @rq: the request structure holding the command 255 * 256 * execute_drive_cmd() issues a special drive command, usually 257 * initiated by ioctl() from the external hdparm program. The 258 * command can be a drive command, drive task or taskfile 259 * operation. Weirdly you can call it with NULL to wait for 260 * all commands to finish. Don't do this as that is due to change 261 */ 262 263static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, 264 struct request *rq) 265{ 266 struct ide_cmd *cmd = rq->special; 267 268 if (cmd) { 269 if (cmd->protocol == ATA_PROT_PIO) { 270 ide_init_sg_cmd(cmd, blk_rq_sectors(rq) << 9); 271 ide_map_sg(drive, cmd); 272 } 273 274 return do_rw_taskfile(drive, cmd); 275 } 276 277 /* 278 * NULL is actually a valid way of waiting for 279 * all current requests to be flushed from the queue. 280 */ 281#ifdef DEBUG 282 printk("%s: DRIVE_CMD (null)\n", drive->name); 283#endif 284 rq->errors = 0; 285 ide_complete_rq(drive, 0, blk_rq_bytes(rq)); 286 287 return ide_stopped; 288} 289 290static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 291{ 292 u8 cmd = rq->cmd[0]; 293 294 switch (cmd) { 295 case REQ_PARK_HEADS: 296 case REQ_UNPARK_HEADS: 297 return ide_do_park_unpark(drive, rq); 298 case REQ_DEVSET_EXEC: 299 return ide_do_devset(drive, rq); 300 case REQ_DRIVE_RESET: 301 return ide_do_reset(drive); 302 default: 303 BUG(); 304 } 305} 306 307/** 308 * start_request - start of I/O and command issuing for IDE 309 * 310 * start_request() initiates handling of a new I/O request. It 311 * accepts commands and I/O (read/write) requests. 312 * 313 * FIXME: this function needs a rename 314 */ 315 316static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq) 317{ 318 ide_startstop_t startstop; 319 320 BUG_ON(!blk_rq_started(rq)); 321 322#ifdef DEBUG 323 printk("%s: start_request: current=0x%08lx\n", 324 drive->hwif->name, (unsigned long) rq); 325#endif 326 327 /* bail early if we've exceeded max_failures */ 328 if (drive->max_failures && (drive->failures > drive->max_failures)) { 329 rq->cmd_flags |= REQ_FAILED; 330 goto kill_rq; 331 } 332 333 if (blk_pm_request(rq)) 334 ide_check_pm_state(drive, rq); 335 336 drive->hwif->tp_ops->dev_select(drive); 337 if (ide_wait_stat(&startstop, drive, drive->ready_stat, 338 ATA_BUSY | ATA_DRQ, WAIT_READY)) { 339 printk(KERN_ERR "%s: drive not ready for command\n", drive->name); 340 return startstop; 341 } 342 343 if (drive->special_flags == 0) { 344 struct ide_driver *drv; 345 346 /* 347 * We reset the drive so we need to issue a SETFEATURES. 348 * Do it _after_ do_special() restored device parameters. 349 */ 350 if (drive->current_speed == 0xff) 351 ide_config_drive_speed(drive, drive->desired_speed); 352 353 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 354 return execute_drive_cmd(drive, rq); 355 else if (blk_pm_request(rq)) { 356 struct request_pm_state *pm = rq->special; 357#ifdef DEBUG_PM 358 printk("%s: start_power_step(step: %d)\n", 359 drive->name, pm->pm_step); 360#endif 361 startstop = ide_start_power_step(drive, rq); 362 if (startstop == ide_stopped && 363 pm->pm_step == IDE_PM_COMPLETED) 364 ide_complete_pm_rq(drive, rq); 365 return startstop; 366 } else if (!rq->rq_disk && blk_special_request(rq)) 367 /* 368 * TODO: Once all ULDs have been modified to 369 * check for specific op codes rather than 370 * blindly accepting any special request, the 371 * check for ->rq_disk above may be replaced 372 * by a more suitable mechanism or even 373 * dropped entirely. 374 */ 375 return ide_special_rq(drive, rq); 376 377 drv = *(struct ide_driver **)rq->rq_disk->private_data; 378 379 return drv->do_request(drive, rq, blk_rq_pos(rq)); 380 } 381 return do_special(drive); 382kill_rq: 383 ide_kill_rq(drive, rq); 384 return ide_stopped; 385} 386 387/** 388 * ide_stall_queue - pause an IDE device 389 * @drive: drive to stall 390 * @timeout: time to stall for (jiffies) 391 * 392 * ide_stall_queue() can be used by a drive to give excess bandwidth back 393 * to the port by sleeping for timeout jiffies. 394 */ 395 396void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) 397{ 398 if (timeout > WAIT_WORSTCASE) 399 timeout = WAIT_WORSTCASE; 400 drive->sleep = timeout + jiffies; 401 drive->dev_flags |= IDE_DFLAG_SLEEPING; 402} 403EXPORT_SYMBOL(ide_stall_queue); 404 405static inline int ide_lock_port(ide_hwif_t *hwif) 406{ 407 if (hwif->busy) 408 return 1; 409 410 hwif->busy = 1; 411 412 return 0; 413} 414 415static inline void ide_unlock_port(ide_hwif_t *hwif) 416{ 417 hwif->busy = 0; 418} 419 420static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif) 421{ 422 int rc = 0; 423 424 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 425 rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy); 426 if (rc == 0) { 427 if (host->get_lock) 428 host->get_lock(ide_intr, hwif); 429 } 430 } 431 return rc; 432} 433 434static inline void ide_unlock_host(struct ide_host *host) 435{ 436 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 437 if (host->release_lock) 438 host->release_lock(); 439 clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy); 440 } 441} 442 443/* 444 * Issue a new request to a device. 445 */ 446void do_ide_request(struct request_queue *q) 447{ 448 ide_drive_t *drive = q->queuedata; 449 ide_hwif_t *hwif = drive->hwif; 450 struct ide_host *host = hwif->host; 451 struct request *rq = NULL; 452 ide_startstop_t startstop; 453 454 /* 455 * drive is doing pre-flush, ordered write, post-flush sequence. even 456 * though that is 3 requests, it must be seen as a single transaction. 457 * we must not preempt this drive until that is complete 458 */ 459 if (blk_queue_flushing(q)) 460 /* 461 * small race where queue could get replugged during 462 * the 3-request flush cycle, just yank the plug since 463 * we want it to finish asap 464 */ 465 blk_remove_plug(q); 466 467 spin_unlock_irq(q->queue_lock); 468 469 /* HLD do_request() callback might sleep, make sure it's okay */ 470 might_sleep(); 471 472 if (ide_lock_host(host, hwif)) 473 goto plug_device_2; 474 475 spin_lock_irq(&hwif->lock); 476 477 if (!ide_lock_port(hwif)) { 478 ide_hwif_t *prev_port; 479repeat: 480 prev_port = hwif->host->cur_port; 481 482 if (drive->dev_flags & IDE_DFLAG_BLOCKED) 483 rq = hwif->rq; 484 else 485 WARN_ON_ONCE(hwif->rq); 486 487 if (drive->dev_flags & IDE_DFLAG_SLEEPING && 488 time_after(drive->sleep, jiffies)) { 489 ide_unlock_port(hwif); 490 goto plug_device; 491 } 492 493 if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) && 494 hwif != prev_port) { 495 ide_drive_t *cur_dev = 496 prev_port ? prev_port->cur_dev : NULL; 497 498 /* 499 * set nIEN for previous port, drives in the 500 * quirk list may not like intr setups/cleanups 501 */ 502 if (cur_dev && 503 (cur_dev->dev_flags & IDE_DFLAG_NIEN_QUIRK) == 0) 504 prev_port->tp_ops->write_devctl(prev_port, 505 ATA_NIEN | 506 ATA_DEVCTL_OBS); 507 508 hwif->host->cur_port = hwif; 509 } 510 hwif->cur_dev = drive; 511 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED); 512 513 if (rq == NULL) { 514 spin_unlock_irq(&hwif->lock); 515 spin_lock_irq(q->queue_lock); 516 /* 517 * we know that the queue isn't empty, but this can 518 * happen if ->prep_rq_fn() decides to kill a request 519 */ 520 rq = blk_fetch_request(drive->queue); 521 spin_unlock_irq(q->queue_lock); 522 spin_lock_irq(&hwif->lock); 523 524 if (rq == NULL) { 525 ide_unlock_port(hwif); 526 goto out; 527 } 528 } 529 530 /* 531 * Sanity: don't accept a request that isn't a PM request 532 * if we are currently power managed. 533 */ 534 BUG_ON((drive->dev_flags & IDE_DFLAG_BLOCKED) && 535 blk_pm_request(rq) == 0); 536 537 hwif->rq = rq; 538 539 spin_unlock_irq(&hwif->lock); 540 startstop = start_request(drive, rq); 541 spin_lock_irq(&hwif->lock); 542 543 if (startstop == ide_stopped) { 544 rq = hwif->rq; 545 hwif->rq = NULL; 546 goto repeat; 547 } 548 } else 549 goto plug_device; 550out: 551 spin_unlock_irq(&hwif->lock); 552 if (rq == NULL) 553 ide_unlock_host(host); 554 spin_lock_irq(q->queue_lock); 555 return; 556 557plug_device: 558 spin_unlock_irq(&hwif->lock); 559 ide_unlock_host(host); 560plug_device_2: 561 spin_lock_irq(q->queue_lock); 562 563 if (rq) 564 blk_requeue_request(q, rq); 565 if (!elv_queue_empty(q)) 566 blk_plug_device(q); 567} 568 569static void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq) 570{ 571 struct request_queue *q = drive->queue; 572 unsigned long flags; 573 574 spin_lock_irqsave(q->queue_lock, flags); 575 576 if (rq) 577 blk_requeue_request(q, rq); 578 if (!elv_queue_empty(q)) 579 blk_plug_device(q); 580 581 spin_unlock_irqrestore(q->queue_lock, flags); 582} 583 584static int drive_is_ready(ide_drive_t *drive) 585{ 586 ide_hwif_t *hwif = drive->hwif; 587 u8 stat = 0; 588 589 if (drive->waiting_for_dma) 590 return hwif->dma_ops->dma_test_irq(drive); 591 592 if (hwif->io_ports.ctl_addr && 593 (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) 594 stat = hwif->tp_ops->read_altstatus(hwif); 595 else 596 /* Note: this may clear a pending IRQ!! */ 597 stat = hwif->tp_ops->read_status(hwif); 598 599 if (stat & ATA_BUSY) 600 /* drive busy: definitely not interrupting */ 601 return 0; 602 603 /* drive ready: *might* be interrupting */ 604 return 1; 605} 606 607/** 608 * ide_timer_expiry - handle lack of an IDE interrupt 609 * @data: timer callback magic (hwif) 610 * 611 * An IDE command has timed out before the expected drive return 612 * occurred. At this point we attempt to clean up the current 613 * mess. If the current handler includes an expiry handler then 614 * we invoke the expiry handler, and providing it is happy the 615 * work is done. If that fails we apply generic recovery rules 616 * invoking the handler and checking the drive DMA status. We 617 * have an excessively incestuous relationship with the DMA 618 * logic that wants cleaning up. 619 */ 620 621void ide_timer_expiry (unsigned long data) 622{ 623 ide_hwif_t *hwif = (ide_hwif_t *)data; 624 ide_drive_t *uninitialized_var(drive); 625 ide_handler_t *handler; 626 unsigned long flags; 627 int wait = -1; 628 int plug_device = 0; 629 struct request *uninitialized_var(rq_in_flight); 630 631 spin_lock_irqsave(&hwif->lock, flags); 632 633 handler = hwif->handler; 634 635 if (handler == NULL || hwif->req_gen != hwif->req_gen_timer) { 636 /* 637 * Either a marginal timeout occurred 638 * (got the interrupt just as timer expired), 639 * or we were "sleeping" to give other devices a chance. 640 * Either way, we don't really want to complain about anything. 641 */ 642 } else { 643 ide_expiry_t *expiry = hwif->expiry; 644 ide_startstop_t startstop = ide_stopped; 645 646 drive = hwif->cur_dev; 647 648 if (expiry) { 649 wait = expiry(drive); 650 if (wait > 0) { /* continue */ 651 /* reset timer */ 652 hwif->timer.expires = jiffies + wait; 653 hwif->req_gen_timer = hwif->req_gen; 654 add_timer(&hwif->timer); 655 spin_unlock_irqrestore(&hwif->lock, flags); 656 return; 657 } 658 } 659 hwif->handler = NULL; 660 hwif->expiry = NULL; 661 /* 662 * We need to simulate a real interrupt when invoking 663 * the handler() function, which means we need to 664 * globally mask the specific IRQ: 665 */ 666 spin_unlock(&hwif->lock); 667 /* disable_irq_nosync ?? */ 668 disable_irq(hwif->irq); 669 /* local CPU only, as if we were handling an interrupt */ 670 local_irq_disable(); 671 if (hwif->polling) { 672 startstop = handler(drive); 673 } else if (drive_is_ready(drive)) { 674 if (drive->waiting_for_dma) 675 hwif->dma_ops->dma_lost_irq(drive); 676 if (hwif->port_ops && hwif->port_ops->clear_irq) 677 hwif->port_ops->clear_irq(drive); 678 679 printk(KERN_WARNING "%s: lost interrupt\n", 680 drive->name); 681 startstop = handler(drive); 682 } else { 683 if (drive->waiting_for_dma) 684 startstop = ide_dma_timeout_retry(drive, wait); 685 else 686 startstop = ide_error(drive, "irq timeout", 687 hwif->tp_ops->read_status(hwif)); 688 } 689 spin_lock_irq(&hwif->lock); 690 enable_irq(hwif->irq); 691 if (startstop == ide_stopped && hwif->polling == 0) { 692 rq_in_flight = hwif->rq; 693 hwif->rq = NULL; 694 ide_unlock_port(hwif); 695 plug_device = 1; 696 } 697 } 698 spin_unlock_irqrestore(&hwif->lock, flags); 699 700 if (plug_device) { 701 ide_unlock_host(hwif->host); 702 ide_requeue_and_plug(drive, rq_in_flight); 703 } 704} 705 706/** 707 * unexpected_intr - handle an unexpected IDE interrupt 708 * @irq: interrupt line 709 * @hwif: port being processed 710 * 711 * There's nothing really useful we can do with an unexpected interrupt, 712 * other than reading the status register (to clear it), and logging it. 713 * There should be no way that an irq can happen before we're ready for it, 714 * so we needn't worry much about losing an "important" interrupt here. 715 * 716 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever 717 * the drive enters "idle", "standby", or "sleep" mode, so if the status 718 * looks "good", we just ignore the interrupt completely. 719 * 720 * This routine assumes __cli() is in effect when called. 721 * 722 * If an unexpected interrupt happens on irq15 while we are handling irq14 723 * and if the two interfaces are "serialized" (CMD640), then it looks like 724 * we could screw up by interfering with a new request being set up for 725 * irq15. 726 * 727 * In reality, this is a non-issue. The new command is not sent unless 728 * the drive is ready to accept one, in which case we know the drive is 729 * not trying to interrupt us. And ide_set_handler() is always invoked 730 * before completing the issuance of any new drive command, so we will not 731 * be accidentally invoked as a result of any valid command completion 732 * interrupt. 733 */ 734 735static void unexpected_intr(int irq, ide_hwif_t *hwif) 736{ 737 u8 stat = hwif->tp_ops->read_status(hwif); 738 739 if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) { 740 /* Try to not flood the console with msgs */ 741 static unsigned long last_msgtime, count; 742 ++count; 743 744 if (time_after(jiffies, last_msgtime + HZ)) { 745 last_msgtime = jiffies; 746 printk(KERN_ERR "%s: unexpected interrupt, " 747 "status=0x%02x, count=%ld\n", 748 hwif->name, stat, count); 749 } 750 } 751} 752 753/** 754 * ide_intr - default IDE interrupt handler 755 * @irq: interrupt number 756 * @dev_id: hwif 757 * @regs: unused weirdness from the kernel irq layer 758 * 759 * This is the default IRQ handler for the IDE layer. You should 760 * not need to override it. If you do be aware it is subtle in 761 * places 762 * 763 * hwif is the interface in the group currently performing 764 * a command. hwif->cur_dev is the drive and hwif->handler is 765 * the IRQ handler to call. As we issue a command the handlers 766 * step through multiple states, reassigning the handler to the 767 * next step in the process. Unlike a smart SCSI controller IDE 768 * expects the main processor to sequence the various transfer 769 * stages. We also manage a poll timer to catch up with most 770 * timeout situations. There are still a few where the handlers 771 * don't ever decide to give up. 772 * 773 * The handler eventually returns ide_stopped to indicate the 774 * request completed. At this point we issue the next request 775 * on the port and the process begins again. 776 */ 777 778irqreturn_t ide_intr (int irq, void *dev_id) 779{ 780 ide_hwif_t *hwif = (ide_hwif_t *)dev_id; 781 struct ide_host *host = hwif->host; 782 ide_drive_t *uninitialized_var(drive); 783 ide_handler_t *handler; 784 unsigned long flags; 785 ide_startstop_t startstop; 786 irqreturn_t irq_ret = IRQ_NONE; 787 int plug_device = 0; 788 struct request *uninitialized_var(rq_in_flight); 789 790 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 791 if (hwif != host->cur_port) 792 goto out_early; 793 } 794 795 spin_lock_irqsave(&hwif->lock, flags); 796 797 if (hwif->port_ops && hwif->port_ops->test_irq && 798 hwif->port_ops->test_irq(hwif) == 0) 799 goto out; 800 801 handler = hwif->handler; 802 803 if (handler == NULL || hwif->polling) { 804 /* 805 * Not expecting an interrupt from this drive. 806 * That means this could be: 807 * (1) an interrupt from another PCI device 808 * sharing the same PCI INT# as us. 809 * or (2) a drive just entered sleep or standby mode, 810 * and is interrupting to let us know. 811 * or (3) a spurious interrupt of unknown origin. 812 * 813 * For PCI, we cannot tell the difference, 814 * so in that case we just ignore it and hope it goes away. 815 */ 816 if ((host->irq_flags & IRQF_SHARED) == 0) { 817 /* 818 * Probably not a shared PCI interrupt, 819 * so we can safely try to do something about it: 820 */ 821 unexpected_intr(irq, hwif); 822 } else { 823 /* 824 * Whack the status register, just in case 825 * we have a leftover pending IRQ. 826 */ 827 (void)hwif->tp_ops->read_status(hwif); 828 } 829 goto out; 830 } 831 832 drive = hwif->cur_dev; 833 834 if (!drive_is_ready(drive)) 835 /* 836 * This happens regularly when we share a PCI IRQ with 837 * another device. Unfortunately, it can also happen 838 * with some buggy drives that trigger the IRQ before 839 * their status register is up to date. Hopefully we have 840 * enough advance overhead that the latter isn't a problem. 841 */ 842 goto out; 843 844 hwif->handler = NULL; 845 hwif->expiry = NULL; 846 hwif->req_gen++; 847 del_timer(&hwif->timer); 848 spin_unlock(&hwif->lock); 849 850 if (hwif->port_ops && hwif->port_ops->clear_irq) 851 hwif->port_ops->clear_irq(drive); 852 853 if (drive->dev_flags & IDE_DFLAG_UNMASK) 854 local_irq_enable_in_hardirq(); 855 856 /* service this interrupt, may set handler for next interrupt */ 857 startstop = handler(drive); 858 859 spin_lock_irq(&hwif->lock); 860 /* 861 * Note that handler() may have set things up for another 862 * interrupt to occur soon, but it cannot happen until 863 * we exit from this routine, because it will be the 864 * same irq as is currently being serviced here, and Linux 865 * won't allow another of the same (on any CPU) until we return. 866 */ 867 if (startstop == ide_stopped && hwif->polling == 0) { 868 BUG_ON(hwif->handler); 869 rq_in_flight = hwif->rq; 870 hwif->rq = NULL; 871 ide_unlock_port(hwif); 872 plug_device = 1; 873 } 874 irq_ret = IRQ_HANDLED; 875out: 876 spin_unlock_irqrestore(&hwif->lock, flags); 877out_early: 878 if (plug_device) { 879 ide_unlock_host(hwif->host); 880 ide_requeue_and_plug(drive, rq_in_flight); 881 } 882 883 return irq_ret; 884} 885EXPORT_SYMBOL_GPL(ide_intr); 886 887void ide_pad_transfer(ide_drive_t *drive, int write, int len) 888{ 889 ide_hwif_t *hwif = drive->hwif; 890 u8 buf[4] = { 0 }; 891 892 while (len > 0) { 893 if (write) 894 hwif->tp_ops->output_data(drive, NULL, buf, min(4, len)); 895 else 896 hwif->tp_ops->input_data(drive, NULL, buf, min(4, len)); 897 len -= 4; 898 } 899} 900EXPORT_SYMBOL_GPL(ide_pad_transfer); 901