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 ide_hwif_t
*hwif
= drive
->hwif
;
33 const struct ide_port_ops
*port_ops
= hwif
->port_ops
;
36 if (port_ops
&& port_ops
->selectproc
)
37 port_ops
->selectproc(drive
);
39 memset(&cmd
, 0, sizeof(cmd
));
40 cmd
.tf_flags
= IDE_TFLAG_OUT_DEVICE
;
42 drive
->hwif
->tp_ops
->tf_load(drive
, &cmd
);
45 void SELECT_MASK(ide_drive_t
*drive
, int mask
)
47 const struct ide_port_ops
*port_ops
= drive
->hwif
->port_ops
;
49 if (port_ops
&& port_ops
->maskproc
)
50 port_ops
->maskproc(drive
, mask
);
53 u8
ide_read_error(ide_drive_t
*drive
)
57 memset(&cmd
, 0, sizeof(cmd
));
58 cmd
.tf_flags
= IDE_TFLAG_IN_FEATURE
;
60 drive
->hwif
->tp_ops
->tf_read(drive
, &cmd
);
64 EXPORT_SYMBOL_GPL(ide_read_error
);
66 void ide_fix_driveid(u16
*id
)
68 #ifndef __LITTLE_ENDIAN
72 for (i
= 0; i
< 256; i
++)
73 id
[i
] = __le16_to_cpu(id
[i
]);
75 # error "Please fix <asm/byteorder.h>"
81 * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
82 * removing leading/trailing blanks and compressing internal blanks.
83 * It is primarily used to tidy up the model name/number fields as
84 * returned by the ATA_CMD_ID_ATA[PI] commands.
87 void ide_fixstring(u8
*s
, const int bytecount
, const int byteswap
)
89 u8
*p
, *end
= &s
[bytecount
& ~1]; /* bytecount must be even */
92 /* convert from big-endian to host byte order */
93 for (p
= s
; p
!= end
; p
+= 2)
94 be16_to_cpus((u16
*) p
);
97 /* strip leading blanks */
99 while (s
!= end
&& *s
== ' ')
101 /* compress internal blanks and strip trailing blanks */
102 while (s
!= end
&& *s
) {
103 if (*s
++ != ' ' || (s
!= end
&& *s
&& *s
!= ' '))
106 /* wipe out trailing garbage */
110 EXPORT_SYMBOL(ide_fixstring
);
113 * This routine busy-waits for the drive status to be not "busy".
114 * It then checks the status for all of the "good" bits and none
115 * of the "bad" bits, and if all is okay it returns 0. All other
116 * cases return error -- caller may then invoke ide_error().
118 * This routine should get fixed to not hog the cpu during extra long waits..
119 * That could be done by busy-waiting for the first jiffy or two, and then
120 * setting a timer to wake up at half second intervals thereafter,
121 * until timeout is achieved, before timing out.
123 static int __ide_wait_stat(ide_drive_t
*drive
, u8 good
, u8 bad
,
124 unsigned long timeout
, u8
*rstat
)
126 ide_hwif_t
*hwif
= drive
->hwif
;
127 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
132 udelay(1); /* spec allows drive 400ns to assert "BUSY" */
133 stat
= tp_ops
->read_status(hwif
);
135 if (stat
& ATA_BUSY
) {
136 local_save_flags(flags
);
137 local_irq_enable_in_hardirq();
139 while ((stat
= tp_ops
->read_status(hwif
)) & ATA_BUSY
) {
140 if (time_after(jiffies
, timeout
)) {
142 * One last read after the timeout in case
143 * heavy interrupt load made us not make any
144 * progress during the timeout..
146 stat
= tp_ops
->read_status(hwif
);
147 if ((stat
& ATA_BUSY
) == 0)
150 local_irq_restore(flags
);
155 local_irq_restore(flags
);
158 * Allow status to settle, then read it again.
159 * A few rare drives vastly violate the 400ns spec here,
160 * so we'll wait up to 10usec for a "good" status
161 * rather than expensively fail things immediately.
162 * This fix courtesy of Matthew Faupel & Niccolo Rigacci.
164 for (i
= 0; i
< 10; i
++) {
166 stat
= tp_ops
->read_status(hwif
);
168 if (OK_STAT(stat
, good
, bad
)) {
178 * In case of error returns error value after doing "*startstop = ide_error()".
179 * The caller should return the updated value of "startstop" in this case,
180 * "startstop" is unchanged when the function returns 0.
182 int ide_wait_stat(ide_startstop_t
*startstop
, ide_drive_t
*drive
, u8 good
,
183 u8 bad
, unsigned long timeout
)
188 /* bail early if we've exceeded max_failures */
189 if (drive
->max_failures
&& (drive
->failures
> drive
->max_failures
)) {
190 *startstop
= ide_stopped
;
194 err
= __ide_wait_stat(drive
, good
, bad
, timeout
, &stat
);
197 char *s
= (err
== -EBUSY
) ? "status timeout" : "status error";
198 *startstop
= ide_error(drive
, s
, stat
);
203 EXPORT_SYMBOL(ide_wait_stat
);
206 * ide_in_drive_list - look for drive in black/white list
207 * @id: drive identifier
208 * @table: list to inspect
210 * Look for a drive in the blacklist and the whitelist tables
211 * Returns 1 if the drive is found in the table.
214 int ide_in_drive_list(u16
*id
, const struct drive_list_entry
*table
)
216 for ( ; table
->id_model
; table
++)
217 if ((!strcmp(table
->id_model
, (char *)&id
[ATA_ID_PROD
])) &&
218 (!table
->id_firmware
||
219 strstr((char *)&id
[ATA_ID_FW_REV
], table
->id_firmware
)))
223 EXPORT_SYMBOL_GPL(ide_in_drive_list
);
226 * Early UDMA66 devices don't set bit14 to 1, only bit13 is valid.
227 * We list them here and depend on the device side cable detection for them.
229 * Some optical devices with the buggy firmwares have the same problem.
231 static const struct drive_list_entry ivb_list
[] = {
232 { "QUANTUM FIREBALLlct10 05" , "A03.0900" },
233 { "TSSTcorp CDDVDW SH-S202J" , "SB00" },
234 { "TSSTcorp CDDVDW SH-S202J" , "SB01" },
235 { "TSSTcorp CDDVDW SH-S202N" , "SB00" },
236 { "TSSTcorp CDDVDW SH-S202N" , "SB01" },
237 { "TSSTcorp CDDVDW SH-S202H" , "SB00" },
238 { "TSSTcorp CDDVDW SH-S202H" , "SB01" },
239 { "SAMSUNG SP0822N" , "WA100-10" },
244 * All hosts that use the 80c ribbon must use!
245 * The name is derived from upper byte of word 93 and the 80c ribbon.
247 u8
eighty_ninty_three(ide_drive_t
*drive
)
249 ide_hwif_t
*hwif
= drive
->hwif
;
251 int ivb
= ide_in_drive_list(id
, ivb_list
);
253 if (hwif
->cbl
== ATA_CBL_PATA40_SHORT
)
257 printk(KERN_DEBUG
"%s: skipping word 93 validity check\n",
260 if (ata_id_is_sata(id
) && !ivb
)
263 if (hwif
->cbl
!= ATA_CBL_PATA80
&& !ivb
)
268 * - change master/slave IDENTIFY order
269 * - force bit13 (80c cable present) check also for !ivb devices
270 * (unless the slave device is pre-ATA3)
272 if ((id
[ATA_ID_HW_CONFIG
] & 0x4000) ||
273 (ivb
&& (id
[ATA_ID_HW_CONFIG
] & 0x2000)))
277 if (drive
->dev_flags
& IDE_DFLAG_UDMA33_WARNED
)
280 printk(KERN_WARNING
"%s: %s side 80-wire cable detection failed, "
281 "limiting max speed to UDMA33\n",
283 hwif
->cbl
== ATA_CBL_PATA80
? "drive" : "host");
285 drive
->dev_flags
|= IDE_DFLAG_UDMA33_WARNED
;
290 int ide_driveid_update(ide_drive_t
*drive
)
295 id
= kmalloc(SECTOR_SIZE
, GFP_ATOMIC
);
299 SELECT_MASK(drive
, 1);
300 rc
= ide_dev_read_id(drive
, ATA_CMD_ID_ATA
, id
);
301 SELECT_MASK(drive
, 0);
306 drive
->id
[ATA_ID_UDMA_MODES
] = id
[ATA_ID_UDMA_MODES
];
307 drive
->id
[ATA_ID_MWDMA_MODES
] = id
[ATA_ID_MWDMA_MODES
];
308 drive
->id
[ATA_ID_SWDMA_MODES
] = id
[ATA_ID_SWDMA_MODES
];
309 drive
->id
[ATA_ID_CFA_MODES
] = id
[ATA_ID_CFA_MODES
];
310 /* anything more ? */
314 if ((drive
->dev_flags
& IDE_DFLAG_USING_DMA
) && ide_id_dma_bug(drive
))
319 SELECT_MASK(drive
, 0);
321 printk(KERN_ERR
"%s: %s: bad status\n", drive
->name
, __func__
);
326 int ide_config_drive_speed(ide_drive_t
*drive
, u8 speed
)
328 ide_hwif_t
*hwif
= drive
->hwif
;
329 const struct ide_tp_ops
*tp_ops
= hwif
->tp_ops
;
330 u16
*id
= drive
->id
, i
;
335 #ifdef CONFIG_BLK_DEV_IDEDMA
336 if (hwif
->dma_ops
) /* check if host supports DMA */
337 hwif
->dma_ops
->dma_host_set(drive
, 0);
340 /* Skip setting PIO flow-control modes on pre-EIDE drives */
341 if ((speed
& 0xf8) == XFER_PIO_0
&& ata_id_has_iordy(drive
->id
) == 0)
345 * Don't use ide_wait_cmd here - it will
346 * attempt to set_geometry and recalibrate,
347 * but for some reason these don't work at
348 * this point (lost interrupt).
352 * FIXME: we race against the running IRQ here if
353 * this is called from non IRQ context. If we use
354 * disable_irq() we hang on the error path. Work
357 disable_irq_nosync(hwif
->irq
);
361 SELECT_MASK(drive
, 1);
363 tp_ops
->write_devctl(hwif
, ATA_NIEN
| ATA_DEVCTL_OBS
);
365 memset(&cmd
, 0, sizeof(cmd
));
366 cmd
.tf_flags
= IDE_TFLAG_OUT_FEATURE
| IDE_TFLAG_OUT_NSECT
;
367 cmd
.tf
.feature
= SETFEATURES_XFER
;
368 cmd
.tf
.nsect
= speed
;
370 tp_ops
->tf_load(drive
, &cmd
);
372 tp_ops
->exec_command(hwif
, ATA_CMD_SET_FEATURES
);
374 if (drive
->quirk_list
== 2)
375 tp_ops
->write_devctl(hwif
, ATA_DEVCTL_OBS
);
377 error
= __ide_wait_stat(drive
, drive
->ready_stat
,
378 ATA_BUSY
| ATA_DRQ
| ATA_ERR
,
381 SELECT_MASK(drive
, 0);
383 enable_irq(hwif
->irq
);
386 (void) ide_dump_status(drive
, "set_drive_speed_status", stat
);
390 if (speed
>= XFER_SW_DMA_0
) {
391 id
[ATA_ID_UDMA_MODES
] &= ~0xFF00;
392 id
[ATA_ID_MWDMA_MODES
] &= ~0x0700;
393 id
[ATA_ID_SWDMA_MODES
] &= ~0x0700;
394 if (ata_id_is_cfa(id
))
395 id
[ATA_ID_CFA_MODES
] &= ~0x0E00;
396 } else if (ata_id_is_cfa(id
))
397 id
[ATA_ID_CFA_MODES
] &= ~0x01C0;
400 #ifdef CONFIG_BLK_DEV_IDEDMA
401 if (speed
>= XFER_SW_DMA_0
&& (drive
->dev_flags
& IDE_DFLAG_USING_DMA
))
402 hwif
->dma_ops
->dma_host_set(drive
, 1);
403 else if (hwif
->dma_ops
) /* check if host supports DMA */
404 ide_dma_off_quietly(drive
);
407 if (speed
>= XFER_UDMA_0
) {
408 i
= 1 << (speed
- XFER_UDMA_0
);
409 id
[ATA_ID_UDMA_MODES
] |= (i
<< 8 | i
);
410 } else if (ata_id_is_cfa(id
) && speed
>= XFER_MW_DMA_3
) {
411 i
= speed
- XFER_MW_DMA_2
;
412 id
[ATA_ID_CFA_MODES
] |= i
<< 9;
413 } else if (speed
>= XFER_MW_DMA_0
) {
414 i
= 1 << (speed
- XFER_MW_DMA_0
);
415 id
[ATA_ID_MWDMA_MODES
] |= (i
<< 8 | i
);
416 } else if (speed
>= XFER_SW_DMA_0
) {
417 i
= 1 << (speed
- XFER_SW_DMA_0
);
418 id
[ATA_ID_SWDMA_MODES
] |= (i
<< 8 | i
);
419 } else if (ata_id_is_cfa(id
) && speed
>= XFER_PIO_5
) {
420 i
= speed
- XFER_PIO_4
;
421 id
[ATA_ID_CFA_MODES
] |= i
<< 6;
424 if (!drive
->init_speed
)
425 drive
->init_speed
= speed
;
426 drive
->current_speed
= speed
;
431 * This should get invoked any time we exit the driver to
432 * wait for an interrupt response from a drive. handler() points
433 * at the appropriate code to handle the next interrupt, and a
434 * timer is started to prevent us from waiting forever in case
435 * something goes wrong (see the ide_timer_expiry() handler later on).
437 * See also ide_execute_command
439 void __ide_set_handler(ide_drive_t
*drive
, ide_handler_t
*handler
,
440 unsigned int timeout
)
442 ide_hwif_t
*hwif
= drive
->hwif
;
444 BUG_ON(hwif
->handler
);
445 hwif
->handler
= handler
;
446 hwif
->timer
.expires
= jiffies
+ timeout
;
447 hwif
->req_gen_timer
= hwif
->req_gen
;
448 add_timer(&hwif
->timer
);
451 void ide_set_handler(ide_drive_t
*drive
, ide_handler_t
*handler
,
452 unsigned int timeout
)
454 ide_hwif_t
*hwif
= drive
->hwif
;
457 spin_lock_irqsave(&hwif
->lock
, flags
);
458 __ide_set_handler(drive
, handler
, timeout
);
459 spin_unlock_irqrestore(&hwif
->lock
, flags
);
461 EXPORT_SYMBOL(ide_set_handler
);
464 * ide_execute_command - execute an IDE command
465 * @drive: IDE drive to issue the command against
467 * @handler: handler for next phase
468 * @timeout: timeout for command
470 * Helper function to issue an IDE command. This handles the
471 * atomicity requirements, command timing and ensures that the
472 * handler and IRQ setup do not race. All IDE command kick off
473 * should go via this function or do equivalent locking.
476 void ide_execute_command(ide_drive_t
*drive
, struct ide_cmd
*cmd
,
477 ide_handler_t
*handler
, unsigned timeout
)
479 ide_hwif_t
*hwif
= drive
->hwif
;
482 spin_lock_irqsave(&hwif
->lock
, flags
);
483 if ((cmd
->protocol
!= ATAPI_PROT_DMA
&&
484 cmd
->protocol
!= ATAPI_PROT_PIO
) ||
485 (drive
->atapi_flags
& IDE_AFLAG_DRQ_INTERRUPT
))
486 __ide_set_handler(drive
, handler
, timeout
);
487 hwif
->tp_ops
->exec_command(hwif
, cmd
->tf
.command
);
489 * Drive takes 400nS to respond, we must avoid the IRQ being
490 * serviced before that.
492 * FIXME: we could skip this delay with care on non shared devices
495 spin_unlock_irqrestore(&hwif
->lock
, flags
);
499 * ide_wait_not_busy() waits for the currently selected device on the hwif
500 * to report a non-busy status, see comments in ide_probe_port().
502 int ide_wait_not_busy(ide_hwif_t
*hwif
, unsigned long timeout
)
508 * Turn this into a schedule() sleep once I'm sure
509 * about locking issues (2.5 work ?).
512 stat
= hwif
->tp_ops
->read_status(hwif
);
513 if ((stat
& ATA_BUSY
) == 0)
516 * Assume a value of 0xff means nothing is connected to
517 * the interface and it doesn't implement the pull-down
522 touch_softlockup_watchdog();
523 touch_nmi_watchdog();