2 * Copyright (C) 2000-2002 Andre Hedrick <andre@linux-ide.org>
3 * Copyright (C) 2003 Red Hat
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>
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>
25 #include <asm/byteorder.h>
27 #include <asm/uaccess.h>
30 void SELECT_MASK(ide_drive_t *drive, int mask)
32 const struct ide_port_ops *port_ops = drive->hwif->port_ops;
34 if (port_ops && port_ops->maskproc)
35 port_ops->maskproc(drive, mask);
38 u8 ide_read_error(ide_drive_t *drive)
40 struct ide_taskfile tf;
42 drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_ERROR);
46 EXPORT_SYMBOL_GPL(ide_read_error);
48 void ide_fix_driveid(u16 *id)
50 #ifndef __LITTLE_ENDIAN
54 for (i = 0; i < 256; i++)
55 id[i] = __le16_to_cpu(id[i]);
57 # error "Please fix <asm/byteorder.h>"
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.
69 void ide_fixstring(u8 *s, const int bytecount, const int byteswap)
71 u8 *p, *end = &s[bytecount & ~1]; /* bytecount must be even */
74 /* convert from big-endian to host byte order */
75 for (p = s ; p != end ; p += 2)
76 be16_to_cpus((u16 *) p);
79 /* strip leading blanks */
81 while (s != end && *s == ' ')
83 /* compress internal blanks and strip trailing blanks */
84 while (s != end && *s) {
85 if (*s++ != ' ' || (s != end && *s && *s != ' '))
88 /* wipe out trailing garbage */
92 EXPORT_SYMBOL(ide_fixstring);
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().
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.
105 static int __ide_wait_stat(ide_drive_t *drive, u8 good, u8 bad,
106 unsigned long timeout, u8 *rstat)
108 ide_hwif_t *hwif = drive->hwif;
109 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
114 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
115 stat = tp_ops->read_status(hwif);
117 if (stat & ATA_BUSY) {
118 local_save_flags(flags);
119 local_irq_enable_in_hardirq();
121 while ((stat = tp_ops->read_status(hwif)) & ATA_BUSY) {
122 if (time_after(jiffies, timeout)) {
124 * One last read after the timeout in case
125 * heavy interrupt load made us not make any
126 * progress during the timeout..
128 stat = tp_ops->read_status(hwif);
129 if ((stat & ATA_BUSY) == 0)
132 local_irq_restore(flags);
137 local_irq_restore(flags);
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.
146 for (i = 0; i < 10; i++) {
148 stat = tp_ops->read_status(hwif);
150 if (OK_STAT(stat, good, bad)) {
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.
164 int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, u8 good,
165 u8 bad, unsigned long timeout)
170 /* bail early if we've exceeded max_failures */
171 if (drive->max_failures && (drive->failures > drive->max_failures)) {
172 *startstop = ide_stopped;
176 err = __ide_wait_stat(drive, good, bad, timeout, &stat);
179 char *s = (err == -EBUSY) ? "status timeout" : "status error";
180 *startstop = ide_error(drive, s, stat);
185 EXPORT_SYMBOL(ide_wait_stat);
188 * ide_in_drive_list - look for drive in black/white list
189 * @id: drive identifier
190 * @table: list to inspect
192 * Look for a drive in the blacklist and the whitelist tables
193 * Returns 1 if the drive is found in the table.
196 int ide_in_drive_list(u16 *id, const struct drive_list_entry *table)
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)))
205 EXPORT_SYMBOL_GPL(ide_in_drive_list);
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.
211 static const struct drive_list_entry ivb_list[] = {
212 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
213 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
214 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
215 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
216 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
217 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
218 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
219 { "SAMSUNG SP0822N" , "WA100-10" },
224 * All hosts that use the 80c ribbon must use!
225 * The name is derived from upper byte of word 93 and the 80c ribbon.
227 u8 eighty_ninty_three(ide_drive_t *drive)
229 ide_hwif_t *hwif = drive->hwif;
231 int ivb = ide_in_drive_list(id, ivb_list);
233 if (hwif->cbl == ATA_CBL_PATA40_SHORT)
237 printk(KERN_DEBUG "%s: skipping word 93 validity check\n",
240 if (ata_id_is_sata(id) && !ivb)
243 if (hwif->cbl != ATA_CBL_PATA80 && !ivb)
248 * - change master/slave IDENTIFY order
249 * - force bit13 (80c cable present) check also for !ivb devices
250 * (unless the slave device is pre-ATA3)
252 if (id[ATA_ID_HW_CONFIG] & 0x4000)
256 const char *model = (char *)&id[ATA_ID_PROD];
258 if (strstr(model, "TSSTcorp CDDVDW SH-S202")) {
260 * These ATAPI devices always report 80c cable
261 * so we have to depend on the host in this case.
263 if (hwif->cbl == ATA_CBL_PATA80)
266 /* Depend on the device side cable detection. */
267 if (id[ATA_ID_HW_CONFIG] & 0x2000)
272 if (drive->dev_flags & IDE_DFLAG_UDMA33_WARNED)
275 printk(KERN_WARNING "%s: %s side 80-wire cable detection failed, "
276 "limiting max speed to UDMA33\n",
278 hwif->cbl == ATA_CBL_PATA80 ? "drive" : "host");
280 drive->dev_flags |= IDE_DFLAG_UDMA33_WARNED;
285 static const char *nien_quirk_list[] = {
286 "QUANTUM FIREBALLlct08 08",
287 "QUANTUM FIREBALLP KA6.4",
288 "QUANTUM FIREBALLP KA9.1",
289 "QUANTUM FIREBALLP KX13.6",
290 "QUANTUM FIREBALLP KX20.5",
291 "QUANTUM FIREBALLP KX27.3",
292 "QUANTUM FIREBALLP LM20.4",
293 "QUANTUM FIREBALLP LM20.5",
297 void ide_check_nien_quirk_list(ide_drive_t *drive)
299 const char **list, *m = (char *)&drive->id[ATA_ID_PROD];
301 for (list = nien_quirk_list; *list != NULL; list++)
302 if (strstr(m, *list) != NULL) {
303 drive->quirk_list = 2;
307 drive->quirk_list = 0;
310 int ide_driveid_update(ide_drive_t *drive)
315 id = kmalloc(SECTOR_SIZE, GFP_ATOMIC);
319 SELECT_MASK(drive, 1);
320 rc = ide_dev_read_id(drive, ATA_CMD_ID_ATA, id);
321 SELECT_MASK(drive, 0);
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 ? */
334 if ((drive->dev_flags & IDE_DFLAG_USING_DMA) && ide_id_dma_bug(drive))
340 printk(KERN_ERR "%s: %s: bad status\n", drive->name, __func__);
345 int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
347 ide_hwif_t *hwif = drive->hwif;
348 const struct ide_tp_ops *tp_ops = hwif->tp_ops;
349 struct ide_taskfile tf;
350 u16 *id = drive->id, i;
354 #ifdef CONFIG_BLK_DEV_IDEDMA
355 if (hwif->dma_ops) /* check if host supports DMA */
356 hwif->dma_ops->dma_host_set(drive, 0);
359 /* Skip setting PIO flow-control modes on pre-EIDE drives */
360 if ((speed & 0xf8) == XFER_PIO_0 && ata_id_has_iordy(drive->id) == 0)
364 * Don't use ide_wait_cmd here - it will
365 * attempt to set_geometry and recalibrate,
366 * but for some reason these don't work at
367 * this point (lost interrupt).
371 * FIXME: we race against the running IRQ here if
372 * this is called from non IRQ context. If we use
373 * disable_irq() we hang on the error path. Work
376 disable_irq_nosync(hwif->irq);
379 tp_ops->dev_select(drive);
380 SELECT_MASK(drive, 1);
382 tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
384 memset(&tf, 0, sizeof(tf));
385 tf.feature = SETFEATURES_XFER;
388 tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE | IDE_VALID_NSECT);
390 tp_ops->exec_command(hwif, ATA_CMD_SET_FEATURES);
392 if (drive->quirk_list == 2)
393 tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
395 error = __ide_wait_stat(drive, drive->ready_stat,
396 ATA_BUSY | ATA_DRQ | ATA_ERR,
399 SELECT_MASK(drive, 0);
401 enable_irq(hwif->irq);
404 (void) ide_dump_status(drive, "set_drive_speed_status", stat);
408 if (speed >= XFER_SW_DMA_0) {
409 id[ATA_ID_UDMA_MODES] &= ~0xFF00;
410 id[ATA_ID_MWDMA_MODES] &= ~0x0700;
411 id[ATA_ID_SWDMA_MODES] &= ~0x0700;
412 if (ata_id_is_cfa(id))
413 id[ATA_ID_CFA_MODES] &= ~0x0E00;
414 } else if (ata_id_is_cfa(id))
415 id[ATA_ID_CFA_MODES] &= ~0x01C0;
418 #ifdef CONFIG_BLK_DEV_IDEDMA
419 if (speed >= XFER_SW_DMA_0 && (drive->dev_flags & IDE_DFLAG_USING_DMA))
420 hwif->dma_ops->dma_host_set(drive, 1);
421 else if (hwif->dma_ops) /* check if host supports DMA */
422 ide_dma_off_quietly(drive);
425 if (speed >= XFER_UDMA_0) {
426 i = 1 << (speed - XFER_UDMA_0);
427 id[ATA_ID_UDMA_MODES] |= (i << 8 | i);
428 } else if (ata_id_is_cfa(id) && speed >= XFER_MW_DMA_3) {
429 i = speed - XFER_MW_DMA_2;
430 id[ATA_ID_CFA_MODES] |= i << 9;
431 } else if (speed >= XFER_MW_DMA_0) {
432 i = 1 << (speed - XFER_MW_DMA_0);
433 id[ATA_ID_MWDMA_MODES] |= (i << 8 | i);
434 } else if (speed >= XFER_SW_DMA_0) {
435 i = 1 << (speed - XFER_SW_DMA_0);
436 id[ATA_ID_SWDMA_MODES] |= (i << 8 | i);
437 } else if (ata_id_is_cfa(id) && speed >= XFER_PIO_5) {
438 i = speed - XFER_PIO_4;
439 id[ATA_ID_CFA_MODES] |= i << 6;
442 if (!drive->init_speed)
443 drive->init_speed = speed;
444 drive->current_speed = speed;
449 * This should get invoked any time we exit the driver to
450 * wait for an interrupt response from a drive. handler() points
451 * at the appropriate code to handle the next interrupt, and a
452 * timer is started to prevent us from waiting forever in case
453 * something goes wrong (see the ide_timer_expiry() handler later on).
455 * See also ide_execute_command
457 void __ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
458 unsigned int timeout)
460 ide_hwif_t *hwif = drive->hwif;
462 BUG_ON(hwif->handler);
463 hwif->handler = handler;
464 hwif->timer.expires = jiffies + timeout;
465 hwif->req_gen_timer = hwif->req_gen;
466 add_timer(&hwif->timer);
469 void ide_set_handler(ide_drive_t *drive, ide_handler_t *handler,
470 unsigned int timeout)
472 ide_hwif_t *hwif = drive->hwif;
475 spin_lock_irqsave(&hwif->lock, flags);
476 __ide_set_handler(drive, handler, timeout);
477 spin_unlock_irqrestore(&hwif->lock, flags);
479 EXPORT_SYMBOL(ide_set_handler);
482 * ide_execute_command - execute an IDE command
483 * @drive: IDE drive to issue the command against
485 * @handler: handler for next phase
486 * @timeout: timeout for command
488 * Helper function to issue an IDE command. This handles the
489 * atomicity requirements, command timing and ensures that the
490 * handler and IRQ setup do not race. All IDE command kick off
491 * should go via this function or do equivalent locking.
494 void ide_execute_command(ide_drive_t *drive, struct ide_cmd *cmd,
495 ide_handler_t *handler, unsigned timeout)
497 ide_hwif_t *hwif = drive->hwif;
500 spin_lock_irqsave(&hwif->lock, flags);
501 if ((cmd->protocol != ATAPI_PROT_DMA &&
502 cmd->protocol != ATAPI_PROT_PIO) ||
503 (drive->atapi_flags & IDE_AFLAG_DRQ_INTERRUPT))
504 __ide_set_handler(drive, handler, timeout);
505 hwif->tp_ops->exec_command(hwif, cmd->tf.command);
507 * Drive takes 400nS to respond, we must avoid the IRQ being
508 * serviced before that.
510 * FIXME: we could skip this delay with care on non shared devices
513 spin_unlock_irqrestore(&hwif->lock, flags);
517 * ide_wait_not_busy() waits for the currently selected device on the hwif
518 * to report a non-busy status, see comments in ide_probe_port().
520 int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
526 * Turn this into a schedule() sleep once I'm sure
527 * about locking issues (2.5 work ?).
530 stat = hwif->tp_ops->read_status(hwif);
531 if ((stat & ATA_BUSY) == 0)
534 * Assume a value of 0xff means nothing is connected to
535 * the interface and it doesn't implement the pull-down
540 touch_softlockup_watchdog();
541 touch_nmi_watchdog();