[PATCH] 2.5.7 IDE 27
[opensuse:kernel.git] / drivers / ide / piix.c
1 /*
2  * $Id: piix.c,v 1.2 2002/03/13 22:50:43 vojtech Exp $
3  *
4  *  Copyright (c) 2000-2002 Vojtech Pavlik
5  *
6  *  Based on the work of:
7  *      Andrzej Krzysztofowicz
8  *      Andre Hedrick
9  *
10  *  Thanks to Daniela Egbert for advice on PIIX bugs.
11  */
12
13 /*
14  * Intel PIIX/ICH and Efar Victory66 IDE driver for Linux.
15  *
16  * UDMA66 and higher modes are autoenabled only in case the BIOS has detected a
17  * 80 wire cable. To ignore the BIOS data and assume the cable is present, use
18  * 'ide0=ata66' or 'ide1=ata66' on the kernel command line.
19  */
20
21 /*
22  * This program is free software; you can redistribute it and/or modify
23  * it under the terms of the GNU General Public License as published by
24  * the Free Software Foundation; either version 2 of the License, or
25  * (at your option) any later version.
26  *
27  * This program is distributed in the hope that it will be useful,
28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30  * GNU General Public License for more details.
31  *
32  * You should have received a copy of the GNU General Public License
33  * along with this program; if not, write to the Free Software
34  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
35  *
36  * Should you need to contact me, the author, you can do so either by
37  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
38  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
39  */
40
41 #include <linux/config.h>
42 #include <linux/kernel.h>
43 #include <linux/ioport.h>
44 #include <linux/blkdev.h>
45 #include <linux/pci.h>
46 #include <linux/init.h>
47 #include <linux/ide.h>
48 #include <asm/io.h>
49
50 #include "ata-timing.h"
51
52 #define PIIX_IDETIM0            0x40
53 #define PIIX_IDETIM1            0x42
54 #define PIIX_SIDETIM            0x44
55 #define PIIX_IDESTAT            0x47
56 #define PIIX_UDMACTL            0x48
57 #define PIIX_UDMATIM            0x4a
58 #define PIIX_IDECFG             0x54
59
60 #define PIIX_UDMA               0x07
61 #define PIIX_UDMA_NONE          0x00
62 #define PIIX_UDMA_33            0x01
63 #define PIIX_UDMA_66            0x02
64 #define PIIX_UDMA_V66           0x03
65 #define PIIX_UDMA_100           0x04
66 #define PIIX_NO_SITRE           0x08    /* Chip doesn't have separate slave timing */
67 #define PIIX_PINGPONG           0x10    /* Enable ping-pong buffers */
68 #define PIIX_VICTORY            0x20    /* Efar Victory66 has a different UDMA setup */
69 #define PIIX_CHECK_REV          0x40    /* May be a buggy revision of PIIX */
70 #define PIIX_NODMA              0x80    /* Don't do DMA with this chip */
71
72 /*
73  * Intel IDE chips
74  */
75
76 static struct piix_ide_chip {
77         unsigned short id;
78         unsigned char flags;
79 } piix_ide_chips[] = {
80         { PCI_DEVICE_ID_INTEL_82801CA_11,       PIIX_UDMA_100 | PIIX_PINGPONG },                    /* Intel 82801CA ICH3 */
81         { PCI_DEVICE_ID_INTEL_82801CA_10,       PIIX_UDMA_100 | PIIX_PINGPONG },                    /* Intel 82801CAM ICH3-M */
82         { PCI_DEVICE_ID_INTEL_82801BA_9,        PIIX_UDMA_100 | PIIX_PINGPONG },                    /* Intel 82801BA ICH2 */
83         { PCI_DEVICE_ID_INTEL_82801BA_8,        PIIX_UDMA_100 | PIIX_PINGPONG },                    /* Intel 82801BAM ICH2-M */
84         { PCI_DEVICE_ID_INTEL_82801AB_1,        PIIX_UDMA_33  | PIIX_PINGPONG },                    /* Intel 82801AB ICH0 */
85         { PCI_DEVICE_ID_INTEL_82801AA_1,        PIIX_UDMA_66  | PIIX_PINGPONG },                    /* Intel 82801AA ICH */
86         { PCI_DEVICE_ID_INTEL_82372FB_1,        PIIX_UDMA_66 },                                     /* Intel 82372FB PIIX5 */
87         { PCI_DEVICE_ID_INTEL_82443MX_1,        PIIX_UDMA_33 },                                     /* Intel 82443MX MPIIX4 */
88         { PCI_DEVICE_ID_INTEL_82371AB,          PIIX_UDMA_33 },                                     /* Intel 82371AB/EB PIIX4/4E */
89         { PCI_DEVICE_ID_INTEL_82371SB_1,        PIIX_UDMA_NONE },                                   /* Intel 82371SB PIIX3 */
90         { PCI_DEVICE_ID_INTEL_82371FB_1,        PIIX_UDMA_NONE | PIIX_NO_SITRE | PIIX_CHECK_REV },  /* Intel 82371FB PIIX */
91         { PCI_DEVICE_ID_EFAR_SLC90E66_1,        PIIX_UDMA_V66 | PIIX_VICTORY },                     /* Efar Victory66 */
92         { 0 }
93 };
94
95 static struct piix_ide_chip *piix_config;
96 static unsigned char piix_enabled;
97 static unsigned int piix_80w;
98 static unsigned int piix_clock;
99
100 static char *piix_dma[] = { "MWDMA16", "UDMA33", "UDMA66", "UDMA66", "UDMA100" };
101
102 /*
103  * PIIX/ICH /proc entry.
104  */
105
106 #ifdef CONFIG_PROC_FS
107
108 #include <linux/stat.h>
109 #include <linux/proc_fs.h>
110
111 byte piix_proc;
112 int piix_base;
113 static struct pci_dev *bmide_dev;
114 extern int (*piix_display_info)(char *, char **, off_t, int); /* ide-proc.c */
115
116 #define piix_print(format, arg...) p += sprintf(p, format "\n" , ## arg)
117 #define piix_print_drive(name, format, arg...)\
118         p += sprintf(p, name); for (i = 0; i < 4; i++) p += sprintf(p, format, ## arg); p += sprintf(p, "\n");
119
120 static int piix_get_info(char *buffer, char **addr, off_t offset, int count)
121 {
122         int speed[4], cycle[4], active[4], recover[4], dmaen[4], uen[4], udma[4], umul;
123         struct pci_dev *dev = bmide_dev;
124         unsigned int i, u;
125         unsigned short c, d, e;
126         unsigned char t;
127         char *p = buffer;
128
129         piix_print("----------PIIX BusMastering IDE Configuration---------------");
130
131         piix_print("Driver Version:                     1.2");
132         piix_print("South Bridge:                       %s", bmide_dev->name);
133
134         pci_read_config_byte(dev, PCI_REVISION_ID, &t);
135         piix_print("Revision:                           IDE %#x", t);
136         piix_print("Highest DMA rate:                   %s", piix_config->flags & PIIX_NODMA ? "No DMA"
137                                                                 : piix_dma[piix_config->flags & PIIX_UDMA]);
138
139         piix_print("BM-DMA base:                        %#x", piix_base);
140         piix_print("PCI clock:                          %d.%dMHz", piix_clock / 1000, piix_clock / 100 % 10);
141
142         piix_print("-----------------------Primary IDE-------Secondary IDE------");
143
144         pci_read_config_word(dev, PIIX_IDETIM0, &d);
145         pci_read_config_word(dev, PIIX_IDETIM1, &e);
146         piix_print("Enabled:               %10s%20s", (d & 0x8000) ? "yes" : "no", (e & 0x8000) ? "yes" : "no");
147
148         c = inb(piix_base + 0x02) | (inb(piix_base + 0x0a) << 8);
149         piix_print("Simplex only:          %10s%20s", (c & 0x80) ? "yes" : "no", (c & 0x8000) ? "yes" : "no");
150
151         piix_print("Cable Type:            %10s%20s", (piix_80w & 1) ? "80w" : "40w", (piix_80w & 2) ? "80w" : "40w");
152
153         if (!piix_clock)
154                 return p - buffer;
155
156         piix_print("-------------------drive0----drive1----drive2----drive3-----");
157
158         piix_print_drive("Prefetch+Post: ", "%10s", (((i & 2) ? d : e) & (1 << (2 + ((i & 1) << 2)))) ? "yes" : "no");
159
160         for (i = 0; i < 4; i++) {
161
162                 pci_read_config_word(dev, PIIX_IDETIM0 + (i & 2), &d);
163                 if (~piix_config->flags & PIIX_NO_SITRE)
164                         pci_read_config_byte(dev, PIIX_SIDETIM, &t);
165
166                 umul = 4;
167                 udma[i] = uen[i] = 0;
168                 active[i] = 12;
169                 recover[i] = 18;
170
171                 switch (i & 1) {
172                         case 1: if (~d & 0x10) break;
173                                 if ((~piix_config->flags & PIIX_NO_SITRE) && (d & 0x4000)) {
174                                         active[i]  = 5 - ((t >> (((i & 2) << 1) + 2)) & 3); 
175                                         recover[i] = 4 - ((t >> (((i & 2) << 1) + 0)) & 3); 
176                                         break;
177                                 }
178
179                         case 0: if (~d & 0x01) break;
180                                 active[i] =  5 - ((d >> 12) & 3);
181                                 recover[i] = 4 - ((d >> 8) & 3);
182                 }
183
184                 dmaen[i] = (c & ((i & 1) ? 0x40 : 0x20) << ((i & 2) << 2));
185                 cycle[i] = 1000000 / piix_clock * (active[i] + recover[i]);
186                 speed[i] = 2 * piix_clock / (active[i] + recover[i]);
187
188                 if (!(piix_config->flags & PIIX_UDMA))
189                         continue;
190
191                 pci_read_config_byte(dev, PIIX_UDMACTL, &t);
192                 uen[i]  = (t & (1 << i)) ? dmaen[i] : 0;
193
194                 if (!uen[i])
195                         continue;
196
197                 pci_read_config_word(dev, PIIX_UDMATIM, &e);
198                 pci_read_config_dword(dev, PIIX_IDECFG, &u);
199
200                 if (~piix_config->flags & PIIX_VICTORY) {
201                         if ((piix_config->flags & PIIX_UDMA) >= PIIX_UDMA_66 && (u & (1 << i))) umul = 2;
202                         if ((piix_config->flags & PIIX_UDMA) >= PIIX_UDMA_100 && (u & ((1 << i) + 12))) umul = 1;
203                         udma[i] = (4 - ((e >> (i << 2)) & 3)) * umul;
204                 } else  udma[i] = (8 - ((e >> (i << 2)) & 7)) * 2;
205
206                 speed[i] = 8 * piix_clock / udma[i];
207                 cycle[i] = 250000 * udma[i] / piix_clock;
208         }
209
210         piix_print_drive("Transfer Mode: ", "%10s", dmaen[i] ? (uen[i] ? "UDMA" : "DMA") : "PIO");
211
212         piix_print_drive("Address Setup: ", "%8dns", (1000000 / piix_clock) * 3);
213         piix_print_drive("Cmd Active:    ", "%8dns", (1000000 / piix_clock) * 12);
214         piix_print_drive("Cmd Recovery:  ", "%8dns", (1000000 / piix_clock) * 18);
215         piix_print_drive("Data Active:   ", "%8dns", (1000000 / piix_clock) * active[i]);
216         piix_print_drive("Data Recovery: ", "%8dns", (1000000 / piix_clock) * recover[i]);
217         piix_print_drive("Cycle Time:    ", "%8dns", cycle[i]);
218         piix_print_drive("Transfer Rate: ", "%4d.%dMB/s", speed[i] / 1000, speed[i] / 100 % 10);
219
220         return p - buffer;      /* hoping it is less than 4K... */
221 }
222
223 #endif
224
225 /*
226  * piix_set_speed() writes timing values to the chipset registers
227  */
228
229 static void piix_set_speed(struct pci_dev *dev, unsigned char dn, struct ata_timing *timing, int umul)
230 {
231         unsigned short t;
232         unsigned char u;
233         unsigned int c;
234
235         pci_read_config_word(dev, PIIX_IDETIM0 + (dn & 2), &t);
236
237         switch (dn & 1) {
238
239                 case 1: 
240                         if (timing->cycle > 9) {
241                                 t &= ~0x30;
242                                 break;
243                         }
244
245                         if (~piix_config->flags & PIIX_NO_SITRE) {
246                                 pci_read_config_byte(dev, PIIX_SIDETIM, &u);
247                                 u &= ~(0xf << ((dn & 2) << 1));
248                                 t |= 0x30;
249                                 u |= (4 - FIT(timing->recover, 1, 4)) << ((dn & 2) << 1);
250                                 u |= (5 - FIT(timing->active, 2, 5)) << (((dn & 2) << 1) + 2);
251                                 pci_write_config_byte(dev, PIIX_SIDETIM, u);
252                                 break;
253                         }
254
255                 case 0:
256                         if ((~dn & 1) && timing->cycle > 9) {
257                                 t &= ~0x03;
258                                 break;
259                         }
260
261                         t &= 0xccff;
262                         t |= 0x03 << ((dn & 1) << 2);
263                         t |= (4 - FIT(timing->recover, 1, 4)) << 8;
264                         t |= (5 - FIT(timing->active, 2, 5)) << 12;
265         }
266
267         pci_write_config_word(dev, PIIX_IDETIM0 + (dn & 2), t);
268
269         if (!(piix_config->flags & PIIX_UDMA)) return;
270
271         pci_read_config_byte(dev, PIIX_UDMACTL, &u);
272         u &= ~(1 << dn);
273
274         if (timing->udma) {
275
276                 u |= 1 << dn;
277
278                 pci_read_config_word(dev, PIIX_UDMATIM, &t);
279
280                 if (piix_config->flags & PIIX_VICTORY) {
281                         t &= ~(0x07 << (dn << 2));
282                         t |= (8 - FIT(timing->udma, 2, 8)) << (dn << 2);
283                 } else {
284                         t &= ~(0x03 << (dn << 2));
285                         t |= (4 - FIT(timing->udma, 2, 4)) << (dn << 2);
286                 }
287
288                 pci_write_config_word(dev, PIIX_UDMATIM, t);
289
290                 if ((piix_config->flags & PIIX_UDMA) > PIIX_UDMA_33
291                         && ~piix_config->flags & PIIX_VICTORY) {
292
293                         pci_read_config_dword(dev, PIIX_IDECFG, &c);
294                         
295                         if ((piix_config->flags & PIIX_UDMA) > PIIX_UDMA_66)
296                                 c &= ~(1 << (dn + 12));
297                         c &= ~(1 << dn);
298
299                         switch (umul) {
300                                 case 2: c |= 1 << dn;           break;
301                                 case 4: c |= 1 << (dn + 12);    break;
302                         }
303
304                         pci_write_config_dword(dev, PIIX_IDECFG, c);
305                 }
306         }
307
308         pci_write_config_byte(dev, PIIX_UDMACTL, u);
309 }
310
311 /*
312  * piix_set_drive() computes timing values configures the drive and
313  * the chipset to a desired transfer mode. It also can be called
314  * by upper layers.
315  */
316
317 static int piix_set_drive(ide_drive_t *drive, unsigned char speed)
318 {
319         ide_drive_t *peer = drive->channel->drives + (~drive->dn & 1);
320         struct ata_timing t, p;
321         int err, T, UT, umul;
322
323         if (speed != XFER_PIO_SLOW && speed != drive->current_speed)
324                 if ((err = ide_config_drive_speed(drive, speed)))
325                         return err;
326
327         umul =  min((speed > XFER_UDMA_4) ? 4 : ((speed > XFER_UDMA_2) ? 2 : 1),
328                 piix_config->flags & PIIX_UDMA);
329
330         if (piix_config->flags & PIIX_VICTORY)
331                 umul = 2;
332
333         T = 1000000000 / piix_clock;
334         UT = T / umul;
335
336         ata_timing_compute(drive, speed, &t, T, UT);
337
338         if ((piix_config->flags & PIIX_NO_SITRE) && peer->present) {
339                         ata_timing_compute(peer, peer->current_speed, &p, T, UT);
340                         if (t.cycle <= 9 && p.cycle <= 9)
341                                 ata_timing_merge(&p, &t, &t, IDE_TIMING_ALL);
342         }
343
344         piix_set_speed(drive->channel->pci_dev, drive->dn, &t, umul);
345
346         if (!drive->init_speed) 
347                 drive->init_speed = speed;
348         drive->current_speed = speed;
349
350         return 0;
351 }
352
353 /*
354  * piix_tune_drive() is a callback from upper layers for
355  * PIO-only tuning.
356  */
357
358 static void piix_tune_drive(ide_drive_t *drive, unsigned char pio)
359 {
360         if (!((piix_enabled >> drive->channel->unit) & 1))
361                 return;
362
363         if (pio == 255) {
364                 piix_set_drive(drive, ata_timing_mode(drive, XFER_PIO | XFER_EPIO));
365                 return;
366         }
367
368         piix_set_drive(drive, XFER_PIO_0 + min_t(byte, pio, 5));
369 }
370
371 #ifdef CONFIG_BLK_DEV_IDEDMA
372
373 /*
374  * piix_dmaproc() is a callback from upper layers that can do
375  * a lot, but we use it for DMA/PIO tuning only, delegating everything
376  * else to the default ide_dmaproc().
377  */
378
379 int piix_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
380 {
381
382         if (func == ide_dma_check) {
383
384                 short w80 = drive->channel->udma_four;
385
386                 short speed = ata_timing_mode(drive,
387                         XFER_PIO | XFER_EPIO | 
388                         (piix_config->flags & PIIX_NODMA ? 0 : (XFER_SWDMA | XFER_MWDMA |
389                         (piix_config->flags & PIIX_UDMA ? XFER_UDMA : 0) |
390                         (w80 && (piix_config->flags & PIIX_UDMA) >= PIIX_UDMA_66 ? XFER_UDMA_66 : 0) |
391                         (w80 && (piix_config->flags & PIIX_UDMA) >= PIIX_UDMA_100 ? XFER_UDMA_100 : 0))));
392
393                 piix_set_drive(drive, speed);
394
395                 func = (drive->channel->autodma && (speed & XFER_MODE) != XFER_PIO)
396                         ? ide_dma_on : ide_dma_off_quietly;
397
398         }
399
400         return ide_dmaproc(func, drive);
401 }
402
403 #endif /* CONFIG_BLK_DEV_IDEDMA */
404
405 /*
406  * The initialization callback. Here we determine the IDE chip type
407  * and initialize its drive independent registers.
408  */
409
410 unsigned int __init pci_init_piix(struct pci_dev *dev, const char *name)
411 {
412         unsigned int u;
413         unsigned short w;
414         unsigned char t;
415         int i;
416
417 /*
418  * Find out which Intel IDE this is.
419  */
420
421         for (piix_config = piix_ide_chips; piix_config->id != 0; ++piix_config)
422                 if (dev->device == piix_config->id)
423                         break;
424
425         if (!piix_config->id) {
426                 printk(KERN_WARNING "PIIX: Unknown PIIX/ICH chip %#x, contact Vojtech Pavlik <vojtech@ucw.cz>\n", dev->device);
427                 return -ENODEV;
428         }
429
430 /*
431  * Check for possibly broken DMA configs.
432  */
433
434         {
435                 struct pci_dev *orion = NULL;
436
437                 if (piix_config->flags & PIIX_CHECK_REV) {
438                         pci_read_config_byte(dev, PCI_REVISION_ID, &t);
439                         if (t < 2) {
440                                 printk(KERN_INFO "PIIX: Found buggy old PIIX rev %#x, disabling DMA\n", t);
441                                 piix_config->flags |= PIIX_NODMA;
442                         }
443                 }
444
445                 if ((orion = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454GX, NULL))) {
446                         pci_read_config_byte(orion, PCI_REVISION_ID, &t);
447                         if (t < 4) {
448                                 printk(KERN_INFO "PIIX: Found buggy 82454GX Orion bridge rev %#x, disabling DMA\n", t);
449                                 piix_config->flags |= PIIX_NODMA;
450                         }
451                 }
452         }
453
454 /*
455  * Check 80-wire cable presence.
456  */
457
458         switch (piix_config->flags & PIIX_UDMA) {
459
460                 case PIIX_UDMA_66:
461                 case PIIX_UDMA_100:
462                         pci_read_config_dword(dev, PIIX_IDECFG, &u);
463                         piix_80w = ((u & 0x30) ? 1 : 0) | ((u & 0xc0) ? 2 : 0);
464                         break;
465
466                 case PIIX_UDMA_V66:
467                         pci_read_config_byte(dev, PIIX_IDESTAT, &t);
468                         piix_80w = ((t & 2) ? 1 : 0) | ((t & 1) ? 2 : 0);
469                         break;
470         }
471
472 /*
473  * Enable ping-pong buffers where applicable.
474  */
475
476         if (piix_config->flags & PIIX_PINGPONG) {
477                 pci_read_config_dword(dev, PIIX_IDECFG, &u);
478                 u |= 0x400; 
479                 pci_write_config_dword(dev, PIIX_IDECFG, u);
480         }
481
482 /*
483  * Detect enabled interfaces, enable slave separate timing if possible.
484  */
485
486         for (i = 0; i < 2; i++) {
487                 pci_read_config_word(dev, PIIX_IDETIM0 + (i << 1), &w);
488                 piix_enabled |= (w & 0x8000) ? (1 << i) : 0;
489                 w &= 0x8c00;
490                 if (~piix_config->flags & PIIX_NO_SITRE) w |= 0x4000;
491                 w |= 0x44;
492                 pci_write_config_word(dev, PIIX_IDETIM0 + (i << 1), w);
493         }
494
495 /*
496  * Determine the system bus clock.
497  */
498
499         piix_clock = system_bus_speed * 1000;
500
501         switch (piix_clock) {
502                 case 33000: piix_clock = 33333; break;
503                 case 37000: piix_clock = 37500; break;
504                 case 41000: piix_clock = 41666; break;
505         }
506
507         if (piix_clock < 20000 || piix_clock > 50000) {
508                 printk(KERN_WARNING "PIIX: User given PCI clock speed impossible (%d), using 33 MHz instead.\n", piix_clock);
509                 printk(KERN_WARNING "PIIX: Use ide0=ata66 if you want to assume 80-wire cable\n");
510                 piix_clock = 33333;
511         }
512
513 /*
514  * Print the boot message.
515  */
516
517         printk(KERN_INFO "PIIX: %s %s controller on pci%s\n",
518                 dev->name, piix_dma[piix_config->flags & PIIX_UDMA], dev->slot_name);
519
520 /*
521  * Register /proc/ide/piix entry
522  */
523
524 #ifdef CONFIG_PROC_FS
525         if (!piix_proc) {
526                 piix_base = pci_resource_start(dev, 4);
527                 bmide_dev = dev;
528                 piix_display_info = &piix_get_info;
529                 piix_proc = 1;
530         }
531 #endif
532
533         return 0;
534 }
535
536 unsigned int __init ata66_piix(struct ata_channel *hwif)
537 {
538         return ((piix_enabled & piix_80w) >> hwif->unit) & 1;
539 }
540
541 void __init ide_init_piix(struct ata_channel *hwif)
542 {
543         int i;
544
545         hwif->tuneproc = &piix_tune_drive;
546         hwif->speedproc = &piix_set_drive;
547         hwif->autodma = 0;
548
549         for (i = 0; i < 2; i++) {
550                 hwif->drives[i].io_32bit = 1;
551                 hwif->drives[i].unmask = 1;
552                 hwif->drives[i].autotune = 1;
553                 hwif->drives[i].dn = hwif->unit * 2 + i;
554         }
555
556 #ifdef CONFIG_BLK_DEV_IDEDMA
557         if (hwif->dma_base) {
558                 hwif->highmem = 1;
559                 hwif->dmaproc = &piix_dmaproc;
560 #ifdef CONFIG_IDEDMA_AUTO
561                 if (!noautodma)
562                         hwif->autodma = 1;
563 #endif
564         }
565 #endif /* CONFIG_BLK_DEV_IDEDMA */
566 }
567
568 /*
569  * We allow the BM-DMA driver only work on enabled interfaces,
570  * and only if DMA is safe with the chip and bridge.
571  */
572
573 void __init ide_dmacapable_piix(struct ata_channel *hwif, unsigned long dmabase)
574 {
575         if (((piix_enabled >> hwif->unit) & 1)
576                 && !(piix_config->flags & PIIX_NODMA))
577                         ide_setup_dma(hwif, dmabase, 8);
578 }