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
)
42 memset(&cmd
, 0, sizeof(cmd
));
43 cmd
.tf_flags
= IDE_TFLAG_IN_ERROR
;
45 drive
->hwif
->tp_ops
->tf_read(drive
, &cmd
);
49 EXPORT_SYMBOL_GPL(ide_read_error
);
51 void ide_fix_driveid(u16
*id
)
53 #ifndef __LITTLE_ENDIAN
57 for (i
= 0; i
< 256; i
++)
58 id
[i
] = __le16_to_cpu(id
[i
]);
60 # error "Please fix <asm/byteorder.h>"
66 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
67 * removing leading/trailing blanks and compressing internal blanks.
68 * It is primarily used to tidy up the model name/number fields as
69 * returned by the ATA_CMD_ID_ATA[PI] commands.
72 void ide_fixstring(u8
*s
, const int bytecount
, const int byteswap
)
74 u8
*p
, *end
= &s
[bytecount
& ~1]; /* bytecount must be even */
77 /* convert from big-endian to host byte order */
78 for (p
= s
; p
!= end
; p
+= 2)
79 be16_to_cpus((u16
*) p
);
82 /* strip leading blanks */
84 while (s
!= end
&& *s
== ' ')
86 /* compress internal blanks and strip trailing blanks */
87 while (s
!= end
&& *s
) {
88 if (*s
++ != ' ' || (s
!= end
&& *s
&& *s
!= ' '))
91 /* wipe out trailing garbage */
95 EXPORT_SYMBOL(ide_fixstring
);
98 * This routine busy-waits for the drive status to be not "busy".
99 * It then checks the status for all of the "good" bits and none
100 * of the "bad" bits, and if all is okay it returns 0. All other
101 * cases return error -- caller may then invoke ide_error().
103 * This routine should get fixed to not hog the cpu during extra long waits..
104 * That could be done by busy-waiting for the first jiffy or two, and then
105 * setting a timer to wake up at half second intervals thereafter,
106 * until timeout is achieved, before timing out.
108 static int __ide_wait_stat(ide_drive_t
*drive
, u8 good
, u8 bad
,
109 unsigned long timeout
, u8
*rstat
)
111 ide_hwif_t
*hwif
= drive
->hwif
;
112 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
117 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
118 stat
= tp_ops
->read_status(hwif
);
120 if (stat
& ATA_BUSY
) {
121 local_save_flags(flags
);
122 local_irq_enable_in_hardirq();
124 while ((stat
= tp_ops
->read_status(hwif
)) & ATA_BUSY
) {
125 if (time_after(jiffies
, timeout
)) {
127 * One last read after the timeout in case
128 * heavy interrupt load made us not make any
129 * progress during the timeout..
131 stat
= tp_ops
->read_status(hwif
);
132 if ((stat
& ATA_BUSY
) == 0)
135 local_irq_restore(flags
);
140 local_irq_restore(flags
);
143 * Allow status to settle, then read it again.
144 * A few rare drives vastly violate the 400ns spec here,
145 * so we'll wait up to 10usec for a "good" status
146 * rather than expensively fail things immediately.
147 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
149 for (i
= 0; i
< 10; i
++) {
151 stat
= tp_ops
->read_status(hwif
);
153 if (OK_STAT(stat
, good
, bad
)) {
163 * In case of error returns error value after doing "*startstop = ide_error()".
164 * The caller should return the updated value of "startstop" in this case,
165 * "startstop" is unchanged when the function returns 0.
167 int ide_wait_stat(ide_startstop_t
*startstop
, ide_drive_t
*drive
, u8 good
,
168 u8 bad
, unsigned long timeout
)
173 /* bail early if we've exceeded max_failures */
174 if (drive
->max_failures
&& (drive
->failures
> drive
->max_failures
)) {
175 *startstop
= ide_stopped
;
179 err
= __ide_wait_stat(drive
, good
, bad
, timeout
, &stat
);
182 char *s
= (err
== -EBUSY
) ? "status timeout" : "status error";
183 *startstop
= ide_error(drive
, s
, stat
);
188 EXPORT_SYMBOL(ide_wait_stat
);
191 * ide_in_drive_list - look for drive in black/white list
192 * @id: drive identifier
193 * @table: list to inspect
195 * Look for a drive in the blacklist and the whitelist tables
196 * Returns 1 if the drive is found in the table.
199 int ide_in_drive_list(u16
*id
, const struct drive_list_entry
*table
)
201 for ( ; table
->id_model
; table
++)
202 if ((!strcmp(table
->id_model
, (char *)&id
[ATA_ID_PROD
])) &&
203 (!table
->id_firmware
||
204 strstr((char *)&id
[ATA_ID_FW_REV
], table
->id_firmware
)))
208 EXPORT_SYMBOL_GPL(ide_in_drive_list
);
211 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
212 * We list them here and depend on the device side cable detection for them.
214 * Some optical devices with the buggy firmwares have the same problem.
216 static const struct drive_list_entry ivb_list
[] = {
217 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
218 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
219 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
220 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
221 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
222 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
223 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
224 { "SAMSUNG SP0822N" , "WA100-10" },
229 * All hosts that use the 80c ribbon must use!
230 * The name is derived from upper byte of word 93 and the 80c ribbon.
232 u8
eighty_ninty_three(ide_drive_t
*drive
)
234 ide_hwif_t
*hwif
= drive
->hwif
;
236 int ivb
= ide_in_drive_list(id
, ivb_list
);
238 if (hwif
->cbl
== ATA_CBL_PATA40_SHORT
)
242 printk(KERN_DEBUG
"%s: skipping word 93 validity check\n",
245 if (ata_id_is_sata(id
) && !ivb
)
248 if (hwif
->cbl
!= ATA_CBL_PATA80
&& !ivb
)
253 * - change master/slave IDENTIFY order
254 * - force bit13 (80c cable present) check also for !ivb devices
255 * (unless the slave device is pre-ATA3)
257 if ((id
[ATA_ID_HW_CONFIG
] & 0x4000) ||
258 (ivb
&& (id
[ATA_ID_HW_CONFIG
] & 0x2000)))
262 if (drive
->dev_flags
& IDE_DFLAG_UDMA33_WARNED
)
265 printk(KERN_WARNING
"%s: %s side 80-wire cable detection failed, "
266 "limiting max speed to UDMA33\n",
268 hwif
->cbl
== ATA_CBL_PATA80
? "drive" : "host");
270 drive
->dev_flags
|= IDE_DFLAG_UDMA33_WARNED
;
275 int ide_driveid_update(ide_drive_t
*drive
)
280 id
= kmalloc(SECTOR_SIZE
, GFP_ATOMIC
);
284 SELECT_MASK(drive
, 1);
285 rc
= ide_dev_read_id(drive
, ATA_CMD_ID_ATA
, id
);
286 SELECT_MASK(drive
, 0);
291 drive
->id
[ATA_ID_UDMA_MODES
] = id
[ATA_ID_UDMA_MODES
];
292 drive
->id
[ATA_ID_MWDMA_MODES
] = id
[ATA_ID_MWDMA_MODES
];
293 drive
->id
[ATA_ID_SWDMA_MODES
] = id
[ATA_ID_SWDMA_MODES
];
294 drive
->id
[ATA_ID_CFA_MODES
] = id
[ATA_ID_CFA_MODES
];
295 /* anything more ? */
299 if ((drive
->dev_flags
& IDE_DFLAG_USING_DMA
) && ide_id_dma_bug(drive
))
304 SELECT_MASK(drive
, 0);
306 printk(KERN_ERR
"%s: %s: bad status\n", drive
->name
, __func__
);
311 int ide_config_drive_speed(ide_drive_t
*drive
, u8 speed
)
313 ide_hwif_t
*hwif
= drive
->hwif
;
314 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
315 u16
*id
= drive
->id
, i
;
320 #ifdef CONFIG_BLK_DEV_IDEDMA
321 if (hwif
->dma_ops
) /* check if host supports DMA */
322 hwif
->dma_ops
->dma_host_set(drive
, 0);
325 /* Skip setting PIO flow-control modes on pre-EIDE drives */
326 if ((speed
& 0xf8) == XFER_PIO_0
&& ata_id_has_iordy(drive
->id
) == 0)
330 * Don't use ide_wait_cmd here - it will
331 * attempt to set_geometry and recalibrate,
332 * but for some reason these don't work at
333 * this point (lost interrupt).
337 * FIXME: we race against the running IRQ here if
338 * this is called from non IRQ context. If we use
339 * disable_irq() we hang on the error path. Work
342 disable_irq_nosync(hwif
->irq
);
345 tp_ops
->dev_select(drive
);
346 SELECT_MASK(drive
, 1);
348 tp_ops
->write_devctl(hwif
, ATA_NIEN
| ATA_DEVCTL_OBS
);
350 memset(&cmd
, 0, sizeof(cmd
));
351 cmd
.tf_flags
= IDE_TFLAG_OUT_FEATURE
| IDE_TFLAG_OUT_NSECT
;
352 cmd
.tf
.feature
= SETFEATURES_XFER
;
353 cmd
.tf
.nsect
= speed
;
355 tp_ops
->tf_load(drive
, &cmd
);
357 tp_ops
->exec_command(hwif
, ATA_CMD_SET_FEATURES
);
359 if (drive
->quirk_list
== 2)
360 tp_ops
->write_devctl(hwif
, ATA_DEVCTL_OBS
);
362 error
= __ide_wait_stat(drive
, drive
->ready_stat
,
363 ATA_BUSY
| ATA_DRQ
| ATA_ERR
,
366 SELECT_MASK(drive
, 0);
368 enable_irq(hwif
->irq
);
371 (void) ide_dump_status(drive
, "set_drive_speed_status", stat
);
375 if (speed
>= XFER_SW_DMA_0
) {
376 id
[ATA_ID_UDMA_MODES
] &= ~0xFF00;
377 id
[ATA_ID_MWDMA_MODES
] &= ~0x0700;
378 id
[ATA_ID_SWDMA_MODES
] &= ~0x0700;
379 if (ata_id_is_cfa(id
))
380 id
[ATA_ID_CFA_MODES
] &= ~0x0E00;
381 } else if (ata_id_is_cfa(id
))
382 id
[ATA_ID_CFA_MODES
] &= ~0x01C0;
385 #ifdef CONFIG_BLK_DEV_IDEDMA
386 if (speed
>= XFER_SW_DMA_0
&& (drive
->dev_flags
& IDE_DFLAG_USING_DMA
))
387 hwif
->dma_ops
->dma_host_set(drive
, 1);
388 else if (hwif
->dma_ops
) /* check if host supports DMA */
389 ide_dma_off_quietly(drive
);
392 if (speed
>= XFER_UDMA_0
) {
393 i
= 1 << (speed
- XFER_UDMA_0
);
394 id
[ATA_ID_UDMA_MODES
] |= (i
<< 8 | i
);
395 } else if (ata_id_is_cfa(id
) && speed
>= XFER_MW_DMA_3
) {
396 i
= speed
- XFER_MW_DMA_2
;
397 id
[ATA_ID_CFA_MODES
] |= i
<< 9;
398 } else if (speed
>= XFER_MW_DMA_0
) {
399 i
= 1 << (speed
- XFER_MW_DMA_0
);
400 id
[ATA_ID_MWDMA_MODES
] |= (i
<< 8 | i
);
401 } else if (speed
>= XFER_SW_DMA_0
) {
402 i
= 1 << (speed
- XFER_SW_DMA_0
);
403 id
[ATA_ID_SWDMA_MODES
] |= (i
<< 8 | i
);
404 } else if (ata_id_is_cfa(id
) && speed
>= XFER_PIO_5
) {
405 i
= speed
- XFER_PIO_4
;
406 id
[ATA_ID_CFA_MODES
] |= i
<< 6;
409 if (!drive
->init_speed
)
410 drive
->init_speed
= speed
;
411 drive
->current_speed
= speed
;
416 * This should get invoked any time we exit the driver to
417 * wait for an interrupt response from a drive. handler() points
418 * at the appropriate code to handle the next interrupt, and a
419 * timer is started to prevent us from waiting forever in case
420 * something goes wrong (see the ide_timer_expiry() handler later on).
422 * See also ide_execute_command
424 void __ide_set_handler(ide_drive_t
*drive
, ide_handler_t
*handler
,
425 unsigned int timeout
)
427 ide_hwif_t
*hwif
= drive
->hwif
;
429 BUG_ON(hwif
->handler
);
430 hwif
->handler
= handler
;
431 hwif
->timer
.expires
= jiffies
+ timeout
;
432 hwif
->req_gen_timer
= hwif
->req_gen
;
433 add_timer(&hwif
->timer
);
436 void ide_set_handler(ide_drive_t
*drive
, ide_handler_t
*handler
,
437 unsigned int timeout
)
439 ide_hwif_t
*hwif
= drive
->hwif
;
442 spin_lock_irqsave(&hwif
->lock
, flags
);
443 __ide_set_handler(drive
, handler
, timeout
);
444 spin_unlock_irqrestore(&hwif
->lock
, flags
);
446 EXPORT_SYMBOL(ide_set_handler
);
449 * ide_execute_command - execute an IDE command
450 * @drive: IDE drive to issue the command against
452 * @handler: handler for next phase
453 * @timeout: timeout for command
455 * Helper function to issue an IDE command. This handles the
456 * atomicity requirements, command timing and ensures that the
457 * handler and IRQ setup do not race. All IDE command kick off
458 * should go via this function or do equivalent locking.
461 void ide_execute_command(ide_drive_t
*drive
, struct ide_cmd
*cmd
,
462 ide_handler_t
*handler
, unsigned timeout
)
464 ide_hwif_t
*hwif
= drive
->hwif
;
467 spin_lock_irqsave(&hwif
->lock
, flags
);
468 if ((cmd
->protocol
!= ATAPI_PROT_DMA
&&
469 cmd
->protocol
!= ATAPI_PROT_PIO
) ||
470 (drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
))
471 __ide_set_handler(drive
, handler
, timeout
);
472 hwif
->tp_ops
->exec_command(hwif
, cmd
->tf
.command
);
474 * Drive takes 400nS to respond, we must avoid the IRQ being
475 * serviced before that.
477 * FIXME: we could skip this delay with care on non shared devices
480 spin_unlock_irqrestore(&hwif
->lock
, flags
);
484 * ide_wait_not_busy() waits for the currently selected device on the hwif
485 * to report a non-busy status, see comments in ide_probe_port().
487 int ide_wait_not_busy(ide_hwif_t
*hwif
, unsigned long timeout
)
493 * Turn this into a schedule() sleep once I'm sure
494 * about locking issues (2.5 work ?).
497 stat
= hwif
->tp_ops
->read_status(hwif
);
498 if ((stat
& ATA_BUSY
) == 0)
501 * Assume a value of 0xff means nothing is connected to
502 * the interface and it doesn't implement the pull-down
507 touch_softlockup_watchdog();
508 touch_nmi_watchdog();