Adrian Bunk | 88278ca | 2008-05-19 16:53:02 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * ebus.c: PCI to EBus bridge device. |
| 3 | * |
| 4 | * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be) |
| 5 | * |
| 6 | * Adopted for sparc by V. Roganov and G. Raiko. |
| 7 | * Fixes for different platforms by Pete Zaitcev. |
| 8 | */ |
| 9 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | #include <linux/kernel.h> |
| 11 | #include <linux/types.h> |
| 12 | #include <linux/init.h> |
| 13 | #include <linux/slab.h> |
| 14 | #include <linux/string.h> |
| 15 | |
| 16 | #include <asm/system.h> |
| 17 | #include <asm/page.h> |
| 18 | #include <asm/pbm.h> |
| 19 | #include <asm/ebus.h> |
| 20 | #include <asm/io.h> |
| 21 | #include <asm/oplib.h> |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 22 | #include <asm/prom.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #include <asm/bpp.h> |
| 24 | |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 25 | struct linux_ebus *ebus_chain = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | |
| 27 | /* We are together with pcic.c under CONFIG_PCI. */ |
Stephen Rothwell | ee5ac9d | 2007-04-26 00:03:53 -0700 | [diff] [blame] | 28 | extern unsigned int pcic_pin_to_irq(unsigned int, const char *name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | |
| 30 | /* |
| 31 | * IRQ Blacklist |
| 32 | * Here we list PROMs and systems that are known to supply crap as IRQ numbers. |
| 33 | */ |
| 34 | struct ebus_device_irq { |
| 35 | char *name; |
| 36 | unsigned int pin; |
| 37 | }; |
| 38 | |
| 39 | struct ebus_system_entry { |
| 40 | char *esname; |
| 41 | struct ebus_device_irq *ipt; |
| 42 | }; |
| 43 | |
| 44 | static struct ebus_device_irq je1_1[] = { |
| 45 | { "8042", 3 }, |
| 46 | { "SUNW,CS4231", 0 }, |
| 47 | { "parallel", 0 }, |
| 48 | { "se", 2 }, |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 49 | { NULL, 0 } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | }; |
| 51 | |
| 52 | /* |
| 53 | * Gleb's JE1 supplied reasonable pin numbers, but mine did not (OBP 2.32). |
| 54 | * Blacklist the sucker... Note that Gleb's system will work. |
| 55 | */ |
| 56 | static struct ebus_system_entry ebus_blacklist[] = { |
| 57 | { "SUNW,JavaEngine1", je1_1 }, |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 58 | { NULL, NULL } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | }; |
| 60 | |
| 61 | static struct ebus_device_irq *ebus_blackp = NULL; |
| 62 | |
| 63 | /* |
| 64 | */ |
| 65 | static inline unsigned long ebus_alloc(size_t size) |
| 66 | { |
| 67 | return (unsigned long)kmalloc(size, GFP_ATOMIC); |
| 68 | } |
| 69 | |
| 70 | /* |
| 71 | */ |
Stephen Rothwell | ee5ac9d | 2007-04-26 00:03:53 -0700 | [diff] [blame] | 72 | int __init ebus_blacklist_irq(const char *name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | { |
| 74 | struct ebus_device_irq *dp; |
| 75 | |
| 76 | if ((dp = ebus_blackp) != NULL) { |
| 77 | for (; dp->name != NULL; dp++) { |
| 78 | if (strcmp(name, dp->name) == 0) { |
| 79 | return pcic_pin_to_irq(dp->pin, name); |
| 80 | } |
| 81 | } |
| 82 | } |
| 83 | return 0; |
| 84 | } |
| 85 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 86 | void __init fill_ebus_child(struct device_node *dp, |
| 87 | struct linux_ebus_child *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | { |
Stephen Rothwell | 8271f04 | 2007-03-29 00:47:23 -0700 | [diff] [blame] | 89 | const int *regs; |
| 90 | const int *irqs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | int i, len; |
| 92 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 93 | dev->prom_node = dp; |
| 94 | regs = of_get_property(dp, "reg", &len); |
| 95 | if (!regs) |
| 96 | len = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | dev->num_addrs = len / sizeof(regs[0]); |
| 98 | |
| 99 | for (i = 0; i < dev->num_addrs; i++) { |
| 100 | if (regs[i] >= dev->parent->num_addrs) { |
| 101 | prom_printf("UGH: property for %s was %d, need < %d\n", |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 102 | dev->prom_node->name, len, |
| 103 | dev->parent->num_addrs); |
Harvey Harrison | 74074de | 2008-03-03 11:41:51 -0800 | [diff] [blame] | 104 | panic(__func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | } |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 106 | |
| 107 | /* XXX resource */ |
| 108 | dev->resource[i].start = |
| 109 | dev->parent->resource[regs[i]].start; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | } |
| 111 | |
| 112 | for (i = 0; i < PROMINTR_MAX; i++) |
| 113 | dev->irqs[i] = PCI_IRQ_NONE; |
| 114 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 115 | if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | dev->num_irqs = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | } else { |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 118 | irqs = of_get_property(dp, "interrupts", &len); |
| 119 | if (!irqs) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | dev->num_irqs = 0; |
| 121 | dev->irqs[0] = 0; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 122 | if (dev->parent->num_irqs != 0) { |
| 123 | dev->num_irqs = 1; |
| 124 | dev->irqs[0] = dev->parent->irqs[0]; |
| 125 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | } else { |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 127 | dev->num_irqs = len / sizeof(irqs[0]); |
| 128 | if (irqs[0] == 0 || irqs[0] >= 8) { |
| 129 | /* |
| 130 | * XXX Zero is a valid pin number... |
| 131 | * This works as long as Ebus is not wired |
| 132 | * to INTA#. |
| 133 | */ |
| 134 | printk("EBUS: %s got bad irq %d from PROM\n", |
| 135 | dev->prom_node->name, irqs[0]); |
| 136 | dev->num_irqs = 0; |
| 137 | dev->irqs[0] = 0; |
| 138 | } else { |
| 139 | dev->irqs[0] = |
| 140 | pcic_pin_to_irq(irqs[0], |
| 141 | dev->prom_node->name); |
| 142 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | } |
| 144 | } |
| 145 | } |
| 146 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 147 | void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | { |
Stephen Rothwell | 8271f04 | 2007-03-29 00:47:23 -0700 | [diff] [blame] | 149 | const struct linux_prom_registers *regs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | struct linux_ebus_child *child; |
David S. Miller | 3d6e470 | 2007-07-18 22:03:25 -0700 | [diff] [blame] | 151 | struct dev_archdata *sd; |
Stephen Rothwell | 8271f04 | 2007-03-29 00:47:23 -0700 | [diff] [blame] | 152 | const int *irqs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | int i, n, len; |
| 154 | unsigned long baseaddr; |
| 155 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 156 | dev->prom_node = dp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 158 | regs = of_get_property(dp, "reg", &len); |
David S. Miller | 9c908f9 | 2007-09-27 13:09:28 -0700 | [diff] [blame] | 159 | if (!regs) |
| 160 | len = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | if (len % sizeof(struct linux_prom_registers)) { |
| 162 | prom_printf("UGH: proplen for %s was %d, need multiple of %d\n", |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 163 | dev->prom_node->name, len, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | (int)sizeof(struct linux_prom_registers)); |
Harvey Harrison | 74074de | 2008-03-03 11:41:51 -0800 | [diff] [blame] | 165 | panic(__func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | } |
| 167 | dev->num_addrs = len / sizeof(struct linux_prom_registers); |
| 168 | |
| 169 | for (i = 0; i < dev->num_addrs; i++) { |
| 170 | /* |
| 171 | * XXX Collect JE-1 PROM |
| 172 | * |
| 173 | * Example - JS-E with 3.11: |
| 174 | * /ebus |
| 175 | * regs |
| 176 | * 0x00000000, 0x0, 0x00000000, 0x0, 0x00000000, |
| 177 | * 0x82000010, 0x0, 0xf0000000, 0x0, 0x01000000, |
| 178 | * 0x82000014, 0x0, 0x38800000, 0x0, 0x00800000, |
| 179 | * ranges |
| 180 | * 0x00, 0x00000000, 0x02000010, 0x0, 0x0, 0x01000000, |
| 181 | * 0x01, 0x01000000, 0x02000014, 0x0, 0x0, 0x00800000, |
| 182 | * /ebus/8042 |
| 183 | * regs |
| 184 | * 0x00000001, 0x00300060, 0x00000008, |
| 185 | * 0x00000001, 0x00300060, 0x00000008, |
| 186 | */ |
| 187 | n = regs[i].which_io; |
| 188 | if (n >= 4) { |
| 189 | /* XXX This is copied from old JE-1 by Gleb. */ |
| 190 | n = (regs[i].which_io - 0x10) >> 2; |
| 191 | } else { |
| 192 | ; |
| 193 | } |
| 194 | |
| 195 | /* |
| 196 | * XXX Now as we have regions, why don't we make an on-demand allocation... |
| 197 | */ |
| 198 | dev->resource[i].start = 0; |
| 199 | if ((baseaddr = dev->bus->self->resource[n].start + |
| 200 | regs[i].phys_addr) != 0) { |
| 201 | /* dev->resource[i].name = dev->prom_name; */ |
| 202 | if ((baseaddr = (unsigned long) ioremap(baseaddr, |
| 203 | regs[i].reg_size)) == 0) { |
| 204 | panic("ebus: unable to remap dev %s", |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 205 | dev->prom_node->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | } |
| 207 | } |
| 208 | dev->resource[i].start = baseaddr; /* XXX Unaligned */ |
| 209 | } |
| 210 | |
| 211 | for (i = 0; i < PROMINTR_MAX; i++) |
| 212 | dev->irqs[i] = PCI_IRQ_NONE; |
| 213 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 214 | if ((dev->irqs[0] = ebus_blacklist_irq(dev->prom_node->name)) != 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | dev->num_irqs = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | } else { |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 217 | irqs = of_get_property(dp, "interrupts", &len); |
| 218 | if (!irqs) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | dev->num_irqs = 0; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 220 | if ((dev->irqs[0] = dev->bus->self->irq) != 0) { |
| 221 | dev->num_irqs = 1; |
| 222 | /* P3 */ /* printk("EBUS: child %s irq %d from parent\n", dev->prom_name, dev->irqs[0]); */ |
| 223 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | } else { |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 225 | dev->num_irqs = 1; /* dev->num_irqs = len / sizeof(irqs[0]); */ |
| 226 | if (irqs[0] == 0 || irqs[0] >= 8) { |
| 227 | /* See above for the parent. XXX */ |
| 228 | printk("EBUS: %s got bad irq %d from PROM\n", |
| 229 | dev->prom_node->name, irqs[0]); |
| 230 | dev->num_irqs = 0; |
| 231 | dev->irqs[0] = 0; |
| 232 | } else { |
| 233 | dev->irqs[0] = |
| 234 | pcic_pin_to_irq(irqs[0], |
| 235 | dev->prom_node->name); |
| 236 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | } |
| 238 | } |
| 239 | |
David S. Miller | 3d6e470 | 2007-07-18 22:03:25 -0700 | [diff] [blame] | 240 | sd = &dev->ofdev.dev.archdata; |
| 241 | sd->prom_node = dp; |
| 242 | sd->op = &dev->ofdev; |
Robert Reif | 3ac4c94 | 2007-08-10 15:52:06 -0700 | [diff] [blame] | 243 | sd->iommu = dev->bus->ofdev.dev.parent->archdata.iommu; |
David S. Miller | 3d6e470 | 2007-07-18 22:03:25 -0700 | [diff] [blame] | 244 | |
David S. Miller | fd53143 | 2006-06-23 15:55:17 -0700 | [diff] [blame] | 245 | dev->ofdev.node = dp; |
| 246 | dev->ofdev.dev.parent = &dev->bus->ofdev.dev; |
| 247 | dev->ofdev.dev.bus = &ebus_bus_type; |
David S. Miller | f5ef9d1 | 2006-10-27 01:03:31 -0700 | [diff] [blame] | 248 | sprintf(dev->ofdev.dev.bus_id, "ebus[%08x]", dp->node); |
David S. Miller | fd53143 | 2006-06-23 15:55:17 -0700 | [diff] [blame] | 249 | |
| 250 | /* Register with core */ |
| 251 | if (of_device_register(&dev->ofdev) != 0) |
| 252 | printk(KERN_DEBUG "ebus: device registration error for %s!\n", |
David S. Miller | f5ef9d1 | 2006-10-27 01:03:31 -0700 | [diff] [blame] | 253 | dp->path_component_name); |
David S. Miller | fd53143 | 2006-06-23 15:55:17 -0700 | [diff] [blame] | 254 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 255 | if ((dp = dp->child) != NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | dev->children = (struct linux_ebus_child *) |
| 257 | ebus_alloc(sizeof(struct linux_ebus_child)); |
| 258 | |
| 259 | child = dev->children; |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 260 | child->next = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | child->parent = dev; |
| 262 | child->bus = dev->bus; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 263 | fill_ebus_child(dp, child); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 265 | while ((dp = dp->sibling) != NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | child->next = (struct linux_ebus_child *) |
| 267 | ebus_alloc(sizeof(struct linux_ebus_child)); |
| 268 | |
| 269 | child = child->next; |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 270 | child->next = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | child->parent = dev; |
| 272 | child->bus = dev->bus; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 273 | fill_ebus_child(dp, child); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | } |
| 275 | } |
| 276 | } |
| 277 | |
| 278 | void __init ebus_init(void) |
| 279 | { |
Stephen Rothwell | 8271f04 | 2007-03-29 00:47:23 -0700 | [diff] [blame] | 280 | const struct linux_prom_pci_registers *regs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | struct linux_pbm_info *pbm; |
| 282 | struct linux_ebus_device *dev; |
| 283 | struct linux_ebus *ebus; |
| 284 | struct ebus_system_entry *sp; |
| 285 | struct pci_dev *pdev; |
| 286 | struct pcidev_cookie *cookie; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 287 | struct device_node *dp; |
Al Viro | cc9bd99 | 2006-09-23 01:18:41 +0100 | [diff] [blame] | 288 | struct resource *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | unsigned short pci_command; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 290 | int len, reg, nreg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | int num_ebus = 0; |
| 292 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 293 | dp = of_find_node_by_path("/"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | for (sp = ebus_blacklist; sp->esname != NULL; sp++) { |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 295 | if (strcmp(dp->name, sp->esname) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | ebus_blackp = sp->ipt; |
| 297 | break; |
| 298 | } |
| 299 | } |
| 300 | |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 301 | pdev = pci_get_device(PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_EBUS, NULL); |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 302 | if (!pdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | return; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 304 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | cookie = pdev->sysdata; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 306 | dp = cookie->prom_node; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | |
| 308 | ebus_chain = ebus = (struct linux_ebus *) |
| 309 | ebus_alloc(sizeof(struct linux_ebus)); |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 310 | ebus->next = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 312 | while (dp) { |
| 313 | struct device_node *nd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 314 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 315 | ebus->prom_node = dp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | ebus->self = pdev; |
| 317 | ebus->parent = pbm = cookie->pbm; |
| 318 | |
| 319 | /* Enable BUS Master. */ |
| 320 | pci_read_config_word(pdev, PCI_COMMAND, &pci_command); |
| 321 | pci_command |= PCI_COMMAND_MASTER; |
| 322 | pci_write_config_word(pdev, PCI_COMMAND, pci_command); |
| 323 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 324 | regs = of_get_property(dp, "reg", &len); |
| 325 | if (!regs) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | prom_printf("%s: can't find reg property\n", |
Harvey Harrison | 74074de | 2008-03-03 11:41:51 -0800 | [diff] [blame] | 327 | __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | prom_halt(); |
| 329 | } |
| 330 | nreg = len / sizeof(struct linux_prom_pci_registers); |
| 331 | |
Al Viro | cc9bd99 | 2006-09-23 01:18:41 +0100 | [diff] [blame] | 332 | p = &ebus->self->resource[0]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | for (reg = 0; reg < nreg; reg++) { |
| 334 | if (!(regs[reg].which_io & 0x03000000)) |
| 335 | continue; |
| 336 | |
Al Viro | cc9bd99 | 2006-09-23 01:18:41 +0100 | [diff] [blame] | 337 | (p++)->start = regs[reg].phys_lo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | } |
| 339 | |
David S. Miller | fd53143 | 2006-06-23 15:55:17 -0700 | [diff] [blame] | 340 | ebus->ofdev.node = dp; |
| 341 | ebus->ofdev.dev.parent = &pdev->dev; |
| 342 | ebus->ofdev.dev.bus = &ebus_bus_type; |
David S. Miller | f5ef9d1 | 2006-10-27 01:03:31 -0700 | [diff] [blame] | 343 | sprintf(ebus->ofdev.dev.bus_id, "ebus%d", num_ebus); |
David S. Miller | fd53143 | 2006-06-23 15:55:17 -0700 | [diff] [blame] | 344 | |
| 345 | /* Register with core */ |
| 346 | if (of_device_register(&ebus->ofdev) != 0) |
| 347 | printk(KERN_DEBUG "ebus: device registration error for %s!\n", |
David S. Miller | f5ef9d1 | 2006-10-27 01:03:31 -0700 | [diff] [blame] | 348 | dp->path_component_name); |
David S. Miller | fd53143 | 2006-06-23 15:55:17 -0700 | [diff] [blame] | 349 | |
| 350 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 351 | nd = dp->child; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | if (!nd) |
| 353 | goto next_ebus; |
| 354 | |
| 355 | ebus->devices = (struct linux_ebus_device *) |
| 356 | ebus_alloc(sizeof(struct linux_ebus_device)); |
| 357 | |
| 358 | dev = ebus->devices; |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 359 | dev->next = NULL; |
| 360 | dev->children = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | dev->bus = ebus; |
| 362 | fill_ebus_device(nd, dev); |
| 363 | |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 364 | while ((nd = nd->sibling) != NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | dev->next = (struct linux_ebus_device *) |
| 366 | ebus_alloc(sizeof(struct linux_ebus_device)); |
| 367 | |
| 368 | dev = dev->next; |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 369 | dev->next = NULL; |
| 370 | dev->children = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | dev->bus = ebus; |
| 372 | fill_ebus_device(nd, dev); |
| 373 | } |
| 374 | |
| 375 | next_ebus: |
| 376 | pdev = pci_get_device(PCI_VENDOR_ID_SUN, |
| 377 | PCI_DEVICE_ID_SUN_EBUS, pdev); |
| 378 | if (!pdev) |
| 379 | break; |
| 380 | |
| 381 | cookie = pdev->sysdata; |
David S. Miller | 942a6bd | 2006-06-23 15:53:31 -0700 | [diff] [blame] | 382 | dp = cookie->prom_node; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | |
| 384 | ebus->next = (struct linux_ebus *) |
| 385 | ebus_alloc(sizeof(struct linux_ebus)); |
| 386 | ebus = ebus->next; |
Al Viro | e4fe342f | 2005-12-04 18:48:45 -0500 | [diff] [blame] | 387 | ebus->next = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | ++num_ebus; |
| 389 | } |
| 390 | if (pdev) |
| 391 | pci_dev_put(pdev); |
| 392 | } |