Add support for the ICH 4 mobile chipset.
[dragonfly.git] / sys / dev / disk / ata / ata-pci.c
1 /*-
2  * Copyright (c) 1998,1999,2000,2001,2002 Søren Schmidt <sos@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification, immediately at the beginning of the file.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * $FreeBSD: src/sys/dev/ata/ata-pci.c,v 1.32.2.15 2003/06/06 13:27:05 fjoe Exp $
29  * $DragonFly: src/sys/dev/disk/ata/ata-pci.c,v 1.5 2003/11/26 14:24:46 asmodai Exp $
30  */
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/disk.h>
36 #include <sys/module.h>
37 #include <sys/bus.h>
38 #include <sys/buf.h>
39 #include <sys/malloc.h>
40 #include <sys/devicestat.h>
41 #include <sys/sysctl.h>
42 #include <machine/stdarg.h>
43 #include <machine/resource.h>
44 #include <machine/bus.h>
45 #include <machine/clock.h>
46 #ifdef __alpha__
47 #include <machine/md_var.h>
48 #endif
49 #include <sys/rman.h>
50 #include <bus/pci/pcivar.h>
51 #include <bus/pci/pcireg.h>
52 #include "ata-all.h"
53
54 /* device structures */
55 struct ata_pci_controller {
56     struct resource *bmio;
57     int bmaddr;
58     struct resource *irq;
59     int irqcnt;
60 };
61
62 /* misc defines */
63 #define IOMASK                  0xfffffffc
64 #define GRANDPARENT(dev)        device_get_parent(device_get_parent(dev))
65 #define ATA_MASTERDEV(dev)      ((pci_get_progif(dev) & 0x80) && \
66                                  (pci_get_progif(dev) & 0x05) != 0x05)
67
68 int
69 ata_find_dev(device_t dev, u_int32_t devid, u_int32_t revid)
70 {
71     device_t *children;
72     int nchildren, i;
73
74     if (device_get_children(device_get_parent(dev), &children, &nchildren))
75         return 0;
76
77     for (i = 0; i < nchildren; i++) {
78         if (pci_get_devid(children[i]) == devid &&
79             pci_get_revid(children[i]) >= revid) {
80             free(children, M_TEMP);
81             return 1;
82         }
83     }
84     free(children, M_TEMP);
85     return 0;
86 }
87
88 static void
89 ata_via_southbridge_fixup(device_t dev)
90 {
91     device_t *children;
92     int nchildren, i;
93
94     if (device_get_children(device_get_parent(dev), &children, &nchildren))
95         return;
96
97     for (i = 0; i < nchildren; i++) {
98         if (pci_get_devid(children[i]) == 0x03051106 ||         /* VIA VT8363 */
99             pci_get_devid(children[i]) == 0x03911106 ||         /* VIA VT8371 */
100             pci_get_devid(children[i]) == 0x31021106 ||         /* VIA VT8662 */
101             pci_get_devid(children[i]) == 0x31121106) {         /* VIA VT8361 */
102             u_int8_t reg76 = pci_read_config(children[i], 0x76, 1);
103
104             if ((reg76 & 0xf0) != 0xd0) {
105                 device_printf(dev,
106                 "Correcting VIA config for southbridge data corruption bug\n");
107                 pci_write_config(children[i], 0x75, 0x80, 1);
108                 pci_write_config(children[i], 0x76, (reg76 & 0x0f) | 0xd0, 1);
109             }
110             break;
111         }
112     }
113     free(children, M_TEMP);
114 }
115
116 static const char *
117 ata_pci_match(device_t dev)
118 {
119     if (pci_get_class(dev) != PCIC_STORAGE)
120         return NULL;
121
122     switch (pci_get_devid(dev)) {
123     /* supported chipsets */
124     case 0x12308086:
125         return "Intel PIIX ATA controller";
126
127     case 0x70108086:
128         return "Intel PIIX3 ATA controller";
129
130     case 0x71118086:
131     case 0x71998086:
132     case 0x84ca8086:
133         return "Intel PIIX4 ATA33 controller";
134
135     case 0x24218086:
136         return "Intel ICH0 ATA33 controller";
137
138     case 0x24118086:
139     case 0x76018086:
140         return "Intel ICH ATA66 controller";
141
142     case 0x244a8086:
143     case 0x244b8086:
144         return "Intel ICH2 ATA100 controller";
145
146     case 0x248a8086:
147     case 0x248b8086:
148         return "Intel ICH3 ATA100 controller";
149
150     case 0x24ca8086:
151     case 0x24cb8086:
152         return "Intel ICH4 ATA100 controller";
153
154     case 0x24db8086:
155         return "Intel ICH5 ATA100 controller";
156
157     case 0x522910b9:
158         if (pci_get_revid(dev) >= 0xc4)
159             return "AcerLabs Aladdin ATA100 controller";
160         else if (pci_get_revid(dev) >= 0xc2)
161             return "AcerLabs Aladdin ATA66 controller";
162         else if (pci_get_revid(dev) >= 0x20)
163             return "AcerLabs Aladdin ATA33 controller";
164         else
165             return "AcerLabs Aladdin ATA controller";
166
167     case 0x05711106: 
168         if (ata_find_dev(dev, 0x05861106, 0x02))
169             return "VIA 82C586 ATA33 controller";
170         if (ata_find_dev(dev, 0x05861106, 0))
171             return "VIA 82C586 ATA controller";
172         if (ata_find_dev(dev, 0x05961106, 0x12))
173             return "VIA 82C596 ATA66 controller";
174         if (ata_find_dev(dev, 0x05961106, 0))
175             return "VIA 82C596 ATA33 controller";
176         if (ata_find_dev(dev, 0x06861106, 0x40))
177             return "VIA 82C686 ATA100 controller";
178         if (ata_find_dev(dev, 0x06861106, 0x10))
179             return "VIA 82C686 ATA66 controller";
180         if (ata_find_dev(dev, 0x06861106, 0))
181             return "VIA 82C686 ATA33 controller";
182         if (ata_find_dev(dev, 0x82311106, 0))
183             return "VIA 8231 ATA100 controller";
184         if (ata_find_dev(dev, 0x30741106, 0) ||
185             ata_find_dev(dev, 0x31091106, 0))
186             return "VIA 8233 ATA100 controller";
187         if (ata_find_dev(dev, 0x31471106, 0))
188             return "VIA 8233 ATA133 controller";
189         if (ata_find_dev(dev, 0x31771106, 0))
190             return "VIA 8235 ATA133 controller";
191         return "VIA Apollo ATA controller";
192
193     case 0x55131039:
194         if (ata_find_dev(dev, 0x06301039, 0x30) ||
195             ata_find_dev(dev, 0x06331039, 0) ||
196             ata_find_dev(dev, 0x06351039, 0) ||
197             ata_find_dev(dev, 0x06401039, 0) ||
198             ata_find_dev(dev, 0x06451039, 0) ||
199             ata_find_dev(dev, 0x06501039, 0) ||
200             ata_find_dev(dev, 0x07301039, 0) ||
201             ata_find_dev(dev, 0x07331039, 0) ||
202             ata_find_dev(dev, 0x07351039, 0) ||
203             ata_find_dev(dev, 0x07401039, 0) ||
204             ata_find_dev(dev, 0x07451039, 0) ||
205             ata_find_dev(dev, 0x07501039, 0))
206             return "SiS 5591 ATA100 controller";
207         else if (ata_find_dev(dev, 0x05301039, 0) ||
208             ata_find_dev(dev, 0x05401039, 0) ||
209             ata_find_dev(dev, 0x06201039, 0) ||
210             ata_find_dev(dev, 0x06301039, 0))
211             return "SiS 5591 ATA66 controller";
212         else
213             return "SiS 5591 ATA33 controller";
214
215     case 0x06801095:
216         return "SiI 0680 ATA133 controller";
217
218     case 0x06491095:
219         return "CMD 649 ATA100 controller";
220
221     case 0x06481095:
222         return "CMD 648 ATA66 controller";
223
224     case 0x06461095:
225         return "CMD 646 ATA controller";
226
227     case 0xc6931080:
228         if (pci_get_subclass(dev) == PCIS_STORAGE_IDE)
229             return "Cypress 82C693 ATA controller";
230         return NULL;
231
232     case 0x01021078:
233         return "Cyrix 5530 ATA33 controller";
234
235     case 0x74091022:
236         return "AMD 756 ATA66 controller";
237
238     case 0x74111022:
239         return "AMD 766 ATA100 controller";
240
241     case 0x74411022:
242         return "AMD 768 ATA100 controller";
243
244     case 0x01bc10de:
245         return "NVIDIA nForce ATA100 controller";
246
247     case 0x006510de:
248         return "NVIDIA nForce ATA133 controller";
249
250     case 0x02111166:
251         return "ServerWorks ROSB4 ATA33 controller";
252
253     case 0x02121166:
254         if (pci_get_revid(dev) >= 0x92)
255             return "ServerWorks CSB5 ATA100 controller";
256         else
257             return "ServerWorks CSB5 ATA66 controller";
258
259     case 0x4d33105a:
260         return "Promise ATA33 controller";
261
262     case 0x0d38105a:
263     case 0x4d38105a:
264         return "Promise ATA66 controller";
265
266     case 0x0d30105a:
267     case 0x4d30105a:
268         return "Promise ATA100 controller";
269
270     case 0x4d68105a:
271     case 0x6268105a: 
272         if (pci_get_devid(GRANDPARENT(dev)) == 0x00221011 &&
273             pci_get_class(GRANDPARENT(dev)) == PCIC_BRIDGE) {
274             static long start = 0, end = 0;
275
276             /* we belive we are on a TX4, now do our (simple) magic */
277             if (pci_get_slot(dev) == 1) {
278                 bus_get_resource(dev, SYS_RES_IRQ, 0, &start, &end);
279                 return "Promise TX4 ATA100 controller (channel 0+1)";
280             }
281             else if (pci_get_slot(dev) == 2 && start && end) {
282                 bus_set_resource(dev, SYS_RES_IRQ, 0, start, end);
283                 start = end = 0;
284                 return "Promise TX4 ATA100 controller (channel 2+3)";
285             }
286             else
287                 start = end = 0;
288         }
289         return "Promise TX2 ATA100 controller";
290
291     case 0x4d69105a:
292     case 0x5275105a:
293     case 0x6269105a: 
294     case 0x7275105a: 
295         return "Promise TX2 ATA133 controller";
296
297     case 0x00041103:
298         switch (pci_get_revid(dev)) {
299         case 0x00:
300         case 0x01:
301             return "HighPoint HPT366 ATA66 controller";
302         case 0x02:
303             return "HighPoint HPT368 ATA66 controller";
304         case 0x03:
305         case 0x04:
306             return "HighPoint HPT370 ATA100 controller";
307         case 0x05:
308             return "HighPoint HPT372 ATA133 controller";
309         }
310         return NULL;
311
312     case 0x00051103:
313         switch (pci_get_revid(dev)) {
314         case 0x01:
315         case 0x02:
316             return "HighPoint HPT372 ATA133 controller";
317         }
318         return NULL;
319
320     case 0x00081103:
321         switch (pci_get_revid(dev)) {
322         case 0x07:
323             return "HighPoint HPT374 ATA133 controller";
324         }
325         return NULL;
326
327     case 0x000116ca:
328         return "Cenatek Rocket Drive controller";
329
330    /* unsupported but known chipsets, generic DMA only */
331     case 0x10001042:
332     case 0x10011042:
333         return "RZ 100? ATA controller !WARNING! buggy chip data loss possible";
334
335     case 0x06401095:
336         return "CMD 640 ATA controller !WARNING! buggy chip data loss possible";
337
338     /* unknown chipsets, try generic DMA if it seems possible */
339     default:
340         if (pci_get_class(dev) == PCIC_STORAGE &&
341             (pci_get_subclass(dev) == PCIS_STORAGE_IDE))
342             return "Generic PCI ATA controller";
343     }
344     return NULL;
345 }
346
347 static int
348 ata_pci_probe(device_t dev)
349 {
350     const char *desc = ata_pci_match(dev);
351     
352     if (desc) {
353         device_set_desc(dev, desc);
354         return 0;
355     } 
356     else
357         return ENXIO;
358 }
359
360 static int
361 ata_pci_add_child(device_t dev, int unit)
362 {
363     device_t child;
364
365     /* check if this is located at one of the std addresses */
366     if (ATA_MASTERDEV(dev)) {
367         if (!(child = device_add_child(dev, "ata", unit)))
368             return ENOMEM;
369     }
370     else {
371         if (!(child = device_add_child(dev, "ata", 2)))
372             return ENOMEM;
373     }
374     return 0;
375 }
376
377 static int
378 ata_pci_attach(device_t dev)
379 {
380     struct ata_pci_controller *controller = device_get_softc(dev);
381     u_int8_t class, subclass;
382     u_int32_t type, cmd;
383     int rid;
384
385     /* set up vendor-specific stuff */
386     type = pci_get_devid(dev);
387     class = pci_get_class(dev);
388     subclass = pci_get_subclass(dev);
389     cmd = pci_read_config(dev, PCIR_COMMAND, 4);
390
391     if (!(cmd & PCIM_CMD_PORTEN)) {
392         device_printf(dev, "ATA channel disabled by BIOS\n");
393         return 0;
394     }
395
396     /* is busmastering supported ? */
397     if ((cmd & (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN)) == 
398         (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN)) {
399
400         /* is there a valid port range to connect to ? */
401         rid = 0x20;
402         controller->bmio = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
403                                               0, ~0, 1, RF_ACTIVE);
404         if (!controller->bmio)
405             device_printf(dev, "Busmastering DMA not configured\n");
406     }
407     else
408         device_printf(dev, "Busmastering DMA not supported\n");
409
410     /* do extra chipset specific setups */
411     switch (type) {
412     case 0x522910b9: /* Aladdin need to activate the ATAPI FIFO */
413         pci_write_config(dev, 0x53, 
414                          (pci_read_config(dev, 0x53, 1) & ~0x01) | 0x02, 1);
415         break;
416
417     case 0x4d38105a: /* Promise 66 & 100 (before TX2) need the clock changed */
418     case 0x4d30105a:
419     case 0x0d30105a:
420         ATA_OUTB(controller->bmio, 0x11, ATA_INB(controller->bmio, 0x11)|0x0a);
421         /* FALLTHROUGH */
422
423     case 0x4d33105a: /* Promise (before TX2) need burst mode turned on */
424         ATA_OUTB(controller->bmio, 0x1f, ATA_INB(controller->bmio, 0x1f)|0x01);
425         break;
426
427     case 0x00041103:    /* HighPoint HPT366/368/370/372 */
428         if (pci_get_revid(dev) < 2) {   /* HPT 366 */
429             /* turn off interrupt prediction */
430             pci_write_config(dev, 0x51, 
431                              (pci_read_config(dev, 0x51, 1) & ~0x80), 1);
432             break;
433         }
434         if (pci_get_revid(dev) < 5) {   /* HPT368/370 */
435             /* turn off interrupt prediction */
436             pci_write_config(dev, 0x51,
437                              (pci_read_config(dev, 0x51, 1) & ~0x03), 1);
438             pci_write_config(dev, 0x55,
439                              (pci_read_config(dev, 0x55, 1) & ~0x03), 1);
440
441             /* turn on interrupts */
442             pci_write_config(dev, 0x5a,
443                              (pci_read_config(dev, 0x5a, 1) & ~0x10), 1);
444
445             /* set clocks etc */
446             pci_write_config(dev, 0x5b, 0x22, 1);
447             break;
448         }
449         /* FALLTHROUGH */
450
451     case 0x00051103:    /* HighPoint HPT372 */
452     case 0x00081103:    /* HighPoint HPT374 */
453         /* turn off interrupt prediction */
454         pci_write_config(dev, 0x51, (pci_read_config(dev, 0x51, 1) & ~0x03), 1);
455         pci_write_config(dev, 0x55, (pci_read_config(dev, 0x55, 1) & ~0x03), 1);
456
457         /* turn on interrupts */
458         pci_write_config(dev, 0x5a, (pci_read_config(dev, 0x5a, 1) & ~0x10), 1);
459
460         /* set clocks etc */
461         pci_write_config(dev, 0x5b,
462                          (pci_read_config(dev, 0x5b, 1) & 0x01) | 0x20, 1);
463         break;
464
465     case 0x05711106: /* VIA 82C586, '596, '686 default setup */
466         /* prepare for ATA-66 on the 82C686a and 82C596b */
467         if ((ata_find_dev(dev, 0x06861106, 0x10) && 
468              !ata_find_dev(dev, 0x06861106, 0x40)) || 
469             ata_find_dev(dev, 0x05961106, 0x12))
470             pci_write_config(dev, 0x50, 0x030b030b, 4);   
471
472         /* the southbridge might need the data corruption fix */
473         if (ata_find_dev(dev, 0x06861106, 0x40) ||
474             ata_find_dev(dev, 0x82311106, 0x10))
475             ata_via_southbridge_fixup(dev);
476         /* FALLTHROUGH */
477
478     case 0x74091022: /* AMD 756 default setup */
479     case 0x74111022: /* AMD 766 default setup */
480     case 0x74411022: /* AMD 768 default setup */
481     case 0x01bc10de: /* NVIDIA nForce default setup */
482     case 0x006510de: /* NVIDIA nForce2 default setup */
483         /* set prefetch, postwrite */
484         pci_write_config(dev, 0x41, pci_read_config(dev, 0x41, 1) | 0xf0, 1);
485
486         /* set fifo configuration half'n'half */
487         pci_write_config(dev, 0x43, 
488                          (pci_read_config(dev, 0x43, 1) & 0x90) | 0x2a, 1);
489
490         /* set status register read retry */
491         pci_write_config(dev, 0x44, pci_read_config(dev, 0x44, 1) | 0x08, 1);
492
493         /* set DMA read & end-of-sector fifo flush */
494         pci_write_config(dev, 0x46, 
495                          (pci_read_config(dev, 0x46, 1) & 0x0c) | 0xf0, 1);
496
497         /* set sector size */
498         pci_write_config(dev, 0x60, DEV_BSIZE, 2);
499         pci_write_config(dev, 0x68, DEV_BSIZE, 2);
500         break;
501
502     case 0x02111166: /* ServerWorks ROSB4 enable UDMA33 */
503         pci_write_config(dev, 0x64,   
504                          (pci_read_config(dev, 0x64, 4) & ~0x00002000) |
505                          0x00004000, 4);
506         break;
507         
508     case 0x02121166: /* ServerWorks CSB5 enable UDMA66/100 depending on rev */
509         pci_write_config(dev, 0x5a,   
510                          (pci_read_config(dev, 0x5a, 1) & ~0x40) |
511                          (pci_get_revid(dev) >= 0x92) ? 0x03 : 0x02, 1);
512         break;
513
514     case 0x06801095: /* SiI 0680 set ATA reference clock speed */
515         if ((pci_read_config(dev, 0x8a, 1) & 0x30) != 0x10)
516             pci_write_config(dev, 0x8a, 
517                              (pci_read_config(dev, 0x8a, 1) & 0x0F) | 0x10, 1);
518         if ((pci_read_config(dev, 0x8a, 1) & 0x30) != 0x10)
519             device_printf(dev, "SiI 0680 could not set clock\n");
520         break;
521
522     case 0x06491095:
523     case 0x06481095:
524     case 0x06461095: /* CMD 646 enable interrupts, set DMA read mode */
525         pci_write_config(dev, 0x71, 0x01, 1);
526         break;
527
528     case 0x10001042:   /* RZ 100? known bad, no DMA */
529     case 0x10011042:
530     case 0x06401095:   /* CMD 640 known bad, no DMA */
531         controller->bmio = NULL;
532         device_printf(dev, "Busmastering DMA disabled\n");
533     }
534
535     if (controller->bmio) {
536         controller->bmaddr = rman_get_start(controller->bmio);
537         BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
538                              SYS_RES_IOPORT, rid, controller->bmio);
539         controller->bmio = NULL;
540     }
541
542     /*
543      * the Cypress chip is a mess, it contains two ATA functions, but 
544      * both channels are visible on the first one.
545      * simply ignore the second function for now, as the right
546      * solution (ignoring the second channel on the first function)
547      * doesn't work with the crappy ATA interrupt setup on the alpha.
548      */
549     if (pci_get_devid(dev) == 0xc6931080 && pci_get_function(dev) > 1)
550         return 0;
551
552     ata_pci_add_child(dev, 0);
553
554     if (ATA_MASTERDEV(dev) || pci_read_config(dev, 0x18, 4) & IOMASK)
555         ata_pci_add_child(dev, 1);
556
557     return bus_generic_attach(dev);
558 }
559
560 static int
561 ata_pci_intr(struct ata_channel *ch)
562 {
563     u_int8_t dmastat;
564
565     /* 
566      * since we might share the IRQ with another device, and in some
567      * cases with our twin channel, we only want to process interrupts
568      * that we know this channel generated.
569      */
570     switch (ch->chiptype) {
571     case 0x00041103:    /* HighPoint HPT366/368/370/372 */
572     case 0x00051103:    /* HighPoint HPT372 */
573     case 0x00081103:    /* HighPoint HPT374 */
574         if (((dmastat = ata_dmastatus(ch)) &
575             (ATA_BMSTAT_ACTIVE | ATA_BMSTAT_INTERRUPT)) != ATA_BMSTAT_INTERRUPT)
576             return 1;
577         ATA_OUTB(ch->r_bmio, ATA_BMSTAT_PORT, dmastat | ATA_BMSTAT_INTERRUPT);
578         DELAY(1);
579         return 0;
580
581     case 0x06481095:    /* CMD 648 */
582     case 0x06491095:    /* CMD 649 */
583         if (!(pci_read_config(device_get_parent(ch->dev), 0x71, 1) &
584               (ch->unit ? 0x08 : 0x04)))
585             return 1;
586         break;
587
588     case 0x4d33105a:    /* Promise Ultra/Fasttrak 33 */
589     case 0x0d38105a:    /* Promise Fasttrak 66 */
590     case 0x4d38105a:    /* Promise Ultra/Fasttrak 66 */
591     case 0x0d30105a:    /* Promise OEM ATA100 */
592     case 0x4d30105a:    /* Promise Ultra/Fasttrak 100 */
593         if (!(ATA_INL(ch->r_bmio, (ch->unit ? 0x14 : 0x1c)) &
594               (ch->unit ? 0x00004000 : 0x00000400)))
595             return 1;
596         break;
597
598     case 0x4d68105a:    /* Promise TX2 ATA100 */
599     case 0x6268105a:    /* Promise TX2 ATA100 */
600     case 0x4d69105a:    /* Promise TX2 ATA133 */
601     case 0x5275105a:    /* Promise TX2 ATA133 */
602     case 0x6269105a:    /* Promise TX2 ATA133 */
603     case 0x7275105a:    /* Promise TX2 ATA133 */
604         ATA_OUTB(ch->r_bmio, ATA_BMDEVSPEC_0, 0x0b);
605         if (!(ATA_INB(ch->r_bmio, ATA_BMDEVSPEC_1) & 0x20))
606             return 1;
607         break;
608     }
609
610     if (ch->flags & ATA_DMA_ACTIVE) {
611         if (!((dmastat = ata_dmastatus(ch)) & ATA_BMSTAT_INTERRUPT))
612             return 1;
613         ATA_OUTB(ch->r_bmio, ATA_BMSTAT_PORT, dmastat | ATA_BMSTAT_INTERRUPT);
614         DELAY(1);
615     }
616     return 0;
617 }
618
619 static int
620 ata_pci_print_child(device_t dev, device_t child)
621 {
622     struct ata_channel *ch = device_get_softc(child);
623     int retval = 0;
624
625     retval += bus_print_child_header(dev, child);
626     retval += printf(": at 0x%lx", rman_get_start(ch->r_io));
627
628     if (ATA_MASTERDEV(dev))
629         retval += printf(" irq %d", 14 + ch->unit);
630     
631     retval += bus_print_child_footer(dev, child);
632
633     return retval;
634 }
635
636 static struct resource *
637 ata_pci_alloc_resource(device_t dev, device_t child, int type, int *rid,
638                        u_long start, u_long end, u_long count, u_int flags)
639 {
640     struct ata_pci_controller *controller = device_get_softc(dev);
641     struct resource *res = NULL;
642     int unit = ((struct ata_channel *)device_get_softc(child))->unit;
643     int myrid;
644
645     if (type == SYS_RES_IOPORT) {
646         switch (*rid) {
647         case ATA_IOADDR_RID:
648             if (ATA_MASTERDEV(dev)) {
649                 myrid = 0;
650                 start = (unit ? ATA_SECONDARY : ATA_PRIMARY);
651                 end = start + ATA_IOSIZE - 1;
652                 count = ATA_IOSIZE;
653                 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
654                                          SYS_RES_IOPORT, &myrid,
655                                          start, end, count, flags);
656             }
657             else {
658                 myrid = 0x10 + 8 * unit;
659                 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev,
660                                          SYS_RES_IOPORT, &myrid,
661                                          start, end, count, flags);
662             }
663             break;
664
665         case ATA_ALTADDR_RID:
666             if (ATA_MASTERDEV(dev)) {
667                 myrid = 0;
668                 start = (unit ? ATA_SECONDARY : ATA_PRIMARY) + ATA_ALTOFFSET;
669                 end = start + ATA_ALTIOSIZE - 1;
670                 count = ATA_ALTIOSIZE;
671                 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
672                                          SYS_RES_IOPORT, &myrid,
673                                          start, end, count, flags);
674             }
675             else {
676                 myrid = 0x14 + 8 * unit;
677                 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev,
678                                          SYS_RES_IOPORT, &myrid,
679                                          start, end, count, flags);
680                 if (res) {
681                         start = rman_get_start(res) + 2;
682                         end = rman_get_start(res) + ATA_ALTIOSIZE - 1;
683                         count = ATA_ALTIOSIZE;
684                         BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
685                                              SYS_RES_IOPORT, myrid, res);
686                         res = BUS_ALLOC_RESOURCE(device_get_parent(dev), dev,
687                                                  SYS_RES_IOPORT, &myrid,
688                                                  start, end, count, flags);
689                 }
690             }
691             break;
692
693         case ATA_BMADDR_RID:
694             if (controller->bmaddr) {
695                 myrid = 0x20;
696                 start = (unit == 0 ? 
697                          controller->bmaddr : controller->bmaddr+ATA_BMIOSIZE);
698                 end = start + ATA_BMIOSIZE - 1;
699                 count = ATA_BMIOSIZE;
700                 res = BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
701                                          SYS_RES_IOPORT, &myrid,
702                                          start, end, count, flags);
703             }
704         }
705         return res;
706     }
707
708     if (type == SYS_RES_IRQ && *rid == ATA_IRQ_RID) {
709         if (ATA_MASTERDEV(dev)) {
710 #ifdef __alpha__
711             return alpha_platform_alloc_ide_intr(unit);
712 #else
713             int irq = (unit == 0 ? 14 : 15);
714
715             return BUS_ALLOC_RESOURCE(device_get_parent(dev), child,
716                                       SYS_RES_IRQ, rid, irq, irq, 1, flags);
717 #endif
718         }
719         else {
720             /* primary and secondary channels share interrupt, keep track */
721             if (!controller->irq)
722                 controller->irq = BUS_ALLOC_RESOURCE(device_get_parent(dev), 
723                                                      dev, SYS_RES_IRQ,
724                                                      rid, 0, ~0, 1, flags);
725             controller->irqcnt++;
726             return controller->irq;
727         }
728     }
729     return 0;
730 }
731
732 static int
733 ata_pci_release_resource(device_t dev, device_t child, int type, int rid,
734                          struct resource *r)
735 {
736     struct ata_pci_controller *controller = device_get_softc(dev);
737     int unit = ((struct ata_channel *)device_get_softc(child))->unit;
738
739     if (type == SYS_RES_IOPORT) {
740         switch (rid) {
741         case ATA_IOADDR_RID:
742             if (ATA_MASTERDEV(dev))
743                 return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
744                                             SYS_RES_IOPORT, 0x0, r);
745             else
746                 return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
747                                             SYS_RES_IOPORT, 0x10 + 8 * unit, r);
748             break;
749
750         case ATA_ALTADDR_RID:
751             if (ATA_MASTERDEV(dev))
752                 return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
753                                             SYS_RES_IOPORT, 0x0, r);
754             else
755                 return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
756                                             SYS_RES_IOPORT, 0x14 + 8 * unit, r);
757             break;
758
759         case ATA_BMADDR_RID:
760             return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
761                                         SYS_RES_IOPORT, 0x20, r);
762         default:
763             return ENOENT;
764         }
765     }
766     if (type == SYS_RES_IRQ) {
767         if (rid != ATA_IRQ_RID)
768             return ENOENT;
769
770         if (ATA_MASTERDEV(dev)) {
771 #ifdef __alpha__
772             return alpha_platform_release_ide_intr(unit, r);
773 #else
774             return BUS_RELEASE_RESOURCE(device_get_parent(dev), child,
775                                         SYS_RES_IRQ, rid, r);
776 #endif
777         }
778         else {
779             /* primary and secondary channels share interrupt, keep track */
780             if (--controller->irqcnt)
781                 return 0;
782             controller->irq = NULL;
783             return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev,
784                                         SYS_RES_IRQ, rid, r);
785         }
786     }
787     return EINVAL;
788 }
789
790 static int
791 ata_pci_setup_intr(device_t dev, device_t child, struct resource *irq, 
792                    int flags, driver_intr_t *intr, void *arg,
793                    void **cookiep)
794 {
795     if (ATA_MASTERDEV(dev)) {
796 #ifdef __alpha__
797         return alpha_platform_setup_ide_intr(irq, intr, arg, cookiep);
798 #else
799         return BUS_SETUP_INTR(device_get_parent(dev), child, irq,
800                               flags, intr, arg, cookiep);
801 #endif
802     }
803     else
804         return BUS_SETUP_INTR(device_get_parent(dev), dev, irq,
805                               flags, intr, arg, cookiep);
806 }
807
808 static int
809 ata_pci_teardown_intr(device_t dev, device_t child, struct resource *irq,
810                       void *cookie)
811 {
812     if (ATA_MASTERDEV(dev)) {
813 #ifdef __alpha__
814         return alpha_platform_teardown_ide_intr(irq, cookie);
815 #else
816         return BUS_TEARDOWN_INTR(device_get_parent(dev), child, irq, cookie);
817 #endif
818     }
819     else
820         return BUS_TEARDOWN_INTR(device_get_parent(dev), dev, irq, cookie);
821 }
822
823 static device_method_t ata_pci_methods[] = {
824     /* device interface */
825     DEVMETHOD(device_probe,             ata_pci_probe),
826     DEVMETHOD(device_attach,            ata_pci_attach),
827     DEVMETHOD(device_shutdown,          bus_generic_shutdown),
828     DEVMETHOD(device_suspend,           bus_generic_suspend),
829     DEVMETHOD(device_resume,            bus_generic_resume),
830
831     /* bus methods */
832     DEVMETHOD(bus_print_child,          ata_pci_print_child),
833     DEVMETHOD(bus_alloc_resource,       ata_pci_alloc_resource),
834     DEVMETHOD(bus_release_resource,     ata_pci_release_resource),
835     DEVMETHOD(bus_activate_resource,    bus_generic_activate_resource),
836     DEVMETHOD(bus_deactivate_resource,  bus_generic_deactivate_resource),
837     DEVMETHOD(bus_setup_intr,           ata_pci_setup_intr),
838     DEVMETHOD(bus_teardown_intr,        ata_pci_teardown_intr),
839     { 0, 0 }
840 };
841
842 static driver_t ata_pci_driver = {
843     "atapci",
844     ata_pci_methods,
845     sizeof(struct ata_pci_controller),
846 };
847
848 static devclass_t ata_pci_devclass;
849
850 DRIVER_MODULE(atapci, pci, ata_pci_driver, ata_pci_devclass, 0, 0);
851
852 static int
853 ata_pcisub_probe(device_t dev)
854 {
855     struct ata_channel *ch = device_get_softc(dev);
856     device_t *children;
857     int count, i;
858
859     /* find channel number on this controller */
860     device_get_children(device_get_parent(dev), &children, &count);
861     for (i = 0; i < count; i++) {
862         if (children[i] == dev)
863             ch->unit = i;
864     }
865     free(children, M_TEMP);
866     ch->chiptype = pci_get_devid(device_get_parent(dev));
867     ch->intr_func = ata_pci_intr;
868     return ata_probe(dev);
869 }
870
871 static device_method_t ata_pcisub_methods[] = {
872     /* device interface */
873     DEVMETHOD(device_probe,     ata_pcisub_probe),
874     DEVMETHOD(device_attach,    ata_attach),
875     DEVMETHOD(device_detach,    ata_detach),
876     DEVMETHOD(device_resume,    ata_resume),
877     { 0, 0 }
878 };
879
880 static driver_t ata_pcisub_driver = {
881     "ata",
882     ata_pcisub_methods,
883     sizeof(struct ata_channel),
884 };
885
886 DRIVER_MODULE(ata, atapci, ata_pcisub_driver, ata_devclass, 0, 0);