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