PM / Sleep: Add more wakeup source initialization routines
[linux-2.6.git] / drivers / ide / ide-iops.c
1 /*
2  *  Copyright (C) 2000-2002     Andre Hedrick <andre@linux-ide.org>
3  *  Copyright (C) 2003          Red Hat
4  *
5  */
6
7 #include <linux/module.h>
8 #include <linux/types.h>
9 #include <linux/string.h>
10 #include <linux/kernel.h>
11 #include <linux/timer.h>
12 #include <linux/mm.h>
13 #include <linux/interrupt.h>
14 #include <linux/major.h>
15 #include <linux/errno.h>
16 #include <linux/genhd.h>
17 #include <linux/blkpg.h>
18 #include <linux/slab.h>
19 #include <linux/pci.h>
20 #include <linux/delay.h>
21 #include <linux/ide.h>
22 #include <linux/bitops.h>
23 #include <linux/nmi.h>
24
25 #include <asm/byteorder.h>
26 #include <asm/irq.h>
27 #include <asm/uaccess.h>
28 #include <asm/io.h>
29
30 void SELECT_MASK(ide_drive_t *drive, int mask)
31 {
32         const struct ide_port_ops *port_ops = drive->hwif->port_ops;
33
34         if (port_ops && port_ops->maskproc)
35                 port_ops->maskproc(drive, mask);
36 }
37
38 u8 ide_read_error(ide_drive_t *drive)
39 {
40         struct ide_taskfile tf;
41
42         drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
43
44         return tf.error;
45 }
46 EXPORT_SYMBOL_GPL(ide_read_error);
47
48 void ide_fix_driveid(u16 *id)
49 {
50 #ifndef __LITTLE_ENDIAN
51 # ifdef __BIG_ENDIAN
52         int i;
53
54         for (i = 0; i < 256; i++)
55                 id[i] = __le16_to_cpu(id[i]);
56 # else
57 #  error "Please fix <asm/byteorder.h>"
58 # endif
59 #endif
60 }
61
62 /*
63  * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
64  * removing leading/trailing blanks and compressing internal blanks.
65  * It is primarily used to tidy up the model name/number fields as
66  * returned by the ATA_CMD_ID_ATA[PI] commands.
67  */
68
69 void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
70 {
71         u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
72
73         if (byteswap) {
74                 /* convert from big-endian to host byte order */
75                 for (p = s ; p != end ; p += 2)
76                         be16_to_cpus((u16 *) p);
77         }
78
79         /* strip leading blanks */
80         p = s;
81         while (s != end && *s == ' ')
82                 ++s;
83         /* compress internal blanks and strip trailing blanks */
84         while (s != end && *s) {
85                 if (*s++ != ' ' || (s != end && *s && *s != ' '))
86                         *p++ = *(s-1);
87         }
88         /* wipe out trailing garbage */
89         while (p != end)
90                 *p++ = '\0';
91 }
92 EXPORT_SYMBOL(ide_fixstring);
93
94 /*
95  * This routine busy-waits for the drive status to be not "busy".
96  * It then checks the status for all of the "good" bits and none
97  * of the "bad" bits, and if all is okay it returns 0.  All other
98  * cases return error -- caller may then invoke ide_error().
99  *
100  * This routine should get fixed to not hog the cpu during extra long waits..
101  * That could be done by busy-waiting for the first jiffy or two, and then
102  * setting a timer to wake up at half second intervals thereafter,
103  * until timeout is achieved, before timing out.
104  */
105 int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
106                     unsigned long timeout, u8 *rstat)
107 {
108         ide_hwif_t *hwif = drive->hwif;
109         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
110         unsigned long flags;
111         int i;
112         u8 stat;
113
114         udelay(1);      /* spec allows drive 400ns to assert "BUSY" */
115         stat = tp_ops->read_status(hwif);
116
117         if (stat & ATA_BUSY) {
118                 local_save_flags(flags);
119                 local_irq_enable_in_hardirq();
120                 timeout += jiffies;
121                 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
122                         if (time_after(jiffies, timeout)) {
123                                 /*
124                                  * One last read after the timeout in case
125                                  * heavy interrupt load made us not make any
126                                  * progress during the timeout..
127                                  */
128                                 stat = tp_ops->read_status(hwif);
129                                 if ((stat & ATA_BUSY) == 0)
130                                         break;
131
132                                 local_irq_restore(flags);
133                                 *rstat = stat;
134                                 return -EBUSY;
135                         }
136                 }
137                 local_irq_restore(flags);
138         }
139         /*
140          * Allow status to settle, then read it again.
141          * A few rare drives vastly violate the 400ns spec here,
142          * so we'll wait up to 10usec for a "good" status
143          * rather than expensively fail things immediately.
144          * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
145          */
146         for (i = 0; i < 10; i++) {
147                 udelay(1);
148                 stat = tp_ops->read_status(hwif);
149
150                 if (OK_STAT(stat, good, bad)) {
151                         *rstat = stat;
152                         return 0;
153                 }
154         }
155         *rstat = stat;
156         return -EFAULT;
157 }
158
159 /*
160  * In case of error returns error value after doing "*startstop = ide_error()".
161  * The caller should return the updated value of "startstop" in this case,
162  * "startstop" is unchanged when the function returns 0.
163  */
164 int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
165                   u8 bad, unsigned long timeout)
166 {
167         int err;
168         u8 stat;
169
170         /* bail early if we've exceeded max_failures */
171         if (drive->max_failures && (drive->failures > drive->max_failures)) {
172                 *startstop = ide_stopped;
173                 return 1;
174         }
175
176         err = __ide_wait_stat(drive, good, bad, timeout, &stat);
177
178         if (err) {
179                 char *s = (err == -EBUSY) ? "status timeout" : "status error";
180                 *startstop = ide_error(drive, s, stat);
181         }
182
183         return err;
184 }
185 EXPORT_SYMBOL(ide_wait_stat);
186
187 /**
188  *      ide_in_drive_list       -       look for drive in black/white list
189  *      @id: drive identifier
190  *      @table: list to inspect
191  *
192  *      Look for a drive in the blacklist and the whitelist tables
193  *      Returns 1 if the drive is found in the table.
194  */
195
196 int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
197 {
198         for ( ; table->id_model; table++)
199                 if ((!strcmp(table->id_model, (char *)&id[ATA_ID_PROD])) &&
200                     (!table->id_firmware ||
201                      strstr((char *)&id[ATA_ID_FW_REV], table->id_firmware)))
202                         return 1;
203         return 0;
204 }
205 EXPORT_SYMBOL_GPL(ide_in_drive_list);
206
207 /*
208  * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
209  * Some optical devices with the buggy firmwares have the same problem.
210  */
211 static const struct drive_list_entry ivb_list[] = {
212         { "QUANTUM FIREBALLlct10 05"    , "A03.0900"    },
213         { "QUANTUM FIREBALLlct20 30"    , "APL.0900"    },
214         { "TSSTcorp CDDVDW SH-S202J"    , "SB00"        },
215         { "TSSTcorp CDDVDW SH-S202J"    , "SB01"        },
216         { "TSSTcorp CDDVDW SH-S202N"    , "SB00"        },
217         { "TSSTcorp CDDVDW SH-S202N"    , "SB01"        },
218         { "TSSTcorp CDDVDW SH-S202H"    , "SB00"        },
219         { "TSSTcorp CDDVDW SH-S202H"    , "SB01"        },
220         { "SAMSUNG SP0822N"             , "WA100-10"    },
221         { NULL                          , NULL          }
222 };
223
224 /*
225  *  All hosts that use the 80c ribbon must use!
226  *  The name is derived from upper byte of word 93 and the 80c ribbon.
227  */
228 u8 eighty_ninty_three(ide_drive_t *drive)
229 {
230         ide_hwif_t *hwif = drive->hwif;
231         u16 *id = drive->id;
232         int ivb = ide_in_drive_list(id, ivb_list);
233
234         if (hwif->cbl == ATA_CBL_SATA || hwif->cbl == ATA_CBL_PATA40_SHORT)
235                 return 1;
236
237         if (ivb)
238                 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
239                                   drive->name);
240
241         if (ata_id_is_sata(id) && !ivb)
242                 return 1;
243
244         if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
245                 goto no_80w;
246
247         /*
248          * FIXME:
249          * - change master/slave IDENTIFY order
250          * - force bit13 (80c cable present) check also for !ivb devices
251          *   (unless the slave device is pre-ATA3)
252          */
253         if (id[ATA_ID_HW_CONFIG] & 0x4000)
254                 return 1;
255
256         if (ivb) {
257                 const char *model = (char *)&id[ATA_ID_PROD];
258
259                 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
260                         /*
261                          * These ATAPI devices always report 80c cable
262                          * so we have to depend on the host in this case.
263                          */
264                         if (hwif->cbl == ATA_CBL_PATA80)
265                                 return 1;
266                 } else {
267                         /* Depend on the device side cable detection. */
268                         if (id[ATA_ID_HW_CONFIG] & 0x2000)
269                                 return 1;
270                 }
271         }
272 no_80w:
273         if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
274                 return 0;
275
276         printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
277                             "limiting max speed to UDMA33\n",
278                             drive->name,
279                             hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
280
281         drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
282
283         return 0;
284 }
285
286 static const char *nien_quirk_list[] = {
287         "QUANTUM FIREBALLlct08 08",
288         "QUANTUM FIREBALLP KA6.4",
289         "QUANTUM FIREBALLP KA9.1",
290         "QUANTUM FIREBALLP KX13.6",
291         "QUANTUM FIREBALLP KX20.5",
292         "QUANTUM FIREBALLP KX27.3",
293         "QUANTUM FIREBALLP LM20.4",
294         "QUANTUM FIREBALLP LM20.5",
295         "FUJITSU MHZ2160BH G2",
296         NULL
297 };
298
299 void ide_check_nien_quirk_list(ide_drive_t *drive)
300 {
301         const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
302
303         for (list = nien_quirk_list; *list != NULL; list++)
304                 if (strstr(m, *list) != NULL) {
305                         drive->dev_flags |= IDE_DFLAG_NIEN_QUIRK;
306                         return;
307                 }
308 }
309
310 int ide_driveid_update(ide_drive_t *drive)
311 {
312         u16 *id;
313         int rc;
314
315         id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
316         if (id == NULL)
317                 return 0;
318
319         SELECT_MASK(drive, 1);
320         rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id, 1);
321         SELECT_MASK(drive, 0);
322
323         if (rc)
324                 goto out_err;
325
326         drive->id[ATA_ID_UDMA_MODES]  = id[ATA_ID_UDMA_MODES];
327         drive->id[ATA_ID_MWDMA_MODES] = id[ATA_ID_MWDMA_MODES];
328         drive->id[ATA_ID_SWDMA_MODES] = id[ATA_ID_SWDMA_MODES];
329         drive->id[ATA_ID_CFA_MODES]   = id[ATA_ID_CFA_MODES];
330         /* anything more ? */
331
332         kfree(id);
333
334         return 1;
335 out_err:
336         if (rc == 2)
337                 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
338         kfree(id);
339         return 0;
340 }
341
342 int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
343 {
344         ide_hwif_t *hwif = drive->hwif;
345         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
346         struct ide_taskfile tf;
347         u16 *id = drive->id, i;
348         int error = 0;
349         u8 stat;
350
351 #ifdef CONFIG_BLK_DEV_IDEDMA
352         if (hwif->dma_ops)      /* check if host supports DMA */
353                 hwif->dma_ops->dma_host_set(drive, 0);
354 #endif
355
356         /* Skip setting PIO flow-control modes on pre-EIDE drives */
357         if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
358                 goto skip;
359
360         /*
361          * Don't use ide_wait_cmd here - it will
362          * attempt to set_geometry and recalibrate,
363          * but for some reason these don't work at
364          * this point (lost interrupt).
365          */
366
367         udelay(1);
368         tp_ops->dev_select(drive);
369         SELECT_MASK(drive, 1);
370         udelay(1);
371         tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
372
373         memset(&tf, 0, sizeof(tf));
374         tf.feature = SETFEATURES_XFER;
375         tf.nsect   = speed;
376
377         tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
378
379         tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
380
381         if (drive->dev_flags & IDE_DFLAG_NIEN_QUIRK)
382                 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
383
384         error = __ide_wait_stat(drive, drive->ready_stat,
385                                 ATA_BUSY | ATA_DRQ | ATA_ERR,
386                                 WAIT_CMD, &stat);
387
388         SELECT_MASK(drive, 0);
389
390         if (error) {
391                 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
392                 return error;
393         }
394
395         if (speed >= XFER_SW_DMA_0) {
396                 id[ATA_ID_UDMA_MODES]  &= ~0xFF00;
397                 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
398                 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
399                 if (ata_id_is_cfa(id))
400                         id[ATA_ID_CFA_MODES] &= ~0x0E00;
401         } else  if (ata_id_is_cfa(id))
402                 id[ATA_ID_CFA_MODES] &= ~0x01C0;
403
404  skip:
405 #ifdef CONFIG_BLK_DEV_IDEDMA
406         if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
407                 hwif->dma_ops->dma_host_set(drive, 1);
408         else if (hwif->dma_ops) /* check if host supports DMA */
409                 ide_dma_off_quietly(drive);
410 #endif
411
412         if (speed >= XFER_UDMA_0) {
413                 i = 1 << (speed - XFER_UDMA_0);
414                 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
415         } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
416                 i = speed - XFER_MW_DMA_2;
417                 id[ATA_ID_CFA_MODES] |= i << 9;
418         } else if (speed >= XFER_MW_DMA_0) {
419                 i = 1 << (speed - XFER_MW_DMA_0);
420                 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
421         } else if (speed >= XFER_SW_DMA_0) {
422                 i = 1 << (speed - XFER_SW_DMA_0);
423                 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
424         } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
425                 i = speed - XFER_PIO_4;
426                 id[ATA_ID_CFA_MODES] |= i << 6;
427         }
428
429         if (!drive->init_speed)
430                 drive->init_speed = speed;
431         drive->current_speed = speed;
432         return error;
433 }
434
435 /*
436  * This should get invoked any time we exit the driver to
437  * wait for an interrupt response from a drive.  handler() points
438  * at the appropriate code to handle the next interrupt, and a
439  * timer is started to prevent us from waiting forever in case
440  * something goes wrong (see the ide_timer_expiry() handler later on).
441  *
442  * See also ide_execute_command
443  */
444 void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
445                        unsigned int timeout)
446 {
447         ide_hwif_t *hwif = drive->hwif;
448
449         BUG_ON(hwif->handler);
450         hwif->handler           = handler;
451         hwif->timer.expires     = jiffies + timeout;
452         hwif->req_gen_timer     = hwif->req_gen;
453         add_timer(&hwif->timer);
454 }
455
456 void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
457                      unsigned int timeout)
458 {
459         ide_hwif_t *hwif = drive->hwif;
460         unsigned long flags;
461
462         spin_lock_irqsave(&hwif->lock, flags);
463         __ide_set_handler(drive, handler, timeout);
464         spin_unlock_irqrestore(&hwif->lock, flags);
465 }
466 EXPORT_SYMBOL(ide_set_handler);
467
468 /**
469  *      ide_execute_command     -       execute an IDE command
470  *      @drive: IDE drive to issue the command against
471  *      @cmd: command
472  *      @handler: handler for next phase
473  *      @timeout: timeout for command
474  *
475  *      Helper function to issue an IDE command. This handles the
476  *      atomicity requirements, command timing and ensures that the
477  *      handler and IRQ setup do not race. All IDE command kick off
478  *      should go via this function or do equivalent locking.
479  */
480
481 void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
482                          ide_handler_t *handler, unsigned timeout)
483 {
484         ide_hwif_t *hwif = drive->hwif;
485         unsigned long flags;
486
487         spin_lock_irqsave(&hwif->lock, flags);
488         if ((cmd->protocol != ATAPI_PROT_DMA &&
489              cmd->protocol != ATAPI_PROT_PIO) ||
490             (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
491                 __ide_set_handler(drive, handler, timeout);
492         hwif->tp_ops->exec_command(hwif, cmd->tf.command);
493         /*
494          * Drive takes 400nS to respond, we must avoid the IRQ being
495          * serviced before that.
496          *
497          * FIXME: we could skip this delay with care on non shared devices
498          */
499         ndelay(400);
500         spin_unlock_irqrestore(&hwif->lock, flags);
501 }
502
503 /*
504  * ide_wait_not_busy() waits for the currently selected device on the hwif
505  * to report a non-busy status, see comments in ide_probe_port().
506  */
507 int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
508 {
509         u8 stat = 0;
510
511         while (timeout--) {
512                 /*
513                  * Turn this into a schedule() sleep once I'm sure
514                  * about locking issues (2.5 work ?).
515                  */
516                 mdelay(1);
517                 stat = hwif->tp_ops->read_status(hwif);
518                 if ((stat & ATA_BUSY) == 0)
519                         return 0;
520                 /*
521                  * Assume a value of 0xff means nothing is connected to
522                  * the interface and it doesn't implement the pull-down
523                  * resistor on D7.
524                  */
525                 if (stat == 0xff)
526                         return -ENODEV;
527                 touch_softlockup_watchdog();
528                 touch_nmi_watchdog();
529         }
530         return -EBUSY;
531 }