Merge branch 'upstream'
[linux-2.6.git] / drivers / scsi / libata-eh.c
1 /*
2  *  libata-eh.c - libata error handling
3  *
4  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
5  *                  Please ALWAYS copy linux-ide@vger.kernel.org
6  *                  on emails.
7  *
8  *  Copyright 2006 Tejun Heo <htejun@gmail.com>
9  *
10  *
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.
15  *
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.
20  *
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,
24  *  USA.
25  *
26  *
27  *  libata documentation is available via 'make {ps|pdf}docs',
28  *  as Documentation/DocBook/libata.*
29  *
30  *  Hardware documentation available from http://www.t13.org/ and
31  *  http://www.sata-io.org/
32  *
33  */
34
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>
42
43 #include <linux/libata.h>
44
45 #include "libata.h"
46
47 /**
48  *      ata_scsi_timed_out - SCSI layer time out callback
49  *      @cmd: timed out SCSI command
50  *
51  *      Handles SCSI layer timeout.  We race with normal completion of
52  *      the qc for @cmd.  If the qc is already gone, we lose and let
53  *      the scsi command finish (EH_HANDLED).  Otherwise, the qc has
54  *      timed out and EH should be invoked.  Prevent ata_qc_complete()
55  *      from finishing it by setting EH_SCHEDULED and return
56  *      EH_NOT_HANDLED.
57  *
58  *      LOCKING:
59  *      Called from timer context
60  *
61  *      RETURNS:
62  *      EH_HANDLED or EH_NOT_HANDLED
63  */
64 enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
65 {
66         struct Scsi_Host *host = cmd->device->host;
67         struct ata_port *ap = ata_shost_to_port(host);
68         unsigned long flags;
69         struct ata_queued_cmd *qc;
70         enum scsi_eh_timer_return ret = EH_HANDLED;
71
72         DPRINTK("ENTER\n");
73
74         spin_lock_irqsave(&ap->host_set->lock, flags);
75         qc = ata_qc_from_tag(ap, ap->active_tag);
76         if (qc) {
77                 WARN_ON(qc->scsicmd != cmd);
78                 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
79                 qc->err_mask |= AC_ERR_TIMEOUT;
80                 ret = EH_NOT_HANDLED;
81         }
82         spin_unlock_irqrestore(&ap->host_set->lock, flags);
83
84         DPRINTK("EXIT, ret=%d\n", ret);
85         return ret;
86 }
87
88 /**
89  *      ata_scsi_error - SCSI layer error handler callback
90  *      @host: SCSI host on which error occurred
91  *
92  *      Handles SCSI-layer-thrown error events.
93  *
94  *      LOCKING:
95  *      Inherited from SCSI layer (none, can sleep)
96  *
97  *      RETURNS:
98  *      Zero.
99  */
100 void ata_scsi_error(struct Scsi_Host *host)
101 {
102         struct ata_port *ap = ata_shost_to_port(host);
103
104         DPRINTK("ENTER\n");
105
106         /* synchronize with IRQ handler and port task */
107         spin_unlock_wait(&ap->host_set->lock);
108         ata_port_flush_task(ap);
109
110         WARN_ON(ata_qc_from_tag(ap, ap->active_tag) == NULL);
111
112         ap->ops->eng_timeout(ap);
113
114         WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
115
116         scsi_eh_flush_done_q(&ap->eh_done_q);
117
118         DPRINTK("EXIT\n");
119 }
120
121 /**
122  *      ata_qc_timeout - Handle timeout of queued command
123  *      @qc: Command that timed out
124  *
125  *      Some part of the kernel (currently, only the SCSI layer)
126  *      has noticed that the active command on port @ap has not
127  *      completed after a specified length of time.  Handle this
128  *      condition by disabling DMA (if necessary) and completing
129  *      transactions, with error if necessary.
130  *
131  *      This also handles the case of the "lost interrupt", where
132  *      for some reason (possibly hardware bug, possibly driver bug)
133  *      an interrupt was not delivered to the driver, even though the
134  *      transaction completed successfully.
135  *
136  *      LOCKING:
137  *      Inherited from SCSI layer (none, can sleep)
138  */
139 static void ata_qc_timeout(struct ata_queued_cmd *qc)
140 {
141         struct ata_port *ap = qc->ap;
142         struct ata_host_set *host_set = ap->host_set;
143         u8 host_stat = 0, drv_stat;
144         unsigned long flags;
145
146         DPRINTK("ENTER\n");
147
148         ap->hsm_task_state = HSM_ST_IDLE;
149
150         spin_lock_irqsave(&host_set->lock, flags);
151
152         switch (qc->tf.protocol) {
153
154         case ATA_PROT_DMA:
155         case ATA_PROT_ATAPI_DMA:
156                 host_stat = ap->ops->bmdma_status(ap);
157
158                 /* before we do anything else, clear DMA-Start bit */
159                 ap->ops->bmdma_stop(qc);
160
161                 /* fall through */
162
163         default:
164                 ata_altstatus(ap);
165                 drv_stat = ata_chk_status(ap);
166
167                 /* ack bmdma irq events */
168                 ap->ops->irq_clear(ap);
169
170                 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
171                        ap->id, qc->tf.command, drv_stat, host_stat);
172
173                 /* complete taskfile transaction */
174                 qc->err_mask |= AC_ERR_TIMEOUT;
175                 break;
176         }
177
178         spin_unlock_irqrestore(&host_set->lock, flags);
179
180         ata_eh_qc_complete(qc);
181
182         DPRINTK("EXIT\n");
183 }
184
185 /**
186  *      ata_eng_timeout - Handle timeout of queued command
187  *      @ap: Port on which timed-out command is active
188  *
189  *      Some part of the kernel (currently, only the SCSI layer)
190  *      has noticed that the active command on port @ap has not
191  *      completed after a specified length of time.  Handle this
192  *      condition by disabling DMA (if necessary) and completing
193  *      transactions, with error if necessary.
194  *
195  *      This also handles the case of the "lost interrupt", where
196  *      for some reason (possibly hardware bug, possibly driver bug)
197  *      an interrupt was not delivered to the driver, even though the
198  *      transaction completed successfully.
199  *
200  *      LOCKING:
201  *      Inherited from SCSI layer (none, can sleep)
202  */
203 void ata_eng_timeout(struct ata_port *ap)
204 {
205         DPRINTK("ENTER\n");
206
207         ata_qc_timeout(ata_qc_from_tag(ap, ap->active_tag));
208
209         DPRINTK("EXIT\n");
210 }
211
212 static void ata_eh_scsidone(struct scsi_cmnd *scmd)
213 {
214         /* nada */
215 }
216
217 static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
218 {
219         struct ata_port *ap = qc->ap;
220         struct scsi_cmnd *scmd = qc->scsicmd;
221         unsigned long flags;
222
223         spin_lock_irqsave(&ap->host_set->lock, flags);
224         qc->scsidone = ata_eh_scsidone;
225         __ata_qc_complete(qc);
226         WARN_ON(ata_tag_valid(qc->tag));
227         spin_unlock_irqrestore(&ap->host_set->lock, flags);
228
229         scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
230 }
231
232 /**
233  *      ata_eh_qc_complete - Complete an active ATA command from EH
234  *      @qc: Command to complete
235  *
236  *      Indicate to the mid and upper layers that an ATA command has
237  *      completed.  To be used from EH.
238  */
239 void ata_eh_qc_complete(struct ata_queued_cmd *qc)
240 {
241         struct scsi_cmnd *scmd = qc->scsicmd;
242         scmd->retries = scmd->allowed;
243         __ata_eh_qc_complete(qc);
244 }
245
246 /**
247  *      ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
248  *      @qc: Command to retry
249  *
250  *      Indicate to the mid and upper layers that an ATA command
251  *      should be retried.  To be used from EH.
252  *
253  *      SCSI midlayer limits the number of retries to scmd->allowed.
254  *      scmd->retries is decremented for commands which get retried
255  *      due to unrelated failures (qc->err_mask is zero).
256  */
257 void ata_eh_qc_retry(struct ata_queued_cmd *qc)
258 {
259         struct scsi_cmnd *scmd = qc->scsicmd;
260         if (!qc->err_mask && scmd->retries)
261                 scmd->retries--;
262         __ata_eh_qc_complete(qc);
263 }