34dfe1e9706f18b99a591c469ba667dabc319a87
[linux-2.6.git] / arch / powerpc / platforms / powermac / pci.c
1 /*
2  * Support for PCI bridges found on Power Macintoshes.
3  *
4  * Copyright (C) 2003 Benjamin Herrenschmuidt (benh@kernel.crashing.org)
5  * Copyright (C) 1997 Paul Mackerras (paulus@samba.org)
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version
10  * 2 of the License, or (at your option) any later version.
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/pci.h>
15 #include <linux/delay.h>
16 #include <linux/string.h>
17 #include <linux/init.h>
18 #include <linux/bootmem.h>
19
20 #include <asm/sections.h>
21 #include <asm/io.h>
22 #include <asm/prom.h>
23 #include <asm/pci-bridge.h>
24 #include <asm/machdep.h>
25 #include <asm/pmac_feature.h>
26 #ifdef CONFIG_PPC64
27 #include <asm/iommu.h>
28 #include <asm/ppc-pci.h>
29 #endif
30
31 #undef DEBUG
32
33 #ifdef DEBUG
34 #define DBG(x...) printk(x)
35 #else
36 #define DBG(x...)
37 #endif
38
39 static int add_bridge(struct device_node *dev);
40 extern void pmac_check_ht_link(void);
41
42 /* XXX Could be per-controller, but I don't think we risk anything by
43  * assuming we won't have both UniNorth and Bandit */
44 static int has_uninorth;
45 #ifdef CONFIG_POWER4
46 static struct pci_controller *u3_agp;
47 #endif /* CONFIG_POWER4 */
48
49 extern u8 pci_cache_line_size;
50 extern int pcibios_assign_bus_offset;
51
52 struct device_node *k2_skiplist[2];
53
54 /*
55  * Magic constants for enabling cache coherency in the bandit/PSX bridge.
56  */
57 #define BANDIT_DEVID_2  8
58 #define BANDIT_REVID    3
59
60 #define BANDIT_DEVNUM   11
61 #define BANDIT_MAGIC    0x50
62 #define BANDIT_COHERENT 0x40
63
64 static int __init fixup_one_level_bus_range(struct device_node *node, int higher)
65 {
66         for (; node != 0;node = node->sibling) {
67                 int * bus_range;
68                 unsigned int *class_code;
69                 int len;
70
71                 /* For PCI<->PCI bridges or CardBus bridges, we go down */
72                 class_code = (unsigned int *) get_property(node, "class-code", NULL);
73                 if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
74                         (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
75                         continue;
76                 bus_range = (int *) get_property(node, "bus-range", &len);
77                 if (bus_range != NULL && len > 2 * sizeof(int)) {
78                         if (bus_range[1] > higher)
79                                 higher = bus_range[1];
80                 }
81                 higher = fixup_one_level_bus_range(node->child, higher);
82         }
83         return higher;
84 }
85
86 /* This routine fixes the "bus-range" property of all bridges in the
87  * system since they tend to have their "last" member wrong on macs
88  *
89  * Note that the bus numbers manipulated here are OF bus numbers, they
90  * are not Linux bus numbers.
91  */
92 static void __init fixup_bus_range(struct device_node *bridge)
93 {
94         int * bus_range;
95         int len;
96
97         /* Lookup the "bus-range" property for the hose */
98         bus_range = (int *) get_property(bridge, "bus-range", &len);
99         if (bus_range == NULL || len < 2 * sizeof(int)) {
100                 printk(KERN_WARNING "Can't get bus-range for %s\n",
101                                bridge->full_name);
102                 return;
103         }
104         bus_range[1] = fixup_one_level_bus_range(bridge->child, bus_range[1]);
105 }
106
107 /*
108  * Apple MacRISC (U3, UniNorth, Bandit, Chaos) PCI controllers.
109  *
110  * The "Bandit" version is present in all early PCI PowerMacs,
111  * and up to the first ones using Grackle. Some machines may
112  * have 2 bandit controllers (2 PCI busses).
113  *
114  * "Chaos" is used in some "Bandit"-type machines as a bridge
115  * for the separate display bus. It is accessed the same
116  * way as bandit, but cannot be probed for devices. It therefore
117  * has its own config access functions.
118  *
119  * The "UniNorth" version is present in all Core99 machines
120  * (iBook, G4, new IMacs, and all the recent Apple machines).
121  * It contains 3 controllers in one ASIC.
122  *
123  * The U3 is the bridge used on G5 machines. It contains an
124  * AGP bus which is dealt with the old UniNorth access routines
125  * and a HyperTransport bus which uses its own set of access
126  * functions.
127  */
128
129 #define MACRISC_CFA0(devfn, off)        \
130         ((1 << (unsigned long)PCI_SLOT(dev_fn)) \
131         | (((unsigned long)PCI_FUNC(dev_fn)) << 8) \
132         | (((unsigned long)(off)) & 0xFCUL))
133
134 #define MACRISC_CFA1(bus, devfn, off)   \
135         ((((unsigned long)(bus)) << 16) \
136         |(((unsigned long)(devfn)) << 8) \
137         |(((unsigned long)(off)) & 0xFCUL) \
138         |1UL)
139
140 static unsigned long macrisc_cfg_access(struct pci_controller* hose,
141                                                u8 bus, u8 dev_fn, u8 offset)
142 {
143         unsigned int caddr;
144
145         if (bus == hose->first_busno) {
146                 if (dev_fn < (11 << 3))
147                         return 0;
148                 caddr = MACRISC_CFA0(dev_fn, offset);
149         } else
150                 caddr = MACRISC_CFA1(bus, dev_fn, offset);
151
152         /* Uninorth will return garbage if we don't read back the value ! */
153         do {
154                 out_le32(hose->cfg_addr, caddr);
155         } while (in_le32(hose->cfg_addr) != caddr);
156
157         offset &= has_uninorth ? 0x07 : 0x03;
158         return ((unsigned long)hose->cfg_data) + offset;
159 }
160
161 static int macrisc_read_config(struct pci_bus *bus, unsigned int devfn,
162                                       int offset, int len, u32 *val)
163 {
164         struct pci_controller *hose;
165         unsigned long addr;
166
167         hose = pci_bus_to_host(bus);
168         if (hose == NULL)
169                 return PCIBIOS_DEVICE_NOT_FOUND;
170
171         addr = macrisc_cfg_access(hose, bus->number, devfn, offset);
172         if (!addr)
173                 return PCIBIOS_DEVICE_NOT_FOUND;
174         /*
175          * Note: the caller has already checked that offset is
176          * suitably aligned and that len is 1, 2 or 4.
177          */
178         switch (len) {
179         case 1:
180                 *val = in_8((u8 *)addr);
181                 break;
182         case 2:
183                 *val = in_le16((u16 *)addr);
184                 break;
185         default:
186                 *val = in_le32((u32 *)addr);
187                 break;
188         }
189         return PCIBIOS_SUCCESSFUL;
190 }
191
192 static int macrisc_write_config(struct pci_bus *bus, unsigned int devfn,
193                                        int offset, int len, u32 val)
194 {
195         struct pci_controller *hose;
196         unsigned long addr;
197
198         hose = pci_bus_to_host(bus);
199         if (hose == NULL)
200                 return PCIBIOS_DEVICE_NOT_FOUND;
201
202         addr = macrisc_cfg_access(hose, bus->number, devfn, offset);
203         if (!addr)
204                 return PCIBIOS_DEVICE_NOT_FOUND;
205         /*
206          * Note: the caller has already checked that offset is
207          * suitably aligned and that len is 1, 2 or 4.
208          */
209         switch (len) {
210         case 1:
211                 out_8((u8 *)addr, val);
212                 (void) in_8((u8 *)addr);
213                 break;
214         case 2:
215                 out_le16((u16 *)addr, val);
216                 (void) in_le16((u16 *)addr);
217                 break;
218         default:
219                 out_le32((u32 *)addr, val);
220                 (void) in_le32((u32 *)addr);
221                 break;
222         }
223         return PCIBIOS_SUCCESSFUL;
224 }
225
226 static struct pci_ops macrisc_pci_ops =
227 {
228         macrisc_read_config,
229         macrisc_write_config
230 };
231
232 /*
233  * Verify that a specific (bus, dev_fn) exists on chaos
234  */
235 static int
236 chaos_validate_dev(struct pci_bus *bus, int devfn, int offset)
237 {
238         struct device_node *np;
239         u32 *vendor, *device;
240
241         np = pci_busdev_to_OF_node(bus, devfn);
242         if (np == NULL)
243                 return PCIBIOS_DEVICE_NOT_FOUND;
244
245         vendor = (u32 *)get_property(np, "vendor-id", NULL);
246         device = (u32 *)get_property(np, "device-id", NULL);
247         if (vendor == NULL || device == NULL)
248                 return PCIBIOS_DEVICE_NOT_FOUND;
249
250         if ((*vendor == 0x106b) && (*device == 3) && (offset >= 0x10)
251             && (offset != 0x14) && (offset != 0x18) && (offset <= 0x24))
252                 return PCIBIOS_BAD_REGISTER_NUMBER;
253
254         return PCIBIOS_SUCCESSFUL;
255 }
256
257 static int
258 chaos_read_config(struct pci_bus *bus, unsigned int devfn, int offset,
259                   int len, u32 *val)
260 {
261         int result = chaos_validate_dev(bus, devfn, offset);
262         if (result == PCIBIOS_BAD_REGISTER_NUMBER)
263                 *val = ~0U;
264         if (result != PCIBIOS_SUCCESSFUL)
265                 return result;
266         return macrisc_read_config(bus, devfn, offset, len, val);
267 }
268
269 static int
270 chaos_write_config(struct pci_bus *bus, unsigned int devfn, int offset,
271                    int len, u32 val)
272 {
273         int result = chaos_validate_dev(bus, devfn, offset);
274         if (result != PCIBIOS_SUCCESSFUL)
275                 return result;
276         return macrisc_write_config(bus, devfn, offset, len, val);
277 }
278
279 static struct pci_ops chaos_pci_ops =
280 {
281         chaos_read_config,
282         chaos_write_config
283 };
284
285 #ifdef CONFIG_POWER4
286 /*
287  * These versions of U3 HyperTransport config space access ops do not
288  * implement self-view of the HT host yet
289  */
290
291 /*
292  * This function deals with some "special cases" devices.
293  *
294  *  0 -> No special case
295  *  1 -> Skip the device but act as if the access was successfull
296  *       (return 0xff's on reads, eventually, cache config space
297  *       accesses in a later version)
298  * -1 -> Hide the device (unsuccessful acess)
299  */
300 static int u3_ht_skip_device(struct pci_controller *hose,
301                              struct pci_bus *bus, unsigned int devfn)
302 {
303         struct device_node *busdn, *dn;
304         int i;
305
306         /* We only allow config cycles to devices that are in OF device-tree
307          * as we are apparently having some weird things going on with some
308          * revs of K2 on recent G5s
309          */
310         if (bus->self)
311                 busdn = pci_device_to_OF_node(bus->self);
312         else
313                 busdn = hose->arch_data;
314         for (dn = busdn->child; dn; dn = dn->sibling)
315                 if (dn->data && PCI_DN(dn)->devfn == devfn)
316                         break;
317         if (dn == NULL)
318                 return -1;
319
320         /*
321          * When a device in K2 is powered down, we die on config
322          * cycle accesses. Fix that here.
323          */
324         for (i=0; i<2; i++)
325                 if (k2_skiplist[i] == dn)
326                         return 1;
327
328         return 0;
329 }
330
331 #define U3_HT_CFA0(devfn, off)          \
332                 ((((unsigned long)devfn) << 8) | offset)
333 #define U3_HT_CFA1(bus, devfn, off)     \
334                 (U3_HT_CFA0(devfn, off) \
335                 + (((unsigned long)bus) << 16) \
336                 + 0x01000000UL)
337
338 static unsigned long u3_ht_cfg_access(struct pci_controller* hose,
339                                              u8 bus, u8 devfn, u8 offset)
340 {
341         if (bus == hose->first_busno) {
342                 /* For now, we don't self probe U3 HT bridge */
343                 if (PCI_SLOT(devfn) == 0)
344                         return 0;
345                 return ((unsigned long)hose->cfg_data) + U3_HT_CFA0(devfn, offset);
346         } else
347                 return ((unsigned long)hose->cfg_data) + U3_HT_CFA1(bus, devfn, offset);
348 }
349
350 static int u3_ht_read_config(struct pci_bus *bus, unsigned int devfn,
351                                     int offset, int len, u32 *val)
352 {
353         struct pci_controller *hose;
354         unsigned long addr;
355
356         hose = pci_bus_to_host(bus);
357         if (hose == NULL)
358                 return PCIBIOS_DEVICE_NOT_FOUND;
359
360         addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
361         if (!addr)
362                 return PCIBIOS_DEVICE_NOT_FOUND;
363
364         switch (u3_ht_skip_device(hose, bus, devfn)) {
365         case 0:
366                 break;
367         case 1:
368                 switch (len) {
369                 case 1:
370                         *val = 0xff; break;
371                 case 2:
372                         *val = 0xffff; break;
373                 default:
374                         *val = 0xfffffffful; break;
375                 }
376                 return PCIBIOS_SUCCESSFUL;
377         default:
378                 return PCIBIOS_DEVICE_NOT_FOUND;
379         }
380
381         /*
382          * Note: the caller has already checked that offset is
383          * suitably aligned and that len is 1, 2 or 4.
384          */
385         switch (len) {
386         case 1:
387                 *val = in_8((u8 *)addr);
388                 break;
389         case 2:
390                 *val = in_le16((u16 *)addr);
391                 break;
392         default:
393                 *val = in_le32((u32 *)addr);
394                 break;
395         }
396         return PCIBIOS_SUCCESSFUL;
397 }
398
399 static int u3_ht_write_config(struct pci_bus *bus, unsigned int devfn,
400                                      int offset, int len, u32 val)
401 {
402         struct pci_controller *hose;
403         unsigned long addr;
404
405         hose = pci_bus_to_host(bus);
406         if (hose == NULL)
407                 return PCIBIOS_DEVICE_NOT_FOUND;
408
409         addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
410         if (!addr)
411                 return PCIBIOS_DEVICE_NOT_FOUND;
412
413         switch (u3_ht_skip_device(hose, bus, devfn)) {
414         case 0:
415                 break;
416         case 1:
417                 return PCIBIOS_SUCCESSFUL;
418         default:
419                 return PCIBIOS_DEVICE_NOT_FOUND;
420         }
421
422         /*
423          * Note: the caller has already checked that offset is
424          * suitably aligned and that len is 1, 2 or 4.
425          */
426         switch (len) {
427         case 1:
428                 out_8((u8 *)addr, val);
429                 (void) in_8((u8 *)addr);
430                 break;
431         case 2:
432                 out_le16((u16 *)addr, val);
433                 (void) in_le16((u16 *)addr);
434                 break;
435         default:
436                 out_le32((u32 *)addr, val);
437                 (void) in_le32((u32 *)addr);
438                 break;
439         }
440         return PCIBIOS_SUCCESSFUL;
441 }
442
443 static struct pci_ops u3_ht_pci_ops =
444 {
445         u3_ht_read_config,
446         u3_ht_write_config
447 };
448 #endif /* CONFIG_POWER4 */
449
450 /*
451  * For a bandit bridge, turn on cache coherency if necessary.
452  * N.B. we could clean this up using the hose ops directly.
453  */
454 static void __init init_bandit(struct pci_controller *bp)
455 {
456         unsigned int vendev, magic;
457         int rev;
458
459         /* read the word at offset 0 in config space for device 11 */
460         out_le32(bp->cfg_addr, (1UL << BANDIT_DEVNUM) + PCI_VENDOR_ID);
461         udelay(2);
462         vendev = in_le32(bp->cfg_data);
463         if (vendev == (PCI_DEVICE_ID_APPLE_BANDIT << 16) +
464                         PCI_VENDOR_ID_APPLE) {
465                 /* read the revision id */
466                 out_le32(bp->cfg_addr,
467                          (1UL << BANDIT_DEVNUM) + PCI_REVISION_ID);
468                 udelay(2);
469                 rev = in_8(bp->cfg_data);
470                 if (rev != BANDIT_REVID)
471                         printk(KERN_WARNING
472                                "Unknown revision %d for bandit\n", rev);
473         } else if (vendev != (BANDIT_DEVID_2 << 16) + PCI_VENDOR_ID_APPLE) {
474                 printk(KERN_WARNING "bandit isn't? (%x)\n", vendev);
475                 return;
476         }
477
478         /* read the word at offset 0x50 */
479         out_le32(bp->cfg_addr, (1UL << BANDIT_DEVNUM) + BANDIT_MAGIC);
480         udelay(2);
481         magic = in_le32(bp->cfg_data);
482         if ((magic & BANDIT_COHERENT) != 0)
483                 return;
484         magic |= BANDIT_COHERENT;
485         udelay(2);
486         out_le32(bp->cfg_data, magic);
487         printk(KERN_INFO "Cache coherency enabled for bandit/PSX\n");
488 }
489
490
491 /*
492  * Tweak the PCI-PCI bridge chip on the blue & white G3s.
493  */
494 static void __init init_p2pbridge(void)
495 {
496         struct device_node *p2pbridge;
497         struct pci_controller* hose;
498         u8 bus, devfn;
499         u16 val;
500
501         /* XXX it would be better here to identify the specific
502            PCI-PCI bridge chip we have. */
503         if ((p2pbridge = find_devices("pci-bridge")) == 0
504             || p2pbridge->parent == NULL
505             || strcmp(p2pbridge->parent->name, "pci") != 0)
506                 return;
507         if (pci_device_from_OF_node(p2pbridge, &bus, &devfn) < 0) {
508                 DBG("Can't find PCI infos for PCI<->PCI bridge\n");
509                 return;
510         }
511         /* Warning: At this point, we have not yet renumbered all busses.
512          * So we must use OF walking to find out hose
513          */
514         hose = pci_find_hose_for_OF_device(p2pbridge);
515         if (!hose) {
516                 DBG("Can't find hose for PCI<->PCI bridge\n");
517                 return;
518         }
519         if (early_read_config_word(hose, bus, devfn,
520                                    PCI_BRIDGE_CONTROL, &val) < 0) {
521                 printk(KERN_ERR "init_p2pbridge: couldn't read bridge control\n");
522                 return;
523         }
524         val &= ~PCI_BRIDGE_CTL_MASTER_ABORT;
525         early_write_config_word(hose, bus, devfn, PCI_BRIDGE_CONTROL, val);
526 }
527
528 /*
529  * Some Apple desktop machines have a NEC PD720100A USB2 controller
530  * on the motherboard. Open Firmware, on these, will disable the
531  * EHCI part of it so it behaves like a pair of OHCI's. This fixup
532  * code re-enables it ;)
533  */
534 static void __init fixup_nec_usb2(void)
535 {
536         struct device_node *nec;
537
538         for (nec = NULL; (nec = of_find_node_by_name(nec, "usb")) != NULL;) {
539                 struct pci_controller *hose;
540                 u32 data, *prop;
541                 u8 bus, devfn;
542                 
543                 prop = (u32 *)get_property(nec, "vendor-id", NULL);
544                 if (prop == NULL)
545                         continue;
546                 if (0x1033 != *prop)
547                         continue;
548                 prop = (u32 *)get_property(nec, "device-id", NULL);
549                 if (prop == NULL)
550                         continue;
551                 if (0x0035 != *prop)
552                         continue;
553                 prop = (u32 *)get_property(nec, "reg", NULL);
554                 if (prop == NULL)
555                         continue;
556                 devfn = (prop[0] >> 8) & 0xff;
557                 bus = (prop[0] >> 16) & 0xff;
558                 if (PCI_FUNC(devfn) != 0)
559                         continue;
560                 hose = pci_find_hose_for_OF_device(nec);
561                 if (!hose)
562                         continue;
563                 early_read_config_dword(hose, bus, devfn, 0xe4, &data);
564                 if (data & 1UL) {
565                         printk("Found NEC PD720100A USB2 chip with disabled EHCI, fixing up...\n");
566                         data &= ~1UL;
567                         early_write_config_dword(hose, bus, devfn, 0xe4, data);
568                         early_write_config_byte(hose, bus, devfn | 2, PCI_INTERRUPT_LINE,
569                                 nec->intrs[0].line);
570                 }
571         }
572 }
573
574 #define GRACKLE_CFA(b, d, o)    (0x80 | ((b) << 8) | ((d) << 16) \
575                                  | (((o) & ~3) << 24))
576
577 #define GRACKLE_PICR1_STG               0x00000040
578 #define GRACKLE_PICR1_LOOPSNOOP         0x00000010
579
580 /* N.B. this is called before bridges is initialized, so we can't
581    use grackle_pcibios_{read,write}_config_dword. */
582 static inline void grackle_set_stg(struct pci_controller* bp, int enable)
583 {
584         unsigned int val;
585
586         out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
587         val = in_le32(bp->cfg_data);
588         val = enable? (val | GRACKLE_PICR1_STG) :
589                 (val & ~GRACKLE_PICR1_STG);
590         out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
591         out_le32(bp->cfg_data, val);
592         (void)in_le32(bp->cfg_data);
593 }
594
595 static inline void grackle_set_loop_snoop(struct pci_controller *bp, int enable)
596 {
597         unsigned int val;
598
599         out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
600         val = in_le32(bp->cfg_data);
601         val = enable? (val | GRACKLE_PICR1_LOOPSNOOP) :
602                 (val & ~GRACKLE_PICR1_LOOPSNOOP);
603         out_be32(bp->cfg_addr, GRACKLE_CFA(0, 0, 0xa8));
604         out_le32(bp->cfg_data, val);
605         (void)in_le32(bp->cfg_data);
606 }
607
608 static int __init
609 setup_uninorth(struct pci_controller* hose, struct reg_property* addr)
610 {
611         pci_assign_all_buses = 1;
612         has_uninorth = 1;
613         hose->ops = &macrisc_pci_ops;
614         hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
615         hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
616         /* We "know" that the bridge at f2000000 has the PCI slots. */
617         return addr->address == 0xf2000000;
618 }
619
620 static void __init
621 setup_bandit(struct pci_controller* hose, struct reg_property* addr)
622 {
623         hose->ops = &macrisc_pci_ops;
624         hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
625         hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
626         init_bandit(hose);
627 }
628
629 static void __init
630 setup_chaos(struct pci_controller* hose, struct reg_property* addr)
631 {
632         /* assume a `chaos' bridge */
633         hose->ops = &chaos_pci_ops;
634         hose->cfg_addr = ioremap(addr->address + 0x800000, 0x1000);
635         hose->cfg_data = ioremap(addr->address + 0xc00000, 0x1000);
636 }
637
638 #ifdef CONFIG_POWER4
639 static void __init setup_u3_agp(struct pci_controller* hose)
640 {
641         /* On G5, we move AGP up to high bus number so we don't need
642          * to reassign bus numbers for HT. If we ever have P2P bridges
643          * on AGP, we'll have to move pci_assign_all_buses to the
644          * pci_controller structure so we enable it for AGP and not for
645          * HT childs.
646          * We hard code the address because of the different size of
647          * the reg address cell, we shall fix that by killing struct
648          * reg_property and using some accessor functions instead
649          */
650         hose->first_busno = 0xf0;
651         hose->last_busno = 0xff;
652         has_uninorth = 1;
653         hose->ops = &macrisc_pci_ops;
654         hose->cfg_addr = ioremap(0xf0000000 + 0x800000, 0x1000);
655         hose->cfg_data = ioremap(0xf0000000 + 0xc00000, 0x1000);
656
657         u3_agp = hose;
658 }
659
660 static void __init setup_u3_ht(struct pci_controller* hose)
661 {
662         struct device_node *np = (struct device_node *)hose->arch_data;
663         int i, cur;
664
665         hose->ops = &u3_ht_pci_ops;
666
667         /* We hard code the address because of the different size of
668          * the reg address cell, we shall fix that by killing struct
669          * reg_property and using some accessor functions instead
670          */
671         hose->cfg_data = (volatile unsigned char *)ioremap(0xf2000000, 0x02000000);
672
673         /*
674          * /ht node doesn't expose a "ranges" property, so we "remove" regions that
675          * have been allocated to AGP. So far, this version of the code doesn't assign
676          * any of the 0xfxxxxxxx "fine" memory regions to /ht.
677          * We need to fix that sooner or later by either parsing all child "ranges"
678          * properties or figuring out the U3 address space decoding logic and
679          * then read its configuration register (if any).
680          */
681         hose->io_base_phys = 0xf4000000;
682         hose->io_base_virt = ioremap(hose->io_base_phys, 0x00400000);
683         isa_io_base = pci_io_base = (unsigned long) hose->io_base_virt;
684         hose->io_resource.name = np->full_name;
685         hose->io_resource.start = 0;
686         hose->io_resource.end = 0x003fffff;
687         hose->io_resource.flags = IORESOURCE_IO;
688         hose->pci_mem_offset = 0;
689         hose->first_busno = 0;
690         hose->last_busno = 0xef;
691         hose->mem_resources[0].name = np->full_name;
692         hose->mem_resources[0].start = 0x80000000;
693         hose->mem_resources[0].end = 0xefffffff;
694         hose->mem_resources[0].flags = IORESOURCE_MEM;
695
696         if (u3_agp == NULL) {
697                 DBG("U3 has no AGP, using full resource range\n");
698                 return;
699         }
700
701         /* We "remove" the AGP resources from the resources allocated to HT, that
702          * is we create "holes". However, that code does assumptions that so far
703          * happen to be true (cross fingers...), typically that resources in the
704          * AGP node are properly ordered
705          */
706         cur = 0;
707         for (i=0; i<3; i++) {
708                 struct resource *res = &u3_agp->mem_resources[i];
709                 if (res->flags != IORESOURCE_MEM)
710                         continue;
711                 /* We don't care about "fine" resources */
712                 if (res->start >= 0xf0000000)
713                         continue;
714                 /* Check if it's just a matter of "shrinking" us in one direction */
715                 if (hose->mem_resources[cur].start == res->start) {
716                         DBG("U3/HT: shrink start of %d, %08lx -> %08lx\n",
717                             cur, hose->mem_resources[cur].start, res->end + 1);
718                         hose->mem_resources[cur].start = res->end + 1;
719                         continue;
720                 }
721                 if (hose->mem_resources[cur].end == res->end) {
722                         DBG("U3/HT: shrink end of %d, %08lx -> %08lx\n",
723                             cur, hose->mem_resources[cur].end, res->start - 1);
724                         hose->mem_resources[cur].end = res->start - 1;
725                         continue;
726                 }
727                 /* No, it's not the case, we need a hole */
728                 if (cur == 2) {
729                         /* not enough resources for a hole, we drop part of the range */
730                         printk(KERN_WARNING "Running out of resources for /ht host !\n");
731                         hose->mem_resources[cur].end = res->start - 1;
732                         continue;
733                 }               
734                 cur++;
735                 DBG("U3/HT: hole, %d end at %08lx, %d start at %08lx\n",
736                     cur-1, res->start - 1, cur, res->end + 1);
737                 hose->mem_resources[cur].name = np->full_name;
738                 hose->mem_resources[cur].flags = IORESOURCE_MEM;
739                 hose->mem_resources[cur].start = res->end + 1;
740                 hose->mem_resources[cur].end = hose->mem_resources[cur-1].end;
741                 hose->mem_resources[cur-1].end = res->start - 1;
742         }
743 }
744
745 #endif /* CONFIG_POWER4 */
746
747 void __init
748 setup_grackle(struct pci_controller *hose)
749 {
750         setup_indirect_pci(hose, 0xfec00000, 0xfee00000);
751         if (machine_is_compatible("AAPL,PowerBook1998"))
752                 grackle_set_loop_snoop(hose, 1);
753 #if 0   /* Disabled for now, HW problems ??? */
754         grackle_set_stg(hose, 1);
755 #endif
756 }
757
758 static void __init pmac_process_bridge_OF_ranges(struct pci_controller *hose,
759                            struct device_node *dev, int primary)
760 {
761         static unsigned int static_lc_ranges[2024];
762         unsigned int *dt_ranges, *lc_ranges, *ranges, *prev;
763         unsigned int size;
764         int rlen = 0, orig_rlen;
765         int memno = 0;
766         struct resource *res;
767         int np, na = prom_n_addr_cells(dev);
768
769         np = na + 5;
770
771         /* First we try to merge ranges to fix a problem with some pmacs
772          * that can have more than 3 ranges, fortunately using contiguous
773          * addresses -- BenH
774          */
775         dt_ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
776         if (!dt_ranges)
777                 return;
778         /*      lc_ranges = alloc_bootmem(rlen);*/
779         lc_ranges = static_lc_ranges;
780         if (!lc_ranges)
781                 return; /* what can we do here ? */
782         memcpy(lc_ranges, dt_ranges, rlen);
783         orig_rlen = rlen;
784
785         /* Let's work on a copy of the "ranges" property instead of damaging
786          * the device-tree image in memory
787          */
788         ranges = lc_ranges;
789         prev = NULL;
790         while ((rlen -= np * sizeof(unsigned int)) >= 0) {
791                 if (prev) {
792                         if (prev[0] == ranges[0] && prev[1] == ranges[1] &&
793                                 (prev[2] + prev[na+4]) == ranges[2] &&
794                                 (prev[na+2] + prev[na+4]) == ranges[na+2]) {
795                                 prev[na+4] += ranges[na+4];
796                                 ranges[0] = 0;
797                                 ranges += np;
798                                 continue;
799                         }
800                 }
801                 prev = ranges;
802                 ranges += np;
803         }
804
805         /*
806          * The ranges property is laid out as an array of elements,
807          * each of which comprises:
808          *   cells 0 - 2:       a PCI address
809          *   cells 3 or 3+4:    a CPU physical address
810          *                      (size depending on dev->n_addr_cells)
811          *   cells 4+5 or 5+6:  the size of the range
812          */
813         ranges = lc_ranges;
814         rlen = orig_rlen;
815         while (ranges && (rlen -= np * sizeof(unsigned int)) >= 0) {
816                 res = NULL;
817                 size = ranges[na+4];
818                 switch (ranges[0] >> 24) {
819                 case 1:         /* I/O space */
820                         if (ranges[2] != 0)
821                                 break;
822                         hose->io_base_phys = ranges[na+2];
823                         /* limit I/O space to 16MB */
824                         if (size > 0x01000000)
825                                 size = 0x01000000;
826                         hose->io_base_virt = ioremap(ranges[na+2], size);
827                         if (primary)
828                                 isa_io_base = (unsigned long) hose->io_base_virt;
829                         res = &hose->io_resource;
830                         res->flags = IORESOURCE_IO;
831                         res->start = ranges[2];
832                         break;
833                 case 2:         /* memory space */
834                         memno = 0;
835                         if (ranges[1] == 0 && ranges[2] == 0
836                             && ranges[na+4] <= (16 << 20)) {
837                                 /* 1st 16MB, i.e. ISA memory area */
838 #if 0
839                                 if (primary)
840                                         isa_mem_base = ranges[na+2];
841 #endif
842                                 memno = 1;
843                         }
844                         while (memno < 3 && hose->mem_resources[memno].flags)
845                                 ++memno;
846                         if (memno == 0)
847                                 hose->pci_mem_offset = ranges[na+2] - ranges[2];
848                         if (memno < 3) {
849                                 res = &hose->mem_resources[memno];
850                                 res->flags = IORESOURCE_MEM;
851                                 res->start = ranges[na+2];
852                         }
853                         break;
854                 }
855                 if (res != NULL) {
856                         res->name = dev->full_name;
857                         res->end = res->start + size - 1;
858                         res->parent = NULL;
859                         res->sibling = NULL;
860                         res->child = NULL;
861                 }
862                 ranges += np;
863         }
864 }
865
866 /*
867  * We assume that if we have a G3 powermac, we have one bridge called
868  * "pci" (a MPC106) and no bandit or chaos bridges, and contrariwise,
869  * if we have one or more bandit or chaos bridges, we don't have a MPC106.
870  */
871 static int __init add_bridge(struct device_node *dev)
872 {
873         int len;
874         struct pci_controller *hose;
875         struct reg_property *addr;
876         char* disp_name;
877         int *bus_range;
878         int primary = 1;
879
880         DBG("Adding PCI host bridge %s\n", dev->full_name);
881
882         addr = (struct reg_property *) get_property(dev, "reg", &len);
883         if (addr == NULL || len < sizeof(*addr)) {
884                 printk(KERN_WARNING "Can't use %s: no address\n",
885                        dev->full_name);
886                 return -ENODEV;
887         }
888         bus_range = (int *) get_property(dev, "bus-range", &len);
889         if (bus_range == NULL || len < 2 * sizeof(int)) {
890                 printk(KERN_WARNING "Can't get bus-range for %s, assume bus 0\n",
891                                dev->full_name);
892         }
893
894         hose = pcibios_alloc_controller();
895         if (!hose)
896                 return -ENOMEM;
897         hose->arch_data = dev;
898         hose->first_busno = bus_range ? bus_range[0] : 0;
899         hose->last_busno = bus_range ? bus_range[1] : 0xff;
900
901         disp_name = NULL;
902 #ifdef CONFIG_POWER4
903         if (device_is_compatible(dev, "u3-agp")) {
904                 setup_u3_agp(hose, addr);
905                 disp_name = "U3-AGP";
906                 primary = 0;
907         } else if (device_is_compatible(dev, "u3-ht")) {
908                 setup_u3_ht(hose, addr);
909                 disp_name = "U3-HT";
910                 primary = 1;
911         } else
912 #endif /* CONFIG_POWER4 */
913         if (device_is_compatible(dev, "uni-north")) {
914                 primary = setup_uninorth(hose, addr);
915                 disp_name = "UniNorth";
916         } else if (strcmp(dev->name, "pci") == 0) {
917                 /* XXX assume this is a mpc106 (grackle) */
918                 setup_grackle(hose);
919                 disp_name = "Grackle (MPC106)";
920         } else if (strcmp(dev->name, "bandit") == 0) {
921                 setup_bandit(hose, addr);
922                 disp_name = "Bandit";
923         } else if (strcmp(dev->name, "chaos") == 0) {
924                 setup_chaos(hose, addr);
925                 disp_name = "Chaos";
926                 primary = 0;
927         }
928         printk(KERN_INFO "Found %s PCI host bridge at 0x%08lx. Firmware bus number: %d->%d\n",
929                 disp_name, addr->address, hose->first_busno, hose->last_busno);
930         DBG(" ->Hose at 0x%p, cfg_addr=0x%p,cfg_data=0x%p\n",
931                 hose, hose->cfg_addr, hose->cfg_data);
932
933         /* Interpret the "ranges" property */
934         /* This also maps the I/O region and sets isa_io/mem_base */
935         pci_process_bridge_OF_ranges(hose, dev, primary);
936
937         /* Fixup "bus-range" OF property */
938         fixup_bus_range(dev);
939
940         return 0;
941 }
942
943 static void __init
944 pcibios_fixup_OF_interrupts(void)
945 {
946         struct pci_dev* dev = NULL;
947
948         /*
949          * Open Firmware often doesn't initialize the
950          * PCI_INTERRUPT_LINE config register properly, so we
951          * should find the device node and apply the interrupt
952          * obtained from the OF device-tree
953          */
954         for_each_pci_dev(dev) {
955                 struct device_node *node;
956                 node = pci_device_to_OF_node(dev);
957                 /* this is the node, see if it has interrupts */
958                 if (node && node->n_intrs > 0)
959                         dev->irq = node->intrs[0].line;
960                 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
961         }
962 }
963
964 void __init
965 pmac_pcibios_fixup(void)
966 {
967         /* Fixup interrupts according to OF tree */
968         pcibios_fixup_OF_interrupts();
969 }
970
971 void __init pmac_find_bridges(void)
972 {
973         struct device_node *np, *root;
974         struct device_node *ht = NULL;
975
976         root = of_find_node_by_path("/");
977         if (root == NULL) {
978                 printk(KERN_CRIT "pmac_find_bridges: can't find root of device tree\n");
979                 return;
980         }
981         for (np = NULL; (np = of_get_next_child(root, np)) != NULL;) {
982                 if (np->name == NULL)
983                         continue;
984                 if (strcmp(np->name, "bandit") == 0
985                     || strcmp(np->name, "chaos") == 0
986                     || strcmp(np->name, "pci") == 0) {
987                         if (add_bridge(np) == 0)
988                                 of_node_get(np);
989                 }
990                 if (strcmp(np->name, "ht") == 0) {
991                         of_node_get(np);
992                         ht = np;
993                 }
994         }
995         of_node_put(root);
996
997         /* Probe HT last as it relies on the agp resources to be already
998          * setup
999          */
1000         if (ht && add_bridge(ht) != 0)
1001                 of_node_put(ht);
1002
1003         init_p2pbridge();
1004         fixup_nec_usb2();
1005         
1006         /* We are still having some issues with the Xserve G4, enabling
1007          * some offset between bus number and domains for now when we
1008          * assign all busses should help for now
1009          */
1010         if (pci_assign_all_buses)
1011                 pcibios_assign_bus_offset = 0x10;
1012
1013 }
1014
1015 int
1016 pmac_pci_enable_device_hook(struct pci_dev *dev, int initial)
1017 {
1018         struct device_node* node;
1019         int updatecfg = 0;
1020         int uninorth_child;
1021
1022         node = pci_device_to_OF_node(dev);
1023
1024         /* We don't want to enable USB controllers absent from the OF tree
1025          * (iBook second controller)
1026          */
1027         if (dev->vendor == PCI_VENDOR_ID_APPLE
1028             && (dev->class == ((PCI_CLASS_SERIAL_USB << 8) | 0x10))
1029             && !node) {
1030                 printk(KERN_INFO "Apple USB OHCI %s disabled by firmware\n",
1031                        pci_name(dev));
1032                 return -EINVAL;
1033         }
1034
1035         if (!node)
1036                 return 0;
1037
1038         uninorth_child = node->parent &&
1039                 device_is_compatible(node->parent, "uni-north");
1040         
1041         /* Firewire & GMAC were disabled after PCI probe, the driver is
1042          * claiming them, we must re-enable them now.
1043          */
1044         if (uninorth_child && !strcmp(node->name, "firewire") &&
1045             (device_is_compatible(node, "pci106b,18") ||
1046              device_is_compatible(node, "pci106b,30") ||
1047              device_is_compatible(node, "pci11c1,5811"))) {
1048                 pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, node, 0, 1);
1049                 pmac_call_feature(PMAC_FTR_1394_ENABLE, node, 0, 1);
1050                 updatecfg = 1;
1051         }
1052         if (uninorth_child && !strcmp(node->name, "ethernet") &&
1053             device_is_compatible(node, "gmac")) {
1054                 pmac_call_feature(PMAC_FTR_GMAC_ENABLE, node, 0, 1);
1055                 updatecfg = 1;
1056         }
1057
1058         if (updatecfg) {
1059                 u16 cmd;
1060         
1061                 /*
1062                  * Make sure PCI is correctly configured
1063                  *
1064                  * We use old pci_bios versions of the function since, by
1065                  * default, gmac is not powered up, and so will be absent
1066                  * from the kernel initial PCI lookup.
1067                  *
1068                  * Should be replaced by 2.4 new PCI mechanisms and really
1069                  * register the device.
1070                  */
1071                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
1072                 cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE;
1073                 pci_write_config_word(dev, PCI_COMMAND, cmd);
1074                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 16);
1075                 pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, pci_cache_line_size);
1076         }
1077
1078         return 0;
1079 }
1080
1081 /* We power down some devices after they have been probed. They'll
1082  * be powered back on later on
1083  */
1084 void __init
1085 pmac_pcibios_after_init(void)
1086 {
1087         struct device_node* nd;
1088
1089 #ifdef CONFIG_BLK_DEV_IDE
1090         struct pci_dev *dev = NULL;
1091
1092         /* OF fails to initialize IDE controllers on macs
1093          * (and maybe other machines)
1094          *
1095          * Ideally, this should be moved to the IDE layer, but we need
1096          * to check specifically with Andre Hedrick how to do it cleanly
1097          * since the common IDE code seem to care about the fact that the
1098          * BIOS may have disabled a controller.
1099          *
1100          * -- BenH
1101          */
1102         for_each_pci_dev(dev) {
1103                 if ((dev->class >> 16) == PCI_BASE_CLASS_STORAGE)
1104                         pci_enable_device(dev);
1105         }
1106 #endif /* CONFIG_BLK_DEV_IDE */
1107
1108         nd = find_devices("firewire");
1109         while (nd) {
1110                 if (nd->parent && (device_is_compatible(nd, "pci106b,18") ||
1111                                    device_is_compatible(nd, "pci106b,30") ||
1112                                    device_is_compatible(nd, "pci11c1,5811"))
1113                     && device_is_compatible(nd->parent, "uni-north")) {
1114                         pmac_call_feature(PMAC_FTR_1394_ENABLE, nd, 0, 0);
1115                         pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, nd, 0, 0);
1116                 }
1117                 nd = nd->next;
1118         }
1119         nd = find_devices("ethernet");
1120         while (nd) {
1121                 if (nd->parent && device_is_compatible(nd, "gmac")
1122                     && device_is_compatible(nd->parent, "uni-north"))
1123                         pmac_call_feature(PMAC_FTR_GMAC_ENABLE, nd, 0, 0);
1124                 nd = nd->next;
1125         }
1126 }
1127
1128 #ifdef CONFIG_PPC64
1129 static void __init pmac_fixup_phb_resources(void)
1130 {
1131         struct pci_controller *hose, *tmp;
1132         
1133         list_for_each_entry_safe(hose, tmp, &hose_list, list_node) {
1134                 unsigned long offset = (unsigned long)hose->io_base_virt - pci_io_base;
1135                 hose->io_resource.start += offset;
1136                 hose->io_resource.end += offset;
1137                 printk(KERN_INFO "PCI Host %d, io start: %lx; io end: %lx\n",
1138                        hose->global_number,
1139                        hose->io_resource.start, hose->io_resource.end);
1140         }
1141 }
1142
1143 void __init pmac_pci_init(void)
1144 {
1145         struct device_node *np, *root;
1146         struct device_node *ht = NULL;
1147
1148         /* Probe root PCI hosts, that is on U3 the AGP host and the
1149          * HyperTransport host. That one is actually "kept" around
1150          * and actually added last as it's resource management relies
1151          * on the AGP resources to have been setup first
1152          */
1153         root = of_find_node_by_path("/");
1154         if (root == NULL) {
1155                 printk(KERN_CRIT "pmac_find_bridges: can't find root of device tree\n");
1156                 return;
1157         }
1158         for (np = NULL; (np = of_get_next_child(root, np)) != NULL;) {
1159                 if (np->name == NULL)
1160                         continue;
1161                 if (strcmp(np->name, "pci") == 0) {
1162                         if (add_bridge(np) == 0)
1163                                 of_node_get(np);
1164                 }
1165                 if (strcmp(np->name, "ht") == 0) {
1166                         of_node_get(np);
1167                         ht = np;
1168                 }
1169         }
1170         of_node_put(root);
1171
1172         /* Now setup the HyperTransport host if we found any
1173          */
1174         if (ht && add_bridge(ht) != 0)
1175                 of_node_put(ht);
1176
1177         /* Fixup the IO resources on our host bridges as the common code
1178          * does it only for childs of the host bridges
1179          */
1180         pmac_fixup_phb_resources();
1181
1182         /* Setup the linkage between OF nodes and PHBs */ 
1183         pci_devs_phb_init();
1184
1185         /* Fixup the PCI<->OF mapping for U3 AGP due to bus renumbering. We
1186          * assume there is no P2P bridge on the AGP bus, which should be a
1187          * safe assumptions hopefully.
1188          */
1189         if (u3_agp) {
1190                 struct device_node *np = u3_agp->arch_data;
1191                 PCI_DN(np)->busno = 0xf0;
1192                 for (np = np->child; np; np = np->sibling)
1193                         PCI_DN(np)->busno = 0xf0;
1194         }
1195
1196         pmac_check_ht_link();
1197
1198         /* Tell pci.c to not use the common resource allocation mecanism */
1199         pci_probe_only = 1;
1200         
1201         /* Allow all IO */
1202         io_page_mask = -1;
1203 }
1204 #endif
1205
1206 #ifdef CONFIG_PPC32
1207 void pmac_pci_fixup_cardbus(struct pci_dev* dev)
1208 {
1209         if (_machine != _MACH_Pmac)
1210                 return;
1211         /*
1212          * Fix the interrupt routing on the various cardbus bridges
1213          * used on powerbooks
1214          */
1215         if (dev->vendor != PCI_VENDOR_ID_TI)
1216                 return;
1217         if (dev->device == PCI_DEVICE_ID_TI_1130 ||
1218             dev->device == PCI_DEVICE_ID_TI_1131) {
1219                 u8 val;
1220                 /* Enable PCI interrupt */
1221                 if (pci_read_config_byte(dev, 0x91, &val) == 0)
1222                         pci_write_config_byte(dev, 0x91, val | 0x30);
1223                 /* Disable ISA interrupt mode */
1224                 if (pci_read_config_byte(dev, 0x92, &val) == 0)
1225                         pci_write_config_byte(dev, 0x92, val & ~0x06);
1226         }
1227         if (dev->device == PCI_DEVICE_ID_TI_1210 ||
1228             dev->device == PCI_DEVICE_ID_TI_1211 ||
1229             dev->device == PCI_DEVICE_ID_TI_1410 ||
1230             dev->device == PCI_DEVICE_ID_TI_1510) {
1231                 u8 val;
1232                 /* 0x8c == TI122X_IRQMUX, 2 says to route the INTA
1233                    signal out the MFUNC0 pin */
1234                 if (pci_read_config_byte(dev, 0x8c, &val) == 0)
1235                         pci_write_config_byte(dev, 0x8c, (val & ~0x0f) | 2);
1236                 /* Disable ISA interrupt mode */
1237                 if (pci_read_config_byte(dev, 0x92, &val) == 0)
1238                         pci_write_config_byte(dev, 0x92, val & ~0x06);
1239         }
1240 }
1241
1242 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_TI, PCI_ANY_ID, pmac_pci_fixup_cardbus);
1243
1244 void pmac_pci_fixup_pciata(struct pci_dev* dev)
1245 {
1246        u8 progif = 0;
1247
1248        /*
1249         * On PowerMacs, we try to switch any PCI ATA controller to
1250         * fully native mode
1251         */
1252         if (_machine != _MACH_Pmac)
1253                 return;
1254         /* Some controllers don't have the class IDE */
1255         if (dev->vendor == PCI_VENDOR_ID_PROMISE)
1256                 switch(dev->device) {
1257                 case PCI_DEVICE_ID_PROMISE_20246:
1258                 case PCI_DEVICE_ID_PROMISE_20262:
1259                 case PCI_DEVICE_ID_PROMISE_20263:
1260                 case PCI_DEVICE_ID_PROMISE_20265:
1261                 case PCI_DEVICE_ID_PROMISE_20267:
1262                 case PCI_DEVICE_ID_PROMISE_20268:
1263                 case PCI_DEVICE_ID_PROMISE_20269:
1264                 case PCI_DEVICE_ID_PROMISE_20270:
1265                 case PCI_DEVICE_ID_PROMISE_20271:
1266                 case PCI_DEVICE_ID_PROMISE_20275:
1267                 case PCI_DEVICE_ID_PROMISE_20276:
1268                 case PCI_DEVICE_ID_PROMISE_20277:
1269                         goto good;
1270                 }
1271         /* Others, check PCI class */
1272         if ((dev->class >> 8) != PCI_CLASS_STORAGE_IDE)
1273                 return;
1274  good:
1275         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1276         if ((progif & 5) != 5) {
1277                 printk(KERN_INFO "Forcing PCI IDE into native mode: %s\n", pci_name(dev));
1278                 (void) pci_write_config_byte(dev, PCI_CLASS_PROG, progif|5);
1279                 if (pci_read_config_byte(dev, PCI_CLASS_PROG, &progif) ||
1280                     (progif & 5) != 5)
1281                         printk(KERN_ERR "Rewrite of PROGIF failed !\n");
1282         }
1283 }
1284 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pmac_pci_fixup_pciata);
1285 #endif
1286
1287 /*
1288  * Disable second function on K2-SATA, it's broken
1289  * and disable IO BARs on first one
1290  */
1291 static void fixup_k2_sata(struct pci_dev* dev)
1292 {
1293         int i;
1294         u16 cmd;
1295
1296         if (PCI_FUNC(dev->devfn) > 0) {
1297                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
1298                 cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
1299                 pci_write_config_word(dev, PCI_COMMAND, cmd);
1300                 for (i = 0; i < 6; i++) {
1301                         dev->resource[i].start = dev->resource[i].end = 0;
1302                         dev->resource[i].flags = 0;
1303                         pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, 0);
1304                 }
1305         } else {
1306                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
1307                 cmd &= ~PCI_COMMAND_IO;
1308                 pci_write_config_word(dev, PCI_COMMAND, cmd);
1309                 for (i = 0; i < 5; i++) {
1310                         dev->resource[i].start = dev->resource[i].end = 0;
1311                         dev->resource[i].flags = 0;
1312                         pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + 4 * i, 0);
1313                 }
1314         }
1315 }
1316 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS, 0x0240, fixup_k2_sata);
1317