2 * libata-eh.c - libata error handling
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
8 * Copyright 2006 Tejun Heo <htejun@gmail.com>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
35 #include <linux/config.h>
36 #include <linux/kernel.h>
37 #include <scsi/scsi.h>
38 #include <scsi/scsi_host.h>
39 #include <scsi/scsi_eh.h>
40 #include <scsi/scsi_device.h>
41 #include <scsi/scsi_cmnd.h>
43 #include <linux/libata.h>
47 static void __ata_port_freeze(struct ata_port *ap);
49 static void ata_ering_record(struct ata_ering *ering, int is_io,
50 unsigned int err_mask)
52 struct ata_ering_entry *ent;
57 ering->cursor %= ATA_ERING_SIZE;
59 ent = &ering->ring[ering->cursor];
61 ent->err_mask = err_mask;
62 ent->timestamp = get_jiffies_64();
65 static struct ata_ering_entry * ata_ering_top(struct ata_ering *ering)
67 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
73 static int ata_ering_map(struct ata_ering *ering,
74 int (*map_fn)(struct ata_ering_entry *, void *),
78 struct ata_ering_entry *ent;
82 ent = &ering->ring[idx];
85 rc = map_fn(ent, arg);
88 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
89 } while (idx != ering->cursor);
95 * ata_scsi_timed_out - SCSI layer time out callback
96 * @cmd: timed out SCSI command
98 * Handles SCSI layer timeout. We race with normal completion of
99 * the qc for @cmd. If the qc is already gone, we lose and let
100 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
101 * timed out and EH should be invoked. Prevent ata_qc_complete()
102 * from finishing it by setting EH_SCHEDULED and return
105 * TODO: kill this function once old EH is gone.
108 * Called from timer context
111 * EH_HANDLED or EH_NOT_HANDLED
113 enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
115 struct Scsi_Host *host = cmd->device->host;
116 struct ata_port *ap = ata_shost_to_port(host);
118 struct ata_queued_cmd *qc;
119 enum scsi_eh_timer_return ret;
123 if (ap->ops->error_handler) {
124 ret = EH_NOT_HANDLED;
129 spin_lock_irqsave(&ap->host_set->lock, flags);
130 qc = ata_qc_from_tag(ap, ap->active_tag);
132 WARN_ON(qc->scsicmd != cmd);
133 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
134 qc->err_mask |= AC_ERR_TIMEOUT;
135 ret = EH_NOT_HANDLED;
137 spin_unlock_irqrestore(&ap->host_set->lock, flags);
140 DPRINTK("EXIT, ret=%d\n", ret);
145 * ata_scsi_error - SCSI layer error handler callback
146 * @host: SCSI host on which error occurred
148 * Handles SCSI-layer-thrown error events.
151 * Inherited from SCSI layer (none, can sleep)
156 void ata_scsi_error(struct Scsi_Host *host)
158 struct ata_port *ap = ata_shost_to_port(host);
159 spinlock_t *hs_lock = &ap->host_set->lock;
160 int i, repeat_cnt = ATA_EH_MAX_REPEAT;
165 /* synchronize with port task */
166 ata_port_flush_task(ap);
168 /* synchronize with host_set lock and sort out timeouts */
170 /* For new EH, all qcs are finished in one of three ways -
171 * normal completion, error completion, and SCSI timeout.
172 * Both cmpletions can race against SCSI timeout. When normal
173 * completion wins, the qc never reaches EH. When error
174 * completion wins, the qc has ATA_QCFLAG_FAILED set.
176 * When SCSI timeout wins, things are a bit more complex.
177 * Normal or error completion can occur after the timeout but
178 * before this point. In such cases, both types of
179 * completions are honored. A scmd is determined to have
180 * timed out iff its associated qc is active and not failed.
182 if (ap->ops->error_handler) {
183 struct scsi_cmnd *scmd, *tmp;
186 spin_lock_irqsave(hs_lock, flags);
188 list_for_each_entry_safe(scmd, tmp, &host->eh_cmd_q, eh_entry) {
189 struct ata_queued_cmd *qc;
191 for (i = 0; i < ATA_MAX_QUEUE; i++) {
192 qc = __ata_qc_from_tag(ap, i);
193 if (qc->flags & ATA_QCFLAG_ACTIVE &&
198 if (i < ATA_MAX_QUEUE) {
199 /* the scmd has an associated qc */
200 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
201 /* which hasn't failed yet, timeout */
202 qc->err_mask |= AC_ERR_TIMEOUT;
203 qc->flags |= ATA_QCFLAG_FAILED;
207 /* Normal completion occurred after
208 * SCSI timeout but before this point.
209 * Successfully complete it.
211 scmd->retries = scmd->allowed;
212 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
216 /* If we have timed out qcs. They belong to EH from
217 * this point but the state of the controller is
218 * unknown. Freeze the port to make sure the IRQ
219 * handler doesn't diddle with those qcs. This must
220 * be done atomically w.r.t. setting QCFLAG_FAILED.
223 __ata_port_freeze(ap);
225 spin_unlock_irqrestore(hs_lock, flags);
227 spin_unlock_wait(hs_lock);
230 /* invoke error handler */
231 if (ap->ops->error_handler) {
232 /* fetch & clear EH info */
233 spin_lock_irqsave(hs_lock, flags);
235 memset(&ap->eh_context, 0, sizeof(ap->eh_context));
236 ap->eh_context.i = ap->eh_info;
237 memset(&ap->eh_info, 0, sizeof(ap->eh_info));
239 ap->flags &= ~ATA_FLAG_EH_PENDING;
241 spin_unlock_irqrestore(hs_lock, flags);
244 ap->ops->error_handler(ap);
246 /* Exception might have happend after ->error_handler
247 * recovered the port but before this point. Repeat
250 spin_lock_irqsave(hs_lock, flags);
252 if (ap->flags & ATA_FLAG_EH_PENDING) {
254 ata_port_printk(ap, KERN_INFO,
255 "EH pending after completion, "
256 "repeating EH (cnt=%d)\n", repeat_cnt);
257 spin_unlock_irqrestore(hs_lock, flags);
260 ata_port_printk(ap, KERN_ERR, "EH pending after %d "
261 "tries, giving up\n", ATA_EH_MAX_REPEAT);
264 /* this run is complete, make sure EH info is clear */
265 memset(&ap->eh_info, 0, sizeof(ap->eh_info));
267 /* Clear host_eh_scheduled while holding hs_lock such
268 * that if exception occurs after this point but
269 * before EH completion, SCSI midlayer will
272 host->host_eh_scheduled = 0;
274 spin_unlock_irqrestore(hs_lock, flags);
276 WARN_ON(ata_qc_from_tag(ap, ap->active_tag) == NULL);
277 ap->ops->eng_timeout(ap);
280 /* finish or retry handled scmd's and clean up */
281 WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
283 scsi_eh_flush_done_q(&ap->eh_done_q);
286 spin_lock_irqsave(hs_lock, flags);
288 if (ap->flags & ATA_FLAG_RECOVERED)
289 ata_port_printk(ap, KERN_INFO, "EH complete\n");
290 ap->flags &= ~ATA_FLAG_RECOVERED;
292 spin_unlock_irqrestore(hs_lock, flags);
298 * ata_qc_timeout - Handle timeout of queued command
299 * @qc: Command that timed out
301 * Some part of the kernel (currently, only the SCSI layer)
302 * has noticed that the active command on port @ap has not
303 * completed after a specified length of time. Handle this
304 * condition by disabling DMA (if necessary) and completing
305 * transactions, with error if necessary.
307 * This also handles the case of the "lost interrupt", where
308 * for some reason (possibly hardware bug, possibly driver bug)
309 * an interrupt was not delivered to the driver, even though the
310 * transaction completed successfully.
312 * TODO: kill this function once old EH is gone.
315 * Inherited from SCSI layer (none, can sleep)
317 static void ata_qc_timeout(struct ata_queued_cmd *qc)
319 struct ata_port *ap = qc->ap;
320 struct ata_host_set *host_set = ap->host_set;
321 u8 host_stat = 0, drv_stat;
326 ap->hsm_task_state = HSM_ST_IDLE;
328 spin_lock_irqsave(&host_set->lock, flags);
330 switch (qc->tf.protocol) {
333 case ATA_PROT_ATAPI_DMA:
334 host_stat = ap->ops->bmdma_status(ap);
336 /* before we do anything else, clear DMA-Start bit */
337 ap->ops->bmdma_stop(qc);
343 drv_stat = ata_chk_status(ap);
345 /* ack bmdma irq events */
346 ap->ops->irq_clear(ap);
348 ata_dev_printk(qc->dev, KERN_ERR, "command 0x%x timeout, "
349 "stat 0x%x host_stat 0x%x\n",
350 qc->tf.command, drv_stat, host_stat);
352 /* complete taskfile transaction */
353 qc->err_mask |= AC_ERR_TIMEOUT;
357 spin_unlock_irqrestore(&host_set->lock, flags);
359 ata_eh_qc_complete(qc);
365 * ata_eng_timeout - Handle timeout of queued command
366 * @ap: Port on which timed-out command is active
368 * Some part of the kernel (currently, only the SCSI layer)
369 * has noticed that the active command on port @ap has not
370 * completed after a specified length of time. Handle this
371 * condition by disabling DMA (if necessary) and completing
372 * transactions, with error if necessary.
374 * This also handles the case of the "lost interrupt", where
375 * for some reason (possibly hardware bug, possibly driver bug)
376 * an interrupt was not delivered to the driver, even though the
377 * transaction completed successfully.
379 * TODO: kill this function once old EH is gone.
382 * Inherited from SCSI layer (none, can sleep)
384 void ata_eng_timeout(struct ata_port *ap)
388 ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
394 * ata_qc_schedule_eh - schedule qc for error handling
395 * @qc: command to schedule error handling for
397 * Schedule error handling for @qc. EH will kick in as soon as
398 * other commands are drained.
401 * spin_lock_irqsave(host_set lock)
403 void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
405 struct ata_port *ap = qc->ap;
407 WARN_ON(!ap->ops->error_handler);
409 qc->flags |= ATA_QCFLAG_FAILED;
410 qc->ap->flags |= ATA_FLAG_EH_PENDING;
412 /* The following will fail if timeout has already expired.
413 * ata_scsi_error() takes care of such scmds on EH entry.
414 * Note that ATA_QCFLAG_FAILED is unconditionally set after
415 * this function completes.
417 scsi_req_abort_cmd(qc->scsicmd);
421 * ata_port_schedule_eh - schedule error handling without a qc
422 * @ap: ATA port to schedule EH for
424 * Schedule error handling for @ap. EH will kick in as soon as
425 * all commands are drained.
428 * spin_lock_irqsave(host_set lock)
430 void ata_port_schedule_eh(struct ata_port *ap)
432 WARN_ON(!ap->ops->error_handler);
434 ap->flags |= ATA_FLAG_EH_PENDING;
435 ata_schedule_scsi_eh(ap->host);
437 DPRINTK("port EH scheduled\n");
441 * ata_port_abort - abort all qc's on the port
442 * @ap: ATA port to abort qc's for
444 * Abort all active qc's of @ap and schedule EH.
447 * spin_lock_irqsave(host_set lock)
450 * Number of aborted qc's.
452 int ata_port_abort(struct ata_port *ap)
454 int tag, nr_aborted = 0;
456 WARN_ON(!ap->ops->error_handler);
458 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
459 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
462 qc->flags |= ATA_QCFLAG_FAILED;
469 ata_port_schedule_eh(ap);
475 * __ata_port_freeze - freeze port
476 * @ap: ATA port to freeze
478 * This function is called when HSM violation or some other
479 * condition disrupts normal operation of the port. Frozen port
480 * is not allowed to perform any operation until the port is
481 * thawed, which usually follows a successful reset.
483 * ap->ops->freeze() callback can be used for freezing the port
484 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
485 * port cannot be frozen hardware-wise, the interrupt handler
486 * must ack and clear interrupts unconditionally while the port
490 * spin_lock_irqsave(host_set lock)
492 static void __ata_port_freeze(struct ata_port *ap)
494 WARN_ON(!ap->ops->error_handler);
499 ap->flags |= ATA_FLAG_FROZEN;
501 DPRINTK("ata%u port frozen\n", ap->id);
505 * ata_port_freeze - abort & freeze port
506 * @ap: ATA port to freeze
508 * Abort and freeze @ap.
511 * spin_lock_irqsave(host_set lock)
514 * Number of aborted commands.
516 int ata_port_freeze(struct ata_port *ap)
520 WARN_ON(!ap->ops->error_handler);
522 nr_aborted = ata_port_abort(ap);
523 __ata_port_freeze(ap);
529 * ata_eh_freeze_port - EH helper to freeze port
530 * @ap: ATA port to freeze
537 void ata_eh_freeze_port(struct ata_port *ap)
541 if (!ap->ops->error_handler)
544 spin_lock_irqsave(&ap->host_set->lock, flags);
545 __ata_port_freeze(ap);
546 spin_unlock_irqrestore(&ap->host_set->lock, flags);
550 * ata_port_thaw_port - EH helper to thaw port
551 * @ap: ATA port to thaw
553 * Thaw frozen port @ap.
558 void ata_eh_thaw_port(struct ata_port *ap)
562 if (!ap->ops->error_handler)
565 spin_lock_irqsave(&ap->host_set->lock, flags);
567 ap->flags &= ~ATA_FLAG_FROZEN;
572 spin_unlock_irqrestore(&ap->host_set->lock, flags);
574 DPRINTK("ata%u port thawed\n", ap->id);
577 static void ata_eh_scsidone(struct scsi_cmnd *scmd)
582 static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
584 struct ata_port *ap = qc->ap;
585 struct scsi_cmnd *scmd = qc->scsicmd;
588 spin_lock_irqsave(&ap->host_set->lock, flags);
589 qc->scsidone = ata_eh_scsidone;
590 __ata_qc_complete(qc);
591 WARN_ON(ata_tag_valid(qc->tag));
592 spin_unlock_irqrestore(&ap->host_set->lock, flags);
594 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
598 * ata_eh_qc_complete - Complete an active ATA command from EH
599 * @qc: Command to complete
601 * Indicate to the mid and upper layers that an ATA command has
602 * completed. To be used from EH.
604 void ata_eh_qc_complete(struct ata_queued_cmd *qc)
606 struct scsi_cmnd *scmd = qc->scsicmd;
607 scmd->retries = scmd->allowed;
608 __ata_eh_qc_complete(qc);
612 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
613 * @qc: Command to retry
615 * Indicate to the mid and upper layers that an ATA command
616 * should be retried. To be used from EH.
618 * SCSI midlayer limits the number of retries to scmd->allowed.
619 * scmd->retries is decremented for commands which get retried
620 * due to unrelated failures (qc->err_mask is zero).
622 void ata_eh_qc_retry(struct ata_queued_cmd *qc)
624 struct scsi_cmnd *scmd = qc->scsicmd;
625 if (!qc->err_mask && scmd->retries)
627 __ata_eh_qc_complete(qc);
631 * ata_eh_about_to_do - about to perform eh_action
632 * @ap: target ATA port
633 * @action: action about to be performed
635 * Called just before performing EH actions to clear related bits
636 * in @ap->eh_info such that eh actions are not unnecessarily
642 static void ata_eh_about_to_do(struct ata_port *ap, unsigned int action)
646 spin_lock_irqsave(&ap->host_set->lock, flags);
647 ap->eh_info.action &= ~action;
648 ap->flags |= ATA_FLAG_RECOVERED;
649 spin_unlock_irqrestore(&ap->host_set->lock, flags);
653 * ata_err_string - convert err_mask to descriptive string
654 * @err_mask: error mask to convert to string
656 * Convert @err_mask to descriptive string. Errors are
657 * prioritized according to severity and only the most severe
664 * Descriptive string for @err_mask
666 static const char * ata_err_string(unsigned int err_mask)
668 if (err_mask & AC_ERR_HOST_BUS)
669 return "host bus error";
670 if (err_mask & AC_ERR_ATA_BUS)
671 return "ATA bus error";
672 if (err_mask & AC_ERR_TIMEOUT)
674 if (err_mask & AC_ERR_HSM)
675 return "HSM violation";
676 if (err_mask & AC_ERR_SYSTEM)
677 return "internal error";
678 if (err_mask & AC_ERR_MEDIA)
679 return "media error";
680 if (err_mask & AC_ERR_INVALID)
681 return "invalid argument";
682 if (err_mask & AC_ERR_DEV)
683 return "device error";
684 return "unknown error";
688 * ata_read_log_page - read a specific log page
689 * @dev: target device
690 * @page: page to read
691 * @buf: buffer to store read page
692 * @sectors: number of sectors to read
694 * Read log page using READ_LOG_EXT command.
697 * Kernel thread context (may sleep).
700 * 0 on success, AC_ERR_* mask otherwise.
702 static unsigned int ata_read_log_page(struct ata_device *dev,
703 u8 page, void *buf, unsigned int sectors)
705 struct ata_taskfile tf;
706 unsigned int err_mask;
708 DPRINTK("read log page - page %d\n", page);
710 ata_tf_init(dev, &tf);
711 tf.command = ATA_CMD_READ_LOG_EXT;
714 tf.hob_nsect = sectors >> 8;
715 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
716 tf.protocol = ATA_PROT_PIO;
718 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
719 buf, sectors * ATA_SECT_SIZE);
721 DPRINTK("EXIT, err_mask=%x\n", err_mask);
726 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
727 * @dev: Device to read log page 10h from
728 * @tag: Resulting tag of the failed command
729 * @tf: Resulting taskfile registers of the failed command
731 * Read log page 10h to obtain NCQ error details and clear error
735 * Kernel thread context (may sleep).
738 * 0 on success, -errno otherwise.
740 static int ata_eh_read_log_10h(struct ata_device *dev,
741 int *tag, struct ata_taskfile *tf)
743 u8 *buf = dev->ap->sector_buf;
744 unsigned int err_mask;
748 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, buf, 1);
753 for (i = 0; i < ATA_SECT_SIZE; i++)
756 ata_dev_printk(dev, KERN_WARNING,
757 "invalid checksum 0x%x on log page 10h\n", csum);
762 *tag = buf[0] & 0x1f;
764 tf->command = buf[2];
765 tf->feature = buf[3];
770 tf->hob_lbal = buf[8];
771 tf->hob_lbam = buf[9];
772 tf->hob_lbah = buf[10];
774 tf->hob_nsect = buf[13];
780 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
781 * @dev: device to perform REQUEST_SENSE to
782 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
784 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
785 * SENSE. This function is EH helper.
788 * Kernel thread context (may sleep).
791 * 0 on success, AC_ERR_* mask on failure
793 static unsigned int atapi_eh_request_sense(struct ata_device *dev,
794 unsigned char *sense_buf)
796 struct ata_port *ap = dev->ap;
797 struct ata_taskfile tf;
798 u8 cdb[ATAPI_CDB_LEN];
800 DPRINTK("ATAPI request sense\n");
802 ata_tf_init(dev, &tf);
804 /* FIXME: is this needed? */
805 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
807 /* XXX: why tf_read here? */
808 ap->ops->tf_read(ap, &tf);
810 /* fill these in, for the case where they are -not- overwritten */
812 sense_buf[2] = tf.feature >> 4;
814 memset(cdb, 0, ATAPI_CDB_LEN);
815 cdb[0] = REQUEST_SENSE;
816 cdb[4] = SCSI_SENSE_BUFFERSIZE;
818 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
819 tf.command = ATA_CMD_PACKET;
821 /* is it pointless to prefer PIO for "safety reasons"? */
822 if (ap->flags & ATA_FLAG_PIO_DMA) {
823 tf.protocol = ATA_PROT_ATAPI_DMA;
824 tf.feature |= ATAPI_PKT_DMA;
826 tf.protocol = ATA_PROT_ATAPI;
827 tf.lbam = (8 * 1024) & 0xff;
828 tf.lbah = (8 * 1024) >> 8;
831 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
832 sense_buf, SCSI_SENSE_BUFFERSIZE);
836 * ata_eh_analyze_serror - analyze SError for a failed port
837 * @ap: ATA port to analyze SError for
839 * Analyze SError if available and further determine cause of
845 static void ata_eh_analyze_serror(struct ata_port *ap)
847 struct ata_eh_context *ehc = &ap->eh_context;
848 u32 serror = ehc->i.serror;
849 unsigned int err_mask = 0, action = 0;
851 if (serror & SERR_PERSISTENT) {
852 err_mask |= AC_ERR_ATA_BUS;
853 action |= ATA_EH_HARDRESET;
856 (SERR_DATA_RECOVERED | SERR_COMM_RECOVERED | SERR_DATA)) {
857 err_mask |= AC_ERR_ATA_BUS;
858 action |= ATA_EH_SOFTRESET;
860 if (serror & SERR_PROTOCOL) {
861 err_mask |= AC_ERR_HSM;
862 action |= ATA_EH_SOFTRESET;
864 if (serror & SERR_INTERNAL) {
865 err_mask |= AC_ERR_SYSTEM;
866 action |= ATA_EH_SOFTRESET;
868 if (serror & (SERR_PHYRDY_CHG | SERR_DEV_XCHG)) {
869 err_mask |= AC_ERR_ATA_BUS;
870 action |= ATA_EH_HARDRESET;
873 ehc->i.err_mask |= err_mask;
874 ehc->i.action |= action;
878 * ata_eh_analyze_ncq_error - analyze NCQ error
879 * @ap: ATA port to analyze NCQ error for
881 * Read log page 10h, determine the offending qc and acquire
882 * error status TF. For NCQ device errors, all LLDDs have to do
883 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
887 * Kernel thread context (may sleep).
889 static void ata_eh_analyze_ncq_error(struct ata_port *ap)
891 struct ata_eh_context *ehc = &ap->eh_context;
892 struct ata_device *dev = ap->device;
893 struct ata_queued_cmd *qc;
894 struct ata_taskfile tf;
897 /* if frozen, we can't do much */
898 if (ap->flags & ATA_FLAG_FROZEN)
901 /* is it NCQ device error? */
902 if (!ap->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
905 /* has LLDD analyzed already? */
906 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
907 qc = __ata_qc_from_tag(ap, tag);
909 if (!(qc->flags & ATA_QCFLAG_FAILED))
916 /* okay, this error is ours */
917 rc = ata_eh_read_log_10h(dev, &tag, &tf);
919 ata_port_printk(ap, KERN_ERR, "failed to read log page 10h "
924 if (!(ap->sactive & (1 << tag))) {
925 ata_port_printk(ap, KERN_ERR, "log page 10h reported "
926 "inactive tag %d\n", tag);
930 /* we've got the perpetrator, condemn it */
931 qc = __ata_qc_from_tag(ap, tag);
932 memcpy(&qc->result_tf, &tf, sizeof(tf));
933 qc->err_mask |= AC_ERR_DEV;
934 ehc->i.err_mask &= ~AC_ERR_DEV;
938 * ata_eh_analyze_tf - analyze taskfile of a failed qc
940 * @tf: Taskfile registers to analyze
942 * Analyze taskfile of @qc and further determine cause of
943 * failure. This function also requests ATAPI sense data if
947 * Kernel thread context (may sleep).
950 * Determined recovery action
952 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
953 const struct ata_taskfile *tf)
955 unsigned int tmp, action = 0;
956 u8 stat = tf->command, err = tf->feature;
958 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
959 qc->err_mask |= AC_ERR_HSM;
960 return ATA_EH_SOFTRESET;
963 if (!(qc->err_mask & AC_ERR_DEV))
966 switch (qc->dev->class) {
969 qc->err_mask |= AC_ERR_ATA_BUS;
971 qc->err_mask |= AC_ERR_MEDIA;
973 qc->err_mask |= AC_ERR_INVALID;
977 tmp = atapi_eh_request_sense(qc->dev,
978 qc->scsicmd->sense_buffer);
980 /* ATA_QCFLAG_SENSE_VALID is used to tell
981 * atapi_qc_complete() that sense data is
984 * TODO: interpret sense data and set
985 * appropriate err_mask.
987 qc->flags |= ATA_QCFLAG_SENSE_VALID;
992 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
993 action |= ATA_EH_SOFTRESET;
998 static int ata_eh_categorize_ering_entry(struct ata_ering_entry *ent)
1000 if (ent->err_mask & (AC_ERR_ATA_BUS | AC_ERR_TIMEOUT))
1004 if (ent->err_mask & AC_ERR_HSM)
1006 if ((ent->err_mask &
1007 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
1014 struct speed_down_needed_arg {
1019 static int speed_down_needed_cb(struct ata_ering_entry *ent, void *void_arg)
1021 struct speed_down_needed_arg *arg = void_arg;
1023 if (ent->timestamp < arg->since)
1026 arg->nr_errors[ata_eh_categorize_ering_entry(ent)]++;
1031 * ata_eh_speed_down_needed - Determine wheter speed down is necessary
1032 * @dev: Device of interest
1034 * This function examines error ring of @dev and determines
1035 * whether speed down is necessary. Speed down is necessary if
1036 * there have been more than 3 of Cat-1 errors or 10 of Cat-2
1037 * errors during last 15 minutes.
1039 * Cat-1 errors are ATA_BUS, TIMEOUT for any command and HSM
1040 * violation for known supported commands.
1042 * Cat-2 errors are unclassified DEV error for known supported
1046 * Inherited from caller.
1049 * 1 if speed down is necessary, 0 otherwise
1051 static int ata_eh_speed_down_needed(struct ata_device *dev)
1053 const u64 interval = 15LLU * 60 * HZ;
1054 static const int err_limits[3] = { -1, 3, 10 };
1055 struct speed_down_needed_arg arg;
1056 struct ata_ering_entry *ent;
1060 ent = ata_ering_top(&dev->ering);
1064 err_cat = ata_eh_categorize_ering_entry(ent);
1068 memset(&arg, 0, sizeof(arg));
1070 j64 = get_jiffies_64();
1071 if (j64 >= interval)
1072 arg.since = j64 - interval;
1076 ata_ering_map(&dev->ering, speed_down_needed_cb, &arg);
1078 return arg.nr_errors[err_cat] > err_limits[err_cat];
1082 * ata_eh_speed_down - record error and speed down if necessary
1083 * @dev: Failed device
1084 * @is_io: Did the device fail during normal IO?
1085 * @err_mask: err_mask of the error
1087 * Record error and examine error history to determine whether
1088 * adjusting transmission speed is necessary. It also sets
1089 * transmission limits appropriately if such adjustment is
1093 * Kernel thread context (may sleep).
1096 * 0 on success, -errno otherwise
1098 static int ata_eh_speed_down(struct ata_device *dev, int is_io,
1099 unsigned int err_mask)
1104 /* record error and determine whether speed down is necessary */
1105 ata_ering_record(&dev->ering, is_io, err_mask);
1107 if (!ata_eh_speed_down_needed(dev))
1110 /* speed down SATA link speed if possible */
1111 if (sata_down_spd_limit(dev->ap) == 0)
1112 return ATA_EH_HARDRESET;
1114 /* lower transfer mode */
1115 if (ata_down_xfermask_limit(dev, 0) == 0)
1116 return ATA_EH_SOFTRESET;
1118 ata_dev_printk(dev, KERN_ERR,
1119 "speed down requested but no transfer mode left\n");
1124 * ata_eh_autopsy - analyze error and determine recovery action
1125 * @ap: ATA port to perform autopsy on
1127 * Analyze why @ap failed and determine which recovery action is
1128 * needed. This function also sets more detailed AC_ERR_* values
1129 * and fills sense data for ATAPI CHECK SENSE.
1132 * Kernel thread context (may sleep).
1134 static void ata_eh_autopsy(struct ata_port *ap)
1136 struct ata_eh_context *ehc = &ap->eh_context;
1137 unsigned int action = ehc->i.action;
1138 struct ata_device *failed_dev = NULL;
1139 unsigned int all_err_mask = 0;
1146 /* obtain and analyze SError */
1147 rc = sata_scr_read(ap, SCR_ERROR, &serror);
1149 ehc->i.serror |= serror;
1150 ata_eh_analyze_serror(ap);
1151 } else if (rc != -EOPNOTSUPP)
1152 action |= ATA_EH_HARDRESET;
1154 /* analyze NCQ failure */
1155 ata_eh_analyze_ncq_error(ap);
1157 /* any real error trumps AC_ERR_OTHER */
1158 if (ehc->i.err_mask & ~AC_ERR_OTHER)
1159 ehc->i.err_mask &= ~AC_ERR_OTHER;
1161 all_err_mask |= ehc->i.err_mask;
1163 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1164 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1166 if (!(qc->flags & ATA_QCFLAG_FAILED))
1169 /* inherit upper level err_mask */
1170 qc->err_mask |= ehc->i.err_mask;
1173 action |= ata_eh_analyze_tf(qc, &qc->result_tf);
1175 /* DEV errors are probably spurious in case of ATA_BUS error */
1176 if (qc->err_mask & AC_ERR_ATA_BUS)
1177 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
1180 /* any real error trumps unknown error */
1181 if (qc->err_mask & ~AC_ERR_OTHER)
1182 qc->err_mask &= ~AC_ERR_OTHER;
1184 /* SENSE_VALID trumps dev/unknown error and revalidation */
1185 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
1186 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
1187 action &= ~ATA_EH_REVALIDATE;
1190 /* accumulate error info */
1191 failed_dev = qc->dev;
1192 all_err_mask |= qc->err_mask;
1193 if (qc->flags & ATA_QCFLAG_IO)
1197 /* speed down iff command was in progress */
1199 action |= ata_eh_speed_down(failed_dev, is_io, all_err_mask);
1201 /* enforce default EH actions */
1202 if (ap->flags & ATA_FLAG_FROZEN ||
1203 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
1204 action |= ATA_EH_SOFTRESET;
1205 else if (all_err_mask)
1206 action |= ATA_EH_REVALIDATE;
1208 /* record autopsy result */
1209 ehc->i.dev = failed_dev;
1210 ehc->i.action = action;
1216 * ata_eh_report - report error handling to user
1217 * @ap: ATA port EH is going on
1219 * Report EH to user.
1224 static void ata_eh_report(struct ata_port *ap)
1226 struct ata_eh_context *ehc = &ap->eh_context;
1227 const char *frozen, *desc;
1228 int tag, nr_failed = 0;
1231 if (ehc->i.desc[0] != '\0')
1234 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1235 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1237 if (!(qc->flags & ATA_QCFLAG_FAILED))
1239 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
1245 if (!nr_failed && !ehc->i.err_mask)
1249 if (ap->flags & ATA_FLAG_FROZEN)
1253 ata_dev_printk(ehc->i.dev, KERN_ERR, "exception Emask 0x%x "
1254 "SAct 0x%x SErr 0x%x action 0x%x%s\n",
1255 ehc->i.err_mask, ap->sactive, ehc->i.serror,
1256 ehc->i.action, frozen);
1258 ata_dev_printk(ehc->i.dev, KERN_ERR, "(%s)\n", desc);
1260 ata_port_printk(ap, KERN_ERR, "exception Emask 0x%x "
1261 "SAct 0x%x SErr 0x%x action 0x%x%s\n",
1262 ehc->i.err_mask, ap->sactive, ehc->i.serror,
1263 ehc->i.action, frozen);
1265 ata_port_printk(ap, KERN_ERR, "(%s)\n", desc);
1268 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1269 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1271 if (!(qc->flags & ATA_QCFLAG_FAILED) || !qc->err_mask)
1274 ata_dev_printk(qc->dev, KERN_ERR, "tag %d cmd 0x%x "
1275 "Emask 0x%x stat 0x%x err 0x%x (%s)\n",
1276 qc->tag, qc->tf.command, qc->err_mask,
1277 qc->result_tf.command, qc->result_tf.feature,
1278 ata_err_string(qc->err_mask));
1282 static int ata_eh_reset(struct ata_port *ap, ata_reset_fn_t softreset,
1283 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
1285 struct ata_eh_context *ehc = &ap->eh_context;
1286 unsigned int classes[ATA_MAX_DEVICES];
1287 int tries = ATA_EH_RESET_TRIES;
1288 ata_reset_fn_t reset;
1291 if (softreset && (!hardreset || (!sata_set_spd_needed(ap) &&
1292 !(ehc->i.action & ATA_EH_HARDRESET))))
1298 ata_port_printk(ap, KERN_INFO, "%s resetting port\n",
1299 reset == softreset ? "soft" : "hard");
1302 ata_eh_about_to_do(ap, ATA_EH_RESET_MASK);
1303 ehc->i.flags |= ATA_EHI_DID_RESET;
1305 rc = ata_do_reset(ap, reset, classes);
1307 if (rc && --tries) {
1308 ata_port_printk(ap, KERN_WARNING,
1309 "%sreset failed, retrying in 5 secs\n",
1310 reset == softreset ? "soft" : "hard");
1313 if (reset == hardreset)
1314 sata_down_spd_limit(ap);
1322 postreset(ap, classes);
1324 /* reset successful, schedule revalidation */
1326 ehc->i.action &= ~ATA_EH_RESET_MASK;
1327 ehc->i.action |= ATA_EH_REVALIDATE;
1333 static int ata_eh_revalidate(struct ata_port *ap,
1334 struct ata_device **r_failed_dev)
1336 struct ata_eh_context *ehc = &ap->eh_context;
1337 struct ata_device *dev;
1342 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1343 dev = &ap->device[i];
1345 if (ehc->i.action & ATA_EH_REVALIDATE && ata_dev_enabled(dev) &&
1346 (!ehc->i.dev || ehc->i.dev == dev)) {
1347 if (ata_port_offline(ap)) {
1352 ata_eh_about_to_do(ap, ATA_EH_REVALIDATE);
1353 rc = ata_dev_revalidate(dev,
1354 ehc->i.flags & ATA_EHI_DID_RESET);
1358 ehc->i.action &= ~ATA_EH_REVALIDATE;
1363 *r_failed_dev = dev;
1369 static int ata_port_nr_enabled(struct ata_port *ap)
1373 for (i = 0; i < ATA_MAX_DEVICES; i++)
1374 if (ata_dev_enabled(&ap->device[i]))
1380 * ata_eh_recover - recover host port after error
1381 * @ap: host port to recover
1382 * @softreset: softreset method (can be NULL)
1383 * @hardreset: hardreset method (can be NULL)
1384 * @postreset: postreset method (can be NULL)
1386 * This is the alpha and omega, eum and yang, heart and soul of
1387 * libata exception handling. On entry, actions required to
1388 * recover each devices are recorded in eh_context. This
1389 * function executes all the operations with appropriate retrials
1390 * and fallbacks to resurrect failed devices.
1393 * Kernel thread context (may sleep).
1396 * 0 on success, -errno on failure.
1398 static int ata_eh_recover(struct ata_port *ap, ata_reset_fn_t softreset,
1399 ata_reset_fn_t hardreset,
1400 ata_postreset_fn_t postreset)
1402 struct ata_eh_context *ehc = &ap->eh_context;
1403 struct ata_device *dev;
1404 int down_xfermask, i, rc;
1408 /* prep for recovery */
1409 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1410 dev = &ap->device[i];
1412 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
1419 /* skip EH if possible. */
1420 if (!ata_port_nr_enabled(ap) && !(ap->flags & ATA_FLAG_FROZEN))
1424 if (ehc->i.action & ATA_EH_RESET_MASK) {
1425 ata_eh_freeze_port(ap);
1427 rc = ata_eh_reset(ap, softreset, hardreset, postreset);
1429 ata_port_printk(ap, KERN_ERR,
1430 "reset failed, giving up\n");
1434 ata_eh_thaw_port(ap);
1437 /* revalidate existing devices */
1438 rc = ata_eh_revalidate(ap, &dev);
1442 /* configure transfer mode if the port has been reset */
1443 if (ehc->i.flags & ATA_EHI_DID_RESET) {
1444 rc = ata_set_mode(ap, &dev);
1457 ehc->tries[dev->devno] = 0;
1460 sata_down_spd_limit(ap);
1462 ehc->tries[dev->devno]--;
1463 if (down_xfermask &&
1464 ata_down_xfermask_limit(dev, ehc->tries[dev->devno] == 1))
1465 ehc->tries[dev->devno] = 0;
1468 /* disable device if it has used up all its chances */
1469 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno])
1470 ata_dev_disable(dev);
1472 /* soft didn't work? be haaaaard */
1473 if (ehc->i.flags & ATA_EHI_DID_RESET)
1474 ehc->i.action |= ATA_EH_HARDRESET;
1476 ehc->i.action |= ATA_EH_SOFTRESET;
1478 if (ata_port_nr_enabled(ap)) {
1479 ata_port_printk(ap, KERN_WARNING, "failed to recover some "
1480 "devices, retrying in 5 secs\n");
1483 /* no device left, repeat fast */
1491 for (i = 0; i < ATA_MAX_DEVICES; i++)
1492 ata_dev_disable(&ap->device[i]);
1495 DPRINTK("EXIT, rc=%d\n", rc);
1500 * ata_eh_finish - finish up EH
1501 * @ap: host port to finish EH for
1503 * Recovery is complete. Clean up EH states and retry or finish
1509 static void ata_eh_finish(struct ata_port *ap)
1513 /* retry or finish qcs */
1514 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1515 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
1517 if (!(qc->flags & ATA_QCFLAG_FAILED))
1521 /* FIXME: Once EH migration is complete,
1522 * generate sense data in this function,
1523 * considering both err_mask and tf.
1525 if (qc->err_mask & AC_ERR_INVALID)
1526 ata_eh_qc_complete(qc);
1528 ata_eh_qc_retry(qc);
1530 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
1531 ata_eh_qc_complete(qc);
1533 /* feed zero TF to sense generation */
1534 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
1535 ata_eh_qc_retry(qc);
1542 * ata_do_eh - do standard error handling
1543 * @ap: host port to handle error for
1544 * @softreset: softreset method (can be NULL)
1545 * @hardreset: hardreset method (can be NULL)
1546 * @postreset: postreset method (can be NULL)
1548 * Perform standard error handling sequence.
1551 * Kernel thread context (may sleep).
1553 void ata_do_eh(struct ata_port *ap, ata_reset_fn_t softreset,
1554 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
1558 ata_eh_recover(ap, softreset, hardreset, postreset);