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