ide-io.c revision 2c316bb57ad4e9f0f3de2d7ef1ae85530c2a7e69
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 rq->data_len; 120 else 121 return rq->hard_cur_sectors << 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 = rq->hard_nr_sectors << 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, 0, 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 187static ide_startstop_t ide_disk_special(ide_drive_t *drive) 188{ 189 special_t *s = &drive->special; 190 struct ide_cmd cmd; 191 192 memset(&cmd, 0, sizeof(cmd)); 193 cmd.protocol = ATA_PROT_NODATA; 194 195 if (s->b.set_geometry) { 196 s->b.set_geometry = 0; 197 ide_tf_set_specify_cmd(drive, &cmd.tf); 198 } else if (s->b.recalibrate) { 199 s->b.recalibrate = 0; 200 ide_tf_set_restore_cmd(drive, &cmd.tf); 201 } else if (s->b.set_multmode) { 202 s->b.set_multmode = 0; 203 ide_tf_set_setmult_cmd(drive, &cmd.tf); 204 } else if (s->all) { 205 int special = s->all; 206 s->all = 0; 207 printk(KERN_ERR "%s: bad special flag: 0x%02x\n", drive->name, special); 208 return ide_stopped; 209 } 210 211 cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE; 212 cmd.valid.in.tf = IDE_VALID_IN_TF | IDE_VALID_DEVICE; 213 cmd.tf_flags = IDE_TFLAG_CUSTOM_HANDLER; 214 215 do_rw_taskfile(drive, &cmd); 216 217 return ide_started; 218} 219 220/** 221 * do_special - issue some special commands 222 * @drive: drive the command is for 223 * 224 * do_special() is used to issue ATA_CMD_INIT_DEV_PARAMS, 225 * ATA_CMD_RESTORE and ATA_CMD_SET_MULTI commands to a drive. 226 * 227 * It used to do much more, but has been scaled back. 228 */ 229 230static ide_startstop_t do_special (ide_drive_t *drive) 231{ 232 special_t *s = &drive->special; 233 234#ifdef DEBUG 235 printk("%s: do_special: 0x%02x\n", drive->name, s->all); 236#endif 237 if (drive->media == ide_disk) 238 return ide_disk_special(drive); 239 240 s->all = 0; 241 drive->mult_req = 0; 242 return ide_stopped; 243} 244 245void ide_map_sg(ide_drive_t *drive, struct ide_cmd *cmd) 246{ 247 ide_hwif_t *hwif = drive->hwif; 248 struct scatterlist *sg = hwif->sg_table; 249 struct request *rq = cmd->rq; 250 251 cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg); 252} 253EXPORT_SYMBOL_GPL(ide_map_sg); 254 255void ide_init_sg_cmd(struct ide_cmd *cmd, unsigned int nr_bytes) 256{ 257 cmd->nbytes = cmd->nleft = nr_bytes; 258 cmd->cursg_ofs = 0; 259 cmd->cursg = NULL; 260} 261EXPORT_SYMBOL_GPL(ide_init_sg_cmd); 262 263/** 264 * execute_drive_command - issue special drive command 265 * @drive: the drive to issue the command on 266 * @rq: the request structure holding the command 267 * 268 * execute_drive_cmd() issues a special drive command, usually 269 * initiated by ioctl() from the external hdparm program. The 270 * command can be a drive command, drive task or taskfile 271 * operation. Weirdly you can call it with NULL to wait for 272 * all commands to finish. Don't do this as that is due to change 273 */ 274 275static ide_startstop_t execute_drive_cmd (ide_drive_t *drive, 276 struct request *rq) 277{ 278 struct ide_cmd *cmd = rq->special; 279 280 if (cmd) { 281 if (cmd->protocol == ATA_PROT_PIO) { 282 ide_init_sg_cmd(cmd, rq->nr_sectors << 9); 283 ide_map_sg(drive, cmd); 284 } 285 286 return do_rw_taskfile(drive, cmd); 287 } 288 289 /* 290 * NULL is actually a valid way of waiting for 291 * all current requests to be flushed from the queue. 292 */ 293#ifdef DEBUG 294 printk("%s: DRIVE_CMD (null)\n", drive->name); 295#endif 296 rq->errors = 0; 297 ide_complete_rq(drive, 0, blk_rq_bytes(rq)); 298 299 return ide_stopped; 300} 301 302static ide_startstop_t ide_special_rq(ide_drive_t *drive, struct request *rq) 303{ 304 u8 cmd = rq->cmd[0]; 305 306 switch (cmd) { 307 case REQ_PARK_HEADS: 308 case REQ_UNPARK_HEADS: 309 return ide_do_park_unpark(drive, rq); 310 case REQ_DEVSET_EXEC: 311 return ide_do_devset(drive, rq); 312 case REQ_DRIVE_RESET: 313 return ide_do_reset(drive); 314 default: 315 BUG(); 316 } 317} 318 319/** 320 * start_request - start of I/O and command issuing for IDE 321 * 322 * start_request() initiates handling of a new I/O request. It 323 * accepts commands and I/O (read/write) requests. 324 * 325 * FIXME: this function needs a rename 326 */ 327 328static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq) 329{ 330 ide_startstop_t startstop; 331 332 BUG_ON(!blk_rq_started(rq)); 333 334#ifdef DEBUG 335 printk("%s: start_request: current=0x%08lx\n", 336 drive->hwif->name, (unsigned long) rq); 337#endif 338 339 /* bail early if we've exceeded max_failures */ 340 if (drive->max_failures && (drive->failures > drive->max_failures)) { 341 rq->cmd_flags |= REQ_FAILED; 342 goto kill_rq; 343 } 344 345 if (blk_pm_request(rq)) 346 ide_check_pm_state(drive, rq); 347 348 drive->hwif->tp_ops->dev_select(drive); 349 if (ide_wait_stat(&startstop, drive, drive->ready_stat, 350 ATA_BUSY | ATA_DRQ, WAIT_READY)) { 351 printk(KERN_ERR "%s: drive not ready for command\n", drive->name); 352 return startstop; 353 } 354 if (!drive->special.all) { 355 struct ide_driver *drv; 356 357 /* 358 * We reset the drive so we need to issue a SETFEATURES. 359 * Do it _after_ do_special() restored device parameters. 360 */ 361 if (drive->current_speed == 0xff) 362 ide_config_drive_speed(drive, drive->desired_speed); 363 364 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) 365 return execute_drive_cmd(drive, rq); 366 else if (blk_pm_request(rq)) { 367 struct request_pm_state *pm = rq->special; 368#ifdef DEBUG_PM 369 printk("%s: start_power_step(step: %d)\n", 370 drive->name, pm->pm_step); 371#endif 372 startstop = ide_start_power_step(drive, rq); 373 if (startstop == ide_stopped && 374 pm->pm_step == IDE_PM_COMPLETED) 375 ide_complete_pm_rq(drive, rq); 376 return startstop; 377 } else if (!rq->rq_disk && blk_special_request(rq)) 378 /* 379 * TODO: Once all ULDs have been modified to 380 * check for specific op codes rather than 381 * blindly accepting any special request, the 382 * check for ->rq_disk above may be replaced 383 * by a more suitable mechanism or even 384 * dropped entirely. 385 */ 386 return ide_special_rq(drive, rq); 387 388 drv = *(struct ide_driver **)rq->rq_disk->private_data; 389 390 return drv->do_request(drive, rq, rq->sector); 391 } 392 return do_special(drive); 393kill_rq: 394 ide_kill_rq(drive, rq); 395 return ide_stopped; 396} 397 398/** 399 * ide_stall_queue - pause an IDE device 400 * @drive: drive to stall 401 * @timeout: time to stall for (jiffies) 402 * 403 * ide_stall_queue() can be used by a drive to give excess bandwidth back 404 * to the port by sleeping for timeout jiffies. 405 */ 406 407void ide_stall_queue (ide_drive_t *drive, unsigned long timeout) 408{ 409 if (timeout > WAIT_WORSTCASE) 410 timeout = WAIT_WORSTCASE; 411 drive->sleep = timeout + jiffies; 412 drive->dev_flags |= IDE_DFLAG_SLEEPING; 413} 414EXPORT_SYMBOL(ide_stall_queue); 415 416static inline int ide_lock_port(ide_hwif_t *hwif) 417{ 418 if (hwif->busy) 419 return 1; 420 421 hwif->busy = 1; 422 423 return 0; 424} 425 426static inline void ide_unlock_port(ide_hwif_t *hwif) 427{ 428 hwif->busy = 0; 429} 430 431static inline int ide_lock_host(struct ide_host *host, ide_hwif_t *hwif) 432{ 433 int rc = 0; 434 435 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 436 rc = test_and_set_bit_lock(IDE_HOST_BUSY, &host->host_busy); 437 if (rc == 0) { 438 if (host->get_lock) 439 host->get_lock(ide_intr, hwif); 440 } 441 } 442 return rc; 443} 444 445static inline void ide_unlock_host(struct ide_host *host) 446{ 447 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 448 if (host->release_lock) 449 host->release_lock(); 450 clear_bit_unlock(IDE_HOST_BUSY, &host->host_busy); 451 } 452} 453 454/* 455 * Issue a new request to a device. 456 */ 457void do_ide_request(struct request_queue *q) 458{ 459 ide_drive_t *drive = q->queuedata; 460 ide_hwif_t *hwif = drive->hwif; 461 struct ide_host *host = hwif->host; 462 struct request *rq = NULL; 463 ide_startstop_t startstop; 464 465 /* 466 * drive is doing pre-flush, ordered write, post-flush sequence. even 467 * though that is 3 requests, it must be seen as a single transaction. 468 * we must not preempt this drive until that is complete 469 */ 470 if (blk_queue_flushing(q)) 471 /* 472 * small race where queue could get replugged during 473 * the 3-request flush cycle, just yank the plug since 474 * we want it to finish asap 475 */ 476 blk_remove_plug(q); 477 478 spin_unlock_irq(q->queue_lock); 479 480 /* HLD do_request() callback might sleep, make sure it's okay */ 481 might_sleep(); 482 483 if (ide_lock_host(host, hwif)) 484 goto plug_device_2; 485 486 spin_lock_irq(&hwif->lock); 487 488 if (!ide_lock_port(hwif)) { 489 ide_hwif_t *prev_port; 490repeat: 491 prev_port = hwif->host->cur_port; 492 hwif->rq = NULL; 493 494 if (drive->dev_flags & IDE_DFLAG_SLEEPING && 495 time_after(drive->sleep, jiffies)) { 496 ide_unlock_port(hwif); 497 goto plug_device; 498 } 499 500 if ((hwif->host->host_flags & IDE_HFLAG_SERIALIZE) && 501 hwif != prev_port) { 502 /* 503 * set nIEN for previous port, drives in the 504 * quirk_list may not like intr setups/cleanups 505 */ 506 if (prev_port && prev_port->cur_dev->quirk_list == 0) 507 prev_port->tp_ops->write_devctl(prev_port, 508 ATA_NIEN | 509 ATA_DEVCTL_OBS); 510 511 hwif->host->cur_port = hwif; 512 } 513 hwif->cur_dev = drive; 514 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED); 515 516 spin_unlock_irq(&hwif->lock); 517 spin_lock_irq(q->queue_lock); 518 /* 519 * we know that the queue isn't empty, but this can happen 520 * if the q->prep_rq_fn() decides to kill a request 521 */ 522 rq = elv_next_request(drive->queue); 523 spin_unlock_irq(q->queue_lock); 524 spin_lock_irq(&hwif->lock); 525 526 if (!rq) { 527 ide_unlock_port(hwif); 528 goto out; 529 } 530 531 /* 532 * Sanity: don't accept a request that isn't a PM request 533 * if we are currently power managed. This is very important as 534 * blk_stop_queue() doesn't prevent the elv_next_request() 535 * above to return us whatever is in the queue. Since we call 536 * ide_do_request() ourselves, we end up taking requests while 537 * the queue is blocked... 538 * 539 * We let requests forced at head of queue with ide-preempt 540 * though. I hope that doesn't happen too much, hopefully not 541 * unless the subdriver triggers such a thing in its own PM 542 * state machine. 543 */ 544 if ((drive->dev_flags & IDE_DFLAG_BLOCKED) && 545 blk_pm_request(rq) == 0 && 546 (rq->cmd_flags & REQ_PREEMPT) == 0) { 547 /* there should be no pending command at this point */ 548 ide_unlock_port(hwif); 549 goto plug_device; 550 } 551 552 hwif->rq = rq; 553 554 spin_unlock_irq(&hwif->lock); 555 startstop = start_request(drive, rq); 556 spin_lock_irq(&hwif->lock); 557 558 if (startstop == ide_stopped) 559 goto repeat; 560 } else 561 goto plug_device; 562out: 563 spin_unlock_irq(&hwif->lock); 564 if (rq == NULL) 565 ide_unlock_host(host); 566 spin_lock_irq(q->queue_lock); 567 return; 568 569plug_device: 570 spin_unlock_irq(&hwif->lock); 571 ide_unlock_host(host); 572plug_device_2: 573 spin_lock_irq(q->queue_lock); 574 575 if (!elv_queue_empty(q)) 576 blk_plug_device(q); 577} 578 579static void ide_plug_device(ide_drive_t *drive) 580{ 581 struct request_queue *q = drive->queue; 582 unsigned long flags; 583 584 spin_lock_irqsave(q->queue_lock, flags); 585 if (!elv_queue_empty(q)) 586 blk_plug_device(q); 587 spin_unlock_irqrestore(q->queue_lock, flags); 588} 589 590static int drive_is_ready(ide_drive_t *drive) 591{ 592 ide_hwif_t *hwif = drive->hwif; 593 u8 stat = 0; 594 595 if (drive->waiting_for_dma) 596 return hwif->dma_ops->dma_test_irq(drive); 597 598 if (hwif->io_ports.ctl_addr && 599 (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) 600 stat = hwif->tp_ops->read_altstatus(hwif); 601 else 602 /* Note: this may clear a pending IRQ!! */ 603 stat = hwif->tp_ops->read_status(hwif); 604 605 if (stat & ATA_BUSY) 606 /* drive busy: definitely not interrupting */ 607 return 0; 608 609 /* drive ready: *might* be interrupting */ 610 return 1; 611} 612 613/** 614 * ide_timer_expiry - handle lack of an IDE interrupt 615 * @data: timer callback magic (hwif) 616 * 617 * An IDE command has timed out before the expected drive return 618 * occurred. At this point we attempt to clean up the current 619 * mess. If the current handler includes an expiry handler then 620 * we invoke the expiry handler, and providing it is happy the 621 * work is done. If that fails we apply generic recovery rules 622 * invoking the handler and checking the drive DMA status. We 623 * have an excessively incestuous relationship with the DMA 624 * logic that wants cleaning up. 625 */ 626 627void ide_timer_expiry (unsigned long data) 628{ 629 ide_hwif_t *hwif = (ide_hwif_t *)data; 630 ide_drive_t *uninitialized_var(drive); 631 ide_handler_t *handler; 632 unsigned long flags; 633 int wait = -1; 634 int plug_device = 0; 635 636 spin_lock_irqsave(&hwif->lock, flags); 637 638 handler = hwif->handler; 639 640 if (handler == NULL || hwif->req_gen != hwif->req_gen_timer) { 641 /* 642 * Either a marginal timeout occurred 643 * (got the interrupt just as timer expired), 644 * or we were "sleeping" to give other devices a chance. 645 * Either way, we don't really want to complain about anything. 646 */ 647 } else { 648 ide_expiry_t *expiry = hwif->expiry; 649 ide_startstop_t startstop = ide_stopped; 650 651 drive = hwif->cur_dev; 652 653 if (expiry) { 654 wait = expiry(drive); 655 if (wait > 0) { /* continue */ 656 /* reset timer */ 657 hwif->timer.expires = jiffies + wait; 658 hwif->req_gen_timer = hwif->req_gen; 659 add_timer(&hwif->timer); 660 spin_unlock_irqrestore(&hwif->lock, flags); 661 return; 662 } 663 } 664 hwif->handler = NULL; 665 hwif->expiry = NULL; 666 /* 667 * We need to simulate a real interrupt when invoking 668 * the handler() function, which means we need to 669 * globally mask the specific IRQ: 670 */ 671 spin_unlock(&hwif->lock); 672 /* disable_irq_nosync ?? */ 673 disable_irq(hwif->irq); 674 /* local CPU only, as if we were handling an interrupt */ 675 local_irq_disable(); 676 if (hwif->polling) { 677 startstop = handler(drive); 678 } else if (drive_is_ready(drive)) { 679 if (drive->waiting_for_dma) 680 hwif->dma_ops->dma_lost_irq(drive); 681 if (hwif->ack_intr) 682 hwif->ack_intr(hwif); 683 printk(KERN_WARNING "%s: lost interrupt\n", 684 drive->name); 685 startstop = handler(drive); 686 } else { 687 if (drive->waiting_for_dma) 688 startstop = ide_dma_timeout_retry(drive, wait); 689 else 690 startstop = ide_error(drive, "irq timeout", 691 hwif->tp_ops->read_status(hwif)); 692 } 693 spin_lock_irq(&hwif->lock); 694 enable_irq(hwif->irq); 695 if (startstop == ide_stopped) { 696 ide_unlock_port(hwif); 697 plug_device = 1; 698 } 699 } 700 spin_unlock_irqrestore(&hwif->lock, flags); 701 702 if (plug_device) { 703 ide_unlock_host(hwif->host); 704 ide_plug_device(drive); 705 } 706} 707 708/** 709 * unexpected_intr - handle an unexpected IDE interrupt 710 * @irq: interrupt line 711 * @hwif: port being processed 712 * 713 * There's nothing really useful we can do with an unexpected interrupt, 714 * other than reading the status register (to clear it), and logging it. 715 * There should be no way that an irq can happen before we're ready for it, 716 * so we needn't worry much about losing an "important" interrupt here. 717 * 718 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever 719 * the drive enters "idle", "standby", or "sleep" mode, so if the status 720 * looks "good", we just ignore the interrupt completely. 721 * 722 * This routine assumes __cli() is in effect when called. 723 * 724 * If an unexpected interrupt happens on irq15 while we are handling irq14 725 * and if the two interfaces are "serialized" (CMD640), then it looks like 726 * we could screw up by interfering with a new request being set up for 727 * irq15. 728 * 729 * In reality, this is a non-issue. The new command is not sent unless 730 * the drive is ready to accept one, in which case we know the drive is 731 * not trying to interrupt us. And ide_set_handler() is always invoked 732 * before completing the issuance of any new drive command, so we will not 733 * be accidentally invoked as a result of any valid command completion 734 * interrupt. 735 */ 736 737static void unexpected_intr(int irq, ide_hwif_t *hwif) 738{ 739 u8 stat = hwif->tp_ops->read_status(hwif); 740 741 if (!OK_STAT(stat, ATA_DRDY, BAD_STAT)) { 742 /* Try to not flood the console with msgs */ 743 static unsigned long last_msgtime, count; 744 ++count; 745 746 if (time_after(jiffies, last_msgtime + HZ)) { 747 last_msgtime = jiffies; 748 printk(KERN_ERR "%s: unexpected interrupt, " 749 "status=0x%02x, count=%ld\n", 750 hwif->name, stat, count); 751 } 752 } 753} 754 755/** 756 * ide_intr - default IDE interrupt handler 757 * @irq: interrupt number 758 * @dev_id: hwif 759 * @regs: unused weirdness from the kernel irq layer 760 * 761 * This is the default IRQ handler for the IDE layer. You should 762 * not need to override it. If you do be aware it is subtle in 763 * places 764 * 765 * hwif is the interface in the group currently performing 766 * a command. hwif->cur_dev is the drive and hwif->handler is 767 * the IRQ handler to call. As we issue a command the handlers 768 * step through multiple states, reassigning the handler to the 769 * next step in the process. Unlike a smart SCSI controller IDE 770 * expects the main processor to sequence the various transfer 771 * stages. We also manage a poll timer to catch up with most 772 * timeout situations. There are still a few where the handlers 773 * don't ever decide to give up. 774 * 775 * The handler eventually returns ide_stopped to indicate the 776 * request completed. At this point we issue the next request 777 * on the port and the process begins again. 778 */ 779 780irqreturn_t ide_intr (int irq, void *dev_id) 781{ 782 ide_hwif_t *hwif = (ide_hwif_t *)dev_id; 783 struct ide_host *host = hwif->host; 784 ide_drive_t *uninitialized_var(drive); 785 ide_handler_t *handler; 786 unsigned long flags; 787 ide_startstop_t startstop; 788 irqreturn_t irq_ret = IRQ_NONE; 789 int plug_device = 0; 790 791 if (host->host_flags & IDE_HFLAG_SERIALIZE) { 792 if (hwif != host->cur_port) 793 goto out_early; 794 } 795 796 spin_lock_irqsave(&hwif->lock, flags); 797 798 if (hwif->ack_intr && hwif->ack_intr(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) { 868 BUG_ON(hwif->handler); 869 ide_unlock_port(hwif); 870 plug_device = 1; 871 } 872 irq_ret = IRQ_HANDLED; 873out: 874 spin_unlock_irqrestore(&hwif->lock, flags); 875out_early: 876 if (plug_device) { 877 ide_unlock_host(hwif->host); 878 ide_plug_device(drive); 879 } 880 881 return irq_ret; 882} 883EXPORT_SYMBOL_GPL(ide_intr); 884 885void ide_pad_transfer(ide_drive_t *drive, int write, int len) 886{ 887 ide_hwif_t *hwif = drive->hwif; 888 u8 buf[4] = { 0 }; 889 890 while (len > 0) { 891 if (write) 892 hwif->tp_ops->output_data(drive, NULL, buf, min(4, len)); 893 else 894 hwif->tp_ops->input_data(drive, NULL, buf, min(4, len)); 895 len -= 4; 896 } 897} 898EXPORT_SYMBOL_GPL(ide_pad_transfer); 899