Lines Matching refs:ap
75 static void __ata_port_freeze(struct ata_port *ap);
76 static void ata_eh_finish(struct ata_port *ap);
78 static void ata_eh_handle_port_suspend(struct ata_port *ap);
79 static void ata_eh_handle_port_resume(struct ata_port *ap);
81 static void ata_eh_handle_port_suspend(struct ata_port *ap)
84 static void ata_eh_handle_port_resume(struct ata_port *ap)
132 struct ata_eh_context *ehc = &dev->ap->eh_context;
184 struct ata_port *ap = ata_shost_to_port(host);
191 if (ap->ops->error_handler) {
197 spin_lock_irqsave(ap->lock, flags);
198 qc = ata_qc_from_tag(ap, ap->active_tag);
205 spin_unlock_irqrestore(ap->lock, flags);
226 struct ata_port *ap = ata_shost_to_port(host);
233 ata_port_flush_task(ap);
249 if (ap->ops->error_handler) {
253 spin_lock_irqsave(ap->lock, flags);
259 qc = __ata_qc_from_tag(ap, i);
279 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
290 __ata_port_freeze(ap);
292 spin_unlock_irqrestore(ap->lock, flags);
294 spin_unlock_wait(ap->lock);
298 if (ap->ops->error_handler) {
300 ata_eh_handle_port_resume(ap);
303 spin_lock_irqsave(ap->lock, flags);
305 memset(&ap->eh_context, 0, sizeof(ap->eh_context));
306 ap->eh_context.i = ap->eh_info;
307 memset(&ap->eh_info, 0, sizeof(ap->eh_info));
309 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
310 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
312 spin_unlock_irqrestore(ap->lock, flags);
315 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
316 ap->ops->error_handler(ap);
318 ata_eh_finish(ap);
321 ata_eh_handle_port_suspend(ap);
327 spin_lock_irqsave(ap->lock, flags);
329 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
331 ata_port_printk(ap, KERN_INFO,
334 spin_unlock_irqrestore(ap->lock, flags);
337 ata_port_printk(ap, KERN_ERR, "EH pending after %d "
339 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
343 memset(&ap->eh_info, 0, sizeof(ap->eh_info));
345 /* Clear host_eh_scheduled while holding ap->lock such
352 spin_unlock_irqrestore(ap->lock, flags);
354 WARN_ON(ata_qc_from_tag(ap, ap->active_tag) == NULL);
355 ap->ops->eng_timeout(ap);
361 scsi_eh_flush_done_q(&ap->eh_done_q);
364 spin_lock_irqsave(ap->lock, flags);
366 if (ap->pflags & ATA_PFLAG_LOADING)
367 ap->pflags &= ~ATA_PFLAG_LOADING;
368 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
369 queue_delayed_work(ata_aux_wq, &ap->hotplug_task, 0);
371 if (ap->pflags & ATA_PFLAG_RECOVERED)
372 ata_port_printk(ap, KERN_INFO, "EH complete\n");
374 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
377 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
378 wake_up_all(&ap->eh_wait_q);
380 spin_unlock_irqrestore(ap->lock, flags);
387 * @ap: Port to wait EH for
394 void ata_port_wait_eh(struct ata_port *ap)
400 spin_lock_irqsave(ap->lock, flags);
402 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
403 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
404 spin_unlock_irqrestore(ap->lock, flags);
406 spin_lock_irqsave(ap->lock, flags);
408 finish_wait(&ap->eh_wait_q, &wait);
410 spin_unlock_irqrestore(ap->lock, flags);
413 if (scsi_host_in_recovery(ap->scsi_host)) {
424 * has noticed that the active command on port @ap has not
441 struct ata_port *ap = qc->ap;
447 ap->hsm_task_state = HSM_ST_IDLE;
449 spin_lock_irqsave(ap->lock, flags);
455 host_stat = ap->ops->bmdma_status(ap);
458 ap->ops->bmdma_stop(qc);
463 ata_altstatus(ap);
464 drv_stat = ata_chk_status(ap);
467 ap->ops->irq_clear(ap);
478 spin_unlock_irqrestore(ap->lock, flags);
487 * @ap: Port on which timed-out command is active
490 * has noticed that the active command on port @ap has not
505 void ata_eng_timeout(struct ata_port *ap)
509 ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
526 struct ata_port *ap = qc->ap;
528 WARN_ON(!ap->ops->error_handler);
531 qc->ap->pflags |= ATA_PFLAG_EH_PENDING;
543 * @ap: ATA port to schedule EH for
545 * Schedule error handling for @ap. EH will kick in as soon as
551 void ata_port_schedule_eh(struct ata_port *ap)
553 WARN_ON(!ap->ops->error_handler);
555 if (ap->pflags & ATA_PFLAG_INITIALIZING)
558 ap->pflags |= ATA_PFLAG_EH_PENDING;
559 scsi_schedule_eh(ap->scsi_host);
566 * @ap: ATA port to abort qc's for
568 * Abort all active qc's of @ap and schedule EH.
576 int ata_port_abort(struct ata_port *ap)
580 WARN_ON(!ap->ops->error_handler);
583 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
593 ata_port_schedule_eh(ap);
600 * @ap: ATA port to freeze
607 * ap->ops->freeze() callback can be used for freezing the port
616 static void __ata_port_freeze(struct ata_port *ap)
618 WARN_ON(!ap->ops->error_handler);
620 if (ap->ops->freeze)
621 ap->ops->freeze(ap);
623 ap->pflags |= ATA_PFLAG_FROZEN;
625 DPRINTK("ata%u port frozen\n", ap->print_id);
630 * @ap: ATA port to freeze
632 * Abort and freeze @ap.
640 int ata_port_freeze(struct ata_port *ap)
644 WARN_ON(!ap->ops->error_handler);
646 nr_aborted = ata_port_abort(ap);
647 __ata_port_freeze(ap);
654 * @ap: ATA port to freeze
656 * Freeze @ap.
661 void ata_eh_freeze_port(struct ata_port *ap)
665 if (!ap->ops->error_handler)
668 spin_lock_irqsave(ap->lock, flags);
669 __ata_port_freeze(ap);
670 spin_unlock_irqrestore(ap->lock, flags);
675 * @ap: ATA port to thaw
677 * Thaw frozen port @ap.
682 void ata_eh_thaw_port(struct ata_port *ap)
686 if (!ap->ops->error_handler)
689 spin_lock_irqsave(ap->lock, flags);
691 ap->pflags &= ~ATA_PFLAG_FROZEN;
693 if (ap->ops->thaw)
694 ap->ops->thaw(ap);
696 spin_unlock_irqrestore(ap->lock, flags);
698 DPRINTK("ata%u port thawed\n", ap->print_id);
708 struct ata_port *ap = qc->ap;
712 spin_lock_irqsave(ap->lock, flags);
716 spin_unlock_irqrestore(ap->lock, flags);
718 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
765 struct ata_port *ap = dev->ap;
770 spin_lock_irqsave(ap->lock, flags);
776 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
780 ata_eh_clear_action(dev, &ap->eh_info, ATA_EH_PERDEV_MASK);
781 ata_eh_clear_action(dev, &ap->eh_context.i, ATA_EH_PERDEV_MASK);
783 spin_unlock_irqrestore(ap->lock, flags);
788 * @ap: target ATA port
793 * in @ap->eh_info such that eh actions are not unnecessarily
799 static void ata_eh_about_to_do(struct ata_port *ap, struct ata_device *dev,
803 struct ata_eh_info *ehi = &ap->eh_info;
804 struct ata_eh_context *ehc = &ap->eh_context;
806 spin_lock_irqsave(ap->lock, flags);
824 ap->pflags |= ATA_PFLAG_RECOVERED;
826 spin_unlock_irqrestore(ap->lock, flags);
831 * @ap: target ATA port
836 * in @ap->eh_context.
841 static void ata_eh_done(struct ata_port *ap, struct ata_device *dev,
847 ap->eh_context.i.flags &= ~ATA_EHI_RESET_MODIFIER_MASK;
850 ata_eh_clear_action(dev, &ap->eh_context.i, action);
944 u8 *buf = dev->ap->sector_buf;
998 struct ata_port *ap = dev->ap;
1023 if (ap->flags & ATA_FLAG_PIO_DMA) {
1038 * @ap: ATA port to analyze SError for
1046 static void ata_eh_analyze_serror(struct ata_port *ap)
1048 struct ata_eh_context *ehc = &ap->eh_context;
1078 * @ap: ATA port to analyze NCQ error for
1088 static void ata_eh_analyze_ncq_error(struct ata_port *ap)
1090 struct ata_eh_context *ehc = &ap->eh_context;
1091 struct ata_device *dev = ap->device;
1097 if (ap->pflags & ATA_PFLAG_FROZEN)
1101 if (!ap->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1106 qc = __ata_qc_from_tag(ap, tag);
1118 ata_port_printk(ap, KERN_ERR, "failed to read log page 10h "
1123 if (!(ap->sactive & (1 << tag))) {
1124 ata_port_printk(ap, KERN_ERR, "log page 10h reported "
1130 qc = __ata_qc_from_tag(ap, tag);
1178 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
1339 if (sata_down_spd_limit(dev->ap) == 0) {
1370 (dev->ap->cbl != ATA_CBL_SATA) &&
1388 * @ap: ATA port to perform autopsy on
1390 * Analyze why @ap failed and determine which recovery action is
1397 static void ata_eh_autopsy(struct ata_port *ap)
1399 struct ata_eh_context *ehc = &ap->eh_context;
1411 rc = sata_scr_read(ap, SCR_ERROR, &serror);
1414 ata_eh_analyze_serror(ap);
1419 ata_eh_analyze_ncq_error(ap);
1428 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1462 if (ap->pflags & ATA_PFLAG_FROZEN ||
1485 * @ap: ATA port EH is going on
1492 static void ata_eh_report(struct ata_port *ap)
1494 struct ata_eh_context *ehc = &ap->eh_context;
1503 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1517 if (ap->pflags & ATA_PFLAG_FROZEN)
1523 ehc->i.err_mask, ap->sactive, ehc->i.serror,
1528 ata_port_printk(ap, KERN_ERR, "exception Emask 0x%x "
1530 ehc->i.err_mask, ap->sactive, ehc->i.serror,
1533 ata_port_printk(ap, KERN_ERR, "(%s)\n", desc);
1543 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1568 static int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
1576 rc = reset(ap, classes, deadline);
1608 static int ata_eh_reset(struct ata_port *ap, int classify,
1612 struct ata_eh_context *ehc = &ap->eh_context;
1622 ata_eh_about_to_do(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
1629 if (softreset && (!hardreset || (!sata_set_spd_needed(ap) &&
1636 rc = prereset(ap, jiffies + ATA_EH_PRERESET_TIMEOUT);
1639 ata_port_printk(ap, KERN_DEBUG,
1641 ap->eh_context.i.action &= ~ATA_EH_RESET_MASK;
1648 ata_port_printk(ap, KERN_ERR,
1679 ata_port_printk(ap, KERN_INFO, "%s resetting port\n",
1688 rc = ata_do_reset(ap, reset, classes, deadline);
1696 ata_port_printk(ap, KERN_ERR,
1702 ata_eh_about_to_do(ap, NULL, ATA_EH_RESET_MASK);
1703 rc = ata_do_reset(ap, reset, classes, deadline);
1707 ata_port_printk(ap, KERN_ERR,
1719 ata_port_printk(ap, KERN_WARNING, "reset failed "
1728 sata_down_spd_limit(ap);
1739 ap->device[i].pio_mode = XFER_PIO_0;
1742 postreset(ap, classes);
1745 ata_eh_done(ap, NULL, ehc->i.action & ATA_EH_RESET_MASK);
1752 static int ata_eh_revalidate_and_attach(struct ata_port *ap,
1755 struct ata_eh_context *ehc = &ap->eh_context;
1770 dev = &ap->device[i];
1777 if (ata_port_offline(ap)) {
1782 ata_eh_about_to_do(ap, dev, ATA_EH_REVALIDATE);
1787 ata_eh_done(ap, dev, ATA_EH_REVALIDATE);
1795 queue_work(ata_aux_wq, &(ap->scsi_rescan_task));
1812 ata_eh_thaw_port(ap);
1823 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ap->ops->cable_detect)
1824 ap->cbl = ap->ops->cable_detect(ap);
1830 dev = &ap->device[i];
1841 spin_lock_irqsave(ap->lock, flags);
1842 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1843 spin_unlock_irqrestore(ap->lock, flags);
1857 static int ata_port_nr_enabled(struct ata_port *ap)
1862 if (ata_dev_enabled(&ap->device[i]))
1867 static int ata_port_nr_vacant(struct ata_port *ap)
1872 if (ap->device[i].class == ATA_DEV_UNKNOWN)
1877 static int ata_eh_skip_recovery(struct ata_port *ap)
1879 struct ata_eh_context *ehc = &ap->eh_context;
1883 if ((ap->pflags & ATA_PFLAG_FROZEN) ||
1884 (ehc->i.flags & ATA_EHI_RESUME_LINK) || ata_port_nr_enabled(ap))
1889 struct ata_device *dev = &ap->device[i];
1901 * @ap: host port to recover
1920 static int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
1924 struct ata_eh_context *ehc = &ap->eh_context;
1932 dev = &ap->device[i];
1958 if (ap->pflags & ATA_PFLAG_UNLOADING)
1962 if (ata_eh_skip_recovery(ap))
1970 ata_eh_freeze_port(ap);
1972 rc = ata_eh_reset(ap, ata_port_nr_vacant(ap), prereset,
1975 ata_port_printk(ap, KERN_ERR,
1980 ata_eh_thaw_port(ap);
1984 rc = ata_eh_revalidate_and_attach(ap, &dev);
1990 rc = ata_set_mode(ap, &dev);
2013 sata_down_spd_limit(ap);
2023 if (ata_port_offline(ap))
2044 if (ata_port_nr_enabled(ap)) {
2045 ata_port_printk(ap, KERN_WARNING, "failed to recover some "
2058 ata_dev_disable(&ap->device[i]);
2067 * @ap: host port to finish EH for
2075 static void ata_eh_finish(struct ata_port *ap)
2081 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2105 * @ap: host port to handle error for
2116 void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
2120 ata_eh_autopsy(ap);
2121 ata_eh_report(ap);
2122 ata_eh_recover(ap, prereset, softreset, hardreset, postreset);
2123 ata_eh_finish(ap);
2129 * @ap: port to suspend
2131 * Suspend @ap.
2136 static void ata_eh_handle_port_suspend(struct ata_port *ap)
2142 spin_lock_irqsave(ap->lock, flags);
2143 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2144 ap->pm_mesg.event == PM_EVENT_ON) {
2145 spin_unlock_irqrestore(ap->lock, flags);
2148 spin_unlock_irqrestore(ap->lock, flags);
2150 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
2153 ata_eh_freeze_port(ap);
2155 if (ap->ops->port_suspend)
2156 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
2159 spin_lock_irqsave(ap->lock, flags);
2161 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
2163 ap->pflags |= ATA_PFLAG_SUSPENDED;
2165 ata_port_schedule_eh(ap);
2167 if (ap->pm_result) {
2168 *ap->pm_result = rc;
2169 ap->pm_result = NULL;
2172 spin_unlock_irqrestore(ap->lock, flags);
2179 * @ap: port to resume
2181 * Resume @ap.
2186 static void ata_eh_handle_port_resume(struct ata_port *ap)
2192 spin_lock_irqsave(ap->lock, flags);
2193 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
2194 ap->pm_mesg.event != PM_EVENT_ON) {
2195 spin_unlock_irqrestore(ap->lock, flags);
2198 spin_unlock_irqrestore(ap->lock, flags);
2200 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
2202 if (ap->ops->port_resume)
2203 rc = ap->ops->port_resume(ap);
2206 spin_lock_irqsave(ap->lock, flags);
2207 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
2208 if (ap->pm_result) {
2209 *ap->pm_result = rc;
2210 ap->pm_result = NULL;
2212 spin_unlock_irqrestore(ap->lock, flags);