diff options
Diffstat (limited to 'drivers/ide/ide-iops.c')
-rw-r--r-- | drivers/ide/ide-iops.c | 299 |
1 files changed, 2 insertions, 297 deletions
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c index cf6c3036ae7f..e0cfa2d2acc7 100644 --- a/drivers/ide/ide-iops.c +++ b/drivers/ide/ide-iops.c | |||
@@ -446,8 +446,8 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed) | |||
446 | * | 446 | * |
447 | * See also ide_execute_command | 447 | * See also ide_execute_command |
448 | */ | 448 | */ |
449 | static void __ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, | 449 | void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler, |
450 | unsigned int timeout, ide_expiry_t *expiry) | 450 | unsigned int timeout, ide_expiry_t *expiry) |
451 | { | 451 | { |
452 | ide_hwif_t *hwif = drive->hwif; | 452 | ide_hwif_t *hwif = drive->hwif; |
453 | 453 | ||
@@ -517,301 +517,6 @@ void ide_execute_pkt_cmd(ide_drive_t *drive) | |||
517 | } | 517 | } |
518 | EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd); | 518 | EXPORT_SYMBOL_GPL(ide_execute_pkt_cmd); |
519 | 519 | ||
520 | static inline void ide_complete_drive_reset(ide_drive_t *drive, int err) | ||
521 | { | ||
522 | struct request *rq = drive->hwif->rq; | ||
523 | |||
524 | if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET) | ||
525 | ide_end_request(drive, err ? err : 1, 0); | ||
526 | } | ||
527 | |||
528 | /* needed below */ | ||
529 | static ide_startstop_t do_reset1(ide_drive_t *, int); | ||
530 | |||
531 | /* | ||
532 | * atapi_reset_pollfunc() gets invoked to poll the interface for completion | ||
533 | * every 50ms during an atapi drive reset operation. If the drive has not yet | ||
534 | * responded, and we have not yet hit our maximum waiting time, then the timer | ||
535 | * is restarted for another 50ms. | ||
536 | */ | ||
537 | static ide_startstop_t atapi_reset_pollfunc(ide_drive_t *drive) | ||
538 | { | ||
539 | ide_hwif_t *hwif = drive->hwif; | ||
540 | u8 stat; | ||
541 | |||
542 | SELECT_DRIVE(drive); | ||
543 | udelay(10); | ||
544 | stat = hwif->tp_ops->read_status(hwif); | ||
545 | |||
546 | if (OK_STAT(stat, 0, ATA_BUSY)) | ||
547 | printk(KERN_INFO "%s: ATAPI reset complete\n", drive->name); | ||
548 | else { | ||
549 | if (time_before(jiffies, hwif->poll_timeout)) { | ||
550 | ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, | ||
551 | NULL); | ||
552 | /* continue polling */ | ||
553 | return ide_started; | ||
554 | } | ||
555 | /* end of polling */ | ||
556 | hwif->polling = 0; | ||
557 | printk(KERN_ERR "%s: ATAPI reset timed-out, status=0x%02x\n", | ||
558 | drive->name, stat); | ||
559 | /* do it the old fashioned way */ | ||
560 | return do_reset1(drive, 1); | ||
561 | } | ||
562 | /* done polling */ | ||
563 | hwif->polling = 0; | ||
564 | ide_complete_drive_reset(drive, 0); | ||
565 | return ide_stopped; | ||
566 | } | ||
567 | |||
568 | static void ide_reset_report_error(ide_hwif_t *hwif, u8 err) | ||
569 | { | ||
570 | static const char *err_master_vals[] = | ||
571 | { NULL, "passed", "formatter device error", | ||
572 | "sector buffer error", "ECC circuitry error", | ||
573 | "controlling MPU error" }; | ||
574 | |||
575 | u8 err_master = err & 0x7f; | ||
576 | |||
577 | printk(KERN_ERR "%s: reset: master: ", hwif->name); | ||
578 | if (err_master && err_master < 6) | ||
579 | printk(KERN_CONT "%s", err_master_vals[err_master]); | ||
580 | else | ||
581 | printk(KERN_CONT "error (0x%02x?)", err); | ||
582 | if (err & 0x80) | ||
583 | printk(KERN_CONT "; slave: failed"); | ||
584 | printk(KERN_CONT "\n"); | ||
585 | } | ||
586 | |||
587 | /* | ||
588 | * reset_pollfunc() gets invoked to poll the interface for completion every 50ms | ||
589 | * during an ide reset operation. If the drives have not yet responded, | ||
590 | * and we have not yet hit our maximum waiting time, then the timer is restarted | ||
591 | * for another 50ms. | ||
592 | */ | ||
593 | static ide_startstop_t reset_pollfunc(ide_drive_t *drive) | ||
594 | { | ||
595 | ide_hwif_t *hwif = drive->hwif; | ||
596 | const struct ide_port_ops *port_ops = hwif->port_ops; | ||
597 | u8 tmp; | ||
598 | int err = 0; | ||
599 | |||
600 | if (port_ops && port_ops->reset_poll) { | ||
601 | err = port_ops->reset_poll(drive); | ||
602 | if (err) { | ||
603 | printk(KERN_ERR "%s: host reset_poll failure for %s.\n", | ||
604 | hwif->name, drive->name); | ||
605 | goto out; | ||
606 | } | ||
607 | } | ||
608 | |||
609 | tmp = hwif->tp_ops->read_status(hwif); | ||
610 | |||
611 | if (!OK_STAT(tmp, 0, ATA_BUSY)) { | ||
612 | if (time_before(jiffies, hwif->poll_timeout)) { | ||
613 | ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL); | ||
614 | /* continue polling */ | ||
615 | return ide_started; | ||
616 | } | ||
617 | printk(KERN_ERR "%s: reset timed-out, status=0x%02x\n", | ||
618 | hwif->name, tmp); | ||
619 | drive->failures++; | ||
620 | err = -EIO; | ||
621 | } else { | ||
622 | tmp = ide_read_error(drive); | ||
623 | |||
624 | if (tmp == 1) { | ||
625 | printk(KERN_INFO "%s: reset: success\n", hwif->name); | ||
626 | drive->failures = 0; | ||
627 | } else { | ||
628 | ide_reset_report_error(hwif, tmp); | ||
629 | drive->failures++; | ||
630 | err = -EIO; | ||
631 | } | ||
632 | } | ||
633 | out: | ||
634 | hwif->polling = 0; /* done polling */ | ||
635 | ide_complete_drive_reset(drive, err); | ||
636 | return ide_stopped; | ||
637 | } | ||
638 | |||
639 | static void ide_disk_pre_reset(ide_drive_t *drive) | ||
640 | { | ||
641 | int legacy = (drive->id[ATA_ID_CFS_ENABLE_2] & 0x0400) ? 0 : 1; | ||
642 | |||
643 | drive->special.all = 0; | ||
644 | drive->special.b.set_geometry = legacy; | ||
645 | drive->special.b.recalibrate = legacy; | ||
646 | |||
647 | drive->mult_count = 0; | ||
648 | drive->dev_flags &= ~IDE_DFLAG_PARKED; | ||
649 | |||
650 | if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0 && | ||
651 | (drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) | ||
652 | drive->mult_req = 0; | ||
653 | |||
654 | if (drive->mult_req != drive->mult_count) | ||
655 | drive->special.b.set_multmode = 1; | ||
656 | } | ||
657 | |||
658 | static void pre_reset(ide_drive_t *drive) | ||
659 | { | ||
660 | const struct ide_port_ops *port_ops = drive->hwif->port_ops; | ||
661 | |||
662 | if (drive->media == ide_disk) | ||
663 | ide_disk_pre_reset(drive); | ||
664 | else | ||
665 | drive->dev_flags |= IDE_DFLAG_POST_RESET; | ||
666 | |||
667 | if (drive->dev_flags & IDE_DFLAG_USING_DMA) { | ||
668 | if (drive->crc_count) | ||
669 | ide_check_dma_crc(drive); | ||
670 | else | ||
671 | ide_dma_off(drive); | ||
672 | } | ||
673 | |||
674 | if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0) { | ||
675 | if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) { | ||
676 | drive->dev_flags &= ~IDE_DFLAG_UNMASK; | ||
677 | drive->io_32bit = 0; | ||
678 | } | ||
679 | return; | ||
680 | } | ||
681 | |||
682 | if (port_ops && port_ops->pre_reset) | ||
683 | port_ops->pre_reset(drive); | ||
684 | |||
685 | if (drive->current_speed != 0xff) | ||
686 | drive->desired_speed = drive->current_speed; | ||
687 | drive->current_speed = 0xff; | ||
688 | } | ||
689 | |||
690 | /* | ||
691 | * do_reset1() attempts to recover a confused drive by resetting it. | ||
692 | * Unfortunately, resetting a disk drive actually resets all devices on | ||
693 | * the same interface, so it can really be thought of as resetting the | ||
694 | * interface rather than resetting the drive. | ||
695 | * | ||
696 | * ATAPI devices have their own reset mechanism which allows them to be | ||
697 | * individually reset without clobbering other devices on the same interface. | ||
698 | * | ||
699 | * Unfortunately, the IDE interface does not generate an interrupt to let | ||
700 | * us know when the reset operation has finished, so we must poll for this. | ||
701 | * Equally poor, though, is the fact that this may a very long time to complete, | ||
702 | * (up to 30 seconds worstcase). So, instead of busy-waiting here for it, | ||
703 | * we set a timer to poll at 50ms intervals. | ||
704 | */ | ||
705 | static ide_startstop_t do_reset1(ide_drive_t *drive, int do_not_try_atapi) | ||
706 | { | ||
707 | ide_hwif_t *hwif = drive->hwif; | ||
708 | struct ide_io_ports *io_ports = &hwif->io_ports; | ||
709 | const struct ide_tp_ops *tp_ops = hwif->tp_ops; | ||
710 | const struct ide_port_ops *port_ops; | ||
711 | ide_drive_t *tdrive; | ||
712 | unsigned long flags, timeout; | ||
713 | int i; | ||
714 | DEFINE_WAIT(wait); | ||
715 | |||
716 | spin_lock_irqsave(&hwif->lock, flags); | ||
717 | |||
718 | /* We must not reset with running handlers */ | ||
719 | BUG_ON(hwif->handler != NULL); | ||
720 | |||
721 | /* For an ATAPI device, first try an ATAPI SRST. */ | ||
722 | if (drive->media != ide_disk && !do_not_try_atapi) { | ||
723 | pre_reset(drive); | ||
724 | SELECT_DRIVE(drive); | ||
725 | udelay(20); | ||
726 | tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET); | ||
727 | ndelay(400); | ||
728 | hwif->poll_timeout = jiffies + WAIT_WORSTCASE; | ||
729 | hwif->polling = 1; | ||
730 | __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL); | ||
731 | spin_unlock_irqrestore(&hwif->lock, flags); | ||
732 | return ide_started; | ||
733 | } | ||
734 | |||
735 | /* We must not disturb devices in the IDE_DFLAG_PARKED state. */ | ||
736 | do { | ||
737 | unsigned long now; | ||
738 | |||
739 | prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE); | ||
740 | timeout = jiffies; | ||
741 | ide_port_for_each_present_dev(i, tdrive, hwif) { | ||
742 | if ((tdrive->dev_flags & IDE_DFLAG_PARKED) && | ||
743 | time_after(tdrive->sleep, timeout)) | ||
744 | timeout = tdrive->sleep; | ||
745 | } | ||
746 | |||
747 | now = jiffies; | ||
748 | if (time_before_eq(timeout, now)) | ||
749 | break; | ||
750 | |||
751 | spin_unlock_irqrestore(&hwif->lock, flags); | ||
752 | timeout = schedule_timeout_uninterruptible(timeout - now); | ||
753 | spin_lock_irqsave(&hwif->lock, flags); | ||
754 | } while (timeout); | ||
755 | finish_wait(&ide_park_wq, &wait); | ||
756 | |||
757 | /* | ||
758 | * First, reset any device state data we were maintaining | ||
759 | * for any of the drives on this interface. | ||
760 | */ | ||
761 | ide_port_for_each_dev(i, tdrive, hwif) | ||
762 | pre_reset(tdrive); | ||
763 | |||
764 | if (io_ports->ctl_addr == 0) { | ||
765 | spin_unlock_irqrestore(&hwif->lock, flags); | ||
766 | ide_complete_drive_reset(drive, -ENXIO); | ||
767 | return ide_stopped; | ||
768 | } | ||
769 | |||
770 | /* | ||
771 | * Note that we also set nIEN while resetting the device, | ||
772 | * to mask unwanted interrupts from the interface during the reset. | ||
773 | * However, due to the design of PC hardware, this will cause an | ||
774 | * immediate interrupt due to the edge transition it produces. | ||
775 | * This single interrupt gives us a "fast poll" for drives that | ||
776 | * recover from reset very quickly, saving us the first 50ms wait time. | ||
777 | * | ||
778 | * TODO: add ->softreset method and stop abusing ->set_irq | ||
779 | */ | ||
780 | /* set SRST and nIEN */ | ||
781 | tp_ops->set_irq(hwif, 4); | ||
782 | /* more than enough time */ | ||
783 | udelay(10); | ||
784 | /* clear SRST, leave nIEN (unless device is on the quirk list) */ | ||
785 | tp_ops->set_irq(hwif, drive->quirk_list == 2); | ||
786 | /* more than enough time */ | ||
787 | udelay(10); | ||
788 | hwif->poll_timeout = jiffies + WAIT_WORSTCASE; | ||
789 | hwif->polling = 1; | ||
790 | __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL); | ||
791 | |||
792 | /* | ||
793 | * Some weird controller like resetting themselves to a strange | ||
794 | * state when the disks are reset this way. At least, the Winbond | ||
795 | * 553 documentation says that | ||
796 | */ | ||
797 | port_ops = hwif->port_ops; | ||
798 | if (port_ops && port_ops->resetproc) | ||
799 | port_ops->resetproc(drive); | ||
800 | |||
801 | spin_unlock_irqrestore(&hwif->lock, flags); | ||
802 | return ide_started; | ||
803 | } | ||
804 | |||
805 | /* | ||
806 | * ide_do_reset() is the entry point to the drive/interface reset code. | ||
807 | */ | ||
808 | |||
809 | ide_startstop_t ide_do_reset(ide_drive_t *drive) | ||
810 | { | ||
811 | return do_reset1(drive, 0); | ||
812 | } | ||
813 | EXPORT_SYMBOL(ide_do_reset); | ||
814 | |||
815 | /* | 520 | /* |
816 | * ide_wait_not_busy() waits for the currently selected device on the hwif | 521 | * ide_wait_not_busy() waits for the currently selected device on the hwif |
817 | * to report a non-busy status, see comments in ide_probe_port(). | 522 | * to report a non-busy status, see comments in ide_probe_port(). |