2 * IDE DMA support (including IDE PCI BM-DMA).
4 * Copyright (C) 1995-1998 Mark Lord
5 * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org>
6 * Copyright (C) 2004, 2007 Bartlomiej Zolnierkiewicz
8 * May be copied or modified under the terms of the GNU General Public License
10 * DMA is supported for all IDE devices (disk drives, cdroms, tapes, floppies).
14 * Special Thanks to Mark for his Six years of work.
18 * Thanks to "Christopher J. Reimer" <reimer@doe.carleton.ca> for
19 * fixing the problem with the BIOS on some Acer motherboards.
21 * Thanks to "Benoit Poulot-Cazajous" <poulot@chorus.fr> for testing
22 * "TX" chipset compatibility and for providing patches for the "TX" chipset.
24 * Thanks to Christian Brunner <chb@muc.de> for taking a good first crack
25 * at generic DMA -- his patches were referred to when preparing this code.
27 * Most importantly, thanks to Robert Bringman <rob@mars.trion.com>
28 * for supplying a Promise UDMA board & WD UDMA drive for this work!
31 #include <linux/types.h>
32 #include <linux/kernel.h>
33 #include <linux/ide.h>
34 #include <linux/scatterlist.h>
35 #include <linux/dma-mapping.h>
39 static const struct drive_list_entry drive_whitelist
[] = {
41 { "Micropolis 2112A" , NULL
},
42 { "CONNER CTMA 4000" , NULL
},
43 { "CONNER CTT8000-A" , NULL
},
44 { "ST34342A" , NULL
},
48 static const struct drive_list_entry drive_blacklist
[] = {
50 { "WDC AC11000H" , NULL
},
51 { "WDC AC22100H" , NULL
},
52 { "WDC AC32500H" , NULL
},
53 { "WDC AC33100H" , NULL
},
54 { "WDC AC31600H" , NULL
},
55 { "WDC AC32100H" , "24.09P07" },
56 { "WDC AC23200L" , "21.10N21" },
57 { "Compaq CRD-8241B" , NULL
},
58 { "CRD-8400B" , NULL
},
59 { "CRD-8480B", NULL
},
60 { "CRD-8482B", NULL
},
62 { "SanDisk SDP3B" , NULL
},
63 { "SanDisk SDP3B-64" , NULL
},
64 { "SANYO CD-ROM CRD" , NULL
},
65 { "HITACHI CDR-8" , NULL
},
66 { "HITACHI CDR-8335" , NULL
},
67 { "HITACHI CDR-8435" , NULL
},
68 { "Toshiba CD-ROM XM-6202B" , NULL
},
69 { "TOSHIBA CD-ROM XM-1702BC", NULL
},
70 { "CD-532E-A" , NULL
},
71 { "E-IDE CD-ROM CR-840", NULL
},
72 { "CD-ROM Drive/F5A", NULL
},
73 { "WPI CDD-820", NULL
},
74 { "SAMSUNG CD-ROM SC-148C", NULL
},
75 { "SAMSUNG CD-ROM SC", NULL
},
76 { "ATAPI CD-ROM DRIVE 40X MAXIMUM", NULL
},
77 { "_NEC DV5800A", NULL
},
78 { "SAMSUNG CD-ROM SN-124", "N001" },
79 { "Seagate STT20000A", NULL
},
80 { "CD-ROM CDR_U200", "1.09" },
86 * ide_dma_intr - IDE DMA interrupt handler
87 * @drive: the drive the interrupt is for
89 * Handle an interrupt completing a read/write DMA transfer on an
93 ide_startstop_t
ide_dma_intr (ide_drive_t
*drive
)
95 ide_hwif_t
*hwif
= drive
->hwif
;
96 u8 stat
= 0, dma_stat
= 0;
98 dma_stat
= hwif
->dma_ops
->dma_end(drive
);
99 stat
= hwif
->tp_ops
->read_status(hwif
);
101 if (OK_STAT(stat
, DRIVE_READY
, drive
->bad_wstat
| ATA_DRQ
)) {
103 struct request
*rq
= HWGROUP(drive
)->rq
;
105 task_end_request(drive
, rq
, stat
);
108 printk(KERN_ERR
"%s: dma_intr: bad DMA status (dma_stat=%x)\n",
109 drive
->name
, dma_stat
);
111 return ide_error(drive
, "dma_intr", stat
);
114 EXPORT_SYMBOL_GPL(ide_dma_intr
);
116 static int ide_dma_good_drive(ide_drive_t
*drive
)
118 return ide_in_drive_list(drive
->id
, drive_whitelist
);
122 * ide_build_sglist - map IDE scatter gather for DMA I/O
123 * @drive: the drive to build the DMA table for
124 * @rq: the request holding the sg list
126 * Perform the DMA mapping magic necessary to access the source or
127 * target buffers of a request via DMA. The lower layers of the
128 * kernel provide the necessary cache management so that we can
129 * operate in a portable fashion.
132 int ide_build_sglist(ide_drive_t
*drive
, struct request
*rq
)
134 ide_hwif_t
*hwif
= HWIF(drive
);
135 struct scatterlist
*sg
= hwif
->sg_table
;
137 ide_map_sg(drive
, rq
);
139 if (rq_data_dir(rq
) == READ
)
140 hwif
->sg_dma_direction
= DMA_FROM_DEVICE
;
142 hwif
->sg_dma_direction
= DMA_TO_DEVICE
;
144 return dma_map_sg(hwif
->dev
, sg
, hwif
->sg_nents
,
145 hwif
->sg_dma_direction
);
148 EXPORT_SYMBOL_GPL(ide_build_sglist
);
150 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
152 * ide_build_dmatable - build IDE DMA table
154 * ide_build_dmatable() prepares a dma request. We map the command
155 * to get the pci bus addresses of the buffers and then build up
156 * the PRD table that the IDE layer wants to be fed.
158 * Most chipsets correctly interpret a length of 0x0000 as 64KB,
159 * but at least one (e.g. CS5530) misinterprets it as zero (!).
160 * So we break the 64KB entry into two 32KB entries instead.
162 * Returns the number of built PRD entries if all went okay,
163 * returns 0 otherwise.
165 * May also be invoked from trm290.c
168 int ide_build_dmatable (ide_drive_t
*drive
, struct request
*rq
)
170 ide_hwif_t
*hwif
= HWIF(drive
);
171 __le32
*table
= (__le32
*)hwif
->dmatable_cpu
;
172 unsigned int is_trm290
= (hwif
->chipset
== ide_trm290
) ? 1 : 0;
173 unsigned int count
= 0;
175 struct scatterlist
*sg
;
177 hwif
->sg_nents
= ide_build_sglist(drive
, rq
);
178 if (hwif
->sg_nents
== 0)
181 for_each_sg(hwif
->sg_table
, sg
, hwif
->sg_nents
, i
) {
182 u32 cur_addr
, cur_len
, xcount
, bcount
;
184 cur_addr
= sg_dma_address(sg
);
185 cur_len
= sg_dma_len(sg
);
188 * Fill in the dma table, without crossing any 64kB boundaries.
189 * Most hardware requires 16-bit alignment of all blocks,
190 * but the trm290 requires 32-bit alignment.
194 if (count
++ >= PRD_ENTRIES
)
195 goto use_pio_instead
;
197 bcount
= 0x10000 - (cur_addr
& 0xffff);
198 if (bcount
> cur_len
)
200 *table
++ = cpu_to_le32(cur_addr
);
201 xcount
= bcount
& 0xffff;
203 xcount
= ((xcount
>> 2) - 1) << 16;
204 if (xcount
== 0x0000) {
205 if (count
++ >= PRD_ENTRIES
)
206 goto use_pio_instead
;
207 *table
++ = cpu_to_le32(0x8000);
208 *table
++ = cpu_to_le32(cur_addr
+ 0x8000);
211 *table
++ = cpu_to_le32(xcount
);
219 *--table
|= cpu_to_le32(0x80000000);
224 printk(KERN_ERR
"%s: %s\n", drive
->name
,
225 count
? "DMA table too small" : "empty DMA table?");
227 ide_destroy_dmatable(drive
);
229 return 0; /* revert to PIO for this request */
231 EXPORT_SYMBOL_GPL(ide_build_dmatable
);
235 * ide_destroy_dmatable - clean up DMA mapping
236 * @drive: The drive to unmap
238 * Teardown mappings after DMA has completed. This must be called
239 * after the completion of each use of ide_build_dmatable and before
240 * the next use of ide_build_dmatable. Failure to do so will cause
241 * an oops as only one mapping can be live for each target at a given
245 void ide_destroy_dmatable (ide_drive_t
*drive
)
247 ide_hwif_t
*hwif
= drive
->hwif
;
249 dma_unmap_sg(hwif
->dev
, hwif
->sg_table
, hwif
->sg_nents
,
250 hwif
->sg_dma_direction
);
253 EXPORT_SYMBOL_GPL(ide_destroy_dmatable
);
255 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
257 * config_drive_for_dma - attempt to activate IDE DMA
258 * @drive: the drive to place in DMA mode
260 * If the drive supports at least mode 2 DMA or UDMA of any kind
261 * then attempt to place it into DMA mode. Drives that are known to
262 * support DMA but predate the DMA properties or that are known
263 * to have DMA handling bugs are also set up appropriately based
264 * on the good/bad drive lists.
267 static int config_drive_for_dma (ide_drive_t
*drive
)
269 ide_hwif_t
*hwif
= drive
->hwif
;
272 if (drive
->media
!= ide_disk
) {
273 if (hwif
->host_flags
& IDE_HFLAG_NO_ATAPI_DMA
)
278 * Enable DMA on any drive that has
279 * UltraDMA (mode 0/1/2/3/4/5/6) enabled
281 if ((id
[ATA_ID_FIELD_VALID
] & 4) &&
282 ((id
[ATA_ID_UDMA_MODES
] >> 8) & 0x7f))
286 * Enable DMA on any drive that has mode2 DMA
287 * (multi or single) enabled
289 if (id
[ATA_ID_FIELD_VALID
] & 2) /* regular DMA */
290 if ((id
[ATA_ID_MWDMA_MODES
] & 0x404) == 0x404 ||
291 (id
[ATA_ID_SWDMA_MODES
] & 0x404) == 0x404)
294 /* Consult the list of known "good" drives */
295 if (ide_dma_good_drive(drive
))
302 * dma_timer_expiry - handle a DMA timeout
303 * @drive: Drive that timed out
305 * An IDE DMA transfer timed out. In the event of an error we ask
306 * the driver to resolve the problem, if a DMA transfer is still
307 * in progress we continue to wait (arguably we need to add a
308 * secondary 'I don't care what the drive thinks' timeout here)
309 * Finally if we have an interrupt we let it complete the I/O.
310 * But only one time - we clear expiry and if it's still not
311 * completed after WAIT_CMD, we error and retry in PIO.
312 * This can occur if an interrupt is lost or due to hang or bugs.
315 static int dma_timer_expiry (ide_drive_t
*drive
)
317 ide_hwif_t
*hwif
= HWIF(drive
);
318 u8 dma_stat
= hwif
->tp_ops
->read_sff_dma_status(hwif
);
320 printk(KERN_WARNING
"%s: dma_timer_expiry: dma status == 0x%02x\n",
321 drive
->name
, dma_stat
);
323 if ((dma_stat
& 0x18) == 0x18) /* BUSY Stupid Early Timer !! */
326 HWGROUP(drive
)->expiry
= NULL
; /* one free ride for now */
328 /* 1 dmaing, 2 error, 4 intr */
329 if (dma_stat
& 2) /* ERROR */
332 if (dma_stat
& 1) /* DMAing */
335 if (dma_stat
& 4) /* Got an Interrupt */
338 return 0; /* Status is unknown -- reset the bus */
342 * ide_dma_host_set - Enable/disable DMA on a host
343 * @drive: drive to control
345 * Enable/disable DMA on an IDE controller following generic
346 * bus-mastering IDE controller behaviour.
349 void ide_dma_host_set(ide_drive_t
*drive
, int on
)
351 ide_hwif_t
*hwif
= HWIF(drive
);
352 u8 unit
= drive
->dn
& 1;
353 u8 dma_stat
= hwif
->tp_ops
->read_sff_dma_status(hwif
);
356 dma_stat
|= (1 << (5 + unit
));
358 dma_stat
&= ~(1 << (5 + unit
));
360 if (hwif
->host_flags
& IDE_HFLAG_MMIO
)
362 (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_STATUS
));
364 outb(dma_stat
, hwif
->dma_base
+ ATA_DMA_STATUS
);
367 EXPORT_SYMBOL_GPL(ide_dma_host_set
);
368 #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
371 * ide_dma_off_quietly - Generic DMA kill
372 * @drive: drive to control
374 * Turn off the current DMA on this IDE controller.
377 void ide_dma_off_quietly(ide_drive_t
*drive
)
379 drive
->dev_flags
&= ~IDE_DFLAG_USING_DMA
;
380 ide_toggle_bounce(drive
, 0);
382 drive
->hwif
->dma_ops
->dma_host_set(drive
, 0);
385 EXPORT_SYMBOL(ide_dma_off_quietly
);
388 * ide_dma_off - disable DMA on a device
389 * @drive: drive to disable DMA on
391 * Disable IDE DMA for a device on this IDE controller.
392 * Inform the user that DMA has been disabled.
395 void ide_dma_off(ide_drive_t
*drive
)
397 printk(KERN_INFO
"%s: DMA disabled\n", drive
->name
);
398 ide_dma_off_quietly(drive
);
401 EXPORT_SYMBOL(ide_dma_off
);
404 * ide_dma_on - Enable DMA on a device
405 * @drive: drive to enable DMA on
407 * Enable IDE DMA for a device on this IDE controller.
410 void ide_dma_on(ide_drive_t
*drive
)
412 drive
->dev_flags
|= IDE_DFLAG_USING_DMA
;
413 ide_toggle_bounce(drive
, 1);
415 drive
->hwif
->dma_ops
->dma_host_set(drive
, 1);
418 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
420 * ide_dma_setup - begin a DMA phase
421 * @drive: target device
423 * Build an IDE DMA PRD (IDE speak for scatter gather table)
424 * and then set up the DMA transfer registers for a device
425 * that follows generic IDE PCI DMA behaviour. Controllers can
426 * override this function if they need to
428 * Returns 0 on success. If a PIO fallback is required then 1
432 int ide_dma_setup(ide_drive_t
*drive
)
434 ide_hwif_t
*hwif
= drive
->hwif
;
435 struct request
*rq
= HWGROUP(drive
)->rq
;
436 unsigned int reading
;
437 u8 mmio
= (hwif
->host_flags
& IDE_HFLAG_MMIO
) ? 1 : 0;
445 /* fall back to pio! */
446 if (!ide_build_dmatable(drive
, rq
)) {
447 ide_map_sg(drive
, rq
);
452 if (hwif
->host_flags
& IDE_HFLAG_MMIO
)
453 writel(hwif
->dmatable_dma
,
454 (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_TABLE_OFS
));
456 outl(hwif
->dmatable_dma
, hwif
->dma_base
+ ATA_DMA_TABLE_OFS
);
460 writeb(reading
, (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_CMD
));
462 outb(reading
, hwif
->dma_base
+ ATA_DMA_CMD
);
464 /* read DMA status for INTR & ERROR flags */
465 dma_stat
= hwif
->tp_ops
->read_sff_dma_status(hwif
);
467 /* clear INTR & ERROR flags */
470 (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_STATUS
));
472 outb(dma_stat
| 6, hwif
->dma_base
+ ATA_DMA_STATUS
);
474 drive
->waiting_for_dma
= 1;
478 EXPORT_SYMBOL_GPL(ide_dma_setup
);
480 void ide_dma_exec_cmd(ide_drive_t
*drive
, u8 command
)
482 /* issue cmd to drive */
483 ide_execute_command(drive
, command
, &ide_dma_intr
, 2*WAIT_CMD
, dma_timer_expiry
);
485 EXPORT_SYMBOL_GPL(ide_dma_exec_cmd
);
487 void ide_dma_start(ide_drive_t
*drive
)
489 ide_hwif_t
*hwif
= drive
->hwif
;
492 /* Note that this is done *after* the cmd has
493 * been issued to the drive, as per the BM-IDE spec.
494 * The Promise Ultra33 doesn't work correctly when
495 * we do this part before issuing the drive cmd.
497 if (hwif
->host_flags
& IDE_HFLAG_MMIO
) {
498 dma_cmd
= readb((void __iomem
*)(hwif
->dma_base
+ ATA_DMA_CMD
));
501 (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_CMD
));
503 dma_cmd
= inb(hwif
->dma_base
+ ATA_DMA_CMD
);
504 outb(dma_cmd
| 1, hwif
->dma_base
+ ATA_DMA_CMD
);
510 EXPORT_SYMBOL_GPL(ide_dma_start
);
512 /* returns 1 on error, 0 otherwise */
513 int ide_dma_end(ide_drive_t
*drive
)
515 ide_hwif_t
*hwif
= drive
->hwif
;
516 u8 mmio
= (hwif
->host_flags
& IDE_HFLAG_MMIO
) ? 1 : 0;
517 u8 dma_stat
= 0, dma_cmd
= 0;
519 drive
->waiting_for_dma
= 0;
522 /* get DMA command mode */
523 dma_cmd
= readb((void __iomem
*)(hwif
->dma_base
+ ATA_DMA_CMD
));
526 (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_CMD
));
528 dma_cmd
= inb(hwif
->dma_base
+ ATA_DMA_CMD
);
529 outb(dma_cmd
& ~1, hwif
->dma_base
+ ATA_DMA_CMD
);
533 dma_stat
= hwif
->tp_ops
->read_sff_dma_status(hwif
);
536 /* clear the INTR & ERROR bits */
538 (void __iomem
*)(hwif
->dma_base
+ ATA_DMA_STATUS
));
540 outb(dma_stat
| 6, hwif
->dma_base
+ ATA_DMA_STATUS
);
542 /* purge DMA mappings */
543 ide_destroy_dmatable(drive
);
544 /* verify good DMA status */
546 return (dma_stat
& 7) != 4 ? (0x10 | dma_stat
) : 0;
548 EXPORT_SYMBOL_GPL(ide_dma_end
);
550 /* returns 1 if dma irq issued, 0 otherwise */
551 int ide_dma_test_irq(ide_drive_t
*drive
)
553 ide_hwif_t
*hwif
= HWIF(drive
);
554 u8 dma_stat
= hwif
->tp_ops
->read_sff_dma_status(hwif
);
556 /* return 1 if INTR asserted */
557 if ((dma_stat
& 4) == 4)
562 EXPORT_SYMBOL_GPL(ide_dma_test_irq
);
564 static inline int config_drive_for_dma(ide_drive_t
*drive
) { return 0; }
565 #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
567 int __ide_dma_bad_drive (ide_drive_t
*drive
)
571 int blacklist
= ide_in_drive_list(id
, drive_blacklist
);
573 printk(KERN_WARNING
"%s: Disabling (U)DMA for %s (blacklisted)\n",
574 drive
->name
, (char *)&id
[ATA_ID_PROD
]);
580 EXPORT_SYMBOL(__ide_dma_bad_drive
);
582 static const u8 xfer_mode_bases
[] = {
588 static unsigned int ide_get_mode_mask(ide_drive_t
*drive
, u8 base
, u8 req_mode
)
591 ide_hwif_t
*hwif
= drive
->hwif
;
592 const struct ide_port_ops
*port_ops
= hwif
->port_ops
;
593 unsigned int mask
= 0;
597 if ((id
[ATA_ID_FIELD_VALID
] & 4) == 0)
600 if (port_ops
&& port_ops
->udma_filter
)
601 mask
= port_ops
->udma_filter(drive
);
603 mask
= hwif
->ultra_mask
;
604 mask
&= id
[ATA_ID_UDMA_MODES
];
607 * avoid false cable warning from eighty_ninty_three()
609 if (req_mode
> XFER_UDMA_2
) {
610 if ((mask
& 0x78) && (eighty_ninty_three(drive
) == 0))
615 if ((id
[ATA_ID_FIELD_VALID
] & 2) == 0)
617 if (port_ops
&& port_ops
->mdma_filter
)
618 mask
= port_ops
->mdma_filter(drive
);
620 mask
= hwif
->mwdma_mask
;
621 mask
&= id
[ATA_ID_MWDMA_MODES
];
624 if (id
[ATA_ID_FIELD_VALID
] & 2) {
625 mask
= id
[ATA_ID_SWDMA_MODES
] & hwif
->swdma_mask
;
626 } else if (id
[ATA_ID_OLD_DMA_MODES
] >> 8) {
627 u8 mode
= id
[ATA_ID_OLD_DMA_MODES
] >> 8;
630 * if the mode is valid convert it to the mask
631 * (the maximum allowed mode is XFER_SW_DMA_2)
634 mask
= ((2 << mode
) - 1) & hwif
->swdma_mask
;
646 * ide_find_dma_mode - compute DMA speed
648 * @req_mode: requested mode
650 * Checks the drive/host capabilities and finds the speed to use for
651 * the DMA transfer. The speed is then limited by the requested mode.
653 * Returns 0 if the drive/host combination is incapable of DMA transfers
654 * or if the requested mode is not a DMA mode.
657 u8
ide_find_dma_mode(ide_drive_t
*drive
, u8 req_mode
)
659 ide_hwif_t
*hwif
= drive
->hwif
;
664 if (drive
->media
!= ide_disk
) {
665 if (hwif
->host_flags
& IDE_HFLAG_NO_ATAPI_DMA
)
669 for (i
= 0; i
< ARRAY_SIZE(xfer_mode_bases
); i
++) {
670 if (req_mode
< xfer_mode_bases
[i
])
672 mask
= ide_get_mode_mask(drive
, xfer_mode_bases
[i
], req_mode
);
675 mode
= xfer_mode_bases
[i
] + x
;
680 if (hwif
->chipset
== ide_acorn
&& mode
== 0) {
684 if (ide_dma_good_drive(drive
) &&
685 drive
->id
[ATA_ID_EIDE_DMA_TIME
] < 150)
686 mode
= XFER_MW_DMA_1
;
689 mode
= min(mode
, req_mode
);
691 printk(KERN_INFO
"%s: %s mode selected\n", drive
->name
,
692 mode
? ide_xfer_verbose(mode
) : "no DMA");
697 EXPORT_SYMBOL_GPL(ide_find_dma_mode
);
699 static int ide_tune_dma(ide_drive_t
*drive
)
701 ide_hwif_t
*hwif
= drive
->hwif
;
704 if (ata_id_has_dma(drive
->id
) == 0 ||
705 (drive
->dev_flags
& IDE_DFLAG_NODMA
))
708 /* consult the list of known "bad" drives */
709 if (__ide_dma_bad_drive(drive
))
712 if (ide_id_dma_bug(drive
))
715 if (hwif
->host_flags
& IDE_HFLAG_TRUST_BIOS_FOR_DMA
)
716 return config_drive_for_dma(drive
);
718 speed
= ide_max_dma_mode(drive
);
723 if (ide_set_dma_mode(drive
, speed
))
729 static int ide_dma_check(ide_drive_t
*drive
)
731 ide_hwif_t
*hwif
= drive
->hwif
;
733 if (ide_tune_dma(drive
))
736 /* TODO: always do PIO fallback */
737 if (hwif
->host_flags
& IDE_HFLAG_TRUST_BIOS_FOR_DMA
)
740 ide_set_max_pio(drive
);
745 int ide_id_dma_bug(ide_drive_t
*drive
)
749 if (id
[ATA_ID_FIELD_VALID
] & 4) {
750 if ((id
[ATA_ID_UDMA_MODES
] >> 8) &&
751 (id
[ATA_ID_MWDMA_MODES
] >> 8))
753 } else if (id
[ATA_ID_FIELD_VALID
] & 2) {
754 if ((id
[ATA_ID_MWDMA_MODES
] >> 8) &&
755 (id
[ATA_ID_SWDMA_MODES
] >> 8))
760 printk(KERN_ERR
"%s: bad DMA info in identify block\n", drive
->name
);
764 int ide_set_dma(ide_drive_t
*drive
)
769 * Force DMAing for the beginning of the check.
770 * Some chipsets appear to do interesting
771 * things, if not checked and cleared.
774 ide_dma_off_quietly(drive
);
776 rc
= ide_dma_check(drive
);
785 void ide_check_dma_crc(ide_drive_t
*drive
)
789 ide_dma_off_quietly(drive
);
790 drive
->crc_count
= 0;
791 mode
= drive
->current_speed
;
793 * Don't try non Ultra-DMA modes without iCRC's. Force the
794 * device to PIO and make the user enable SWDMA/MWDMA modes.
796 if (mode
> XFER_UDMA_0
&& mode
<= XFER_UDMA_7
)
800 ide_set_xfer_rate(drive
, mode
);
801 if (drive
->current_speed
>= XFER_SW_DMA_0
)
805 void ide_dma_lost_irq(ide_drive_t
*drive
)
807 printk(KERN_ERR
"%s: DMA interrupt recovery\n", drive
->name
);
809 EXPORT_SYMBOL_GPL(ide_dma_lost_irq
);
811 void ide_dma_timeout(ide_drive_t
*drive
)
813 ide_hwif_t
*hwif
= HWIF(drive
);
815 printk(KERN_ERR
"%s: timeout waiting for DMA\n", drive
->name
);
817 if (hwif
->dma_ops
->dma_test_irq(drive
))
820 ide_dump_status(drive
, "DMA timeout", hwif
->tp_ops
->read_status(hwif
));
822 hwif
->dma_ops
->dma_end(drive
);
824 EXPORT_SYMBOL_GPL(ide_dma_timeout
);
826 void ide_release_dma_engine(ide_hwif_t
*hwif
)
828 if (hwif
->dmatable_cpu
) {
829 int prd_size
= hwif
->prd_max_nents
* hwif
->prd_ent_size
;
831 dma_free_coherent(hwif
->dev
, prd_size
,
832 hwif
->dmatable_cpu
, hwif
->dmatable_dma
);
833 hwif
->dmatable_cpu
= NULL
;
836 EXPORT_SYMBOL_GPL(ide_release_dma_engine
);
838 int ide_allocate_dma_engine(ide_hwif_t
*hwif
)
842 if (hwif
->prd_max_nents
== 0)
843 hwif
->prd_max_nents
= PRD_ENTRIES
;
844 if (hwif
->prd_ent_size
== 0)
845 hwif
->prd_ent_size
= PRD_BYTES
;
847 prd_size
= hwif
->prd_max_nents
* hwif
->prd_ent_size
;
849 hwif
->dmatable_cpu
= dma_alloc_coherent(hwif
->dev
, prd_size
,
852 if (hwif
->dmatable_cpu
== NULL
) {
853 printk(KERN_ERR
"%s: unable to allocate PRD table\n",
860 EXPORT_SYMBOL_GPL(ide_allocate_dma_engine
);
862 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
863 const struct ide_dma_ops sff_dma_ops
= {
864 .dma_host_set
= ide_dma_host_set
,
865 .dma_setup
= ide_dma_setup
,
866 .dma_exec_cmd
= ide_dma_exec_cmd
,
867 .dma_start
= ide_dma_start
,
868 .dma_end
= ide_dma_end
,
869 .dma_test_irq
= ide_dma_test_irq
,
870 .dma_timeout
= ide_dma_timeout
,
871 .dma_lost_irq
= ide_dma_lost_irq
,
873 EXPORT_SYMBOL_GPL(sff_dma_ops
);
874 #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */