void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry) { unsigned long flags; spin_lock_irqsave(&io_request_lock, flags); __ide_set_handler(drive, handler, timeout, expiry); spin_unlock_irqrestore(&io_request_lock, flags); }
void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout) { ide_hwif_t *hwif = drive->hwif; unsigned long flags; spin_lock_irqsave(&hwif->lock, flags); __ide_set_handler(drive, handler, timeout); spin_unlock_irqrestore(&hwif->lock, flags); }
void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd, ide_handler_t *handler, unsigned timeout) { ide_hwif_t *hwif = drive->hwif; unsigned long flags; spin_lock_irqsave(&hwif->lock, flags); if ((cmd->protocol != ATAPI_PROT_DMA && cmd->protocol != ATAPI_PROT_PIO) || (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT)) __ide_set_handler(drive, handler, timeout); hwif->tp_ops->exec_command(hwif, cmd->tf.command); ndelay(400); spin_unlock_irqrestore(&hwif->lock, flags); }
void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd, ide_handler_t *handler, unsigned timeout) { ide_hwif_t *hwif = drive->hwif; unsigned long flags; spin_lock_irqsave(&hwif->lock, flags); if ((cmd->protocol != ATAPI_PROT_DMA && cmd->protocol != ATAPI_PROT_PIO) || (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT)) __ide_set_handler(drive, handler, timeout); hwif->tp_ops->exec_command(hwif, cmd->tf.command); /* * Drive takes 400nS to respond, we must avoid the IRQ being * serviced before that. * * FIXME: we could skip this delay with care on non shared devices */ ndelay(400); spin_unlock_irqrestore(&hwif->lock, flags); }
static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi) { unsigned int unit; unsigned long flags; ide_hwif_t *hwif; ide_hwgroup_t *hwgroup; spin_lock_irqsave(&io_request_lock, flags); hwgroup = HWGROUP(drive); hwif = HWIF(drive); /* We must not reset with running handlers */ if(hwgroup->handler != NULL) BUG(); /* For an ATAPI device, first try an ATAPI SRST. */ if (drive->media != ide_disk && !do_not_try_atapi) { pre_reset(drive); SELECT_DRIVE(drive); udelay (20); hwif->OUTB(WIN_SRST, IDE_COMMAND_REG); hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE; __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL); spin_unlock_irqrestore(&io_request_lock, flags); return ide_started; } /* * First, reset any device state data we were maintaining * for any of the drives on this interface. */ for (unit = 0; unit < MAX_DRIVES; ++unit) pre_reset(&hwif->drives[unit]); #if OK_TO_RESET_CONTROLLER if (!IDE_CONTROL_REG) { spin_unlock_irqrestore(&io_request_lock, flags); return ide_stopped; } /* * Note that we also set nIEN while resetting the device, * to mask unwanted interrupts from the interface during the reset. * However, due to the design of PC hardware, this will cause an * immediate interrupt due to the edge transition it produces. * This single interrupt gives us a "fast poll" for drives that * recover from reset very quickly, saving us the first 50ms wait time. */ /* set SRST and nIEN */ hwif->OUTBSYNC(drive, drive->ctl|6,IDE_CONTROL_REG); /* more than enough time */ udelay(10); if (drive->quirk_list == 2) { /* clear SRST and nIEN */ hwif->OUTBSYNC(drive, drive->ctl, IDE_CONTROL_REG); } else { /* clear SRST, leave nIEN */ hwif->OUTBSYNC(drive, drive->ctl|2, IDE_CONTROL_REG); } /* more than enough time */ udelay(10); hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE; __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL); /* * Some weird controller like resetting themselves to a strange * state when the disks are reset this way. At least, the Winbond * 553 documentation says that */ if (hwif->resetproc != NULL) { hwif->resetproc(drive); } #endif /* OK_TO_RESET_CONTROLLER */ spin_unlock_irqrestore(&io_request_lock, flags); return ide_started; }
/* * do_reset1() attempts to recover a confused drive by resetting it. * Unfortunately, resetting a disk drive actually resets all devices on * the same interface, so it can really be thought of as resetting the * interface rather than resetting the drive. * * ATAPI devices have their own reset mechanism which allows them to be * individually reset without clobbering other devices on the same interface. * * Unfortunately, the IDE interface does not generate an interrupt to let * us know when the reset operation has finished, so we must poll for this. * Equally poor, though, is the fact that this may a very long time to complete, * (up to 30 seconds worstcase). So, instead of busy-waiting here for it, * we set a timer to poll at 50ms intervals. */ static ide_startstop_t do_reset1(ide_drive_t *drive, int do_not_try_atapi) { ide_hwif_t *hwif = drive->hwif; struct ide_io_ports *io_ports = &hwif->io_ports; const struct ide_tp_ops *tp_ops = hwif->tp_ops; const struct ide_port_ops *port_ops; ide_drive_t *tdrive; unsigned long flags, timeout; int i; DEFINE_WAIT(wait); spin_lock_irqsave(&hwif->lock, flags); /* We must not reset with running handlers */ BUG_ON(hwif->handler != NULL); /* For an ATAPI device, first try an ATAPI SRST. */ if (drive->media != ide_disk && !do_not_try_atapi) { pre_reset(drive); tp_ops->dev_select(drive); udelay(20); tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET); ndelay(400); hwif->poll_timeout = jiffies + WAIT_WORSTCASE; hwif->polling = 1; __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20); spin_unlock_irqrestore(&hwif->lock, flags); return ide_started; } /* We must not disturb devices in the IDE_DFLAG_PARKED state. */ do { unsigned long now; prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE); timeout = jiffies; ide_port_for_each_present_dev(i, tdrive, hwif) { if ((tdrive->dev_flags & IDE_DFLAG_PARKED) && time_after(tdrive->sleep, timeout)) timeout = tdrive->sleep; } now = jiffies; if (time_before_eq(timeout, now)) break; spin_unlock_irqrestore(&hwif->lock, flags); timeout = schedule_timeout_uninterruptible(timeout - now); spin_lock_irqsave(&hwif->lock, flags); } while (timeout); finish_wait(&ide_park_wq, &wait); /* * First, reset any device state data we were maintaining * for any of the drives on this interface. */ ide_port_for_each_dev(i, tdrive, hwif) pre_reset(tdrive); if (io_ports->ctl_addr == 0) { spin_unlock_irqrestore(&hwif->lock, flags); ide_complete_drive_reset(drive, -ENXIO); return ide_stopped; } /* * Note that we also set nIEN while resetting the device, * to mask unwanted interrupts from the interface during the reset. * However, due to the design of PC hardware, this will cause an * immediate interrupt due to the edge transition it produces. * This single interrupt gives us a "fast poll" for drives that * recover from reset very quickly, saving us the first 50ms wait time. */ /* set SRST and nIEN */ tp_ops->write_devctl(hwif, ATA_SRST | ATA_NIEN | ATA_DEVCTL_OBS); /* more than enough time */ udelay(10); /* clear SRST, leave nIEN (unless device is on the quirk list) */ tp_ops->write_devctl(hwif, ((drive->dev_flags & IDE_DFLAG_NIEN_QUIRK) ? 0 : ATA_NIEN) | ATA_DEVCTL_OBS); /* more than enough time */ udelay(10); hwif->poll_timeout = jiffies + WAIT_WORSTCASE; hwif->polling = 1; __ide_set_handler(drive, &reset_pollfunc, HZ/20); /* * Some weird controller like resetting themselves to a strange * state when the disks are reset this way. At least, the Winbond * 553 documentation says that */ port_ops = hwif->port_ops; if (port_ops && port_ops->resetproc) port_ops->resetproc(drive); spin_unlock_irqrestore(&hwif->lock, flags); return ide_started; }
/* * do_reset1() attempts to recover a confused drive by resetting it. * Unfortunately, resetting a disk drive actually resets all devices on * the same interface, so it can really be thought of as resetting the * interface rather than resetting the drive. * * ATAPI devices have their own reset mechanism which allows them to be * individually reset without clobbering other devices on the same interface. * * Unfortunately, the IDE interface does not generate an interrupt to let * us know when the reset operation has finished, so we must poll for this. * Equally poor, though, is the fact that this may a very long time to complete, * (up to 30 seconds worstcase). So, instead of busy-waiting here for it, * we set a timer to poll at 50ms intervals. */ static ide_startstop_t do_reset1 (ide_drive_t *drive, int do_not_try_atapi) { unsigned int unit; unsigned long flags; ide_hwif_t *hwif = HWIF(drive); ide_hwgroup_t *hwgroup; //Added by Frank 96/1/11 struct venus_state *state = hwif->hwif_data; //*************************************** spin_lock_irqsave(&ide_lock, flags); //hwif = HWIF(drive); hwgroup = HWGROUP(drive); /* We must not reset with running handlers */ if(hwgroup->handler != NULL) BUG(); /* For an ATAPI device, first try an ATAPI SRST. */ if (drive->media != ide_disk && !do_not_try_atapi) { pre_reset(drive); SELECT_DRIVE(drive); udelay (20); // Modified by Frank 96/1/11 for hardware reset if (state){ hwif->OUTB(0x00, state->rst); udelay (25); // RESET- asserted >25us hwif->OUTB(0x01, state->rst); }else{ hwif->OUTB(WIN_SRST, IDE_COMMAND_REG); } hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE*4; // ********************************************* hwgroup->polling = 1; __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20, NULL); spin_unlock_irqrestore(&ide_lock, flags); return ide_started; } /* * First, reset any device state data we were maintaining * for any of the drives on this interface. */ for (unit = 0; unit < MAX_DRIVES; ++unit) pre_reset(&hwif->drives[unit]); #if OK_TO_RESET_CONTROLLER if (!IDE_CONTROL_REG) { spin_unlock_irqrestore(&ide_lock, flags); return ide_stopped; } /* * Note that we also set nIEN while resetting the device, * to mask unwanted interrupts from the interface during the reset. * However, due to the design of PC hardware, this will cause an * immediate interrupt due to the edge transition it produces. * This single interrupt gives us a "fast poll" for drives that * recover from reset very quickly, saving us the first 50ms wait time. */ /* set SRST and nIEN */ //hwif->OUTBSYNC(drive, drive->ctl|6,IDE_CONTROL_REG); /* more than enough time */ printk("%s: ready to reset(x version)\n", drive->name); if ((readl((void __iomem *) 0xb801a200)& 0xffff)!=0x1282){ unsigned long value = readl((void __iomem *) 0xb801b034); if ((strcmp(drive->name, "hda")==0)||(strcmp(drive->name, "hdb")==0)) value|=0x01; else value|=0x04; writel(value, (void __iomem *) 0xb801b034); udelay(100); } hwif->OUTB(0x00, state->rst); udelay(10); hwif->OUTB(0x01, state->rst); //if (drive->quirk_list == 2) { /* clear SRST and nIEN */ // hwif->OUTBSYNC(drive, drive->ctl, IDE_CONTROL_REG); //} else { /* clear SRST, leave nIEN */ // hwif->OUTBSYNC(drive, drive->ctl|2, IDE_CONTROL_REG); //} /* more than enough time */ udelay(10); hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE; hwgroup->polling = 1; __ide_set_handler(drive, &reset_pollfunc, HZ/20, NULL); /* * Some weird controller like resetting themselves to a strange * state when the disks are reset this way. At least, the Winbond * 553 documentation says that */ //if (hwif->resetproc != NULL) { // hwif->resetproc(drive); //} #endif /* OK_TO_RESET_CONTROLLER */ spin_unlock_irqrestore(&ide_lock, flags); return ide_started; }