[PATCH] 2.5.12 IDE 49
[opensuse:kernel.git] / drivers / ide / ide-dma.c
1 /*
2  *  Copyright (c) 1999-2000  Andre Hedrick <andre@linux-ide.org>
3  *  Copyright (c) 1995-1998  Mark Lord
4  *
5  *  May be copied or modified under the terms of the GNU General Public License
6  *
7  *  Special Thanks to Mark for his Six years of work.
8  *
9  * This module provides support for the bus-master IDE DMA functions
10  * of various PCI chipsets, including the Intel PIIX (i82371FB for
11  * the 430 FX chipset), the PIIX3 (i82371SB for the 430 HX/VX and
12  * 440 chipsets), and the PIIX4 (i82371AB for the 430 TX chipset)
13  * ("PIIX" stands for "PCI ISA IDE Xcellerator").
14  *
15  * Pretty much the same code works for other IDE PCI bus-mastering chipsets.
16  *
17  * DMA is supported for all IDE devices (disk drives, cdroms, tapes, floppies).
18  *
19  * By default, DMA support is prepared for use, but is currently enabled only
20  * for drives which already have DMA enabled (UltraDMA or mode 2 multi/single),
21  * or which are recognized as "good" (see table below).  Drives with only mode0
22  * or mode1 (multi/single) DMA should also work with this chipset/driver
23  * (eg. MC2112A) but are not enabled by default.
24  *
25  * Use "hdparm -i" to view modes supported by a given drive.
26  *
27  * The hdparm-3.5 (or later) utility can be used for manually enabling/disabling
28  * DMA support, but must be (re-)compiled against this kernel version or later.
29  *
30  * To enable DMA, use "hdparm -d1 /dev/hd?" on a per-drive basis after booting.
31  * If problems arise, ide.c will disable DMA operation after a few retries.
32  * This error recovery mechanism works and has been extremely well exercised.
33  *
34  * IDE drives, depending on their vintage, may support several different modes
35  * of DMA operation.  The boot-time modes are indicated with a "*" in
36  * the "hdparm -i" listing, and can be changed with *knowledgeable* use of
37  * the "hdparm -X" feature.  There is seldom a need to do this, as drives
38  * normally power-up with their "best" PIO/DMA modes enabled.
39  *
40  * Testing has been done with a rather extensive number of drives,
41  * with Quantum & Western Digital models generally outperforming the pack,
42  * and Fujitsu & Conner (and some Seagate which are really Conner) drives
43  * showing more lackluster throughput.
44  *
45  * Keep an eye on /var/adm/messages for "DMA disabled" messages.
46  *
47  * Some people have reported trouble with Intel Zappa motherboards.
48  * This can be fixed by upgrading the AMI BIOS to version 1.00.04.BS0,
49  * available from ftp://ftp.intel.com/pub/bios/10004bs0.exe
50  * (thanks to Glen Morrell <glen@spin.Stanford.edu> for researching this).
51  *
52  * Thanks to "Christopher J. Reimer" <reimer@doe.carleton.ca> for
53  * fixing the problem with the BIOS on some Acer motherboards.
54  *
55  * Thanks to "Benoit Poulot-Cazajous" <poulot@chorus.fr> for testing
56  * "TX" chipset compatibility and for providing patches for the "TX" chipset.
57  *
58  * Thanks to Christian Brunner <chb@muc.de> for taking a good first crack
59  * at generic DMA -- his patches were referred to when preparing this code.
60  *
61  * Most importantly, thanks to Robert Bringman <rob@mars.trion.com>
62  * for supplying a Promise UDMA board & WD UDMA drive for this work!
63  *
64  * And, yes, Intel Zappa boards really *do* use both PIIX IDE ports.
65  *
66  * check_drive_lists(ide_drive_t *drive, int good_bad)
67  *
68  * ATA-66/100 and recovery functions, I forgot the rest......
69  */
70
71 #include <linux/config.h>
72 #include <linux/types.h>
73 #include <linux/kernel.h>
74 #include <linux/timer.h>
75 #include <linux/mm.h>
76 #include <linux/interrupt.h>
77 #include <linux/pci.h>
78 #include <linux/init.h>
79 #include <linux/ide.h>
80 #include <linux/delay.h>
81
82 #include <asm/io.h>
83 #include <asm/irq.h>
84
85 /*
86  * Long lost data from 2.0.34 that is now in 2.0.39
87  *
88  * This was used in ./drivers/block/triton.c to do DMA Base address setup
89  * when PnP failed.  Oh the things we forget.  I believe this was part
90  * of SFF-8038i that has been withdrawn from public access... :-((
91  */
92 #define DEFAULT_BMIBA   0xe800  /* in case BIOS did not init it */
93 #define DEFAULT_BMCRBA  0xcc00  /* VIA's default value */
94 #define DEFAULT_BMALIBA 0xd400  /* ALI's default value */
95
96 #ifdef CONFIG_IDEDMA_NEW_DRIVE_LISTINGS
97
98 struct drive_list_entry {
99         char * id_model;
100         char * id_firmware;
101 };
102
103 struct drive_list_entry drive_whitelist[] = {
104         { "Micropolis 2112A", NULL },
105         { "CONNER CTMA 4000", NULL },
106         { "CONNER CTT8000-A", NULL },
107         { "ST34342A", NULL },
108         { NULL, NULL }
109 };
110
111 struct drive_list_entry drive_blacklist[] = {
112
113         { "WDC AC11000H", NULL },
114         { "WDC AC22100H", NULL },
115         { "WDC AC32500H", NULL },
116         { "WDC AC33100H", NULL },
117         { "WDC AC31600H", NULL },
118         { "WDC AC32100H", "24.09P07" },
119         { "WDC AC23200L", "21.10N21" },
120         { "Compaq CRD-8241B", NULL },
121         { "CRD-8400B", NULL },
122         { "CRD-8480B", NULL },
123         { "CRD-8480C", NULL },
124         { "CRD-8482B", NULL },
125         { "CRD-84", NULL },
126         { "SanDisk SDP3B", NULL },
127         { "SanDisk SDP3B-64", NULL },
128         { "SANYO CD-ROM CRD", NULL },
129         { "HITACHI CDR-8", NULL },
130         { "HITACHI CDR-8335", NULL },
131         { "HITACHI CDR-8435", NULL },
132         { "Toshiba CD-ROM XM-6202B", NULL },
133         { "CD-532E-A", NULL },
134         { "E-IDE CD-ROM CR-840", NULL },
135         { "CD-ROM Drive/F5A", NULL },
136         { "RICOH CD-R/RW MP7083A", NULL },
137         { "WPI CDD-820", NULL },
138         { "SAMSUNG CD-ROM SC-148C", NULL },
139         { "SAMSUNG CD-ROM SC-148F", NULL },
140         { "SAMSUNG CD-ROM SC", NULL },
141         { "SanDisk SDP3B-64", NULL },
142         { "SAMSUNG CD-ROM SN-124", NULL },
143         { "PLEXTOR CD-R PX-W8432T", NULL },
144         { "ATAPI CD-ROM DRIVE 40X MAXIMUM", NULL },
145         { "_NEC DV5800A", NULL },
146         { NULL, NULL }
147
148 };
149
150 static int in_drive_list(struct hd_driveid *id, struct drive_list_entry * drive_table)
151 {
152         for ( ; drive_table->id_model ; drive_table++)
153                 if ((!strcmp(drive_table->id_model, id->model)) &&
154                     ((drive_table->id_firmware && !strstr(drive_table->id_firmware, id->fw_rev)) ||
155                      (!drive_table->id_firmware)))
156                         return 1;
157         return 0;
158 }
159
160 #else
161
162 /*
163  * good_dma_drives() lists the model names (from "hdparm -i")
164  * of drives which do not support mode2 DMA but which are
165  * known to work fine with this interface under Linux.
166  */
167 const char *good_dma_drives[] = {"Micropolis 2112A",
168                                  "CONNER CTMA 4000",
169                                  "CONNER CTT8000-A",
170                                  "ST34342A",    /* for Sun Ultra */
171                                  NULL};
172
173 /*
174  * bad_dma_drives() lists the model names (from "hdparm -i")
175  * of drives which supposedly support (U)DMA but which are
176  * known to corrupt data with this interface under Linux.
177  *
178  * This is an empirical list. Its generated from bug reports. That means
179  * while it reflects actual problem distributions it doesn't answer whether
180  * the drive or the controller, or cabling, or software, or some combination
181  * thereof is the fault. If you don't happen to agree with the kernel's
182  * opinion of your drive - use hdparm to turn DMA on.
183  */
184 const char *bad_dma_drives[] = {"WDC AC11000H",
185                                 "WDC AC22100H",
186                                 "WDC AC32100H",
187                                 "WDC AC32500H",
188                                 "WDC AC33100H",
189                                 "WDC AC31600H",
190                                 NULL};
191
192 #endif
193
194 /*
195  * dma_intr() is the handler for disk read/write DMA interrupts
196  */
197 ide_startstop_t ide_dma_intr(struct ata_device *drive, struct request *rq)
198 {
199         byte stat, dma_stat;
200
201         dma_stat = drive->channel->udma(ide_dma_end, drive, rq);
202         if (OK_STAT(stat = GET_STAT(),DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
203                 if (!dma_stat) {
204                         __ide_end_request(drive, rq, 1, rq->nr_sectors);
205                         return ide_stopped;
206                 }
207                 printk("%s: dma_intr: bad DMA status (dma_stat=%x)\n",
208                        drive->name, dma_stat);
209         }
210         return ide_error(drive, "dma_intr", stat);
211 }
212
213 /*
214  * FIXME: taskfiles should be a map of pages, not a long virt address... /jens
215  * FIXME: I agree with Jens --mdcki!
216  */
217 static int build_sglist(struct ata_channel *ch, struct request *rq)
218 {
219         struct scatterlist *sg = ch->sg_table;
220         int nents = 0;
221
222         if (rq->flags & REQ_DRIVE_ACB) {
223                 struct ata_taskfile *args = rq->special;
224 #if 1
225                 unsigned char *virt_addr = rq->buffer;
226                 int sector_count = rq->nr_sectors;
227 #else
228                 nents = blk_rq_map_sg(rq->q, rq, ch->sg_table);
229
230                 if (nents > rq->nr_segments)
231                         printk("ide-dma: received %d segments, build %d\n", rq->nr_segments, nents);
232 #endif
233
234                 if (args->command_type == IDE_DRIVE_TASK_RAW_WRITE)
235                         ch->sg_dma_direction = PCI_DMA_TODEVICE;
236                 else
237                         ch->sg_dma_direction = PCI_DMA_FROMDEVICE;
238
239                 /*
240                  * FIXME: This depends upon a hard coded page size!
241                  */
242                 if (sector_count > 128) {
243                         memset(&sg[nents], 0, sizeof(*sg));
244
245                         sg[nents].page = virt_to_page(virt_addr);
246                         sg[nents].offset = (unsigned long) virt_addr & ~PAGE_MASK;
247                         sg[nents].length = 128  * SECTOR_SIZE;
248                         ++nents;
249                         virt_addr = virt_addr + (128 * SECTOR_SIZE);
250                         sector_count -= 128;
251                 }
252                 memset(&sg[nents], 0, sizeof(*sg));
253                 sg[nents].page = virt_to_page(virt_addr);
254                 sg[nents].offset = (unsigned long) virt_addr & ~PAGE_MASK;
255                 sg[nents].length =  sector_count  * SECTOR_SIZE;
256                 ++nents;
257         } else {
258                 nents = blk_rq_map_sg(rq->q, rq, ch->sg_table);
259
260                 if (rq->q && nents > rq->nr_phys_segments)
261                         printk("ide-dma: received %d phys segments, build %d\n", rq->nr_phys_segments, nents);
262
263                 if (rq_data_dir(rq) == READ)
264                         ch->sg_dma_direction = PCI_DMA_FROMDEVICE;
265                 else
266                         ch->sg_dma_direction = PCI_DMA_TODEVICE;
267
268         }
269         return pci_map_sg(ch->pci_dev, sg, nents, ch->sg_dma_direction);
270 }
271
272 /*
273  * This prepares a dma request.  Returns 0 if all went okay, returns 1
274  * otherwise.  May also be invoked from trm290.c
275  */
276 int ide_build_dmatable(struct ata_device *drive, ide_dma_action_t func)
277 {
278         struct ata_channel *ch = drive->channel;
279         unsigned int *table = ch->dmatable_cpu;
280 #ifdef CONFIG_BLK_DEV_TRM290
281         unsigned int is_trm290_chipset = (ch->chipset == ide_trm290);
282 #else
283         const int is_trm290_chipset = 0;
284 #endif
285         unsigned int count = 0;
286         int i;
287         struct scatterlist *sg;
288
289         ch->sg_nents = i = build_sglist(ch, HWGROUP(drive)->rq);
290         if (!i)
291                 return 0;
292
293         sg = ch->sg_table;
294         while (i) {
295                 u32 cur_addr;
296                 u32 cur_len;
297
298                 cur_addr = sg_dma_address(sg);
299                 cur_len = sg_dma_len(sg);
300
301                 /*
302                  * Fill in the dma table, without crossing any 64kB boundaries.
303                  * Most hardware requires 16-bit alignment of all blocks,
304                  * but the trm290 requires 32-bit alignment.
305                  */
306
307                 while (cur_len) {
308                         u32 xcount, bcount = 0x10000 - (cur_addr & 0xffff);
309
310                         if (count++ >= PRD_ENTRIES) {
311                                 printk("ide-dma: count %d, sg_nents %d, cur_len %d, cur_addr %u\n",
312                                                 count, ch->sg_nents, cur_len, cur_addr);
313                                 BUG();
314                         }
315
316                         if (bcount > cur_len)
317                                 bcount = cur_len;
318                         *table++ = cpu_to_le32(cur_addr);
319                         xcount = bcount & 0xffff;
320                         if (is_trm290_chipset)
321                                 xcount = ((xcount >> 2) - 1) << 16;
322                         if (xcount == 0x0000) {
323                         /*
324                          * Most chipsets correctly interpret a length of
325                          * 0x0000 as 64KB, but at least one (e.g. CS5530)
326                          * misinterprets it as zero (!). So here we break
327                          * the 64KB entry into two 32KB entries instead.
328                          */
329                                 if (count++ >= PRD_ENTRIES) {
330                                         pci_unmap_sg(ch->pci_dev, sg,
331                                                      ch->sg_nents,
332                                                      ch->sg_dma_direction);
333                                         return 0;
334                                 }
335
336                                 *table++ = cpu_to_le32(0x8000);
337                                 *table++ = cpu_to_le32(cur_addr + 0x8000);
338                                 xcount = 0x8000;
339                         }
340                         *table++ = cpu_to_le32(xcount);
341                         cur_addr += bcount;
342                         cur_len -= bcount;
343                 }
344
345                 sg++;
346                 i--;
347         }
348
349         if (!count)
350                 printk("%s: empty DMA table?\n", drive->name);
351         else if (!is_trm290_chipset)
352                 *--table |= cpu_to_le32(0x80000000);
353
354         return count;
355 }
356
357 /* Teardown mappings after DMA has completed.  */
358 void ide_destroy_dmatable (ide_drive_t *drive)
359 {
360         struct pci_dev *dev = drive->channel->pci_dev;
361         struct scatterlist *sg = drive->channel->sg_table;
362         int nents = drive->channel->sg_nents;
363
364         pci_unmap_sg(dev, sg, nents, drive->channel->sg_dma_direction);
365 }
366
367 /*
368  *  For both Blacklisted and Whitelisted drives.
369  *  This is setup to be called as an extern for future support
370  *  to other special driver code.
371  */
372 int check_drive_lists (ide_drive_t *drive, int good_bad)
373 {
374         struct hd_driveid *id = drive->id;
375
376 #ifdef CONFIG_IDEDMA_NEW_DRIVE_LISTINGS
377         if (good_bad) {
378                 return in_drive_list(id, drive_whitelist);
379         } else {
380                 int blacklist = in_drive_list(id, drive_blacklist);
381                 if (blacklist)
382                         printk("%s: Disabling (U)DMA for %s\n", drive->name, id->model);
383                 return(blacklist);
384         }
385 #else /* !CONFIG_IDEDMA_NEW_DRIVE_LISTINGS */
386         const char **list;
387
388         if (good_bad) {
389                 /* Consult the list of known "good" drives */
390                 list = good_dma_drives;
391                 while (*list) {
392                         if (!strcmp(*list++,id->model))
393                                 return 1;
394                 }
395         } else {
396                 /* Consult the list of known "bad" drives */
397                 list = bad_dma_drives;
398                 while (*list) {
399                         if (!strcmp(*list++,id->model)) {
400                                 printk("%s: Disabling (U)DMA for %s\n",
401                                         drive->name, id->model);
402                                 return 1;
403                         }
404                 }
405         }
406 #endif /* CONFIG_IDEDMA_NEW_DRIVE_LISTINGS */
407         return 0;
408 }
409
410 int report_drive_dmaing (ide_drive_t *drive)
411 {
412         struct hd_driveid *id = drive->id;
413
414         if ((id->field_valid & 4) && (eighty_ninty_three(drive)) &&
415             (id->dma_ultra & (id->dma_ultra >> 14) & 3)) {
416                 if ((id->dma_ultra >> 15) & 1) {
417                         printk(", UDMA(mode 7)");       /* UDMA BIOS-enabled! */
418                 } else {
419                         printk(", UDMA(133)");  /* UDMA BIOS-enabled! */
420                 }
421         } else if ((id->field_valid & 4) && (eighty_ninty_three(drive)) &&
422                   (id->dma_ultra & (id->dma_ultra >> 11) & 7)) {
423                 if ((id->dma_ultra >> 13) & 1) {
424                         printk(", UDMA(100)");  /* UDMA BIOS-enabled! */
425                 } else if ((id->dma_ultra >> 12) & 1) {
426                         printk(", UDMA(66)");   /* UDMA BIOS-enabled! */
427                 } else {
428                         printk(", UDMA(44)");   /* UDMA BIOS-enabled! */
429                 }
430         } else if ((id->field_valid & 4) &&
431                    (id->dma_ultra & (id->dma_ultra >> 8) & 7)) {
432                 if ((id->dma_ultra >> 10) & 1) {
433                         printk(", UDMA(33)");   /* UDMA BIOS-enabled! */
434                 } else if ((id->dma_ultra >> 9) & 1) {
435                         printk(", UDMA(25)");   /* UDMA BIOS-enabled! */
436                 } else {
437                         printk(", UDMA(16)");   /* UDMA BIOS-enabled! */
438                 }
439         } else if (id->field_valid & 4) {
440                 printk(", (U)DMA");     /* Can be BIOS-enabled! */
441         } else {
442                 printk(", DMA");
443         }
444         return 1;
445 }
446
447 static int config_drive_for_dma (ide_drive_t *drive)
448 {
449         int config_allows_dma = 1;
450         struct hd_driveid *id = drive->id;
451         struct ata_channel *hwif = drive->channel;
452
453 #ifdef CONFIG_IDEDMA_ONLYDISK
454         if (drive->type != ATA_DISK)
455                 config_allows_dma = 0;
456 #endif
457
458         if (id && (id->capability & 1) && hwif->autodma && config_allows_dma) {
459                 /* Consult the list of known "bad" drives */
460                 if (ide_dmaproc(ide_dma_bad_drive, drive, NULL))
461                         return hwif->udma(ide_dma_off, drive, NULL);
462
463                 /* Enable DMA on any drive that has UltraDMA (mode 6/7/?) enabled */
464                 if ((id->field_valid & 4) && (eighty_ninty_three(drive)))
465                         if ((id->dma_ultra & (id->dma_ultra >> 14) & 2))
466                                 return hwif->udma(ide_dma_on, drive, NULL);
467                 /* Enable DMA on any drive that has UltraDMA (mode 3/4/5) enabled */
468                 if ((id->field_valid & 4) && (eighty_ninty_three(drive)))
469                         if ((id->dma_ultra & (id->dma_ultra >> 11) & 7))
470                                 return hwif->udma(ide_dma_on, drive, NULL);
471                 /* Enable DMA on any drive that has UltraDMA (mode 0/1/2) enabled */
472                 if (id->field_valid & 4)        /* UltraDMA */
473                         if ((id->dma_ultra & (id->dma_ultra >> 8) & 7))
474                                 return hwif->udma(ide_dma_on, drive, NULL);
475                 /* Enable DMA on any drive that has mode2 DMA (multi or single) enabled */
476                 if (id->field_valid & 2)        /* regular DMA */
477                         if ((id->dma_mword & 0x404) == 0x404 || (id->dma_1word & 0x404) == 0x404)
478                                 return hwif->udma(ide_dma_on, drive, NULL);
479                 /* Consult the list of known "good" drives */
480                 if (ide_dmaproc(ide_dma_good_drive, drive, NULL))
481                         return hwif->udma(ide_dma_on, drive, NULL);
482         }
483         return hwif->udma(ide_dma_off_quietly, drive, NULL);
484 }
485
486 /*
487  * 1 dma-ing, 2 error, 4 intr
488  */
489 static int dma_timer_expiry(struct ata_device *drive, struct request *__rq)
490 {
491         /* FIXME: What's that? */
492         u8 dma_stat = inb(drive->channel->dma_base+2);
493
494 #ifdef DEBUG
495         printk("%s: dma_timer_expiry: dma status == 0x%02x\n", drive->name, dma_stat);
496 #endif /* DEBUG */
497
498 #if 0
499         HWGROUP(drive)->expiry = NULL;  /* one free ride for now */
500 #endif
501
502         if (dma_stat & 2) {     /* ERROR */
503                 u8 stat = GET_STAT();
504                 return ide_error(drive, "dma_timer_expiry", stat);
505         }
506         if (dma_stat & 1)       /* DMAing */
507                 return WAIT_CMD;
508         return 0;
509 }
510
511 static void ide_toggle_bounce(ide_drive_t *drive, int on)
512 {
513         u64 addr = BLK_BOUNCE_HIGH;
514
515         if (on && drive->type == ATA_DISK && drive->channel->highmem) {
516                 if (!PCI_DMA_BUS_IS_PHYS)
517                         addr = BLK_BOUNCE_ANY;
518                 else
519                         addr = drive->channel->pci_dev->dma_mask;
520         }
521
522         blk_queue_bounce_limit(&drive->queue, addr);
523 }
524
525 /*
526  * This initiates/aborts DMA read/write operations on a drive.
527  *
528  * The caller is assumed to have selected the drive and programmed the drive's
529  * sector address using CHS or LBA.  All that remains is to prepare for DMA
530  * and then issue the actual read/write DMA/PIO command to the drive.
531  *
532  * For ATAPI devices, we just prepare for DMA and return. The caller should
533  * then issue the packet command to the drive and call us again with
534  * ide_dma_begin afterwards.
535  *
536  * Returns 0 if all went well.
537  * Returns 1 if DMA read/write could not be started, in which case
538  * the caller should revert to PIO for the current request.
539  * May also be invoked from trm290.c
540  */
541 int ide_dmaproc(ide_dma_action_t func, struct ata_device *drive, struct request *rq)
542 {
543         struct ata_channel *hwif = drive->channel;
544         unsigned long dma_base = hwif->dma_base;
545         byte unit = (drive->select.b.unit & 0x01);
546         unsigned int count, reading = 0, set_high = 1;
547         byte dma_stat;
548
549         switch (func) {
550                 case ide_dma_off:
551                         printk("%s: DMA disabled\n", drive->name);
552                 case ide_dma_off_quietly:
553                         set_high = 0;
554                         outb(inb(dma_base+2) & ~(1<<(5+unit)), dma_base+2);
555                 case ide_dma_on:
556                         ide_toggle_bounce(drive, set_high);
557                         drive->using_dma = (func == ide_dma_on);
558                         if (drive->using_dma)
559                                 outb(inb(dma_base+2)|(1<<(5+unit)), dma_base+2);
560                         return 0;
561                 case ide_dma_check:
562                         return config_drive_for_dma (drive);
563                 case ide_dma_read:
564                         reading = 1 << 3;
565                 case ide_dma_write:
566                         /* active tuning based on IO direction */
567                         if (hwif->rwproc)
568                                 hwif->rwproc(drive, func);
569
570                         if (!(count = ide_build_dmatable(drive, func)))
571                                 return 1;       /* try PIO instead of DMA */
572                         outl(hwif->dmatable_dma, dma_base + 4); /* PRD table */
573                         outb(reading, dma_base);                        /* specify r/w */
574                         outb(inb(dma_base+2)|6, dma_base+2);            /* clear INTR & ERROR flags */
575                         drive->waiting_for_dma = 1;
576                         if (drive->type != ATA_DISK)
577                                 return 0;
578
579                         ide_set_handler(drive, ide_dma_intr, WAIT_CMD, dma_timer_expiry);       /* issue cmd to drive */
580                         if ((rq->flags & REQ_DRIVE_ACB) && (drive->addressing == 1)) {
581                                 struct ata_taskfile *args = rq->special;
582
583                                 OUT_BYTE(args->taskfile.command, IDE_COMMAND_REG);
584                         } else if (drive->addressing) {
585                                 OUT_BYTE(reading ? WIN_READDMA_EXT : WIN_WRITEDMA_EXT, IDE_COMMAND_REG);
586                         } else {
587                                 OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA, IDE_COMMAND_REG);
588                         }
589                         return drive->channel->udma(ide_dma_begin, drive, NULL);
590                 case ide_dma_begin:
591                         /* Note that this is done *after* the cmd has
592                          * been issued to the drive, as per the BM-IDE spec.
593                          * The Promise Ultra33 doesn't work correctly when
594                          * we do this part before issuing the drive cmd.
595                          */
596                         outb(inb(dma_base)|1, dma_base);                /* start DMA */
597                         return 0;
598                 case ide_dma_end: /* returns 1 on error, 0 otherwise */
599                         drive->waiting_for_dma = 0;
600                         outb(inb(dma_base)&~1, dma_base);       /* stop DMA */
601                         dma_stat = inb(dma_base+2);             /* get DMA status */
602                         outb(dma_stat|6, dma_base+2);   /* clear the INTR & ERROR bits */
603                         ide_destroy_dmatable(drive);    /* purge DMA mappings */
604                         return (dma_stat & 7) != 4 ? (0x10 | dma_stat) : 0;     /* verify good DMA status */
605                 case ide_dma_test_irq: /* returns 1 if dma irq issued, 0 otherwise */
606                         dma_stat = inb(dma_base+2);
607 #if 0  /* do not set unless you know what you are doing */
608                         if (dma_stat & 4) {
609                                 byte stat = GET_STAT();
610                                 outb(dma_base+2, dma_stat & 0xE4);
611                         }
612 #endif
613                         return (dma_stat & 4) == 4;     /* return 1 if INTR asserted */
614                 case ide_dma_bad_drive:
615                 case ide_dma_good_drive:
616                         return check_drive_lists(drive, (func == ide_dma_good_drive));
617                 case ide_dma_verbose:
618                         return report_drive_dmaing(drive);
619                 case ide_dma_timeout:
620                         printk(KERN_ERR "%s: DMA timeout occured!\n", __FUNCTION__);
621                         return 1;
622                 case ide_dma_retune:
623                 case ide_dma_lostirq:
624                         printk(KERN_ERR "%s: chipset supported func only: %d\n", __FUNCTION__,  func);
625                         return 1;
626                 default:
627                         printk(KERN_ERR "%s: unsupported func: %d\n", __FUNCTION__, func);
628                         return 1;
629         }
630 }
631
632 /*
633  * Needed for allowing full modular support of ide-driver
634  */
635 void ide_release_dma(struct ata_channel *hwif)
636 {
637         if (!hwif->dma_base)
638                 return;
639
640         if (hwif->dmatable_cpu) {
641                 pci_free_consistent(hwif->pci_dev,
642                                     PRD_ENTRIES * PRD_BYTES,
643                                     hwif->dmatable_cpu,
644                                     hwif->dmatable_dma);
645                 hwif->dmatable_cpu = NULL;
646         }
647         if (hwif->sg_table) {
648                 kfree(hwif->sg_table);
649                 hwif->sg_table = NULL;
650         }
651         if ((hwif->dma_extra) && (hwif->unit == 0))
652                 release_region((hwif->dma_base + 16), hwif->dma_extra);
653         release_region(hwif->dma_base, 8);
654         hwif->dma_base = 0;
655 }
656
657 /*
658  * This can be called for a dynamically installed interface. Don't __init it
659  */
660 void ide_setup_dma(struct ata_channel *hwif, unsigned long dma_base, unsigned int num_ports)
661 {
662         printk("    %s: BM-DMA at 0x%04lx-0x%04lx", hwif->name, dma_base, dma_base + num_ports - 1);
663         if (check_region(dma_base, num_ports)) {
664                 printk(" -- ERROR, PORT ADDRESSES ALREADY IN USE\n");
665                 return;
666         }
667         request_region(dma_base, num_ports, hwif->name);
668         hwif->dma_base = dma_base;
669         hwif->dmatable_cpu = pci_alloc_consistent(hwif->pci_dev,
670                                                   PRD_ENTRIES * PRD_BYTES,
671                                                   &hwif->dmatable_dma);
672         if (hwif->dmatable_cpu == NULL)
673                 goto dma_alloc_failure;
674
675         hwif->sg_table = kmalloc(sizeof(struct scatterlist) * PRD_ENTRIES,
676                                  GFP_KERNEL);
677         if (hwif->sg_table == NULL) {
678                 pci_free_consistent(hwif->pci_dev, PRD_ENTRIES * PRD_BYTES,
679                                     hwif->dmatable_cpu, hwif->dmatable_dma);
680                 goto dma_alloc_failure;
681         }
682
683         hwif->udma = ide_dmaproc;
684
685         if (hwif->chipset != ide_trm290) {
686                 byte dma_stat = inb(dma_base+2);
687                 printk(", BIOS settings: %s:%s, %s:%s",
688                        hwif->drives[0].name, (dma_stat & 0x20) ? "DMA" : "pio",
689                        hwif->drives[1].name, (dma_stat & 0x40) ? "DMA" : "pio");
690         }
691         printk("\n");
692         return;
693
694 dma_alloc_failure:
695         printk(" -- ERROR, UNABLE TO ALLOCATE DMA TABLES\n");
696 }