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