#include <linux/kernel.h> #include <linux/init.h> #include <linux/pci.h> #include <linux/slab.h> #include <asm/oplib.h> #include <asm/isa.h> struct sparc_isa_bridge *isa_chain; static void __init fatal_err(const char *reason) { prom_printf("ISA: fatal error, %s.\n", reason); } static void __init report_dev(struct sparc_isa_device *isa_dev, int child) { if (child) printk(" (%s)", isa_dev->prom_name); else printk(" [%s", isa_dev->prom_name); } static void __init isa_dev_get_resource(struct sparc_isa_device *isa_dev, struct linux_prom_registers *pregs, int pregs_size) { unsigned long base, len; int prop_len; prop_len = prom_getproperty(isa_dev->prom_node, "reg", (char *) pregs, pregs_size); if (prop_len <= 0) return; /* Only the first one is interesting. */ len = pregs[0].reg_size; base = (((unsigned long)pregs[0].which_io << 32) | (unsigned long)pregs[0].phys_addr); base += isa_dev->bus->parent->io_space.start; isa_dev->resource.start = base; isa_dev->resource.end = (base + len - 1UL); isa_dev->resource.flags = IORESOURCE_IO; isa_dev->resource.name = isa_dev->prom_name; request_resource(&isa_dev->bus->parent->io_space, &isa_dev->resource); } /* I can't believe they didn't put a real INO in the isa device * interrupts property. The whole point of the OBP properties * is to shield the kernel from IRQ routing details. * * The P1275 standard for ISA devices seems to also have been * totally ignored. * * On later systems, an interrupt-map and interrupt-map-mask scheme * akin to EBUS is used. */ static struct { int obp_irq; int pci_ino; } grover_irq_table[] = { { 1, 0x00 }, /* dma, unknown ino at this point */ { 2, 0x27 }, /* floppy */ { 3, 0x22 }, /* parallel */ { 4, 0x2b }, /* serial */ { 5, 0x25 }, /* acpi power management */ { 0, 0x00 } /* end of table */ }; static int __init isa_dev_get_irq_using_imap(struct sparc_isa_device *isa_dev, struct sparc_isa_bridge *isa_br, int *interrupt, struct linux_prom_registers *pregs) { unsigned int hi, lo, irq; int i; hi = pregs->which_io & isa_br->isa_intmask.phys_hi; lo = pregs->phys_addr & isa_br->isa_intmask.phys_lo; irq = *interrupt & isa_br->isa_intmask.interrupt; for (i = 0; i < isa_br->num_isa_intmap; i++) { if ((isa_br->isa_intmap[i].phys_hi == hi) && (isa_br->isa_intmap[i].phys_lo == lo) && (isa_br->isa_intmap[i].interrupt == irq)) { *interrupt = isa_br->isa_intmap[i].cinterrupt; return 0; } } return -1; } static void __init isa_dev_get_irq(struct sparc_isa_device *isa_dev, struct linux_prom_registers *pregs) { int irq_prop; irq_prop = prom_getintdefault(isa_dev->prom_node, "interrupts", -1); if (irq_prop <= 0) { goto no_irq; } else { struct pci_controller_info *pcic; struct pci_pbm_info *pbm; int i; if (isa_dev->bus->num_isa_intmap) { if (!isa_dev_get_irq_using_imap(isa_dev, isa_dev->bus, &irq_prop, pregs)) goto route_irq; } for (i = 0; grover_irq_table[i].obp_irq != 0; i++) { if (grover_irq_table[i].obp_irq == irq_prop) { int ino = grover_irq_table[i].pci_ino; if (ino == 0) goto no_irq; irq_prop = ino; goto route_irq; } } goto no_irq; route_irq: pbm = isa_dev->bus->parent; pcic = pbm->parent; isa_dev->irq = pcic->irq_build(pbm, NULL, irq_prop); return; } no_irq: isa_dev->irq = PCI_IRQ_NONE; } static void __init isa_fill_children(struct sparc_isa_device *parent_isa_dev) { int node = prom_getchild(parent_isa_dev->prom_node); if (node == 0) return; printk(" ->"); while (node != 0) { struct linux_prom_registers regs[PROMREG_MAX]; struct sparc_isa_device *isa_dev; int prop_len; isa_dev = kmalloc(sizeof(*isa_dev), GFP_KERNEL); if (!isa_dev) { fatal_err("cannot allocate child isa_dev"); prom_halt(); } memset(isa_dev, 0, sizeof(*isa_dev)); /* Link it in to parent. */ isa_dev->next = parent_isa_dev->child; parent_isa_dev->child = isa_dev; isa_dev->bus = parent_isa_dev->bus; isa_dev->prom_node = node; prop_len = prom_getproperty(node, "name", (char *) isa_dev->prom_name, sizeof(isa_dev->prom_name)); if (prop_len <= 0) { fatal_err("cannot get child isa_dev OBP node name"); prom_halt(); } prop_len = prom_getproperty(node, "compatible", (char *) isa_dev->compatible, sizeof(isa_dev->compatible)); /* Not having this is OK. */ if (prop_len <= 0) isa_dev->compatible[0] = '\0'; isa_dev_get_resource(isa_dev, regs, sizeof(regs)); isa_dev_get_irq(isa_dev, regs); report_dev(isa_dev, 1); node = prom_getsibling(node); } } static void __init isa_fill_devices(struct sparc_isa_bridge *isa_br) { int node = prom_getchild(isa_br->prom_node); while (node != 0) { struct linux_prom_registers regs[PROMREG_MAX]; struct sparc_isa_device *isa_dev; int prop_len; isa_dev = kmalloc(sizeof(*isa_dev), GFP_KERNEL); if (!isa_dev) { fatal_err("cannot allocate isa_dev"); prom_halt(); } memset(isa_dev, 0, sizeof(*isa_dev)); /* Link it in. */ isa_dev->next = NULL; if (isa_br->devices == NULL) { isa_br->devices = isa_dev; } else { struct sparc_isa_device *tmp = isa_br->devices; while (tmp->next) tmp = tmp->next; tmp->next = isa_dev; } isa_dev->bus = isa_br; isa_dev->prom_node = node; prop_len = prom_getproperty(node, "name", (char *) isa_dev->prom_name, sizeof(isa_dev->prom_name)); if (prop_len <= 0) { fatal_err("cannot get isa_dev OBP node name"); prom_halt(); } prop_len = prom_getproperty(node, "compatible", (char *) isa_dev->compatible, sizeof(isa_dev->compatible)); /* Not having this is OK. */ if (prop_len <= 0) isa_dev->compatible[0] = '\0'; isa_dev_get_resource(isa_dev, regs, sizeof(regs)); isa_dev_get_irq(isa_dev, regs); report_dev(isa_dev, 0); isa_fill_children(isa_dev); printk("]"); node = prom_getsibling(node); } } void __init isa_init(void) { struct pci_dev *pdev; unsigned short vendor, device; int index = 0; vendor = PCI_VENDOR_ID_AL; device = PCI_DEVICE_ID_AL_M1533; pdev = NULL; while ((pdev = pci_get_device(vendor, device, pdev)) != NULL) { struct pcidev_cookie *pdev_cookie; struct pci_pbm_info *pbm; struct sparc_isa_bridge *isa_br; int prop_len; pdev_cookie = pdev->sysdata; if (!pdev_cookie) { printk("ISA: Warning, ISA bridge ignored due to " "lack of OBP data.\n"); continue; } pbm = pdev_cookie->pbm; isa_br = kmalloc(sizeof(*isa_br), GFP_KERNEL); if (!isa_br) { fatal_err("cannot allocate sparc_isa_bridge"); prom_halt(); } memset(isa_br, 0, sizeof(*isa_br)); /* Link it in. */ isa_br->next = isa_chain; isa_chain = isa_br; isa_br->parent = pbm; isa_br->self = pdev; isa_br->index = index++; isa_br->prom_node = pdev_cookie->prom_node; strncpy(isa_br->prom_name, pdev_cookie->prom_name, sizeof(isa_br->prom_name)); prop_len = prom_getproperty(isa_br->prom_node, "ranges", (char *) isa_br->isa_ranges, sizeof(isa_br->isa_ranges)); if (prop_len <= 0) isa_br->num_isa_ranges = 0; else isa_br->num_isa_ranges = (prop_len / sizeof(struct linux_prom_isa_ranges)); prop_len = prom_getproperty(isa_br->prom_node, "interrupt-map", (char *) isa_br->isa_intmap, sizeof(isa_br->isa_intmap)); if (prop_len <= 0) isa_br->num_isa_intmap = 0; else isa_br->num_isa_intmap = (prop_len / sizeof(struct linux_prom_isa_intmap)); prop_len = prom_getproperty(isa_br->prom_node, "interrupt-map-mask", (char *) &(isa_br->isa_intmask), sizeof(isa_br->isa_intmask)); printk("isa%d:", isa_br->index); isa_fill_devices(isa_br); printk("\n"); } }