blob: 7ee44f86bc5475065a962f8b2380cd0b86158d1b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Bartlomiej Zolnierkiewicz204f47c2008-02-26 21:50:36 +01002 * IDE DMA support (including IDE PCI BM-DMA).
3 *
Bartlomiej Zolnierkiewicz59bca8c2008-02-01 23:09:33 +01004 * Copyright (C) 1995-1998 Mark Lord
5 * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org>
6 * Copyright (C) 2004, 2007 Bartlomiej Zolnierkiewicz
Bartlomiej Zolnierkiewicz58f189f2008-02-01 23:09:33 +01007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * May be copied or modified under the terms of the GNU General Public License
Bartlomiej Zolnierkiewicz204f47c2008-02-26 21:50:36 +01009 *
10 * DMA is supported for all IDE devices (disk drives, cdroms, tapes, floppies).
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
13/*
14 * Special Thanks to Mark for his Six years of work.
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
17/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * Thanks to "Christopher J. Reimer" <reimer@doe.carleton.ca> for
19 * fixing the problem with the BIOS on some Acer motherboards.
20 *
21 * Thanks to "Benoit Poulot-Cazajous" <poulot@chorus.fr> for testing
22 * "TX" chipset compatibility and for providing patches for the "TX" chipset.
23 *
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.
26 *
27 * Most importantly, thanks to Robert Bringman <rob@mars.trion.com>
28 * for supplying a Promise UDMA board & WD UDMA drive for this work!
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 */
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/module.h>
32#include <linux/types.h>
33#include <linux/kernel.h>
34#include <linux/timer.h>
35#include <linux/mm.h>
36#include <linux/interrupt.h>
37#include <linux/pci.h>
38#include <linux/init.h>
39#include <linux/ide.h>
40#include <linux/delay.h>
41#include <linux/scatterlist.h>
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +010042#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44#include <asm/io.h>
45#include <asm/irq.h>
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static const struct drive_list_entry drive_whitelist [] = {
48
Junio C Hamanoc2d3ce82007-07-09 23:17:56 +020049 { "Micropolis 2112A" , NULL },
50 { "CONNER CTMA 4000" , NULL },
51 { "CONNER CTT8000-A" , NULL },
52 { "ST34342A" , NULL },
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 { NULL , NULL }
54};
55
56static const struct drive_list_entry drive_blacklist [] = {
57
Junio C Hamanoc2d3ce82007-07-09 23:17:56 +020058 { "WDC AC11000H" , NULL },
59 { "WDC AC22100H" , NULL },
60 { "WDC AC32500H" , NULL },
61 { "WDC AC33100H" , NULL },
62 { "WDC AC31600H" , NULL },
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 { "WDC AC32100H" , "24.09P07" },
64 { "WDC AC23200L" , "21.10N21" },
Junio C Hamanoc2d3ce82007-07-09 23:17:56 +020065 { "Compaq CRD-8241B" , NULL },
66 { "CRD-8400B" , NULL },
67 { "CRD-8480B", NULL },
68 { "CRD-8482B", NULL },
69 { "CRD-84" , NULL },
70 { "SanDisk SDP3B" , NULL },
71 { "SanDisk SDP3B-64" , NULL },
72 { "SANYO CD-ROM CRD" , NULL },
73 { "HITACHI CDR-8" , NULL },
74 { "HITACHI CDR-8335" , NULL },
75 { "HITACHI CDR-8435" , NULL },
76 { "Toshiba CD-ROM XM-6202B" , NULL },
77 { "TOSHIBA CD-ROM XM-1702BC", NULL },
78 { "CD-532E-A" , NULL },
79 { "E-IDE CD-ROM CR-840", NULL },
80 { "CD-ROM Drive/F5A", NULL },
81 { "WPI CDD-820", NULL },
82 { "SAMSUNG CD-ROM SC-148C", NULL },
83 { "SAMSUNG CD-ROM SC", NULL },
84 { "ATAPI CD-ROM DRIVE 40X MAXIMUM", NULL },
85 { "_NEC DV5800A", NULL },
Junio C Hamano5a6248c2007-05-24 02:42:38 +020086 { "SAMSUNG CD-ROM SN-124", "N001" },
Junio C Hamanoc2d3ce82007-07-09 23:17:56 +020087 { "Seagate STT20000A", NULL },
Bartlomiej Zolnierkiewiczb0bc65b2007-11-27 21:35:56 +010088 { "CD-ROM CDR_U200", "1.09" },
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 { NULL , NULL }
90
91};
92
93/**
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 * ide_dma_intr - IDE DMA interrupt handler
95 * @drive: the drive the interrupt is for
96 *
97 * Handle an interrupt completing a read/write DMA transfer on an
98 * IDE device
99 */
100
101ide_startstop_t ide_dma_intr (ide_drive_t *drive)
102{
103 u8 stat = 0, dma_stat = 0;
104
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200105 dma_stat = drive->hwif->dma_ops->dma_end(drive);
Bartlomiej Zolnierkiewiczc47137a2008-02-06 02:57:51 +0100106 stat = ide_read_status(drive);
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
109 if (!dma_stat) {
110 struct request *rq = HWGROUP(drive)->rq;
111
Tejun Heo4d7a9842008-01-26 20:13:11 +0100112 task_end_request(drive, rq, stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 return ide_stopped;
114 }
115 printk(KERN_ERR "%s: dma_intr: bad DMA status (dma_stat=%x)\n",
116 drive->name, dma_stat);
117 }
118 return ide_error(drive, "dma_intr", stat);
119}
120
121EXPORT_SYMBOL_GPL(ide_dma_intr);
122
Bartlomiej Zolnierkiewicz75d7d962007-10-13 17:47:50 +0200123static int ide_dma_good_drive(ide_drive_t *drive)
124{
125 return ide_in_drive_list(drive->id, drive_whitelist);
126}
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/**
129 * ide_build_sglist - map IDE scatter gather for DMA I/O
130 * @drive: the drive to build the DMA table for
131 * @rq: the request holding the sg list
132 *
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +0100133 * Perform the DMA mapping magic necessary to access the source or
134 * target buffers of a request via DMA. The lower layers of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 * kernel provide the necessary cache management so that we can
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +0100136 * operate in a portable fashion.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 */
138
139int ide_build_sglist(ide_drive_t *drive, struct request *rq)
140{
141 ide_hwif_t *hwif = HWIF(drive);
142 struct scatterlist *sg = hwif->sg_table;
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 ide_map_sg(drive, rq);
145
146 if (rq_data_dir(rq) == READ)
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +0100147 hwif->sg_dma_direction = DMA_FROM_DEVICE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 else
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +0100149 hwif->sg_dma_direction = DMA_TO_DEVICE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +0100151 return dma_map_sg(hwif->dev, sg, hwif->sg_nents,
152 hwif->sg_dma_direction);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153}
154
155EXPORT_SYMBOL_GPL(ide_build_sglist);
156
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100157#ifdef CONFIG_BLK_DEV_IDEDMA_SFF
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158/**
159 * ide_build_dmatable - build IDE DMA table
160 *
161 * ide_build_dmatable() prepares a dma request. We map the command
162 * to get the pci bus addresses of the buffers and then build up
163 * the PRD table that the IDE layer wants to be fed. The code
164 * knows about the 64K wrap bug in the CS5530.
165 *
166 * Returns the number of built PRD entries if all went okay,
167 * returns 0 otherwise.
168 *
169 * May also be invoked from trm290.c
170 */
171
172int ide_build_dmatable (ide_drive_t *drive, struct request *rq)
173{
174 ide_hwif_t *hwif = HWIF(drive);
175 unsigned int *table = hwif->dmatable_cpu;
176 unsigned int is_trm290 = (hwif->chipset == ide_trm290) ? 1 : 0;
177 unsigned int count = 0;
178 int i;
179 struct scatterlist *sg;
180
181 hwif->sg_nents = i = ide_build_sglist(drive, rq);
182
183 if (!i)
184 return 0;
185
186 sg = hwif->sg_table;
187 while (i) {
188 u32 cur_addr;
189 u32 cur_len;
190
191 cur_addr = sg_dma_address(sg);
192 cur_len = sg_dma_len(sg);
193
194 /*
195 * Fill in the dma table, without crossing any 64kB boundaries.
196 * Most hardware requires 16-bit alignment of all blocks,
197 * but the trm290 requires 32-bit alignment.
198 */
199
200 while (cur_len) {
201 if (count++ >= PRD_ENTRIES) {
202 printk(KERN_ERR "%s: DMA table too small\n", drive->name);
203 goto use_pio_instead;
204 } else {
205 u32 xcount, bcount = 0x10000 - (cur_addr & 0xffff);
206
207 if (bcount > cur_len)
208 bcount = cur_len;
209 *table++ = cpu_to_le32(cur_addr);
210 xcount = bcount & 0xffff;
211 if (is_trm290)
212 xcount = ((xcount >> 2) - 1) << 16;
213 if (xcount == 0x0000) {
214 /*
215 * Most chipsets correctly interpret a length of 0x0000 as 64KB,
216 * but at least one (e.g. CS5530) misinterprets it as zero (!).
217 * So here we break the 64KB entry into two 32KB entries instead.
218 */
219 if (count++ >= PRD_ENTRIES) {
220 printk(KERN_ERR "%s: DMA table too small\n", drive->name);
221 goto use_pio_instead;
222 }
223 *table++ = cpu_to_le32(0x8000);
224 *table++ = cpu_to_le32(cur_addr + 0x8000);
225 xcount = 0x8000;
226 }
227 *table++ = cpu_to_le32(xcount);
228 cur_addr += bcount;
229 cur_len -= bcount;
230 }
231 }
232
Jens Axboe55c16a72007-07-25 08:13:56 +0200233 sg = sg_next(sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 i--;
235 }
236
237 if (count) {
238 if (!is_trm290)
239 *--table |= cpu_to_le32(0x80000000);
240 return count;
241 }
Bartlomiej Zolnierkiewiczf6fb7862008-02-01 23:09:31 +0100242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 printk(KERN_ERR "%s: empty DMA table?\n", drive->name);
Bartlomiej Zolnierkiewiczf6fb7862008-02-01 23:09:31 +0100244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245use_pio_instead:
Bartlomiej Zolnierkiewiczf6fb7862008-02-01 23:09:31 +0100246 ide_destroy_dmatable(drive);
247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return 0; /* revert to PIO for this request */
249}
250
251EXPORT_SYMBOL_GPL(ide_build_dmatable);
Bartlomiej Zolnierkiewicz062f9f02008-02-01 23:09:32 +0100252#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254/**
255 * ide_destroy_dmatable - clean up DMA mapping
256 * @drive: The drive to unmap
257 *
258 * Teardown mappings after DMA has completed. This must be called
259 * after the completion of each use of ide_build_dmatable and before
260 * the next use of ide_build_dmatable. Failure to do so will cause
261 * an oops as only one mapping can be live for each target at a given
262 * time.
263 */
264
265void ide_destroy_dmatable (ide_drive_t *drive)
266{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100267 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Bartlomiej Zolnierkiewicz5c05ff62008-02-01 23:09:32 +0100269 dma_unmap_sg(hwif->dev, hwif->sg_table, hwif->sg_nents,
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100270 hwif->sg_dma_direction);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
273EXPORT_SYMBOL_GPL(ide_destroy_dmatable);
274
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100275#ifdef CONFIG_BLK_DEV_IDEDMA_SFF
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276/**
277 * config_drive_for_dma - attempt to activate IDE DMA
278 * @drive: the drive to place in DMA mode
279 *
280 * If the drive supports at least mode 2 DMA or UDMA of any kind
281 * then attempt to place it into DMA mode. Drives that are known to
282 * support DMA but predate the DMA properties or that are known
283 * to have DMA handling bugs are also set up appropriately based
284 * on the good/bad drive lists.
285 */
286
287static int config_drive_for_dma (ide_drive_t *drive)
288{
Bartlomiej Zolnierkiewicz1116fae2007-08-20 22:42:55 +0200289 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 struct hd_driveid *id = drive->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Bartlomiej Zolnierkiewicz33c10022007-10-19 00:30:06 +0200292 if (drive->media != ide_disk) {
293 if (hwif->host_flags & IDE_HFLAG_NO_ATAPI_DMA)
Bartlomiej Zolnierkiewiczbcbf6ee2007-11-05 21:42:30 +0100294 return 0;
Bartlomiej Zolnierkiewicz33c10022007-10-19 00:30:06 +0200295 }
Bartlomiej Zolnierkiewicz1116fae2007-08-20 22:42:55 +0200296
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200297 /*
298 * Enable DMA on any drive that has
299 * UltraDMA (mode 0/1/2/3/4/5/6) enabled
300 */
301 if ((id->field_valid & 4) && ((id->dma_ultra >> 8) & 0x7f))
302 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200304 /*
305 * Enable DMA on any drive that has mode2 DMA
306 * (multi or single) enabled
307 */
308 if (id->field_valid & 2) /* regular DMA */
309 if ((id->dma_mword & 0x404) == 0x404 ||
310 (id->dma_1word & 0x404) == 0x404)
311 return 1;
Bartlomiej Zolnierkiewicz3608b5d2007-02-17 02:40:26 +0100312
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200313 /* Consult the list of known "good" drives */
314 if (ide_dma_good_drive(drive))
315 return 1;
316
317 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
320/**
321 * dma_timer_expiry - handle a DMA timeout
322 * @drive: Drive that timed out
323 *
324 * An IDE DMA transfer timed out. In the event of an error we ask
325 * the driver to resolve the problem, if a DMA transfer is still
326 * in progress we continue to wait (arguably we need to add a
327 * secondary 'I don't care what the drive thinks' timeout here)
328 * Finally if we have an interrupt we let it complete the I/O.
329 * But only one time - we clear expiry and if it's still not
330 * completed after WAIT_CMD, we error and retry in PIO.
331 * This can occur if an interrupt is lost or due to hang or bugs.
332 */
333
334static int dma_timer_expiry (ide_drive_t *drive)
335{
336 ide_hwif_t *hwif = HWIF(drive);
337 u8 dma_stat = hwif->INB(hwif->dma_status);
338
339 printk(KERN_WARNING "%s: dma_timer_expiry: dma status == 0x%02x\n",
340 drive->name, dma_stat);
341
342 if ((dma_stat & 0x18) == 0x18) /* BUSY Stupid Early Timer !! */
343 return WAIT_CMD;
344
345 HWGROUP(drive)->expiry = NULL; /* one free ride for now */
346
347 /* 1 dmaing, 2 error, 4 intr */
348 if (dma_stat & 2) /* ERROR */
349 return -1;
350
351 if (dma_stat & 1) /* DMAing */
352 return WAIT_CMD;
353
354 if (dma_stat & 4) /* Got an Interrupt */
355 return WAIT_CMD;
356
357 return 0; /* Status is unknown -- reset the bus */
358}
359
360/**
Bartlomiej Zolnierkiewicz15ce9262008-01-26 20:13:03 +0100361 * ide_dma_host_set - Enable/disable DMA on a host
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 * @drive: drive to control
363 *
Bartlomiej Zolnierkiewicz15ce9262008-01-26 20:13:03 +0100364 * Enable/disable DMA on an IDE controller following generic
365 * bus-mastering IDE controller behaviour.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 */
367
Bartlomiej Zolnierkiewicz15ce9262008-01-26 20:13:03 +0100368void ide_dma_host_set(ide_drive_t *drive, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 ide_hwif_t *hwif = HWIF(drive);
371 u8 unit = (drive->select.b.unit & 0x01);
372 u8 dma_stat = hwif->INB(hwif->dma_status);
373
Bartlomiej Zolnierkiewicz15ce9262008-01-26 20:13:03 +0100374 if (on)
375 dma_stat |= (1 << (5 + unit));
376 else
377 dma_stat &= ~(1 << (5 + unit));
378
379 hwif->OUTB(dma_stat, hwif->dma_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}
381
Bartlomiej Zolnierkiewicz15ce9262008-01-26 20:13:03 +0100382EXPORT_SYMBOL_GPL(ide_dma_host_set);
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100383#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385/**
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100386 * ide_dma_off_quietly - Generic DMA kill
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 * @drive: drive to control
388 *
389 * Turn off the current DMA on this IDE controller.
390 */
391
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100392void ide_dma_off_quietly(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
394 drive->using_dma = 0;
395 ide_toggle_bounce(drive, 0);
396
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200397 drive->hwif->dma_ops->dma_host_set(drive, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100400EXPORT_SYMBOL(ide_dma_off_quietly);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
402/**
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100403 * ide_dma_off - disable DMA on a device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 * @drive: drive to disable DMA on
405 *
406 * Disable IDE DMA for a device on this IDE controller.
407 * Inform the user that DMA has been disabled.
408 */
409
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100410void ide_dma_off(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
412 printk(KERN_INFO "%s: DMA disabled\n", drive->name);
Bartlomiej Zolnierkiewicz4a546e02008-01-26 20:13:01 +0100413 ide_dma_off_quietly(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414}
415
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100416EXPORT_SYMBOL(ide_dma_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418/**
Bartlomiej Zolnierkiewicz4a546e02008-01-26 20:13:01 +0100419 * ide_dma_on - Enable DMA on a device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 * @drive: drive to enable DMA on
421 *
422 * Enable IDE DMA for a device on this IDE controller.
423 */
Bartlomiej Zolnierkiewicz4a546e02008-01-26 20:13:01 +0100424
425void ide_dma_on(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 drive->using_dma = 1;
428 ide_toggle_bounce(drive, 1);
429
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200430 drive->hwif->dma_ops->dma_host_set(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431}
432
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100433#ifdef CONFIG_BLK_DEV_IDEDMA_SFF
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 * ide_dma_setup - begin a DMA phase
436 * @drive: target device
437 *
438 * Build an IDE DMA PRD (IDE speak for scatter gather table)
439 * and then set up the DMA transfer registers for a device
440 * that follows generic IDE PCI DMA behaviour. Controllers can
441 * override this function if they need to
442 *
443 * Returns 0 on success. If a PIO fallback is required then 1
444 * is returned.
445 */
446
447int ide_dma_setup(ide_drive_t *drive)
448{
449 ide_hwif_t *hwif = drive->hwif;
450 struct request *rq = HWGROUP(drive)->rq;
451 unsigned int reading;
452 u8 dma_stat;
453
454 if (rq_data_dir(rq))
455 reading = 0;
456 else
457 reading = 1 << 3;
458
459 /* fall back to pio! */
460 if (!ide_build_dmatable(drive, rq)) {
461 ide_map_sg(drive, rq);
462 return 1;
463 }
464
465 /* PRD table */
Bartlomiej Zolnierkiewicz13572142008-07-15 21:21:49 +0200466 if (hwif->host_flags & IDE_HFLAG_MMIO)
Bartlomiej Zolnierkiewicz55224bc2008-04-28 23:44:42 +0200467 writel(hwif->dmatable_dma,
468 (void __iomem *)(hwif->dma_base + ATA_DMA_TABLE_OFS));
Bartlomiej Zolnierkiewicz0ecdca22007-02-17 02:40:25 +0100469 else
Bartlomiej Zolnierkiewicz55224bc2008-04-28 23:44:42 +0200470 outl(hwif->dmatable_dma, hwif->dma_base + ATA_DMA_TABLE_OFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 /* specify r/w */
473 hwif->OUTB(reading, hwif->dma_command);
474
475 /* read dma_status for INTR & ERROR flags */
476 dma_stat = hwif->INB(hwif->dma_status);
477
478 /* clear INTR & ERROR flags */
479 hwif->OUTB(dma_stat|6, hwif->dma_status);
480 drive->waiting_for_dma = 1;
481 return 0;
482}
483
484EXPORT_SYMBOL_GPL(ide_dma_setup);
485
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200486void ide_dma_exec_cmd(ide_drive_t *drive, u8 command)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
488 /* issue cmd to drive */
489 ide_execute_command(drive, command, &ide_dma_intr, 2*WAIT_CMD, dma_timer_expiry);
490}
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200491EXPORT_SYMBOL_GPL(ide_dma_exec_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493void ide_dma_start(ide_drive_t *drive)
494{
495 ide_hwif_t *hwif = HWIF(drive);
496 u8 dma_cmd = hwif->INB(hwif->dma_command);
497
498 /* Note that this is done *after* the cmd has
499 * been issued to the drive, as per the BM-IDE spec.
500 * The Promise Ultra33 doesn't work correctly when
501 * we do this part before issuing the drive cmd.
502 */
503 /* start DMA */
504 hwif->OUTB(dma_cmd|1, hwif->dma_command);
505 hwif->dma = 1;
506 wmb();
507}
508
509EXPORT_SYMBOL_GPL(ide_dma_start);
510
511/* returns 1 on error, 0 otherwise */
512int __ide_dma_end (ide_drive_t *drive)
513{
514 ide_hwif_t *hwif = HWIF(drive);
515 u8 dma_stat = 0, dma_cmd = 0;
516
517 drive->waiting_for_dma = 0;
518 /* get dma_command mode */
519 dma_cmd = hwif->INB(hwif->dma_command);
520 /* stop DMA */
521 hwif->OUTB(dma_cmd&~1, hwif->dma_command);
522 /* get DMA status */
523 dma_stat = hwif->INB(hwif->dma_status);
524 /* clear the INTR & ERROR bits */
525 hwif->OUTB(dma_stat|6, hwif->dma_status);
526 /* purge DMA mappings */
527 ide_destroy_dmatable(drive);
528 /* verify good DMA status */
529 hwif->dma = 0;
530 wmb();
531 return (dma_stat & 7) != 4 ? (0x10 | dma_stat) : 0;
532}
533
534EXPORT_SYMBOL(__ide_dma_end);
535
536/* returns 1 if dma irq issued, 0 otherwise */
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200537int ide_dma_test_irq(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
539 ide_hwif_t *hwif = HWIF(drive);
540 u8 dma_stat = hwif->INB(hwif->dma_status);
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 /* return 1 if INTR asserted */
543 if ((dma_stat & 4) == 4)
544 return 1;
545 if (!drive->waiting_for_dma)
546 printk(KERN_WARNING "%s: (%s) called while not waiting\n",
Harvey Harrisoneb639632008-04-26 22:25:20 +0200547 drive->name, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 return 0;
549}
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200550EXPORT_SYMBOL_GPL(ide_dma_test_irq);
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200551#else
552static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; }
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100553#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555int __ide_dma_bad_drive (ide_drive_t *drive)
556{
557 struct hd_driveid *id = drive->id;
558
Jordan Crouse65e5f2e2005-12-15 02:16:18 +0100559 int blacklist = ide_in_drive_list(id, drive_blacklist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if (blacklist) {
561 printk(KERN_WARNING "%s: Disabling (U)DMA for %s (blacklisted)\n",
562 drive->name, id->model);
563 return blacklist;
564 }
565 return 0;
566}
567
568EXPORT_SYMBOL(__ide_dma_bad_drive);
569
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200570static const u8 xfer_mode_bases[] = {
571 XFER_UDMA_0,
572 XFER_MW_DMA_0,
573 XFER_SW_DMA_0,
574};
575
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200576static unsigned int ide_get_mode_mask(ide_drive_t *drive, u8 base, u8 req_mode)
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200577{
578 struct hd_driveid *id = drive->id;
579 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200580 const struct ide_port_ops *port_ops = hwif->port_ops;
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200581 unsigned int mask = 0;
582
583 switch(base) {
584 case XFER_UDMA_0:
585 if ((id->field_valid & 4) == 0)
586 break;
587
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200588 if (port_ops && port_ops->udma_filter)
589 mask = port_ops->udma_filter(drive);
Sergei Shtylyov851dd332007-10-11 23:53:59 +0200590 else
591 mask = hwif->ultra_mask;
592 mask &= id->dma_ultra;
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200593
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200594 /*
595 * avoid false cable warning from eighty_ninty_three()
596 */
597 if (req_mode > XFER_UDMA_2) {
598 if ((mask & 0x78) && (eighty_ninty_three(drive) == 0))
599 mask &= 0x07;
600 }
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200601 break;
602 case XFER_MW_DMA_0:
Sergei Shtylyovb4e44362007-10-11 23:53:58 +0200603 if ((id->field_valid & 2) == 0)
604 break;
Bartlomiej Zolnierkiewiczac95bee2008-04-26 22:25:14 +0200605 if (port_ops && port_ops->mdma_filter)
606 mask = port_ops->mdma_filter(drive);
Sergei Shtylyovb4e44362007-10-11 23:53:58 +0200607 else
608 mask = hwif->mwdma_mask;
609 mask &= id->dma_mword;
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200610 break;
611 case XFER_SW_DMA_0:
Bartlomiej Zolnierkiewicz15a4f942007-07-09 23:17:57 +0200612 if (id->field_valid & 2) {
Bartlomiej Zolnierkiewicz3649c062007-05-16 00:51:46 +0200613 mask = id->dma_1word & hwif->swdma_mask;
Bartlomiej Zolnierkiewicz15a4f942007-07-09 23:17:57 +0200614 } else if (id->tDMA) {
615 /*
616 * ide_fix_driveid() doesn't convert ->tDMA to the
617 * CPU endianness so we need to do it here
618 */
619 u8 mode = le16_to_cpu(id->tDMA);
620
621 /*
622 * if the mode is valid convert it to the mask
623 * (the maximum allowed mode is XFER_SW_DMA_2)
624 */
625 if (mode <= 2)
626 mask = ((2 << mode) - 1) & hwif->swdma_mask;
627 }
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200628 break;
629 default:
630 BUG();
631 break;
632 }
633
634 return mask;
635}
636
637/**
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200638 * ide_find_dma_mode - compute DMA speed
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200639 * @drive: IDE device
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200640 * @req_mode: requested mode
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200641 *
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200642 * Checks the drive/host capabilities and finds the speed to use for
643 * the DMA transfer. The speed is then limited by the requested mode.
644 *
645 * Returns 0 if the drive/host combination is incapable of DMA transfers
646 * or if the requested mode is not a DMA mode.
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200647 */
648
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200649u8 ide_find_dma_mode(ide_drive_t *drive, u8 req_mode)
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200650{
651 ide_hwif_t *hwif = drive->hwif;
652 unsigned int mask;
653 int x, i;
654 u8 mode = 0;
655
Bartlomiej Zolnierkiewicz33c10022007-10-19 00:30:06 +0200656 if (drive->media != ide_disk) {
657 if (hwif->host_flags & IDE_HFLAG_NO_ATAPI_DMA)
658 return 0;
659 }
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200660
661 for (i = 0; i < ARRAY_SIZE(xfer_mode_bases); i++) {
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200662 if (req_mode < xfer_mode_bases[i])
663 continue;
664 mask = ide_get_mode_mask(drive, xfer_mode_bases[i], req_mode);
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200665 x = fls(mask) - 1;
666 if (x >= 0) {
667 mode = xfer_mode_bases[i] + x;
668 break;
669 }
670 }
671
Bartlomiej Zolnierkiewicz75d7d962007-10-13 17:47:50 +0200672 if (hwif->chipset == ide_acorn && mode == 0) {
673 /*
674 * is this correct?
675 */
676 if (ide_dma_good_drive(drive) && drive->id->eide_dma_time < 150)
677 mode = XFER_MW_DMA_1;
678 }
679
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100680 mode = min(mode, req_mode);
681
682 printk(KERN_INFO "%s: %s mode selected\n", drive->name,
Bartlomiej Zolnierkiewiczd34887d2007-11-05 21:42:27 +0100683 mode ? ide_xfer_verbose(mode) : "no DMA");
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200684
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100685 return mode;
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200686}
687
Bartlomiej Zolnierkiewicz7670df72007-10-11 23:53:59 +0200688EXPORT_SYMBOL_GPL(ide_find_dma_mode);
Bartlomiej Zolnierkiewicz2d5eaa62007-05-10 00:01:08 +0200689
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200690static int ide_tune_dma(ide_drive_t *drive)
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200691{
Bartlomiej Zolnierkiewicz8704de82008-01-26 20:13:00 +0100692 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200693 u8 speed;
694
Bartlomiej Zolnierkiewicz931ee0d2008-07-15 21:21:47 +0200695 if (drive->nodma || (drive->id->capability & 1) == 0)
Bartlomiej Zolnierkiewicz122ab082007-05-16 00:51:46 +0200696 return 0;
697
698 /* consult the list of known "bad" drives */
699 if (__ide_dma_bad_drive(drive))
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200700 return 0;
701
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100702 if (ide_id_dma_bug(drive))
703 return 0;
704
Bartlomiej Zolnierkiewicz8704de82008-01-26 20:13:00 +0100705 if (hwif->host_flags & IDE_HFLAG_TRUST_BIOS_FOR_DMA)
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200706 return config_drive_for_dma(drive);
707
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200708 speed = ide_max_dma_mode(drive);
709
Bartlomiej Zolnierkiewicz951784b2008-04-26 17:36:38 +0200710 if (!speed)
711 return 0;
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200712
Bartlomiej Zolnierkiewicz88b2b322007-10-13 17:47:51 +0200713 if (ide_set_dma_mode(drive, speed))
Bartlomiej Zolnierkiewicz4728d542007-05-16 00:51:46 +0200714 return 0;
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200715
Bartlomiej Zolnierkiewicz4728d542007-05-16 00:51:46 +0200716 return 1;
Bartlomiej Zolnierkiewicz29e744d2007-05-10 00:01:09 +0200717}
718
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200719static int ide_dma_check(ide_drive_t *drive)
720{
721 ide_hwif_t *hwif = drive->hwif;
722 int vdma = (hwif->host_flags & IDE_HFLAG_VDMA)? 1 : 0;
723
724 if (!vdma && ide_tune_dma(drive))
725 return 0;
726
727 /* TODO: always do PIO fallback */
728 if (hwif->host_flags & IDE_HFLAG_TRUST_BIOS_FOR_DMA)
729 return -1;
730
731 ide_set_max_pio(drive);
732
733 return vdma ? 0 : -1;
734}
735
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100736int ide_id_dma_bug(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100738 struct hd_driveid *id = drive->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
740 if (id->field_valid & 4) {
741 if ((id->dma_ultra >> 8) && (id->dma_mword >> 8))
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100742 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 } else if (id->field_valid & 2) {
744 if ((id->dma_mword >> 8) && (id->dma_1word >> 8))
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100745 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100747 return 0;
748err_out:
749 printk(KERN_ERR "%s: bad DMA info in identify block\n", drive->name);
750 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
752
Bartlomiej Zolnierkiewicz3608b5d2007-02-17 02:40:26 +0100753int ide_set_dma(ide_drive_t *drive)
754{
Bartlomiej Zolnierkiewicz3608b5d2007-02-17 02:40:26 +0100755 int rc;
756
Bartlomiej Zolnierkiewicz7b905992008-01-25 22:17:19 +0100757 /*
758 * Force DMAing for the beginning of the check.
759 * Some chipsets appear to do interesting
760 * things, if not checked and cleared.
761 * PARANOIA!!!
762 */
Bartlomiej Zolnierkiewicz4a546e02008-01-26 20:13:01 +0100763 ide_dma_off_quietly(drive);
Bartlomiej Zolnierkiewicz7b905992008-01-25 22:17:19 +0100764
Bartlomiej Zolnierkiewicz0ae2e172007-10-16 22:29:55 +0200765 rc = ide_dma_check(drive);
Bartlomiej Zolnierkiewicz7b905992008-01-25 22:17:19 +0100766 if (rc)
767 return rc;
Bartlomiej Zolnierkiewicz3608b5d2007-02-17 02:40:26 +0100768
Bartlomiej Zolnierkiewicz4a546e02008-01-26 20:13:01 +0100769 ide_dma_on(drive);
770
771 return 0;
Bartlomiej Zolnierkiewicz3608b5d2007-02-17 02:40:26 +0100772}
773
Bartlomiej Zolnierkiewicz578cfa02008-02-02 19:56:47 +0100774void ide_check_dma_crc(ide_drive_t *drive)
775{
776 u8 mode;
777
778 ide_dma_off_quietly(drive);
779 drive->crc_count = 0;
780 mode = drive->current_speed;
781 /*
782 * Don't try non Ultra-DMA modes without iCRC's. Force the
783 * device to PIO and make the user enable SWDMA/MWDMA modes.
784 */
785 if (mode > XFER_UDMA_0 && mode <= XFER_UDMA_7)
786 mode--;
787 else
788 mode = XFER_PIO_4;
789 ide_set_xfer_rate(drive, mode);
790 if (drive->current_speed >= XFER_SW_DMA_0)
791 ide_dma_on(drive);
792}
793
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100794#ifdef CONFIG_BLK_DEV_IDEDMA_SFF
Sergei Shtylyov841d2a92007-07-09 23:17:54 +0200795void ide_dma_lost_irq (ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796{
797 printk("%s: DMA interrupt recovery\n", drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798}
799
Sergei Shtylyov841d2a92007-07-09 23:17:54 +0200800EXPORT_SYMBOL(ide_dma_lost_irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Sergei Shtylyovc283f5d2007-07-09 23:17:54 +0200802void ide_dma_timeout (ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803{
Sergei Shtylyovc283f5d2007-07-09 23:17:54 +0200804 ide_hwif_t *hwif = HWIF(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
Sergei Shtylyovc283f5d2007-07-09 23:17:54 +0200806 printk(KERN_ERR "%s: timeout waiting for DMA\n", drive->name);
807
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200808 if (hwif->dma_ops->dma_test_irq(drive))
Sergei Shtylyovc283f5d2007-07-09 23:17:54 +0200809 return;
810
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200811 hwif->dma_ops->dma_end(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812}
813
Sergei Shtylyovc283f5d2007-07-09 23:17:54 +0200814EXPORT_SYMBOL(ide_dma_timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Bartlomiej Zolnierkiewicz0d1bad22008-04-26 22:25:19 +0200816void ide_release_dma_engine(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817{
818 if (hwif->dmatable_cpu) {
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100819 struct pci_dev *pdev = to_pci_dev(hwif->dev);
820
821 pci_free_consistent(pdev, PRD_ENTRIES * PRD_BYTES,
822 hwif->dmatable_cpu, hwif->dmatable_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 hwif->dmatable_cpu = NULL;
824 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825}
826
Bartlomiej Zolnierkiewiczb8e73fb2008-04-26 22:25:21 +0200827int ide_allocate_dma_engine(ide_hwif_t *hwif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828{
Bartlomiej Zolnierkiewicz36501652008-02-01 23:09:31 +0100829 struct pci_dev *pdev = to_pci_dev(hwif->dev);
830
831 hwif->dmatable_cpu = pci_alloc_consistent(pdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 PRD_ENTRIES * PRD_BYTES,
833 &hwif->dmatable_dma);
834
835 if (hwif->dmatable_cpu)
836 return 0;
837
Sergei Shtylylovdc844e02006-10-03 01:14:14 -0700838 printk(KERN_ERR "%s: -- Error, unable to allocate DMA table.\n",
Bartlomiej Zolnierkiewicz5e59c232008-04-26 22:25:20 +0200839 hwif->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return 1;
842}
Bartlomiej Zolnierkiewiczb8e73fb2008-04-26 22:25:21 +0200843EXPORT_SYMBOL_GPL(ide_allocate_dma_engine);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200845static const struct ide_dma_ops sff_dma_ops = {
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200846 .dma_host_set = ide_dma_host_set,
847 .dma_setup = ide_dma_setup,
848 .dma_exec_cmd = ide_dma_exec_cmd,
849 .dma_start = ide_dma_start,
850 .dma_end = __ide_dma_end,
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200851 .dma_test_irq = ide_dma_test_irq,
Bartlomiej Zolnierkiewicz5e37bdc2008-04-26 22:25:24 +0200852 .dma_timeout = ide_dma_timeout,
853 .dma_lost_irq = ide_dma_lost_irq,
854};
855
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200856void ide_setup_dma(ide_hwif_t *hwif, unsigned long base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
Bartlomiej Zolnierkiewicza02bfd32007-10-20 00:32:37 +0200858 hwif->dma_base = base;
859
Sergei Shtylyovecf327962008-02-01 23:09:30 +0100860 if (!hwif->dma_command)
861 hwif->dma_command = hwif->dma_base + 0;
Sergei Shtylyovecf327962008-02-01 23:09:30 +0100862 if (!hwif->dma_status)
863 hwif->dma_status = hwif->dma_base + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Bartlomiej Zolnierkiewiczf37afda2008-04-26 22:25:24 +0200865 hwif->dma_ops = &sff_dma_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866}
867
868EXPORT_SYMBOL_GPL(ide_setup_dma);
Sergei Shtylyov8e882ba2008-02-11 00:32:14 +0100869#endif /* CONFIG_BLK_DEV_IDEDMA_SFF */