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