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_DRIVE(ide_drive_t
*drive
)
32 drive
->hwif
->tp_ops
->dev_select(drive
);
35 void SELECT_MASK(ide_drive_t
*drive
, int mask
)
37 const struct ide_port_ops
*port_ops
= drive
->hwif
->port_ops
;
39 if (port_ops
&& port_ops
->maskproc
)
40 port_ops
->maskproc(drive
, mask
);
43 u8
ide_read_error(ide_drive_t
*drive
)
47 memset(&cmd
, 0, sizeof(cmd
));
48 cmd
.tf_flags
= IDE_TFLAG_IN_ERROR
;
50 drive
->hwif
->tp_ops
->tf_read(drive
, &cmd
);
54 EXPORT_SYMBOL_GPL(ide_read_error
);
56 void ide_fix_driveid(u16
*id
)
58 #ifndef __LITTLE_ENDIAN
62 for (i
= 0; i
< 256; i
++)
63 id
[i
] = __le16_to_cpu(id
[i
]);
65 # error "Please fix <asm/byteorder.h>"
71 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
72 * removing leading/trailing blanks and compressing internal blanks.
73 * It is primarily used to tidy up the model name/number fields as
74 * returned by the ATA_CMD_ID_ATA[PI] commands.
77 void ide_fixstring(u8
*s
, const int bytecount
, const int byteswap
)
79 u8
*p
, *end
= &s
[bytecount
& ~1]; /* bytecount must be even */
82 /* convert from big-endian to host byte order */
83 for (p
= s
; p
!= end
; p
+= 2)
84 be16_to_cpus((u16
*) p
);
87 /* strip leading blanks */
89 while (s
!= end
&& *s
== ' ')
91 /* compress internal blanks and strip trailing blanks */
92 while (s
!= end
&& *s
) {
93 if (*s
++ != ' ' || (s
!= end
&& *s
&& *s
!= ' '))
96 /* wipe out trailing garbage */
100 EXPORT_SYMBOL(ide_fixstring
);
103 * This routine busy-waits for the drive status to be not "busy".
104 * It then checks the status for all of the "good" bits and none
105 * of the "bad" bits, and if all is okay it returns 0. All other
106 * cases return error -- caller may then invoke ide_error().
108 * This routine should get fixed to not hog the cpu during extra long waits..
109 * That could be done by busy-waiting for the first jiffy or two, and then
110 * setting a timer to wake up at half second intervals thereafter,
111 * until timeout is achieved, before timing out.
113 static int __ide_wait_stat(ide_drive_t
*drive
, u8 good
, u8 bad
,
114 unsigned long timeout
, u8
*rstat
)
116 ide_hwif_t
*hwif
= drive
->hwif
;
117 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
122 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
123 stat
= tp_ops
->read_status(hwif
);
125 if (stat
& ATA_BUSY
) {
126 local_save_flags(flags
);
127 local_irq_enable_in_hardirq();
129 while ((stat
= tp_ops
->read_status(hwif
)) & ATA_BUSY
) {
130 if (time_after(jiffies
, timeout
)) {
132 * One last read after the timeout in case
133 * heavy interrupt load made us not make any
134 * progress during the timeout..
136 stat
= tp_ops
->read_status(hwif
);
137 if ((stat
& ATA_BUSY
) == 0)
140 local_irq_restore(flags
);
145 local_irq_restore(flags
);
148 * Allow status to settle, then read it again.
149 * A few rare drives vastly violate the 400ns spec here,
150 * so we'll wait up to 10usec for a "good" status
151 * rather than expensively fail things immediately.
152 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
154 for (i
= 0; i
< 10; i
++) {
156 stat
= tp_ops
->read_status(hwif
);
158 if (OK_STAT(stat
, good
, bad
)) {
168 * In case of error returns error value after doing "*startstop = ide_error()".
169 * The caller should return the updated value of "startstop" in this case,
170 * "startstop" is unchanged when the function returns 0.
172 int ide_wait_stat(ide_startstop_t
*startstop
, ide_drive_t
*drive
, u8 good
,
173 u8 bad
, unsigned long timeout
)
178 /* bail early if we've exceeded max_failures */
179 if (drive
->max_failures
&& (drive
->failures
> drive
->max_failures
)) {
180 *startstop
= ide_stopped
;
184 err
= __ide_wait_stat(drive
, good
, bad
, timeout
, &stat
);
187 char *s
= (err
== -EBUSY
) ? "status timeout" : "status error";
188 *startstop
= ide_error(drive
, s
, stat
);
193 EXPORT_SYMBOL(ide_wait_stat
);
196 * ide_in_drive_list - look for drive in black/white list
197 * @id: drive identifier
198 * @table: list to inspect
200 * Look for a drive in the blacklist and the whitelist tables
201 * Returns 1 if the drive is found in the table.
204 int ide_in_drive_list(u16
*id
, const struct drive_list_entry
*table
)
206 for ( ; table
->id_model
; table
++)
207 if ((!strcmp(table
->id_model
, (char *)&id
[ATA_ID_PROD
])) &&
208 (!table
->id_firmware
||
209 strstr((char *)&id
[ATA_ID_FW_REV
], table
->id_firmware
)))
213 EXPORT_SYMBOL_GPL(ide_in_drive_list
);
216 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
217 * We list them here and depend on the device side cable detection for them.
219 * Some optical devices with the buggy firmwares have the same problem.
221 static const struct drive_list_entry ivb_list
[] = {
222 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
223 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
224 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
225 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
226 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
227 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
228 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
229 { "SAMSUNG SP0822N" , "WA100-10" },
234 * All hosts that use the 80c ribbon must use!
235 * The name is derived from upper byte of word 93 and the 80c ribbon.
237 u8
eighty_ninty_three(ide_drive_t
*drive
)
239 ide_hwif_t
*hwif
= drive
->hwif
;
241 int ivb
= ide_in_drive_list(id
, ivb_list
);
243 if (hwif
->cbl
== ATA_CBL_PATA40_SHORT
)
247 printk(KERN_DEBUG
"%s: skipping word 93 validity check\n",
250 if (ata_id_is_sata(id
) && !ivb
)
253 if (hwif
->cbl
!= ATA_CBL_PATA80
&& !ivb
)
258 * - change master/slave IDENTIFY order
259 * - force bit13 (80c cable present) check also for !ivb devices
260 * (unless the slave device is pre-ATA3)
262 if ((id
[ATA_ID_HW_CONFIG
] & 0x4000) ||
263 (ivb
&& (id
[ATA_ID_HW_CONFIG
] & 0x2000)))
267 if (drive
->dev_flags
& IDE_DFLAG_UDMA33_WARNED
)
270 printk(KERN_WARNING
"%s: %s side 80-wire cable detection failed, "
271 "limiting max speed to UDMA33\n",
273 hwif
->cbl
== ATA_CBL_PATA80
? "drive" : "host");
275 drive
->dev_flags
|= IDE_DFLAG_UDMA33_WARNED
;
280 int ide_driveid_update(ide_drive_t
*drive
)
285 id
= kmalloc(SECTOR_SIZE
, GFP_ATOMIC
);
289 SELECT_MASK(drive
, 1);
290 rc
= ide_dev_read_id(drive
, ATA_CMD_ID_ATA
, id
);
291 SELECT_MASK(drive
, 0);
296 drive
->id
[ATA_ID_UDMA_MODES
] = id
[ATA_ID_UDMA_MODES
];
297 drive
->id
[ATA_ID_MWDMA_MODES
] = id
[ATA_ID_MWDMA_MODES
];
298 drive
->id
[ATA_ID_SWDMA_MODES
] = id
[ATA_ID_SWDMA_MODES
];
299 drive
->id
[ATA_ID_CFA_MODES
] = id
[ATA_ID_CFA_MODES
];
300 /* anything more ? */
304 if ((drive
->dev_flags
& IDE_DFLAG_USING_DMA
) && ide_id_dma_bug(drive
))
309 SELECT_MASK(drive
, 0);
311 printk(KERN_ERR
"%s: %s: bad status\n", drive
->name
, __func__
);
316 int ide_config_drive_speed(ide_drive_t
*drive
, u8 speed
)
318 ide_hwif_t
*hwif
= drive
->hwif
;
319 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
320 u16
*id
= drive
->id
, i
;
325 #ifdef CONFIG_BLK_DEV_IDEDMA
326 if (hwif
->dma_ops
) /* check if host supports DMA */
327 hwif
->dma_ops
->dma_host_set(drive
, 0);
330 /* Skip setting PIO flow-control modes on pre-EIDE drives */
331 if ((speed
& 0xf8) == XFER_PIO_0
&& ata_id_has_iordy(drive
->id
) == 0)
335 * Don't use ide_wait_cmd here - it will
336 * attempt to set_geometry and recalibrate,
337 * but for some reason these don't work at
338 * this point (lost interrupt).
342 * FIXME: we race against the running IRQ here if
343 * this is called from non IRQ context. If we use
344 * disable_irq() we hang on the error path. Work
347 disable_irq_nosync(hwif
->irq
);
351 SELECT_MASK(drive
, 1);
353 tp_ops
->write_devctl(hwif
, ATA_NIEN
| ATA_DEVCTL_OBS
);
355 memset(&cmd
, 0, sizeof(cmd
));
356 cmd
.tf_flags
= IDE_TFLAG_OUT_FEATURE
| IDE_TFLAG_OUT_NSECT
;
357 cmd
.tf
.feature
= SETFEATURES_XFER
;
358 cmd
.tf
.nsect
= speed
;
360 tp_ops
->tf_load(drive
, &cmd
);
362 tp_ops
->exec_command(hwif
, ATA_CMD_SET_FEATURES
);
364 if (drive
->quirk_list
== 2)
365 tp_ops
->write_devctl(hwif
, ATA_DEVCTL_OBS
);
367 error
= __ide_wait_stat(drive
, drive
->ready_stat
,
368 ATA_BUSY
| ATA_DRQ
| ATA_ERR
,
371 SELECT_MASK(drive
, 0);
373 enable_irq(hwif
->irq
);
376 (void) ide_dump_status(drive
, "set_drive_speed_status", stat
);
380 if (speed
>= XFER_SW_DMA_0
) {
381 id
[ATA_ID_UDMA_MODES
] &= ~0xFF00;
382 id
[ATA_ID_MWDMA_MODES
] &= ~0x0700;
383 id
[ATA_ID_SWDMA_MODES
] &= ~0x0700;
384 if (ata_id_is_cfa(id
))
385 id
[ATA_ID_CFA_MODES
] &= ~0x0E00;
386 } else if (ata_id_is_cfa(id
))
387 id
[ATA_ID_CFA_MODES
] &= ~0x01C0;
390 #ifdef CONFIG_BLK_DEV_IDEDMA
391 if (speed
>= XFER_SW_DMA_0
&& (drive
->dev_flags
& IDE_DFLAG_USING_DMA
))
392 hwif
->dma_ops
->dma_host_set(drive
, 1);
393 else if (hwif
->dma_ops
) /* check if host supports DMA */
394 ide_dma_off_quietly(drive
);
397 if (speed
>= XFER_UDMA_0
) {
398 i
= 1 << (speed
- XFER_UDMA_0
);
399 id
[ATA_ID_UDMA_MODES
] |= (i
<< 8 | i
);
400 } else if (ata_id_is_cfa(id
) && speed
>= XFER_MW_DMA_3
) {
401 i
= speed
- XFER_MW_DMA_2
;
402 id
[ATA_ID_CFA_MODES
] |= i
<< 9;
403 } else if (speed
>= XFER_MW_DMA_0
) {
404 i
= 1 << (speed
- XFER_MW_DMA_0
);
405 id
[ATA_ID_MWDMA_MODES
] |= (i
<< 8 | i
);
406 } else if (speed
>= XFER_SW_DMA_0
) {
407 i
= 1 << (speed
- XFER_SW_DMA_0
);
408 id
[ATA_ID_SWDMA_MODES
] |= (i
<< 8 | i
);
409 } else if (ata_id_is_cfa(id
) && speed
>= XFER_PIO_5
) {
410 i
= speed
- XFER_PIO_4
;
411 id
[ATA_ID_CFA_MODES
] |= i
<< 6;
414 if (!drive
->init_speed
)
415 drive
->init_speed
= speed
;
416 drive
->current_speed
= speed
;
421 * This should get invoked any time we exit the driver to
422 * wait for an interrupt response from a drive. handler() points
423 * at the appropriate code to handle the next interrupt, and a
424 * timer is started to prevent us from waiting forever in case
425 * something goes wrong (see the ide_timer_expiry() handler later on).
427 * See also ide_execute_command
429 void __ide_set_handler(ide_drive_t
*drive
, ide_handler_t
*handler
,
430 unsigned int timeout
)
432 ide_hwif_t
*hwif
= drive
->hwif
;
434 BUG_ON(hwif
->handler
);
435 hwif
->handler
= handler
;
436 hwif
->timer
.expires
= jiffies
+ timeout
;
437 hwif
->req_gen_timer
= hwif
->req_gen
;
438 add_timer(&hwif
->timer
);
441 void ide_set_handler(ide_drive_t
*drive
, ide_handler_t
*handler
,
442 unsigned int timeout
)
444 ide_hwif_t
*hwif
= drive
->hwif
;
447 spin_lock_irqsave(&hwif
->lock
, flags
);
448 __ide_set_handler(drive
, handler
, timeout
);
449 spin_unlock_irqrestore(&hwif
->lock
, flags
);
451 EXPORT_SYMBOL(ide_set_handler
);
454 * ide_execute_command - execute an IDE command
455 * @drive: IDE drive to issue the command against
457 * @handler: handler for next phase
458 * @timeout: timeout for command
460 * Helper function to issue an IDE command. This handles the
461 * atomicity requirements, command timing and ensures that the
462 * handler and IRQ setup do not race. All IDE command kick off
463 * should go via this function or do equivalent locking.
466 void ide_execute_command(ide_drive_t
*drive
, struct ide_cmd
*cmd
,
467 ide_handler_t
*handler
, unsigned timeout
)
469 ide_hwif_t
*hwif
= drive
->hwif
;
472 spin_lock_irqsave(&hwif
->lock
, flags
);
473 if ((cmd
->protocol
!= ATAPI_PROT_DMA
&&
474 cmd
->protocol
!= ATAPI_PROT_PIO
) ||
475 (drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
))
476 __ide_set_handler(drive
, handler
, timeout
);
477 hwif
->tp_ops
->exec_command(hwif
, cmd
->tf
.command
);
479 * Drive takes 400nS to respond, we must avoid the IRQ being
480 * serviced before that.
482 * FIXME: we could skip this delay with care on non shared devices
485 spin_unlock_irqrestore(&hwif
->lock
, flags
);
489 * ide_wait_not_busy() waits for the currently selected device on the hwif
490 * to report a non-busy status, see comments in ide_probe_port().
492 int ide_wait_not_busy(ide_hwif_t
*hwif
, unsigned long timeout
)
498 * Turn this into a schedule() sleep once I'm sure
499 * about locking issues (2.5 work ?).
502 stat
= hwif
->tp_ops
->read_status(hwif
);
503 if ((stat
& ATA_BUSY
) == 0)
506 * Assume a value of 0xff means nothing is connected to
507 * the interface and it doesn't implement the pull-down
512 touch_softlockup_watchdog();
513 touch_nmi_watchdog();