[SPARC64]: Convert sparc64 PCI layer to in-kernel device tree.
[linux-2.6.git] / arch / sparc64 / kernel / pci_common.c
1 /* $Id: pci_common.c,v 1.29 2002/02/01 00:56:03 davem Exp $
2  * pci_common.c: PCI controller common support.
3  *
4  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
5  */
6
7 #include <linux/string.h>
8 #include <linux/slab.h>
9 #include <linux/init.h>
10
11 #include <asm/pbm.h>
12 #include <asm/prom.h>
13
14 #include "pci_impl.h"
15
16 /* Pass "pci=irq_verbose" on the kernel command line to enable this.  */
17 int pci_irq_verbose;
18
19 /* Fix self device of BUS and hook it into BUS->self.
20  * The pci_scan_bus does not do this for the host bridge.
21  */
22 void __init pci_fixup_host_bridge_self(struct pci_bus *pbus)
23 {
24         struct pci_dev *pdev;
25
26         list_for_each_entry(pdev, &pbus->devices, bus_list) {
27                 if (pdev->class >> 8 == PCI_CLASS_BRIDGE_HOST) {
28                         pbus->self = pdev;
29                         return;
30                 }
31         }
32
33         prom_printf("PCI: Critical error, cannot find host bridge PDEV.\n");
34         prom_halt();
35 }
36
37 /* Find the OBP PROM device tree node for a PCI device.  */
38 static struct device_node * __init
39 find_device_prom_node(struct pci_pbm_info *pbm, struct pci_dev *pdev,
40                       struct device_node *bus_node,
41                       struct linux_prom_pci_registers **pregs,
42                       int *nregs)
43 {
44         struct device_node *dp;
45
46         *nregs = 0;
47
48         /*
49          * Return the PBM's PROM node in case we are it's PCI device,
50          * as the PBM's reg property is different to standard PCI reg
51          * properties. We would delete this device entry otherwise,
52          * which confuses XFree86's device probing...
53          */
54         if ((pdev->bus->number == pbm->pci_bus->number) && (pdev->devfn == 0) &&
55             (pdev->vendor == PCI_VENDOR_ID_SUN) &&
56             (pdev->device == PCI_DEVICE_ID_SUN_PBM ||
57              pdev->device == PCI_DEVICE_ID_SUN_SCHIZO ||
58              pdev->device == PCI_DEVICE_ID_SUN_TOMATILLO ||
59              pdev->device == PCI_DEVICE_ID_SUN_SABRE ||
60              pdev->device == PCI_DEVICE_ID_SUN_HUMMINGBIRD))
61                 return bus_node;
62
63         dp = bus_node->child;
64         while (dp) {
65                 struct linux_prom_pci_registers *regs;
66                 struct property *prop;
67                 int len;
68
69                 prop = of_find_property(dp, "reg", &len);
70                 if (!prop)
71                         goto do_next_sibling;
72
73                 regs = prop->value;
74                 if (((regs[0].phys_hi >> 8) & 0xff) == pdev->devfn) {
75                         *pregs = regs;
76                         *nregs = len / sizeof(struct linux_prom_pci_registers);
77                         return dp;
78                 }
79
80         do_next_sibling:
81                 dp = dp->sibling;
82         }
83
84         return NULL;
85 }
86
87 /* Older versions of OBP on PCI systems encode 64-bit MEM
88  * space assignments incorrectly, this fixes them up.  We also
89  * take the opportunity here to hide other kinds of bogus
90  * assignments.
91  */
92 static void __init fixup_obp_assignments(struct pci_dev *pdev,
93                                          struct pcidev_cookie *pcp)
94 {
95         int i;
96
97         if (pdev->vendor == PCI_VENDOR_ID_AL &&
98             (pdev->device == PCI_DEVICE_ID_AL_M7101 ||
99              pdev->device == PCI_DEVICE_ID_AL_M1533)) {
100                 int i;
101
102                 /* Zap all of the normal resources, they are
103                  * meaningless and generate bogus resource collision
104                  * messages.  This is OpenBoot's ill-fated attempt to
105                  * represent the implicit resources that these devices
106                  * have.
107                  */
108                 pcp->num_prom_assignments = 0;
109                 for (i = 0; i < 6; i++) {
110                         pdev->resource[i].start =
111                                 pdev->resource[i].end =
112                                 pdev->resource[i].flags = 0;
113                 }
114                 pdev->resource[PCI_ROM_RESOURCE].start =
115                         pdev->resource[PCI_ROM_RESOURCE].end =
116                         pdev->resource[PCI_ROM_RESOURCE].flags = 0;
117                 return;
118         }
119
120         for (i = 0; i < pcp->num_prom_assignments; i++) {
121                 struct linux_prom_pci_registers *ap;
122                 int space;
123
124                 ap = &pcp->prom_assignments[i];
125                 space = ap->phys_hi >> 24;
126                 if ((space & 0x3) == 2 &&
127                     (space & 0x4) != 0) {
128                         ap->phys_hi &= ~(0x7 << 24);
129                         ap->phys_hi |= 0x3 << 24;
130                 }
131         }
132 }
133
134 /* Fill in the PCI device cookie sysdata for the given
135  * PCI device.  This cookie is the means by which one
136  * can get to OBP and PCI controller specific information
137  * for a PCI device.
138  */
139 static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,
140                                       struct pci_dev *pdev,
141                                       struct device_node *bus_node)
142 {
143         struct linux_prom_pci_registers *pregs = NULL;
144         struct pcidev_cookie *pcp;
145         struct device_node *dp;
146         struct property *prop;
147         int nregs, len;
148
149         dp = find_device_prom_node(pbm, pdev, bus_node,
150                                    &pregs, &nregs);
151         if (!dp) {
152                 /* If it is not in the OBP device tree then
153                  * there must be a damn good reason for it.
154                  *
155                  * So what we do is delete the device from the
156                  * PCI device tree completely.  This scenario
157                  * is seen, for example, on CP1500 for the
158                  * second EBUS/HappyMeal pair if the external
159                  * connector for it is not present.
160                  */
161                 pci_remove_bus_device(pdev);
162                 return;
163         }
164
165         pcp = kzalloc(sizeof(*pcp), GFP_ATOMIC);
166         if (pcp == NULL) {
167                 prom_printf("PCI_COOKIE: Fatal malloc error, aborting...\n");
168                 prom_halt();
169         }
170         pcp->pbm = pbm;
171         pcp->prom_node = dp;
172         memcpy(pcp->prom_regs, pregs,
173                nregs * sizeof(struct linux_prom_pci_registers));
174         pcp->num_prom_regs = nregs;
175
176         /* We can't have the pcidev_cookie assignments be just
177          * direct pointers into the property value, since they
178          * are potentially modified by the probing process.
179          */
180         prop = of_find_property(dp, "assigned-addresses", &len);
181         if (!prop) {
182                 pcp->num_prom_assignments = 0;
183         } else {
184                 memcpy(pcp->prom_assignments, prop->value, len);
185                 pcp->num_prom_assignments =
186                         (len / sizeof(pcp->prom_assignments[0]));
187         }
188
189         if (strcmp(dp->name, "ebus") == 0) {
190                 struct linux_prom_ebus_ranges *erng;
191                 int iter;
192
193                 /* EBUS is special... */
194                 prop = of_find_property(dp, "ranges", &len);
195                 if (!prop) {
196                         prom_printf("EBUS: Fatal error, no range property\n");
197                         prom_halt();
198                 }
199                 erng = prop->value;
200                 len = (len / sizeof(erng[0]));
201                 for (iter = 0; iter < len; iter++) {
202                         struct linux_prom_ebus_ranges *ep = &erng[iter];
203                         struct linux_prom_pci_registers *ap;
204
205                         ap = &pcp->prom_assignments[iter];
206
207                         ap->phys_hi = ep->parent_phys_hi;
208                         ap->phys_mid = ep->parent_phys_mid;
209                         ap->phys_lo = ep->parent_phys_lo;
210                         ap->size_hi = 0;
211                         ap->size_lo = ep->size;
212                 }
213                 pcp->num_prom_assignments = len;
214         }
215
216         fixup_obp_assignments(pdev, pcp);
217
218         pdev->sysdata = pcp;
219 }
220
221 void __init pci_fill_in_pbm_cookies(struct pci_bus *pbus,
222                                     struct pci_pbm_info *pbm,
223                                     struct device_node *dp)
224 {
225         struct pci_dev *pdev, *pdev_next;
226         struct pci_bus *this_pbus, *pbus_next;
227
228         /* This must be _safe because the cookie fillin
229            routine can delete devices from the tree.  */
230         list_for_each_entry_safe(pdev, pdev_next, &pbus->devices, bus_list)
231                 pdev_cookie_fillin(pbm, pdev, dp);
232
233         list_for_each_entry_safe(this_pbus, pbus_next, &pbus->children, node) {
234                 struct pcidev_cookie *pcp = this_pbus->self->sysdata;
235
236                 pci_fill_in_pbm_cookies(this_pbus, pbm, pcp->prom_node);
237         }
238 }
239
240 static void __init bad_assignment(struct pci_dev *pdev,
241                                   struct linux_prom_pci_registers *ap,
242                                   struct resource *res,
243                                   int do_prom_halt)
244 {
245         prom_printf("PCI: Bogus PROM assignment. BUS[%02x] DEVFN[%x]\n",
246                     pdev->bus->number, pdev->devfn);
247         if (ap)
248                 prom_printf("PCI: phys[%08x:%08x:%08x] size[%08x:%08x]\n",
249                             ap->phys_hi, ap->phys_mid, ap->phys_lo,
250                             ap->size_hi, ap->size_lo);
251         if (res)
252                 prom_printf("PCI: RES[%016lx-->%016lx:(%lx)]\n",
253                             res->start, res->end, res->flags);
254         if (do_prom_halt)
255                 prom_halt();
256 }
257
258 static struct resource *
259 __init get_root_resource(struct linux_prom_pci_registers *ap,
260                          struct pci_pbm_info *pbm)
261 {
262         int space = (ap->phys_hi >> 24) & 3;
263
264         switch (space) {
265         case 0:
266                 /* Configuration space, silently ignore it. */
267                 return NULL;
268
269         case 1:
270                 /* 16-bit IO space */
271                 return &pbm->io_space;
272
273         case 2:
274                 /* 32-bit MEM space */
275                 return &pbm->mem_space;
276
277         case 3:
278                 /* 64-bit MEM space, these are allocated out of
279                  * the 32-bit mem_space range for the PBM, ie.
280                  * we just zero out the upper 32-bits.
281                  */
282                 return &pbm->mem_space;
283
284         default:
285                 printk("PCI: What is resource space %x?\n", space);
286                 return NULL;
287         };
288 }
289
290 static struct resource *
291 __init get_device_resource(struct linux_prom_pci_registers *ap,
292                            struct pci_dev *pdev)
293 {
294         struct resource *res;
295         int breg = (ap->phys_hi & 0xff);
296
297         switch (breg) {
298         case  PCI_ROM_ADDRESS:
299                 /* Unfortunately I have seen several cases where
300                  * buggy FCODE uses a space value of '1' (I/O space)
301                  * in the register property for the ROM address
302                  * so disable this sanity check for now.
303                  */
304 #if 0
305         {
306                 int space = (ap->phys_hi >> 24) & 3;
307
308                 /* It had better be MEM space. */
309                 if (space != 2)
310                         bad_assignment(pdev, ap, NULL, 0);
311         }
312 #endif
313                 res = &pdev->resource[PCI_ROM_RESOURCE];
314                 break;
315
316         case PCI_BASE_ADDRESS_0:
317         case PCI_BASE_ADDRESS_1:
318         case PCI_BASE_ADDRESS_2:
319         case PCI_BASE_ADDRESS_3:
320         case PCI_BASE_ADDRESS_4:
321         case PCI_BASE_ADDRESS_5:
322                 res = &pdev->resource[(breg - PCI_BASE_ADDRESS_0) / 4];
323                 break;
324
325         default:
326                 bad_assignment(pdev, ap, NULL, 0);
327                 res = NULL;
328                 break;
329         };
330
331         return res;
332 }
333
334 static int __init pdev_resource_collisions_expected(struct pci_dev *pdev)
335 {
336         if (pdev->vendor != PCI_VENDOR_ID_SUN)
337                 return 0;
338
339         if (pdev->device == PCI_DEVICE_ID_SUN_RIO_EBUS ||
340             pdev->device == PCI_DEVICE_ID_SUN_RIO_1394 ||
341             pdev->device == PCI_DEVICE_ID_SUN_RIO_USB)
342                 return 1;
343
344         return 0;
345 }
346
347 static void __init pdev_record_assignments(struct pci_pbm_info *pbm,
348                                            struct pci_dev *pdev)
349 {
350         struct pcidev_cookie *pcp = pdev->sysdata;
351         int i;
352
353         for (i = 0; i < pcp->num_prom_assignments; i++) {
354                 struct linux_prom_pci_registers *ap;
355                 struct resource *root, *res;
356
357                 /* The format of this property is specified in
358                  * the PCI Bus Binding to IEEE1275-1994.
359                  */
360                 ap = &pcp->prom_assignments[i];
361                 root = get_root_resource(ap, pbm);
362                 res = get_device_resource(ap, pdev);
363                 if (root == NULL || res == NULL ||
364                     res->flags == 0)
365                         continue;
366
367                 /* Ok we know which resource this PROM assignment is
368                  * for, sanity check it.
369                  */
370                 if ((res->start & 0xffffffffUL) != ap->phys_lo)
371                         bad_assignment(pdev, ap, res, 1);
372
373                 /* If it is a 64-bit MEM space assignment, verify that
374                  * the resource is too and that the upper 32-bits match.
375                  */
376                 if (((ap->phys_hi >> 24) & 3) == 3) {
377                         if (((res->flags & IORESOURCE_MEM) == 0) ||
378                             ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
379                              != PCI_BASE_ADDRESS_MEM_TYPE_64))
380                                 bad_assignment(pdev, ap, res, 1);
381                         if ((res->start >> 32) != ap->phys_mid)
382                                 bad_assignment(pdev, ap, res, 1);
383
384                         /* PBM cannot generate cpu initiated PIOs
385                          * to the full 64-bit space.  Therefore the
386                          * upper 32-bits better be zero.  If it is
387                          * not, just skip it and we will assign it
388                          * properly ourselves.
389                          */
390                         if ((res->start >> 32) != 0UL) {
391                                 printk(KERN_ERR "PCI: OBP assigns out of range MEM address "
392                                        "%016lx for region %ld on device %s\n",
393                                        res->start, (res - &pdev->resource[0]), pci_name(pdev));
394                                 continue;
395                         }
396                 }
397
398                 /* Adjust the resource into the physical address space
399                  * of this PBM.
400                  */
401                 pbm->parent->resource_adjust(pdev, res, root);
402
403                 if (request_resource(root, res) < 0) {
404                         /* OK, there is some conflict.  But this is fine
405                          * since we'll reassign it in the fixup pass.
406                          *
407                          * We notify the user that OBP made an error if it
408                          * is a case we don't expect.
409                          */
410                         if (!pdev_resource_collisions_expected(pdev)) {
411                                 printk(KERN_ERR "PCI: Address space collision on region %ld "
412                                        "[%016lx:%016lx] of device %s\n",
413                                        (res - &pdev->resource[0]),
414                                        res->start, res->end,
415                                        pci_name(pdev));
416                         }
417                 }
418         }
419 }
420
421 void __init pci_record_assignments(struct pci_pbm_info *pbm,
422                                    struct pci_bus *pbus)
423 {
424         struct pci_dev *dev;
425         struct pci_bus *bus;
426
427         list_for_each_entry(dev, &pbus->devices, bus_list)
428                 pdev_record_assignments(pbm, dev);
429
430         list_for_each_entry(bus, &pbus->children, node)
431                 pci_record_assignments(pbm, bus);
432 }
433
434 /* Return non-zero if PDEV has implicit I/O resources even
435  * though it may not have an I/O base address register
436  * active.
437  */
438 static int __init has_implicit_io(struct pci_dev *pdev)
439 {
440         int class = pdev->class >> 8;
441
442         if (class == PCI_CLASS_NOT_DEFINED ||
443             class == PCI_CLASS_NOT_DEFINED_VGA ||
444             class == PCI_CLASS_STORAGE_IDE ||
445             (pdev->class >> 16) == PCI_BASE_CLASS_DISPLAY)
446                 return 1;
447
448         return 0;
449 }
450
451 static void __init pdev_assign_unassigned(struct pci_pbm_info *pbm,
452                                           struct pci_dev *pdev)
453 {
454         u32 reg;
455         u16 cmd;
456         int i, io_seen, mem_seen;
457
458         io_seen = mem_seen = 0;
459         for (i = 0; i < PCI_NUM_RESOURCES; i++) {
460                 struct resource *root, *res;
461                 unsigned long size, min, max, align;
462
463                 res = &pdev->resource[i];
464
465                 if (res->flags & IORESOURCE_IO)
466                         io_seen++;
467                 else if (res->flags & IORESOURCE_MEM)
468                         mem_seen++;
469
470                 /* If it is already assigned or the resource does
471                  * not exist, there is nothing to do.
472                  */
473                 if (res->parent != NULL || res->flags == 0UL)
474                         continue;
475
476                 /* Determine the root we allocate from. */
477                 if (res->flags & IORESOURCE_IO) {
478                         root = &pbm->io_space;
479                         min = root->start + 0x400UL;
480                         max = root->end;
481                 } else {
482                         root = &pbm->mem_space;
483                         min = root->start;
484                         max = min + 0x80000000UL;
485                 }
486
487                 size = res->end - res->start;
488                 align = size + 1;
489                 if (allocate_resource(root, res, size + 1, min, max, align, NULL, NULL) < 0) {
490                         /* uh oh */
491                         prom_printf("PCI: Failed to allocate resource %d for %s\n",
492                                     i, pci_name(pdev));
493                         prom_halt();
494                 }
495
496                 /* Update PCI config space. */
497                 pbm->parent->base_address_update(pdev, i);
498         }
499
500         /* Special case, disable the ROM.  Several devices
501          * act funny (ie. do not respond to memory space writes)
502          * when it is left enabled.  A good example are Qlogic,ISP
503          * adapters.
504          */
505         pci_read_config_dword(pdev, PCI_ROM_ADDRESS, &reg);
506         reg &= ~PCI_ROM_ADDRESS_ENABLE;
507         pci_write_config_dword(pdev, PCI_ROM_ADDRESS, reg);
508
509         /* If we saw I/O or MEM resources, enable appropriate
510          * bits in PCI command register.
511          */
512         if (io_seen || mem_seen) {
513                 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
514                 if (io_seen || has_implicit_io(pdev))
515                         cmd |= PCI_COMMAND_IO;
516                 if (mem_seen)
517                         cmd |= PCI_COMMAND_MEMORY;
518                 pci_write_config_word(pdev, PCI_COMMAND, cmd);
519         }
520
521         /* If this is a PCI bridge or an IDE controller,
522          * enable bus mastering.  In the former case also
523          * set the cache line size correctly.
524          */
525         if (((pdev->class >> 8) == PCI_CLASS_BRIDGE_PCI) ||
526             (((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) &&
527              ((pdev->class & 0x80) != 0))) {
528                 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
529                 cmd |= PCI_COMMAND_MASTER;
530                 pci_write_config_word(pdev, PCI_COMMAND, cmd);
531
532                 if ((pdev->class >> 8) == PCI_CLASS_BRIDGE_PCI)
533                         pci_write_config_byte(pdev,
534                                               PCI_CACHE_LINE_SIZE,
535                                               (64 / sizeof(u32)));
536         }
537 }
538
539 void __init pci_assign_unassigned(struct pci_pbm_info *pbm,
540                                   struct pci_bus *pbus)
541 {
542         struct pci_dev *dev;
543         struct pci_bus *bus;
544
545         list_for_each_entry(dev, &pbus->devices, bus_list)
546                 pdev_assign_unassigned(pbm, dev);
547
548         list_for_each_entry(bus, &pbus->children, node)
549                 pci_assign_unassigned(pbm, bus);
550 }
551
552 static inline unsigned int pci_slot_swivel(struct pci_pbm_info *pbm,
553                                            struct pci_dev *toplevel_pdev,
554                                            struct pci_dev *pdev,
555                                            unsigned int interrupt)
556 {
557         unsigned int ret;
558
559         if (unlikely(interrupt < 1 || interrupt > 4)) {
560                 printk("%s: Device %s interrupt value of %u is strange.\n",
561                        pbm->name, pci_name(pdev), interrupt);
562                 return interrupt;
563         }
564
565         ret = ((interrupt - 1 + (PCI_SLOT(pdev->devfn) & 3)) & 3) + 1;
566
567         if (pci_irq_verbose)
568                 printk("%s: %s IRQ Swivel %s [%x:%x] -> [%x]\n",
569                        pbm->name, pci_name(toplevel_pdev), pci_name(pdev),
570                        interrupt, PCI_SLOT(pdev->devfn), ret);
571
572         return ret;
573 }
574
575 static inline unsigned int pci_apply_intmap(struct pci_pbm_info *pbm,
576                                             struct pci_dev *toplevel_pdev,
577                                             struct pci_dev *pbus,
578                                             struct pci_dev *pdev,
579                                             unsigned int interrupt,
580                                             struct device_node **cnode)
581 {
582         struct linux_prom_pci_intmap *imap;
583         struct linux_prom_pci_intmask *imask;
584         struct pcidev_cookie *pbus_pcp = pbus->sysdata;
585         struct pcidev_cookie *pdev_pcp = pdev->sysdata;
586         struct linux_prom_pci_registers *pregs = pdev_pcp->prom_regs;
587         struct property *prop;
588         int plen, num_imap, i;
589         unsigned int hi, mid, lo, irq, orig_interrupt;
590
591         *cnode = pbus_pcp->prom_node;
592
593         prop = of_find_property(pbus_pcp->prom_node, "interrupt-map", &plen);
594         if (!prop ||
595             (plen % sizeof(struct linux_prom_pci_intmap)) != 0) {
596                 printk("%s: Device %s interrupt-map has bad len %d\n",
597                        pbm->name, pci_name(pbus), plen);
598                 goto no_intmap;
599         }
600         imap = prop->value;
601         num_imap = plen / sizeof(struct linux_prom_pci_intmap);
602
603         prop = of_find_property(pbus_pcp->prom_node, "interrupt-map-mask", &plen);
604         if (!prop ||
605             (plen % sizeof(struct linux_prom_pci_intmask)) != 0) {
606                 printk("%s: Device %s interrupt-map-mask has bad len %d\n",
607                        pbm->name, pci_name(pbus), plen);
608                 goto no_intmap;
609         }
610         imask = prop->value;
611
612         orig_interrupt = interrupt;
613
614         hi   = pregs->phys_hi & imask->phys_hi;
615         mid  = pregs->phys_mid & imask->phys_mid;
616         lo   = pregs->phys_lo & imask->phys_lo;
617         irq  = interrupt & imask->interrupt;
618
619         for (i = 0; i < num_imap; i++) {
620                 if (imap[i].phys_hi  == hi   &&
621                     imap[i].phys_mid == mid  &&
622                     imap[i].phys_lo  == lo   &&
623                     imap[i].interrupt == irq) {
624                         *cnode = of_find_node_by_phandle(imap[i].cnode);
625                         interrupt = imap[i].cinterrupt;
626                 }
627         }
628
629         if (pci_irq_verbose)
630                 printk("%s: %s MAP BUS %s DEV %s [%x] -> [%x]\n",
631                        pbm->name, pci_name(toplevel_pdev),
632                        pci_name(pbus), pci_name(pdev),
633                        orig_interrupt, interrupt);
634
635 no_intmap:
636         return interrupt;
637 }
638
639 /* For each PCI bus on the way to the root:
640  * 1) If it has an interrupt-map property, apply it.
641  * 2) Else, swivel the interrupt number based upon the PCI device number.
642  *
643  * Return the "IRQ controller" node.  If this is the PBM's device node,
644  * all interrupt translations are complete, else we should use that node's
645  * "reg" property to apply the PBM's "interrupt-{map,mask}" to the interrupt.
646  */
647 static struct device_node * __init
648 pci_intmap_match_to_root(struct pci_pbm_info *pbm,
649                          struct pci_dev *pdev,
650                          unsigned int *interrupt)
651 {
652         struct pci_dev *toplevel_pdev = pdev;
653         struct pcidev_cookie *toplevel_pcp = toplevel_pdev->sysdata;
654         struct device_node *cnode = toplevel_pcp->prom_node;
655
656         while (pdev->bus->number != pbm->pci_first_busno) {
657                 struct pci_dev *pbus = pdev->bus->self;
658                 struct pcidev_cookie *pcp = pbus->sysdata;
659                 struct property *prop;
660
661                 prop = of_find_property(pcp->prom_node, "interrupt-map", NULL);
662                 if (!prop) {
663                         *interrupt = pci_slot_swivel(pbm, toplevel_pdev,
664                                                      pdev, *interrupt);
665                         cnode = pcp->prom_node;
666                 } else {
667                         *interrupt = pci_apply_intmap(pbm, toplevel_pdev,
668                                                       pbus, pdev,
669                                                       *interrupt, &cnode);
670
671                         while (pcp->prom_node != cnode &&
672                                pbus->bus->number != pbm->pci_first_busno) {
673                                 pbus = pbus->bus->self;
674                                 pcp = pbus->sysdata;
675                         }
676                 }
677                 pdev = pbus;
678
679                 if (cnode == pbm->prom_node)
680                         break;
681         }
682
683         return cnode;
684 }
685
686 static int __init pci_intmap_match(struct pci_dev *pdev, unsigned int *interrupt)
687 {
688         struct pcidev_cookie *dev_pcp = pdev->sysdata;
689         struct pci_pbm_info *pbm = dev_pcp->pbm;
690         struct linux_prom_pci_registers *reg;
691         struct device_node *cnode;
692         struct property *prop;
693         unsigned int hi, mid, lo, irq;
694         int i, plen;
695
696         cnode = pci_intmap_match_to_root(pbm, pdev, interrupt);
697         if (cnode == pbm->prom_node)
698                 goto success;
699
700         prop = of_find_property(cnode, "reg", &plen);
701         if (!prop ||
702             (plen % sizeof(struct linux_prom_pci_registers)) != 0) {
703                 printk("%s: OBP node %s reg property has bad len %d\n",
704                        pbm->name, cnode->full_name, plen);
705                 goto fail;
706         }
707         reg = prop->value;
708
709         hi   = reg[0].phys_hi & pbm->pbm_intmask->phys_hi;
710         mid  = reg[0].phys_mid & pbm->pbm_intmask->phys_mid;
711         lo   = reg[0].phys_lo & pbm->pbm_intmask->phys_lo;
712         irq  = *interrupt & pbm->pbm_intmask->interrupt;
713
714         for (i = 0; i < pbm->num_pbm_intmap; i++) {
715                 struct linux_prom_pci_intmap *intmap;
716
717                 intmap = &pbm->pbm_intmap[i];
718
719                 if (intmap->phys_hi  == hi  &&
720                     intmap->phys_mid == mid &&
721                     intmap->phys_lo  == lo  &&
722                     intmap->interrupt == irq) {
723                         *interrupt = intmap->cinterrupt;
724                         goto success;
725                 }
726         }
727
728 fail:
729         return 0;
730
731 success:
732         if (pci_irq_verbose)
733                 printk("%s: Routing bus[%2x] slot[%2x] to INO[%02x]\n",
734                        pbm->name,
735                        pdev->bus->number, PCI_SLOT(pdev->devfn),
736                        *interrupt);
737         return 1;
738 }
739
740 static void __init pdev_fixup_irq(struct pci_dev *pdev)
741 {
742         struct pcidev_cookie *pcp = pdev->sysdata;
743         struct pci_pbm_info *pbm = pcp->pbm;
744         struct pci_controller_info *p = pbm->parent;
745         unsigned int portid = pbm->portid;
746         unsigned int prom_irq;
747         struct device_node *dp = pcp->prom_node;
748         struct property *prop;
749
750         /* If this is an empty EBUS device, sometimes OBP fails to
751          * give it a valid fully specified interrupts property.
752          * The EBUS hooked up to SunHME on PCI I/O boards of
753          * Ex000 systems is one such case.
754          *
755          * The interrupt is not important so just ignore it.
756          */
757         if (pdev->vendor == PCI_VENDOR_ID_SUN &&
758             pdev->device == PCI_DEVICE_ID_SUN_EBUS &&
759             !dp->child) {
760                 pdev->irq = 0;
761                 return;
762         }
763
764         prop = of_find_property(dp, "interrupts", NULL);
765         if (!prop) {
766                 pdev->irq = 0;
767                 return;
768         }
769         prom_irq = *(unsigned int *) prop->value;
770
771         if (tlb_type != hypervisor) {
772                 /* Fully specified already? */
773                 if (((prom_irq & PCI_IRQ_IGN) >> 6) == portid) {
774                         pdev->irq = p->irq_build(pbm, pdev, prom_irq);
775                         goto have_irq;
776                 }
777
778                 /* An onboard device? (bit 5 set) */
779                 if ((prom_irq & PCI_IRQ_INO) & 0x20) {
780                         pdev->irq = p->irq_build(pbm, pdev, (portid << 6 | prom_irq));
781                         goto have_irq;
782                 }
783         }
784
785         /* Can we find a matching entry in the interrupt-map? */
786         if (pci_intmap_match(pdev, &prom_irq)) {
787                 pdev->irq = p->irq_build(pbm, pdev, (portid << 6) | prom_irq);
788                 goto have_irq;
789         }
790
791         /* Ok, we have to do it the hard way. */
792         {
793                 unsigned int bus, slot, line;
794
795                 bus = (pbm == &pbm->parent->pbm_B) ? (1 << 4) : 0;
796
797                 /* If we have a legal interrupt property, use it as
798                  * the IRQ line.
799                  */
800                 if (prom_irq > 0 && prom_irq < 5) {
801                         line = ((prom_irq - 1) & 3);
802                 } else {
803                         u8 pci_irq_line;
804
805                         /* Else just directly consult PCI config space. */
806                         pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pci_irq_line);
807                         line = ((pci_irq_line - 1) & 3);
808                 }
809
810                 /* Now figure out the slot.
811                  *
812                  * Basically, device number zero on the top-level bus is
813                  * always the PCI host controller.  Slot 0 is then device 1.
814                  * PBM A supports two external slots (0 and 1), and PBM B
815                  * supports 4 external slots (0, 1, 2, and 3).  On-board PCI
816                  * devices are wired to device numbers outside of these
817                  * ranges. -DaveM
818                  */
819                 if (pdev->bus->number == pbm->pci_first_busno) {
820                         slot = PCI_SLOT(pdev->devfn) - pbm->pci_first_slot;
821                 } else {
822                         struct pci_dev *bus_dev;
823
824                         /* Underneath a bridge, use slot number of parent
825                          * bridge which is closest to the PBM.
826                          */
827                         bus_dev = pdev->bus->self;
828                         while (bus_dev->bus &&
829                                bus_dev->bus->number != pbm->pci_first_busno)
830                                 bus_dev = bus_dev->bus->self;
831
832                         slot = PCI_SLOT(bus_dev->devfn) - pbm->pci_first_slot;
833                 }
834                 slot = slot << 2;
835
836                 pdev->irq = p->irq_build(pbm, pdev,
837                                          ((portid << 6) & PCI_IRQ_IGN) |
838                                          (bus | slot | line));
839         }
840
841 have_irq:
842         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
843                               pdev->irq & PCI_IRQ_INO);
844 }
845
846 void __init pci_fixup_irq(struct pci_pbm_info *pbm,
847                           struct pci_bus *pbus)
848 {
849         struct pci_dev *dev;
850         struct pci_bus *bus;
851
852         list_for_each_entry(dev, &pbus->devices, bus_list)
853                 pdev_fixup_irq(dev);
854
855         list_for_each_entry(bus, &pbus->children, node)
856                 pci_fixup_irq(pbm, bus);
857 }
858
859 static void pdev_setup_busmastering(struct pci_dev *pdev, int is_66mhz)
860 {
861         u16 cmd;
862         u8 hdr_type, min_gnt, ltimer;
863
864         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
865         cmd |= PCI_COMMAND_MASTER;
866         pci_write_config_word(pdev, PCI_COMMAND, cmd);
867
868         /* Read it back, if the mastering bit did not
869          * get set, the device does not support bus
870          * mastering so we have nothing to do here.
871          */
872         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
873         if ((cmd & PCI_COMMAND_MASTER) == 0)
874                 return;
875
876         /* Set correct cache line size, 64-byte on all
877          * Sparc64 PCI systems.  Note that the value is
878          * measured in 32-bit words.
879          */
880         pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
881                               64 / sizeof(u32));
882
883         pci_read_config_byte(pdev, PCI_HEADER_TYPE, &hdr_type);
884         hdr_type &= ~0x80;
885         if (hdr_type != PCI_HEADER_TYPE_NORMAL)
886                 return;
887
888         /* If the latency timer is already programmed with a non-zero
889          * value, assume whoever set it (OBP or whoever) knows what
890          * they are doing.
891          */
892         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ltimer);
893         if (ltimer != 0)
894                 return;
895
896         /* XXX Since I'm tipping off the min grant value to
897          * XXX choose a suitable latency timer value, I also
898          * XXX considered making use of the max latency value
899          * XXX as well.  Unfortunately I've seen too many bogusly
900          * XXX low settings for it to the point where it lacks
901          * XXX any usefulness.  In one case, an ethernet card
902          * XXX claimed a min grant of 10 and a max latency of 5.
903          * XXX Now, if I had two such cards on the same bus I
904          * XXX could not set the desired burst period (calculated
905          * XXX from min grant) without violating the max latency
906          * XXX bound.  Duh...
907          * XXX
908          * XXX I blame dumb PC bios implementors for stuff like
909          * XXX this, most of them don't even try to do something
910          * XXX sensible with latency timer values and just set some
911          * XXX default value (usually 32) into every device.
912          */
913
914         pci_read_config_byte(pdev, PCI_MIN_GNT, &min_gnt);
915
916         if (min_gnt == 0) {
917                 /* If no min_gnt setting then use a default
918                  * value.
919                  */
920                 if (is_66mhz)
921                         ltimer = 16;
922                 else
923                         ltimer = 32;
924         } else {
925                 int shift_factor;
926
927                 if (is_66mhz)
928                         shift_factor = 2;
929                 else
930                         shift_factor = 3;
931
932                 /* Use a default value when the min_gnt value
933                  * is erroneously high.
934                  */
935                 if (((unsigned int) min_gnt << shift_factor) > 512 ||
936                     ((min_gnt << shift_factor) & 0xff) == 0) {
937                         ltimer = 8 << shift_factor;
938                 } else {
939                         ltimer = min_gnt << shift_factor;
940                 }
941         }
942
943         pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ltimer);
944 }
945
946 void pci_determine_66mhz_disposition(struct pci_pbm_info *pbm,
947                                      struct pci_bus *pbus)
948 {
949         struct pci_dev *pdev;
950         int all_are_66mhz;
951         u16 status;
952
953         if (pbm->is_66mhz_capable == 0) {
954                 all_are_66mhz = 0;
955                 goto out;
956         }
957
958         all_are_66mhz = 1;
959         list_for_each_entry(pdev, &pbus->devices, bus_list) {
960                 pci_read_config_word(pdev, PCI_STATUS, &status);
961                 if (!(status & PCI_STATUS_66MHZ)) {
962                         all_are_66mhz = 0;
963                         break;
964                 }
965         }
966 out:
967         pbm->all_devs_66mhz = all_are_66mhz;
968
969         printk("PCI%d(PBM%c): Bus running at %dMHz\n",
970                pbm->parent->index,
971                (pbm == &pbm->parent->pbm_A) ? 'A' : 'B',
972                (all_are_66mhz ? 66 : 33));
973 }
974
975 void pci_setup_busmastering(struct pci_pbm_info *pbm,
976                             struct pci_bus *pbus)
977 {
978         struct pci_dev *dev;
979         struct pci_bus *bus;
980         int is_66mhz;
981
982         is_66mhz = pbm->is_66mhz_capable && pbm->all_devs_66mhz;
983
984         list_for_each_entry(dev, &pbus->devices, bus_list)
985                 pdev_setup_busmastering(dev, is_66mhz);
986
987         list_for_each_entry(bus, &pbus->children, node)
988                 pci_setup_busmastering(pbm, bus);
989 }
990
991 void pci_register_legacy_regions(struct resource *io_res,
992                                  struct resource *mem_res)
993 {
994         struct resource *p;
995
996         /* VGA Video RAM. */
997         p = kzalloc(sizeof(*p), GFP_KERNEL);
998         if (!p)
999                 return;
1000
1001         p->name = "Video RAM area";
1002         p->start = mem_res->start + 0xa0000UL;
1003         p->end = p->start + 0x1ffffUL;
1004         p->flags = IORESOURCE_BUSY;
1005         request_resource(mem_res, p);
1006
1007         p = kzalloc(sizeof(*p), GFP_KERNEL);
1008         if (!p)
1009                 return;
1010
1011         p->name = "System ROM";
1012         p->start = mem_res->start + 0xf0000UL;
1013         p->end = p->start + 0xffffUL;
1014         p->flags = IORESOURCE_BUSY;
1015         request_resource(mem_res, p);
1016
1017         p = kzalloc(sizeof(*p), GFP_KERNEL);
1018         if (!p)
1019                 return;
1020
1021         p->name = "Video ROM";
1022         p->start = mem_res->start + 0xc0000UL;
1023         p->end = p->start + 0x7fffUL;
1024         p->flags = IORESOURCE_BUSY;
1025         request_resource(mem_res, p);
1026 }
1027
1028 /* Generic helper routines for PCI error reporting. */
1029 void pci_scan_for_target_abort(struct pci_controller_info *p,
1030                                struct pci_pbm_info *pbm,
1031                                struct pci_bus *pbus)
1032 {
1033         struct pci_dev *pdev;
1034         struct pci_bus *bus;
1035
1036         list_for_each_entry(pdev, &pbus->devices, bus_list) {
1037                 u16 status, error_bits;
1038
1039                 pci_read_config_word(pdev, PCI_STATUS, &status);
1040                 error_bits =
1041                         (status & (PCI_STATUS_SIG_TARGET_ABORT |
1042                                    PCI_STATUS_REC_TARGET_ABORT));
1043                 if (error_bits) {
1044                         pci_write_config_word(pdev, PCI_STATUS, error_bits);
1045                         printk("PCI%d(PBM%c): Device [%s] saw Target Abort [%016x]\n",
1046                                p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
1047                                pci_name(pdev), status);
1048                 }
1049         }
1050
1051         list_for_each_entry(bus, &pbus->children, node)
1052                 pci_scan_for_target_abort(p, pbm, bus);
1053 }
1054
1055 void pci_scan_for_master_abort(struct pci_controller_info *p,
1056                                struct pci_pbm_info *pbm,
1057                                struct pci_bus *pbus)
1058 {
1059         struct pci_dev *pdev;
1060         struct pci_bus *bus;
1061
1062         list_for_each_entry(pdev, &pbus->devices, bus_list) {
1063                 u16 status, error_bits;
1064
1065                 pci_read_config_word(pdev, PCI_STATUS, &status);
1066                 error_bits =
1067                         (status & (PCI_STATUS_REC_MASTER_ABORT));
1068                 if (error_bits) {
1069                         pci_write_config_word(pdev, PCI_STATUS, error_bits);
1070                         printk("PCI%d(PBM%c): Device [%s] received Master Abort [%016x]\n",
1071                                p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
1072                                pci_name(pdev), status);
1073                 }
1074         }
1075
1076         list_for_each_entry(bus, &pbus->children, node)
1077                 pci_scan_for_master_abort(p, pbm, bus);
1078 }
1079
1080 void pci_scan_for_parity_error(struct pci_controller_info *p,
1081                                struct pci_pbm_info *pbm,
1082                                struct pci_bus *pbus)
1083 {
1084         struct pci_dev *pdev;
1085         struct pci_bus *bus;
1086
1087         list_for_each_entry(pdev, &pbus->devices, bus_list) {
1088                 u16 status, error_bits;
1089
1090                 pci_read_config_word(pdev, PCI_STATUS, &status);
1091                 error_bits =
1092                         (status & (PCI_STATUS_PARITY |
1093                                    PCI_STATUS_DETECTED_PARITY));
1094                 if (error_bits) {
1095                         pci_write_config_word(pdev, PCI_STATUS, error_bits);
1096                         printk("PCI%d(PBM%c): Device [%s] saw Parity Error [%016x]\n",
1097                                p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
1098                                pci_name(pdev), status);
1099                 }
1100         }
1101
1102         list_for_each_entry(bus, &pbus->children, node)
1103                 pci_scan_for_parity_error(p, pbm, bus);
1104 }