[SCSI] cxgb3i: subscribe to error notification from cxgb3 driver
[linux-2.6] / drivers / ide / ide-eh.c
1
2 #include <linux/kernel.h>
3 #include <linux/ide.h>
4 #include <linux/delay.h>
5
6 static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq,
7                                      u8 stat, u8 err)
8 {
9         ide_hwif_t *hwif = drive->hwif;
10
11         if ((stat & ATA_BUSY) ||
12             ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
13                 /* other bits are useless when BUSY */
14                 rq->errors |= ERROR_RESET;
15         } else if (stat & ATA_ERR) {
16                 /* err has different meaning on cdrom and tape */
17                 if (err == ATA_ABORTED) {
18                         if ((drive->dev_flags & IDE_DFLAG_LBA) &&
19                             /* some newer drives don't support ATA_CMD_INIT_DEV_PARAMS */
20                             hwif->tp_ops->read_status(hwif) == ATA_CMD_INIT_DEV_PARAMS)
21                                 return ide_stopped;
22                 } else if ((err & BAD_CRC) == BAD_CRC) {
23                         /* UDMA crc error, just retry the operation */
24                         drive->crc_count++;
25                 } else if (err & (ATA_BBK | ATA_UNC)) {
26                         /* retries won't help these */
27                         rq->errors = ERROR_MAX;
28                 } else if (err & ATA_TRK0NF) {
29                         /* help it find track zero */
30                         rq->errors |= ERROR_RECAL;
31                 }
32         }
33
34         if ((stat & ATA_DRQ) && rq_data_dir(rq) == READ &&
35             (hwif->host_flags & IDE_HFLAG_ERROR_STOPS_FIFO) == 0) {
36                 int nsect = drive->mult_count ? drive->mult_count : 1;
37
38                 ide_pad_transfer(drive, READ, nsect * SECTOR_SIZE);
39         }
40
41         if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) {
42                 ide_kill_rq(drive, rq);
43                 return ide_stopped;
44         }
45
46         if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
47                 rq->errors |= ERROR_RESET;
48
49         if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
50                 ++rq->errors;
51                 return ide_do_reset(drive);
52         }
53
54         if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
55                 drive->special.b.recalibrate = 1;
56
57         ++rq->errors;
58
59         return ide_stopped;
60 }
61
62 static ide_startstop_t ide_atapi_error(ide_drive_t *drive, struct request *rq,
63                                        u8 stat, u8 err)
64 {
65         ide_hwif_t *hwif = drive->hwif;
66
67         if ((stat & ATA_BUSY) ||
68             ((stat & ATA_DF) && (drive->dev_flags & IDE_DFLAG_NOWERR) == 0)) {
69                 /* other bits are useless when BUSY */
70                 rq->errors |= ERROR_RESET;
71         } else {
72                 /* add decoding error stuff */
73         }
74
75         if (hwif->tp_ops->read_status(hwif) & (ATA_BUSY | ATA_DRQ))
76                 /* force an abort */
77                 hwif->tp_ops->exec_command(hwif, ATA_CMD_IDLEIMMEDIATE);
78
79         if (rq->errors >= ERROR_MAX) {
80                 ide_kill_rq(drive, rq);
81         } else {
82                 if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
83                         ++rq->errors;
84                         return ide_do_reset(drive);
85                 }
86                 ++rq->errors;
87         }
88
89         return ide_stopped;
90 }
91
92 static ide_startstop_t __ide_error(ide_drive_t *drive, struct request *rq,
93                                    u8 stat, u8 err)
94 {
95         if (drive->media == ide_disk)
96                 return ide_ata_error(drive, rq, stat, err);
97         return ide_atapi_error(drive, rq, stat, err);
98 }
99
100 /**
101  *      ide_error       -       handle an error on the IDE
102  *      @drive: drive the error occurred on
103  *      @msg: message to report
104  *      @stat: status bits
105  *
106  *      ide_error() takes action based on the error returned by the drive.
107  *      For normal I/O that may well include retries. We deal with
108  *      both new-style (taskfile) and old style command handling here.
109  *      In the case of taskfile command handling there is work left to
110  *      do
111  */
112
113 ide_startstop_t ide_error(ide_drive_t *drive, const char *msg, u8 stat)
114 {
115         struct request *rq;
116         u8 err;
117
118         err = ide_dump_status(drive, msg, stat);
119
120         rq = drive->hwif->rq;
121         if (rq == NULL)
122                 return ide_stopped;
123
124         /* retry only "normal" I/O: */
125         if (!blk_fs_request(rq)) {
126                 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
127                         struct ide_cmd *cmd = rq->special;
128
129                         if (cmd)
130                                 ide_complete_cmd(drive, cmd, stat, err);
131                 } else if (blk_pm_request(rq)) {
132                         rq->errors = 1;
133                         ide_complete_pm_rq(drive, rq);
134                         return ide_stopped;
135                 }
136                 rq->errors = err;
137                 ide_complete_rq(drive, err ? -EIO : 0, blk_rq_bytes(rq));
138                 return ide_stopped;
139         }
140
141         return __ide_error(drive, rq, stat, err);
142 }
143 EXPORT_SYMBOL_GPL(ide_error);
144
145 static inline void ide_complete_drive_reset(ide_drive_t *drive, int err)
146 {
147         struct request *rq = drive->hwif->rq;
148
149         if (rq && blk_special_request(rq) && rq->cmd[0] == REQ_DRIVE_RESET) {
150                 if (err <= 0 && rq->errors == 0)
151                         rq->errors = -EIO;
152                 ide_complete_rq(drive, err ? err : 0, ide_rq_bytes(rq));
153         }
154 }
155
156 /* needed below */
157 static ide_startstop_t do_reset1(ide_drive_t *, int);
158
159 /*
160  * atapi_reset_pollfunc() gets invoked to poll the interface for completion
161  * every 50ms during an atapi drive reset operation.  If the drive has not yet
162  * responded, and we have not yet hit our maximum waiting time, then the timer
163  * is restarted for another 50ms.
164  */
165 static ide_startstop_t atapi_reset_pollfunc(ide_drive_t *drive)
166 {
167         ide_hwif_t *hwif = drive->hwif;
168         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
169         u8 stat;
170
171         tp_ops->dev_select(drive);
172         udelay(10);
173         stat = tp_ops->read_status(hwif);
174
175         if (OK_STAT(stat, 0, ATA_BUSY))
176                 printk(KERN_INFO "%s: ATAPI reset complete\n", drive->name);
177         else {
178                 if (time_before(jiffies, hwif->poll_timeout)) {
179                         ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20);
180                         /* continue polling */
181                         return ide_started;
182                 }
183                 /* end of polling */
184                 hwif->polling = 0;
185                 printk(KERN_ERR "%s: ATAPI reset timed-out, status=0x%02x\n",
186                         drive->name, stat);
187                 /* do it the old fashioned way */
188                 return do_reset1(drive, 1);
189         }
190         /* done polling */
191         hwif->polling = 0;
192         ide_complete_drive_reset(drive, 0);
193         return ide_stopped;
194 }
195
196 static void ide_reset_report_error(ide_hwif_t *hwif, u8 err)
197 {
198         static const char *err_master_vals[] =
199                 { NULL, "passed", "formatter device error",
200                   "sector buffer error", "ECC circuitry error",
201                   "controlling MPU error" };
202
203         u8 err_master = err & 0x7f;
204
205         printk(KERN_ERR "%s: reset: master: ", hwif->name);
206         if (err_master && err_master < 6)
207                 printk(KERN_CONT "%s", err_master_vals[err_master]);
208         else
209                 printk(KERN_CONT "error (0x%02x?)", err);
210         if (err & 0x80)
211                 printk(KERN_CONT "; slave: failed");
212         printk(KERN_CONT "\n");
213 }
214
215 /*
216  * reset_pollfunc() gets invoked to poll the interface for completion every 50ms
217  * during an ide reset operation. If the drives have not yet responded,
218  * and we have not yet hit our maximum waiting time, then the timer is restarted
219  * for another 50ms.
220  */
221 static ide_startstop_t reset_pollfunc(ide_drive_t *drive)
222 {
223         ide_hwif_t *hwif = drive->hwif;
224         const struct ide_port_ops *port_ops = hwif->port_ops;
225         u8 tmp;
226         int err = 0;
227
228         if (port_ops && port_ops->reset_poll) {
229                 err = port_ops->reset_poll(drive);
230                 if (err) {
231                         printk(KERN_ERR "%s: host reset_poll failure for %s.\n",
232                                 hwif->name, drive->name);
233                         goto out;
234                 }
235         }
236
237         tmp = hwif->tp_ops->read_status(hwif);
238
239         if (!OK_STAT(tmp, 0, ATA_BUSY)) {
240                 if (time_before(jiffies, hwif->poll_timeout)) {
241                         ide_set_handler(drive, &reset_pollfunc, HZ/20);
242                         /* continue polling */
243                         return ide_started;
244                 }
245                 printk(KERN_ERR "%s: reset timed-out, status=0x%02x\n",
246                         hwif->name, tmp);
247                 drive->failures++;
248                 err = -EIO;
249         } else  {
250                 tmp = ide_read_error(drive);
251
252                 if (tmp == 1) {
253                         printk(KERN_INFO "%s: reset: success\n", hwif->name);
254                         drive->failures = 0;
255                 } else {
256                         ide_reset_report_error(hwif, tmp);
257                         drive->failures++;
258                         err = -EIO;
259                 }
260         }
261 out:
262         hwif->polling = 0;      /* done polling */
263         ide_complete_drive_reset(drive, err);
264         return ide_stopped;
265 }
266
267 static void ide_disk_pre_reset(ide_drive_t *drive)
268 {
269         int legacy = (drive->id[ATA_ID_CFS_ENABLE_2] & 0x0400) ? 0 : 1;
270
271         drive->special.all = 0;
272         drive->special.b.set_geometry = legacy;
273         drive->special.b.recalibrate  = legacy;
274
275         drive->mult_count = 0;
276         drive->dev_flags &= ~IDE_DFLAG_PARKED;
277
278         if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0 &&
279             (drive->dev_flags & IDE_DFLAG_USING_DMA) == 0)
280                 drive->mult_req = 0;
281
282         if (drive->mult_req != drive->mult_count)
283                 drive->special.b.set_multmode = 1;
284 }
285
286 static void pre_reset(ide_drive_t *drive)
287 {
288         const struct ide_port_ops *port_ops = drive->hwif->port_ops;
289
290         if (drive->media == ide_disk)
291                 ide_disk_pre_reset(drive);
292         else
293                 drive->dev_flags |= IDE_DFLAG_POST_RESET;
294
295         if (drive->dev_flags & IDE_DFLAG_USING_DMA) {
296                 if (drive->crc_count)
297                         ide_check_dma_crc(drive);
298                 else
299                         ide_dma_off(drive);
300         }
301
302         if ((drive->dev_flags & IDE_DFLAG_KEEP_SETTINGS) == 0) {
303                 if ((drive->dev_flags & IDE_DFLAG_USING_DMA) == 0) {
304                         drive->dev_flags &= ~IDE_DFLAG_UNMASK;
305                         drive->io_32bit = 0;
306                 }
307                 return;
308         }
309
310         if (port_ops && port_ops->pre_reset)
311                 port_ops->pre_reset(drive);
312
313         if (drive->current_speed != 0xff)
314                 drive->desired_speed = drive->current_speed;
315         drive->current_speed = 0xff;
316 }
317
318 /*
319  * do_reset1() attempts to recover a confused drive by resetting it.
320  * Unfortunately, resetting a disk drive actually resets all devices on
321  * the same interface, so it can really be thought of as resetting the
322  * interface rather than resetting the drive.
323  *
324  * ATAPI devices have their own reset mechanism which allows them to be
325  * individually reset without clobbering other devices on the same interface.
326  *
327  * Unfortunately, the IDE interface does not generate an interrupt to let
328  * us know when the reset operation has finished, so we must poll for this.
329  * Equally poor, though, is the fact that this may a very long time to complete,
330  * (up to 30 seconds worstcase).  So, instead of busy-waiting here for it,
331  * we set a timer to poll at 50ms intervals.
332  */
333 static ide_startstop_t do_reset1(ide_drive_t *drive, int do_not_try_atapi)
334 {
335         ide_hwif_t *hwif = drive->hwif;
336         struct ide_io_ports *io_ports = &hwif->io_ports;
337         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
338         const struct ide_port_ops *port_ops;
339         ide_drive_t *tdrive;
340         unsigned long flags, timeout;
341         int i;
342         DEFINE_WAIT(wait);
343
344         spin_lock_irqsave(&hwif->lock, flags);
345
346         /* We must not reset with running handlers */
347         BUG_ON(hwif->handler != NULL);
348
349         /* For an ATAPI device, first try an ATAPI SRST. */
350         if (drive->media != ide_disk && !do_not_try_atapi) {
351                 pre_reset(drive);
352                 tp_ops->dev_select(drive);
353                 udelay(20);
354                 tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
355                 ndelay(400);
356                 hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
357                 hwif->polling = 1;
358                 __ide_set_handler(drive, &atapi_reset_pollfunc, HZ/20);
359                 spin_unlock_irqrestore(&hwif->lock, flags);
360                 return ide_started;
361         }
362
363         /* We must not disturb devices in the IDE_DFLAG_PARKED state. */
364         do {
365                 unsigned long now;
366
367                 prepare_to_wait(&ide_park_wq, &wait, TASK_UNINTERRUPTIBLE);
368                 timeout = jiffies;
369                 ide_port_for_each_present_dev(i, tdrive, hwif) {
370                         if ((tdrive->dev_flags & IDE_DFLAG_PARKED) &&
371                             time_after(tdrive->sleep, timeout))
372                                 timeout = tdrive->sleep;
373                 }
374
375                 now = jiffies;
376                 if (time_before_eq(timeout, now))
377                         break;
378
379                 spin_unlock_irqrestore(&hwif->lock, flags);
380                 timeout = schedule_timeout_uninterruptible(timeout - now);
381                 spin_lock_irqsave(&hwif->lock, flags);
382         } while (timeout);
383         finish_wait(&ide_park_wq, &wait);
384
385         /*
386          * First, reset any device state data we were maintaining
387          * for any of the drives on this interface.
388          */
389         ide_port_for_each_dev(i, tdrive, hwif)
390                 pre_reset(tdrive);
391
392         if (io_ports->ctl_addr == 0) {
393                 spin_unlock_irqrestore(&hwif->lock, flags);
394                 ide_complete_drive_reset(drive, -ENXIO);
395                 return ide_stopped;
396         }
397
398         /*
399          * Note that we also set nIEN while resetting the device,
400          * to mask unwanted interrupts from the interface during the reset.
401          * However, due to the design of PC hardware, this will cause an
402          * immediate interrupt due to the edge transition it produces.
403          * This single interrupt gives us a "fast poll" for drives that
404          * recover from reset very quickly, saving us the first 50ms wait time.
405          */
406         /* set SRST and nIEN */
407         tp_ops->write_devctl(hwif, ATA_SRST | ATA_NIEN | ATA_DEVCTL_OBS);
408         /* more than enough time */
409         udelay(10);
410         /* clear SRST, leave nIEN (unless device is on the quirk list) */
411         tp_ops->write_devctl(hwif, (drive->quirk_list == 2 ? 0 : ATA_NIEN) |
412                              ATA_DEVCTL_OBS);
413         /* more than enough time */
414         udelay(10);
415         hwif->poll_timeout = jiffies + WAIT_WORSTCASE;
416         hwif->polling = 1;
417         __ide_set_handler(drive, &reset_pollfunc, HZ/20);
418
419         /*
420          * Some weird controller like resetting themselves to a strange
421          * state when the disks are reset this way. At least, the Winbond
422          * 553 documentation says that
423          */
424         port_ops = hwif->port_ops;
425         if (port_ops && port_ops->resetproc)
426                 port_ops->resetproc(drive);
427
428         spin_unlock_irqrestore(&hwif->lock, flags);
429         return ide_started;
430 }
431
432 /*
433  * ide_do_reset() is the entry point to the drive/interface reset code.
434  */
435
436 ide_startstop_t ide_do_reset(ide_drive_t *drive)
437 {
438         return do_reset1(drive, 0);
439 }
440 EXPORT_SYMBOL(ide_do_reset);