2 * linux/drivers/ide/ide-dma.c Version 4.10 June 9, 2000
4 * Copyright (c) 1999-2000 Andre Hedrick <andre@linux-ide.org>
5 * May be copied or modified under the terms of the GNU General Public License
9 * Special Thanks to Mark for his Six years of work.
11 * Copyright (c) 1995-1998 Mark Lord
12 * May be copied or modified under the terms of the GNU General Public License
16 * This module provides support for the bus-master IDE DMA functions
17 * of various PCI chipsets, including the Intel PIIX (i82371FB for
18 * the 430 FX chipset), the PIIX3 (i82371SB for the 430 HX/VX and
19 * 440 chipsets), and the PIIX4 (i82371AB for the 430 TX chipset)
20 * ("PIIX" stands for "PCI ISA IDE Xcellerator").
22 * Pretty much the same code works for other IDE PCI bus-mastering chipsets.
24 * DMA is supported for all IDE devices (disk drives, cdroms, tapes, floppies).
26 * By default, DMA support is prepared for use, but is currently enabled only
27 * for drives which already have DMA enabled (UltraDMA or mode 2 multi/single),
28 * or which are recognized as "good" (see table below). Drives with only mode0
29 * or mode1 (multi/single) DMA should also work with this chipset/driver
30 * (eg. MC2112A) but are not enabled by default.
32 * Use "hdparm -i" to view modes supported by a given drive.
34 * The hdparm-3.5 (or later) utility can be used for manually enabling/disabling
35 * DMA support, but must be (re-)compiled against this kernel version or later.
37 * To enable DMA, use "hdparm -d1 /dev/hd?" on a per-drive basis after booting.
38 * If problems arise, ide.c will disable DMA operation after a few retries.
39 * This error recovery mechanism works and has been extremely well exercised.
41 * IDE drives, depending on their vintage, may support several different modes
42 * of DMA operation. The boot-time modes are indicated with a "*" in
43 * the "hdparm -i" listing, and can be changed with *knowledgeable* use of
44 * the "hdparm -X" feature. There is seldom a need to do this, as drives
45 * normally power-up with their "best" PIO/DMA modes enabled.
47 * Testing has been done with a rather extensive number of drives,
48 * with Quantum & Western Digital models generally outperforming the pack,
49 * and Fujitsu & Conner (and some Seagate which are really Conner) drives
50 * showing more lackluster throughput.
52 * Keep an eye on /var/adm/messages for "DMA disabled" messages.
54 * Some people have reported trouble with Intel Zappa motherboards.
55 * This can be fixed by upgrading the AMI BIOS to version 1.00.04.BS0,
56 * available from ftp://ftp.intel.com/pub/bios/10004bs0.exe
57 * (thanks to Glen Morrell <glen@spin.Stanford.edu> for researching this).
59 * Thanks to "Christopher J. Reimer" <reimer@doe.carleton.ca> for
60 * fixing the problem with the BIOS on some Acer motherboards.
62 * Thanks to "Benoit Poulot-Cazajous" <poulot@chorus.fr> for testing
63 * "TX" chipset compatibility and for providing patches for the "TX" chipset.
65 * Thanks to Christian Brunner <chb@muc.de> for taking a good first crack
66 * at generic DMA -- his patches were referred to when preparing this code.
68 * Most importantly, thanks to Robert Bringman <rob@mars.trion.com>
69 * for supplying a Promise UDMA board & WD UDMA drive for this work!
71 * And, yes, Intel Zappa boards really *do* use both PIIX IDE ports.
73 * ATA-66/100 and recovery functions, I forgot the rest......
77 #include <linux/module.h>
78 #include <linux/types.h>
79 #include <linux/kernel.h>
80 #include <linux/timer.h>
82 #include <linux/interrupt.h>
83 #include <linux/pci.h>
84 #include <linux/init.h>
85 #include <linux/ide.h>
86 #include <linux/delay.h>
87 #include <linux/scatterlist.h>
92 static const struct drive_list_entry drive_whitelist
[] = {
94 { "Micropolis 2112A" , NULL
},
95 { "CONNER CTMA 4000" , NULL
},
96 { "CONNER CTT8000-A" , NULL
},
97 { "ST34342A" , NULL
},
101 static const struct drive_list_entry drive_blacklist
[] = {
103 { "WDC AC11000H" , NULL
},
104 { "WDC AC22100H" , NULL
},
105 { "WDC AC32500H" , NULL
},
106 { "WDC AC33100H" , NULL
},
107 { "WDC AC31600H" , NULL
},
108 { "WDC AC32100H" , "24.09P07" },
109 { "WDC AC23200L" , "21.10N21" },
110 { "Compaq CRD-8241B" , NULL
},
111 { "CRD-8400B" , NULL
},
112 { "CRD-8480B", NULL
},
113 { "CRD-8482B", NULL
},
115 { "SanDisk SDP3B" , NULL
},
116 { "SanDisk SDP3B-64" , NULL
},
117 { "SANYO CD-ROM CRD" , NULL
},
118 { "HITACHI CDR-8" , NULL
},
119 { "HITACHI CDR-8335" , NULL
},
120 { "HITACHI CDR-8435" , NULL
},
121 { "Toshiba CD-ROM XM-6202B" , NULL
},
122 { "TOSHIBA CD-ROM XM-1702BC", NULL
},
123 { "CD-532E-A" , NULL
},
124 { "E-IDE CD-ROM CR-840", NULL
},
125 { "CD-ROM Drive/F5A", NULL
},
126 { "WPI CDD-820", NULL
},
127 { "SAMSUNG CD-ROM SC-148C", NULL
},
128 { "SAMSUNG CD-ROM SC", NULL
},
129 { "ATAPI CD-ROM DRIVE 40X MAXIMUM", NULL
},
130 { "_NEC DV5800A", NULL
},
131 { "SAMSUNG CD-ROM SN-124", "N001" },
132 { "Seagate STT20000A", NULL
},
133 { "CD-ROM CDR_U200", "1.09" },
139 * ide_dma_intr - IDE DMA interrupt handler
140 * @drive: the drive the interrupt is for
142 * Handle an interrupt completing a read/write DMA transfer on an
146 ide_startstop_t
ide_dma_intr (ide_drive_t
*drive
)
148 u8 stat
= 0, dma_stat
= 0;
150 dma_stat
= HWIF(drive
)->ide_dma_end(drive
);
151 stat
= HWIF(drive
)->INB(IDE_STATUS_REG
); /* get drive status */
152 if (OK_STAT(stat
,DRIVE_READY
,drive
->bad_wstat
|DRQ_STAT
)) {
154 struct request
*rq
= HWGROUP(drive
)->rq
;
156 task_end_request(drive
, rq
, stat
);
159 printk(KERN_ERR
"%s: dma_intr: bad DMA status (dma_stat=%x)\n",
160 drive
->name
, dma_stat
);
162 return ide_error(drive
, "dma_intr", stat
);
165 EXPORT_SYMBOL_GPL(ide_dma_intr
);
167 static int ide_dma_good_drive(ide_drive_t
*drive
)
169 return ide_in_drive_list(drive
->id
, drive_whitelist
);
172 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
174 * ide_build_sglist - map IDE scatter gather for DMA I/O
175 * @drive: the drive to build the DMA table for
176 * @rq: the request holding the sg list
178 * Perform the PCI mapping magic necessary to access the source or
179 * target buffers of a request via PCI DMA. The lower layers of the
180 * kernel provide the necessary cache management so that we can
181 * operate in a portable fashion
184 int ide_build_sglist(ide_drive_t
*drive
, struct request
*rq
)
186 ide_hwif_t
*hwif
= HWIF(drive
);
187 struct scatterlist
*sg
= hwif
->sg_table
;
189 BUG_ON((rq
->cmd_type
== REQ_TYPE_ATA_TASKFILE
) && rq
->nr_sectors
> 256);
191 ide_map_sg(drive
, rq
);
193 if (rq_data_dir(rq
) == READ
)
194 hwif
->sg_dma_direction
= PCI_DMA_FROMDEVICE
;
196 hwif
->sg_dma_direction
= PCI_DMA_TODEVICE
;
198 return pci_map_sg(hwif
->pci_dev
, sg
, hwif
->sg_nents
, hwif
->sg_dma_direction
);
201 EXPORT_SYMBOL_GPL(ide_build_sglist
);
204 * ide_build_dmatable - build IDE DMA table
206 * ide_build_dmatable() prepares a dma request. We map the command
207 * to get the pci bus addresses of the buffers and then build up
208 * the PRD table that the IDE layer wants to be fed. The code
209 * knows about the 64K wrap bug in the CS5530.
211 * Returns the number of built PRD entries if all went okay,
212 * returns 0 otherwise.
214 * May also be invoked from trm290.c
217 int ide_build_dmatable (ide_drive_t
*drive
, struct request
*rq
)
219 ide_hwif_t
*hwif
= HWIF(drive
);
220 unsigned int *table
= hwif
->dmatable_cpu
;
221 unsigned int is_trm290
= (hwif
->chipset
== ide_trm290
) ? 1 : 0;
222 unsigned int count
= 0;
224 struct scatterlist
*sg
;
226 hwif
->sg_nents
= i
= ide_build_sglist(drive
, rq
);
236 cur_addr
= sg_dma_address(sg
);
237 cur_len
= sg_dma_len(sg
);
240 * Fill in the dma table, without crossing any 64kB boundaries.
241 * Most hardware requires 16-bit alignment of all blocks,
242 * but the trm290 requires 32-bit alignment.
246 if (count
++ >= PRD_ENTRIES
) {
247 printk(KERN_ERR
"%s: DMA table too small\n", drive
->name
);
248 goto use_pio_instead
;
250 u32 xcount
, bcount
= 0x10000 - (cur_addr
& 0xffff);
252 if (bcount
> cur_len
)
254 *table
++ = cpu_to_le32(cur_addr
);
255 xcount
= bcount
& 0xffff;
257 xcount
= ((xcount
>> 2) - 1) << 16;
258 if (xcount
== 0x0000) {
260 * Most chipsets correctly interpret a length of 0x0000 as 64KB,
261 * but at least one (e.g. CS5530) misinterprets it as zero (!).
262 * So here we break the 64KB entry into two 32KB entries instead.
264 if (count
++ >= PRD_ENTRIES
) {
265 printk(KERN_ERR
"%s: DMA table too small\n", drive
->name
);
266 goto use_pio_instead
;
268 *table
++ = cpu_to_le32(0x8000);
269 *table
++ = cpu_to_le32(cur_addr
+ 0x8000);
272 *table
++ = cpu_to_le32(xcount
);
284 *--table
|= cpu_to_le32(0x80000000);
287 printk(KERN_ERR
"%s: empty DMA table?\n", drive
->name
);
289 pci_unmap_sg(hwif
->pci_dev
,
292 hwif
->sg_dma_direction
);
293 return 0; /* revert to PIO for this request */
296 EXPORT_SYMBOL_GPL(ide_build_dmatable
);
299 * ide_destroy_dmatable - clean up DMA mapping
300 * @drive: The drive to unmap
302 * Teardown mappings after DMA has completed. This must be called
303 * after the completion of each use of ide_build_dmatable and before
304 * the next use of ide_build_dmatable. Failure to do so will cause
305 * an oops as only one mapping can be live for each target at a given
309 void ide_destroy_dmatable (ide_drive_t
*drive
)
311 struct pci_dev
*dev
= HWIF(drive
)->pci_dev
;
312 struct scatterlist
*sg
= HWIF(drive
)->sg_table
;
313 int nents
= HWIF(drive
)->sg_nents
;
315 pci_unmap_sg(dev
, sg
, nents
, HWIF(drive
)->sg_dma_direction
);
318 EXPORT_SYMBOL_GPL(ide_destroy_dmatable
);
321 * config_drive_for_dma - attempt to activate IDE DMA
322 * @drive: the drive to place in DMA mode
324 * If the drive supports at least mode 2 DMA or UDMA of any kind
325 * then attempt to place it into DMA mode. Drives that are known to
326 * support DMA but predate the DMA properties or that are known
327 * to have DMA handling bugs are also set up appropriately based
328 * on the good/bad drive lists.
331 static int config_drive_for_dma (ide_drive_t
*drive
)
333 ide_hwif_t
*hwif
= drive
->hwif
;
334 struct hd_driveid
*id
= drive
->id
;
336 if (drive
->media
!= ide_disk
) {
337 if (hwif
->host_flags
& IDE_HFLAG_NO_ATAPI_DMA
)
342 * Enable DMA on any drive that has
343 * UltraDMA (mode 0/1/2/3/4/5/6) enabled
345 if ((id
->field_valid
& 4) && ((id
->dma_ultra
>> 8) & 0x7f))
349 * Enable DMA on any drive that has mode2 DMA
350 * (multi or single) enabled
352 if (id
->field_valid
& 2) /* regular DMA */
353 if ((id
->dma_mword
& 0x404) == 0x404 ||
354 (id
->dma_1word
& 0x404) == 0x404)
357 /* Consult the list of known "good" drives */
358 if (ide_dma_good_drive(drive
))
365 * dma_timer_expiry - handle a DMA timeout
366 * @drive: Drive that timed out
368 * An IDE DMA transfer timed out. In the event of an error we ask
369 * the driver to resolve the problem, if a DMA transfer is still
370 * in progress we continue to wait (arguably we need to add a
371 * secondary 'I don't care what the drive thinks' timeout here)
372 * Finally if we have an interrupt we let it complete the I/O.
373 * But only one time - we clear expiry and if it's still not
374 * completed after WAIT_CMD, we error and retry in PIO.
375 * This can occur if an interrupt is lost or due to hang or bugs.
378 static int dma_timer_expiry (ide_drive_t
*drive
)
380 ide_hwif_t
*hwif
= HWIF(drive
);
381 u8 dma_stat
= hwif
->INB(hwif
->dma_status
);
383 printk(KERN_WARNING
"%s: dma_timer_expiry: dma status == 0x%02x\n",
384 drive
->name
, dma_stat
);
386 if ((dma_stat
& 0x18) == 0x18) /* BUSY Stupid Early Timer !! */
389 HWGROUP(drive
)->expiry
= NULL
; /* one free ride for now */
391 /* 1 dmaing, 2 error, 4 intr */
392 if (dma_stat
& 2) /* ERROR */
395 if (dma_stat
& 1) /* DMAing */
398 if (dma_stat
& 4) /* Got an Interrupt */
401 return 0; /* Status is unknown -- reset the bus */
405 * ide_dma_host_set - Enable/disable DMA on a host
406 * @drive: drive to control
408 * Enable/disable DMA on an IDE controller following generic
409 * bus-mastering IDE controller behaviour.
412 void ide_dma_host_set(ide_drive_t
*drive
, int on
)
414 ide_hwif_t
*hwif
= HWIF(drive
);
415 u8 unit
= (drive
->select
.b
.unit
& 0x01);
416 u8 dma_stat
= hwif
->INB(hwif
->dma_status
);
419 dma_stat
|= (1 << (5 + unit
));
421 dma_stat
&= ~(1 << (5 + unit
));
423 hwif
->OUTB(dma_stat
, hwif
->dma_status
);
426 EXPORT_SYMBOL_GPL(ide_dma_host_set
);
427 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
430 * ide_dma_off_quietly - Generic DMA kill
431 * @drive: drive to control
433 * Turn off the current DMA on this IDE controller.
436 void ide_dma_off_quietly(ide_drive_t
*drive
)
438 drive
->using_dma
= 0;
439 ide_toggle_bounce(drive
, 0);
441 drive
->hwif
->dma_host_set(drive
, 0);
444 EXPORT_SYMBOL(ide_dma_off_quietly
);
447 * ide_dma_off - disable DMA on a device
448 * @drive: drive to disable DMA on
450 * Disable IDE DMA for a device on this IDE controller.
451 * Inform the user that DMA has been disabled.
454 void ide_dma_off(ide_drive_t
*drive
)
456 printk(KERN_INFO
"%s: DMA disabled\n", drive
->name
);
457 ide_dma_off_quietly(drive
);
460 EXPORT_SYMBOL(ide_dma_off
);
463 * ide_dma_on - Enable DMA on a device
464 * @drive: drive to enable DMA on
466 * Enable IDE DMA for a device on this IDE controller.
469 void ide_dma_on(ide_drive_t
*drive
)
471 drive
->using_dma
= 1;
472 ide_toggle_bounce(drive
, 1);
474 drive
->hwif
->dma_host_set(drive
, 1);
477 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
479 * ide_dma_setup - begin a DMA phase
480 * @drive: target device
482 * Build an IDE DMA PRD (IDE speak for scatter gather table)
483 * and then set up the DMA transfer registers for a device
484 * that follows generic IDE PCI DMA behaviour. Controllers can
485 * override this function if they need to
487 * Returns 0 on success. If a PIO fallback is required then 1
491 int ide_dma_setup(ide_drive_t
*drive
)
493 ide_hwif_t
*hwif
= drive
->hwif
;
494 struct request
*rq
= HWGROUP(drive
)->rq
;
495 unsigned int reading
;
503 /* fall back to pio! */
504 if (!ide_build_dmatable(drive
, rq
)) {
505 ide_map_sg(drive
, rq
);
511 writel(hwif
->dmatable_dma
, (void __iomem
*)hwif
->dma_prdtable
);
513 outl(hwif
->dmatable_dma
, hwif
->dma_prdtable
);
516 hwif
->OUTB(reading
, hwif
->dma_command
);
518 /* read dma_status for INTR & ERROR flags */
519 dma_stat
= hwif
->INB(hwif
->dma_status
);
521 /* clear INTR & ERROR flags */
522 hwif
->OUTB(dma_stat
|6, hwif
->dma_status
);
523 drive
->waiting_for_dma
= 1;
527 EXPORT_SYMBOL_GPL(ide_dma_setup
);
529 static void ide_dma_exec_cmd(ide_drive_t
*drive
, u8 command
)
531 /* issue cmd to drive */
532 ide_execute_command(drive
, command
, &ide_dma_intr
, 2*WAIT_CMD
, dma_timer_expiry
);
535 void ide_dma_start(ide_drive_t
*drive
)
537 ide_hwif_t
*hwif
= HWIF(drive
);
538 u8 dma_cmd
= hwif
->INB(hwif
->dma_command
);
540 /* Note that this is done *after* the cmd has
541 * been issued to the drive, as per the BM-IDE spec.
542 * The Promise Ultra33 doesn't work correctly when
543 * we do this part before issuing the drive cmd.
546 hwif
->OUTB(dma_cmd
|1, hwif
->dma_command
);
551 EXPORT_SYMBOL_GPL(ide_dma_start
);
553 /* returns 1 on error, 0 otherwise */
554 int __ide_dma_end (ide_drive_t
*drive
)
556 ide_hwif_t
*hwif
= HWIF(drive
);
557 u8 dma_stat
= 0, dma_cmd
= 0;
559 drive
->waiting_for_dma
= 0;
560 /* get dma_command mode */
561 dma_cmd
= hwif
->INB(hwif
->dma_command
);
563 hwif
->OUTB(dma_cmd
&~1, hwif
->dma_command
);
565 dma_stat
= hwif
->INB(hwif
->dma_status
);
566 /* clear the INTR & ERROR bits */
567 hwif
->OUTB(dma_stat
|6, hwif
->dma_status
);
568 /* purge DMA mappings */
569 ide_destroy_dmatable(drive
);
570 /* verify good DMA status */
573 return (dma_stat
& 7) != 4 ? (0x10 | dma_stat
) : 0;
576 EXPORT_SYMBOL(__ide_dma_end
);
578 /* returns 1 if dma irq issued, 0 otherwise */
579 static int __ide_dma_test_irq(ide_drive_t
*drive
)
581 ide_hwif_t
*hwif
= HWIF(drive
);
582 u8 dma_stat
= hwif
->INB(hwif
->dma_status
);
584 /* return 1 if INTR asserted */
585 if ((dma_stat
& 4) == 4)
587 if (!drive
->waiting_for_dma
)
588 printk(KERN_WARNING
"%s: (%s) called while not waiting\n",
589 drive
->name
, __FUNCTION__
);
593 static inline int config_drive_for_dma(ide_drive_t
*drive
) { return 0; }
594 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
596 int __ide_dma_bad_drive (ide_drive_t
*drive
)
598 struct hd_driveid
*id
= drive
->id
;
600 int blacklist
= ide_in_drive_list(id
, drive_blacklist
);
602 printk(KERN_WARNING
"%s: Disabling (U)DMA for %s (blacklisted)\n",
603 drive
->name
, id
->model
);
609 EXPORT_SYMBOL(__ide_dma_bad_drive
);
611 static const u8 xfer_mode_bases
[] = {
617 static unsigned int ide_get_mode_mask(ide_drive_t
*drive
, u8 base
, u8 req_mode
)
619 struct hd_driveid
*id
= drive
->id
;
620 ide_hwif_t
*hwif
= drive
->hwif
;
621 unsigned int mask
= 0;
625 if ((id
->field_valid
& 4) == 0)
628 if (hwif
->udma_filter
)
629 mask
= hwif
->udma_filter(drive
);
631 mask
= hwif
->ultra_mask
;
632 mask
&= id
->dma_ultra
;
635 * avoid false cable warning from eighty_ninty_three()
637 if (req_mode
> XFER_UDMA_2
) {
638 if ((mask
& 0x78) && (eighty_ninty_three(drive
) == 0))
643 if ((id
->field_valid
& 2) == 0)
645 if (hwif
->mdma_filter
)
646 mask
= hwif
->mdma_filter(drive
);
648 mask
= hwif
->mwdma_mask
;
649 mask
&= id
->dma_mword
;
652 if (id
->field_valid
& 2) {
653 mask
= id
->dma_1word
& hwif
->swdma_mask
;
654 } else if (id
->tDMA
) {
656 * ide_fix_driveid() doesn't convert ->tDMA to the
657 * CPU endianness so we need to do it here
659 u8 mode
= le16_to_cpu(id
->tDMA
);
662 * if the mode is valid convert it to the mask
663 * (the maximum allowed mode is XFER_SW_DMA_2)
666 mask
= ((2 << mode
) - 1) & hwif
->swdma_mask
;
678 * ide_find_dma_mode - compute DMA speed
680 * @req_mode: requested mode
682 * Checks the drive/host capabilities and finds the speed to use for
683 * the DMA transfer. The speed is then limited by the requested mode.
685 * Returns 0 if the drive/host combination is incapable of DMA transfers
686 * or if the requested mode is not a DMA mode.
689 u8
ide_find_dma_mode(ide_drive_t
*drive
, u8 req_mode
)
691 ide_hwif_t
*hwif
= drive
->hwif
;
696 if (drive
->media
!= ide_disk
) {
697 if (hwif
->host_flags
& IDE_HFLAG_NO_ATAPI_DMA
)
701 for (i
= 0; i
< ARRAY_SIZE(xfer_mode_bases
); i
++) {
702 if (req_mode
< xfer_mode_bases
[i
])
704 mask
= ide_get_mode_mask(drive
, xfer_mode_bases
[i
], req_mode
);
707 mode
= xfer_mode_bases
[i
] + x
;
712 if (hwif
->chipset
== ide_acorn
&& mode
== 0) {
716 if (ide_dma_good_drive(drive
) && drive
->id
->eide_dma_time
< 150)
717 mode
= XFER_MW_DMA_1
;
720 mode
= min(mode
, req_mode
);
722 printk(KERN_INFO
"%s: %s mode selected\n", drive
->name
,
723 mode
? ide_xfer_verbose(mode
) : "no DMA");
728 EXPORT_SYMBOL_GPL(ide_find_dma_mode
);
730 static int ide_tune_dma(ide_drive_t
*drive
)
732 ide_hwif_t
*hwif
= drive
->hwif
;
735 if (noautodma
|| drive
->nodma
|| (drive
->id
->capability
& 1) == 0)
738 /* consult the list of known "bad" drives */
739 if (__ide_dma_bad_drive(drive
))
742 if (ide_id_dma_bug(drive
))
745 if (hwif
->host_flags
& IDE_HFLAG_TRUST_BIOS_FOR_DMA
)
746 return config_drive_for_dma(drive
);
748 speed
= ide_max_dma_mode(drive
);
751 /* is this really correct/needed? */
752 if ((hwif
->host_flags
& IDE_HFLAG_CY82C693
) &&
753 ide_dma_good_drive(drive
))
759 if (hwif
->host_flags
& IDE_HFLAG_NO_SET_MODE
)
762 if (ide_set_dma_mode(drive
, speed
))
768 static int ide_dma_check(ide_drive_t
*drive
)
770 ide_hwif_t
*hwif
= drive
->hwif
;
771 int vdma
= (hwif
->host_flags
& IDE_HFLAG_VDMA
)? 1 : 0;
773 if (!vdma
&& ide_tune_dma(drive
))
776 /* TODO: always do PIO fallback */
777 if (hwif
->host_flags
& IDE_HFLAG_TRUST_BIOS_FOR_DMA
)
780 ide_set_max_pio(drive
);
782 return vdma
? 0 : -1;
785 int ide_id_dma_bug(ide_drive_t
*drive
)
787 struct hd_driveid
*id
= drive
->id
;
789 if (id
->field_valid
& 4) {
790 if ((id
->dma_ultra
>> 8) && (id
->dma_mword
>> 8))
792 } else if (id
->field_valid
& 2) {
793 if ((id
->dma_mword
>> 8) && (id
->dma_1word
>> 8))
798 printk(KERN_ERR
"%s: bad DMA info in identify block\n", drive
->name
);
802 int ide_set_dma(ide_drive_t
*drive
)
807 * Force DMAing for the beginning of the check.
808 * Some chipsets appear to do interesting
809 * things, if not checked and cleared.
812 ide_dma_off_quietly(drive
);
814 rc
= ide_dma_check(drive
);
823 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
824 void ide_dma_lost_irq (ide_drive_t
*drive
)
826 printk("%s: DMA interrupt recovery\n", drive
->name
);
829 EXPORT_SYMBOL(ide_dma_lost_irq
);
831 void ide_dma_timeout (ide_drive_t
*drive
)
833 ide_hwif_t
*hwif
= HWIF(drive
);
835 printk(KERN_ERR
"%s: timeout waiting for DMA\n", drive
->name
);
837 if (hwif
->ide_dma_test_irq(drive
))
840 hwif
->ide_dma_end(drive
);
843 EXPORT_SYMBOL(ide_dma_timeout
);
845 static void ide_release_dma_engine(ide_hwif_t
*hwif
)
847 if (hwif
->dmatable_cpu
) {
848 pci_free_consistent(hwif
->pci_dev
,
849 PRD_ENTRIES
* PRD_BYTES
,
852 hwif
->dmatable_cpu
= NULL
;
856 static int ide_release_iomio_dma(ide_hwif_t
*hwif
)
858 release_region(hwif
->dma_base
, 8);
859 if (hwif
->extra_ports
)
860 release_region(hwif
->extra_base
, hwif
->extra_ports
);
865 * Needed for allowing full modular support of ide-driver
867 int ide_release_dma(ide_hwif_t
*hwif
)
869 ide_release_dma_engine(hwif
);
874 return ide_release_iomio_dma(hwif
);
877 static int ide_allocate_dma_engine(ide_hwif_t
*hwif
)
879 hwif
->dmatable_cpu
= pci_alloc_consistent(hwif
->pci_dev
,
880 PRD_ENTRIES
* PRD_BYTES
,
881 &hwif
->dmatable_dma
);
883 if (hwif
->dmatable_cpu
)
886 printk(KERN_ERR
"%s: -- Error, unable to allocate DMA table.\n",
892 static int ide_mapped_mmio_dma(ide_hwif_t
*hwif
, unsigned long base
, unsigned int ports
)
894 printk(KERN_INFO
" %s: MMIO-DMA ", hwif
->name
);
899 static int ide_iomio_dma(ide_hwif_t
*hwif
, unsigned long base
, unsigned int ports
)
901 printk(KERN_INFO
" %s: BM-DMA at 0x%04lx-0x%04lx",
902 hwif
->name
, base
, base
+ ports
- 1);
904 if (!request_region(base
, ports
, hwif
->name
)) {
905 printk(" -- Error, ports in use.\n");
909 if (hwif
->cds
->extra
) {
910 hwif
->extra_base
= base
+ (hwif
->channel
? 8 : 16);
912 if (!hwif
->mate
|| !hwif
->mate
->extra_ports
) {
913 if (!request_region(hwif
->extra_base
,
914 hwif
->cds
->extra
, hwif
->cds
->name
)) {
915 printk(" -- Error, extra ports in use.\n");
916 release_region(base
, ports
);
919 hwif
->extra_ports
= hwif
->cds
->extra
;
926 static int ide_dma_iobase(ide_hwif_t
*hwif
, unsigned long base
, unsigned int ports
)
929 return ide_mapped_mmio_dma(hwif
, base
,ports
);
931 return ide_iomio_dma(hwif
, base
, ports
);
934 void ide_setup_dma(ide_hwif_t
*hwif
, unsigned long base
, unsigned num_ports
)
938 if (ide_dma_iobase(hwif
, base
, num_ports
))
941 if (ide_allocate_dma_engine(hwif
)) {
942 ide_release_dma(hwif
);
946 hwif
->dma_base
= base
;
948 if (!(hwif
->dma_command
))
949 hwif
->dma_command
= hwif
->dma_base
;
950 if (!(hwif
->dma_vendor1
))
951 hwif
->dma_vendor1
= (hwif
->dma_base
+ 1);
952 if (!(hwif
->dma_status
))
953 hwif
->dma_status
= (hwif
->dma_base
+ 2);
954 if (!(hwif
->dma_vendor3
))
955 hwif
->dma_vendor3
= (hwif
->dma_base
+ 3);
956 if (!(hwif
->dma_prdtable
))
957 hwif
->dma_prdtable
= (hwif
->dma_base
+ 4);
959 if (!hwif
->dma_host_set
)
960 hwif
->dma_host_set
= &ide_dma_host_set
;
961 if (!hwif
->dma_setup
)
962 hwif
->dma_setup
= &ide_dma_setup
;
963 if (!hwif
->dma_exec_cmd
)
964 hwif
->dma_exec_cmd
= &ide_dma_exec_cmd
;
965 if (!hwif
->dma_start
)
966 hwif
->dma_start
= &ide_dma_start
;
967 if (!hwif
->ide_dma_end
)
968 hwif
->ide_dma_end
= &__ide_dma_end
;
969 if (!hwif
->ide_dma_test_irq
)
970 hwif
->ide_dma_test_irq
= &__ide_dma_test_irq
;
971 if (!hwif
->dma_timeout
)
972 hwif
->dma_timeout
= &ide_dma_timeout
;
973 if (!hwif
->dma_lost_irq
)
974 hwif
->dma_lost_irq
= &ide_dma_lost_irq
;
976 dma_stat
= hwif
->INB(hwif
->dma_status
);
977 printk(KERN_CONT
", BIOS settings: %s:%s, %s:%s\n",
978 hwif
->drives
[0].name
, (dma_stat
& 0x20) ? "DMA" : "PIO",
979 hwif
->drives
[1].name
, (dma_stat
& 0x40) ? "DMA" : "PIO");
982 EXPORT_SYMBOL_GPL(ide_setup_dma
);
983 #endif /* CONFIG_BLK_DEV_IDEDMA_PCI */