ide-io.c revision 3503e0acbfab0dbcd24ccadd5fe841f3f8290e81
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 115int ide_complete_rq(ide_drive_t *drive, int error, unsigned int nr_bytes) 116{ 117 ide_hwif_t *hwif = drive->hwif; 118 struct request *rq = hwif->rq; 119 int rc; 120 121 /* 122 * if failfast is set on a request, override number of sectors 123 * and complete the whole request right now 124 */ 125 if (blk_noretry_request(rq) && error <= 0) 126 nr_bytes = blk_rq_sectors(rq) << 9; 127 128 rc = ide_end_rq(drive, rq, error, nr_bytes); 129 if (rc == 0) 130 hwif->rq = NULL; 131 132 return rc; 133} 134EXPORT_SYMBOL(ide_complete_rq); 135 136void ide_kill_rq(ide_drive_t *drive, struct request *rq) 137{ 138 u8 drv_req = blk_special_request(rq) && rq->rq_disk; 139 u8 media = drive->media; 140 141 drive->failed_pc = NULL; 142 143 if ((media == ide_floppy || media == ide_tape) && drv_req) { 144 rq->errors = 0; 145 } else { 146 if (media == ide_tape) 147 rq->errors = IDE_DRV_ERROR_GENERAL; 148 else if (blk_fs_request(rq) == 0 && rq->errors == 0) 149 rq->errors = -EIO; 150 } 151 152 ide_complete_rq(drive, -EIO, blk_rq_bytes(rq)); 153} 154 155static void ide_tf_set_specify_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 156{ 157 tf->nsect = drive->sect; 158 tf->lbal = drive->sect; 159 tf->lbam = drive->cyl; 160 tf->lbah = drive->cyl >> 8; 161 tf->device = (drive->head - 1) | drive->select; 162 tf->command = ATA_CMD_INIT_DEV_PARAMS; 163} 164 165static void ide_tf_set_restore_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 166{ 167 tf->nsect = drive->sect; 168 tf->command = ATA_CMD_RESTORE; 169} 170 171static void ide_tf_set_setmult_cmd(ide_drive_t *drive, struct ide_taskfile *tf) 172{ 173 tf->nsect = drive->mult_req; 174 tf->command = ATA_CMD_SET_MULTI; 175} 176 177/** 178 * do_special - issue some special commands 179 * @drive: drive the command is for 180 * 181 * do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS, 182 * ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive. 183 */ 184 185static ide_startstop_t do_special(ide_drive_t *drive) 186{ 187 struct ide_cmd cmd; 188 189#ifdef DEBUG 190 printk(KERN_DEBUG "%s: %s: 0x%02x\n", drive->name, __func__, 191 drive->special_flags); 192#endif 193 if (drive->media != ide_disk) { 194 drive->special_flags = 0; 195 drive->mult_req = 0; 196 return ide_stopped; 197 } 198 199 memset(&cmd, 0, sizeof(cmd)); 200 cmd.protocol = ATA_PROT_NODATA; 201 202 if (drive->special_flags & IDE_SFLAG_SET_GEOMETRY) { 203 drive->special_flags &= ~IDE_SFLAG_SET_GEOMETRY; 204 ide_tf_set_specify_cmd(drive, &cmd.tf); 205 } else if (drive->special_flags & IDE_SFLAG_RECALIBRATE) { 206 drive->special_flags &= ~IDE_SFLAG_RECALIBRATE; 207 ide_tf_set_restore_cmd(drive, &cmd.tf); 208 } else if (drive->special_flags & IDE_SFLAG_SET_MULTMODE) { 209 drive->special_flags &= ~IDE_SFLAG_SET_MULTMODE; 210 ide_tf_set_setmult_cmd(drive, &cmd.tf); 211 } else 212 BUG(); 213 214 cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE; 215 cmd.valid.in.tf = IDE_VALID_IN_TF | IDE_VALID_DEVICE; 216 cmd.tf_flags = IDE_TFLAG_CUSTOM_HANDLER; 217 218 do_rw_taskfile(drive, &cmd); 219 220 return ide_started; 221} 222 223void ide_map_sg(ide_drive_t *drive, struct ide_cmd *cmd) 224{ 225 ide_hwif_t *hwif = drive->hwif; 226 struct scatterlist *sg = hwif->sg_table; 227 struct request *rq = cmd->rq; 228 229 cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); 230} 231EXPORT_SYMBOL_GPL(ide_map_sg); 232 233void ide_init_sg_cmd(struct ide_cmd *cmd, unsigned int nr_bytes) 234{ 235 cmd->nbytes = cmd->nleft = nr_bytes; 236 cmd->cursg_ofs = 0; 237 cmd->cursg = NULL; 238} 239EXPORT_SYMBOL_GPL(ide_init_sg_cmd); 240 241/** 242 * execute_drive_command - issue special drive command 243 * @drive: the drive to issue the command on 244 * @rq: the request structure holding the command 245 * 246 * execute_drive_cmd() issues a special drive command, usually 247 * initiated by ioctl() from the external hdparm program. The 248 * command can be a drive command, drive task or taskfile 249 * operation. Weirdly you can call it with NULL to wait for 250 * all commands to finish. Don't do this as that is due to change 251 */ 252 253static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, 254 struct request *rq) 255{ 256 struct ide_cmd *cmd = rq->special; 257 258 if (cmd) { 259 if (cmd->protocol == ATA_PROT_PIO) { 260 ide_init_sg_cmd(cmd, blk_rq_sectors(rq) << 9); 261 ide_map_sg(drive, cmd); 262 } 263 264 return do_rw_taskfile(drive, cmd); 265 } 266 267 /* 268 * NULL is actually a valid way of waiting for 269 * all current requests to be flushed from the queue. 270 */ 271#ifdef DEBUG 272 printk("%s: DRIVE_CMD (null)\n", drive->name); 273#endif 274 rq->errors = 0; 275 ide_complete_rq(drive, 0, blk_rq_bytes(rq)); 276 277 return ide_stopped; 278} 279 280static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 281{ 282 u8 cmd = rq->cmd[0]; 283 284 switch (cmd) { 285 case REQ_PARK_HEADS: 286 case REQ_UNPARK_HEADS: 287 return ide_do_park_unpark(drive, rq); 288 case REQ_DEVSET_EXEC: 289 return ide_do_devset(drive, rq); 290 case REQ_DRIVE_RESET: 291 return ide_do_reset(drive); 292 default: 293 BUG(); 294 } 295} 296 297/** 298 * start_request - start of I/O and command issuing for IDE 299 * 300 * start_request() initiates handling of a new I/O request. It 301 * accepts commands and I/O (read/write) requests. 302 * 303 * FIXME: this function needs a rename 304 */ 305 306static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq) 307{ 308 ide_startstop_t startstop; 309 310 BUG_ON(!blk_rq_started(rq)); 311 312#ifdef DEBUG 313 printk("%s: start_request: current=0x%08lx\n", 314 drive->hwif->name, (unsigned long) rq); 315#endif 316 317 /* bail early if we've exceeded max_failures */ 318 if (drive->max_failures && (drive->failures > drive->max_failures)) { 319 rq->cmd_flags |= REQ_FAILED; 320 goto kill_rq; 321 } 322 323 if (blk_pm_request(rq)) 324 ide_check_pm_state(drive, rq); 325 326 drive->hwif->tp_ops->dev_select(drive); 327 if (ide_wait_stat(&startstop, drive, drive->ready_stat, 328 ATA_BUSY | ATA_DRQ, WAIT_READY)) { 329 printk(KERN_ERR "%s: drive not ready for command\n", drive->name); 330 return startstop; 331 } 332 333 if (drive->special_flags == 0) { 334 struct ide_driver *drv; 335 336 /* 337 * We reset the drive so we need to issue a SETFEATURES. 338 * Do it _after_ do_special() restored device parameters. 339 */ 340 if (drive->current_speed == 0xff) 341 ide_config_drive_speed(drive, drive->desired_speed); 342 343 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 344 return execute_drive_cmd(drive, rq); 345 else if (blk_pm_request(rq)) { 346 struct request_pm_state *pm = rq->special; 347#ifdef DEBUG_PM 348 printk("%s: start_power_step(step: %d)\n", 349 drive->name, pm->pm_step); 350#endif 351 startstop = ide_start_power_step(drive, rq); 352 if (startstop == ide_stopped && 353 pm->pm_step == IDE_PM_COMPLETED) 354 ide_complete_pm_rq(drive, rq); 355 return startstop; 356 } else if (!rq->rq_disk && blk_special_request(rq)) 357 /* 358 * TODO: Once all ULDs have been modified to 359 * check for specific op codes rather than 360 * blindly accepting any special request, the 361 * check for ->rq_disk above may be replaced 362 * by a more suitable mechanism or even 363 * dropped entirely. 364 */ 365 return ide_special_rq(drive, rq); 366 367 drv = *(struct ide_driver **)rq->rq_disk->private_data; 368 369 return drv->do_request(drive, rq, blk_rq_pos(rq)); 370 } 371 return do_special(drive); 372kill_rq: 373 ide_kill_rq(drive, rq); 374 return ide_stopped; 375} 376 377/** 378 * ide_stall_queue - pause an IDE device 379 * @drive: drive to stall 380 * @timeout: time to stall for (jiffies) 381 * 382 * ide_stall_queue() can be used by a drive to give excess bandwidth back 383 * to the port by sleeping for timeout jiffies. 384 */ 385 386void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) 387{ 388 if (timeout > WAIT_WORSTCASE) 389 timeout = WAIT_WORSTCASE; 390 drive->sleep = timeout + jiffies; 391 drive->dev_flags |= IDE_DFLAG_SLEEPING; 392} 393EXPORT_SYMBOL(ide_stall_queue); 394 395static inline int ide_lock_port(ide_hwif_t *hwif) 396{ 397 if (hwif->busy) 398 return 1; 399 400 hwif->busy = 1; 401 402 return 0; 403} 404 405static inline void ide_unlock_port(ide_hwif_t *hwif) 406{ 407 hwif->busy = 0; 408} 409 410static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif) 411{ 412 int rc = 0; 413 414 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 415 rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy); 416 if (rc == 0) { 417 if (host->get_lock) 418 host->get_lock(ide_intr, hwif); 419 } 420 } 421 return rc; 422} 423 424static inline void ide_unlock_host(struct ide_host *host) 425{ 426 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 427 if (host->release_lock) 428 host->release_lock(); 429 clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy); 430 } 431} 432 433/* 434 * Issue a new request to a device. 435 */ 436void do_ide_request(struct request_queue *q) 437{ 438 ide_drive_t *drive = q->queuedata; 439 ide_hwif_t *hwif = drive->hwif; 440 struct ide_host *host = hwif->host; 441 struct request *rq = NULL; 442 ide_startstop_t startstop; 443 444 /* 445 * drive is doing pre-flush, ordered write, post-flush sequence. even 446 * though that is 3 requests, it must be seen as a single transaction. 447 * we must not preempt this drive until that is complete 448 */ 449 if (blk_queue_flushing(q)) 450 /* 451 * small race where queue could get replugged during 452 * the 3-request flush cycle, just yank the plug since 453 * we want it to finish asap 454 */ 455 blk_remove_plug(q); 456 457 spin_unlock_irq(q->queue_lock); 458 459 /* HLD do_request() callback might sleep, make sure it's okay */ 460 might_sleep(); 461 462 if (ide_lock_host(host, hwif)) 463 goto plug_device_2; 464 465 spin_lock_irq(&hwif->lock); 466 467 if (!ide_lock_port(hwif)) { 468 ide_hwif_t *prev_port; 469 470 WARN_ON_ONCE(hwif->rq); 471repeat: 472 prev_port = hwif->host->cur_port; 473 if (drive->dev_flags & IDE_DFLAG_SLEEPING && 474 time_after(drive->sleep, jiffies)) { 475 ide_unlock_port(hwif); 476 goto plug_device; 477 } 478 479 if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) && 480 hwif != prev_port) { 481 ide_drive_t *cur_dev = 482 prev_port ? prev_port->cur_dev : NULL; 483 484 /* 485 * set nIEN for previous port, drives in the 486 * quirk list may not like intr setups/cleanups 487 */ 488 if (cur_dev && 489 (cur_dev->dev_flags & IDE_DFLAG_NIEN_QUIRK) == 0) 490 prev_port->tp_ops->write_devctl(prev_port, 491 ATA_NIEN | 492 ATA_DEVCTL_OBS); 493 494 hwif->host->cur_port = hwif; 495 } 496 hwif->cur_dev = drive; 497 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED); 498 499 spin_unlock_irq(&hwif->lock); 500 spin_lock_irq(q->queue_lock); 501 /* 502 * we know that the queue isn't empty, but this can happen 503 * if the q->prep_rq_fn() decides to kill a request 504 */ 505 if (!rq) 506 rq = blk_fetch_request(drive->queue); 507 508 spin_unlock_irq(q->queue_lock); 509 spin_lock_irq(&hwif->lock); 510 511 if (!rq) { 512 ide_unlock_port(hwif); 513 goto out; 514 } 515 516 /* 517 * Sanity: don't accept a request that isn't a PM request 518 * if we are currently power managed. This is very important as 519 * blk_stop_queue() doesn't prevent the blk_fetch_request() 520 * above to return us whatever is in the queue. Since we call 521 * ide_do_request() ourselves, we end up taking requests while 522 * the queue is blocked... 523 * 524 * We let requests forced at head of queue with ide-preempt 525 * though. I hope that doesn't happen too much, hopefully not 526 * unless the subdriver triggers such a thing in its own PM 527 * state machine. 528 */ 529 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) && 530 blk_pm_request(rq) == 0 && 531 (rq->cmd_flags & REQ_PREEMPT) == 0) { 532 /* there should be no pending command at this point */ 533 ide_unlock_port(hwif); 534 goto plug_device; 535 } 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