1 #include <linux/string.h> 2 #include <linux/kernel.h> 3 #include <linux/of.h> 4 #include <linux/init.h> 5 #include <linux/module.h> 6 #include <linux/mod_devicetable.h> 7 #include <linux/slab.h> 8 #include <linux/errno.h> 9 #include <linux/irq.h> 10 #include <linux/of_device.h> 11 #include <linux/of_platform.h> 12 13 #include "of_device_common.h" 14 15 /* 16 * PCI bus specific translator 17 */ 18 19 static int of_bus_pci_match(struct device_node *np) 20 { 21 if (!strcmp(np->type, "pci") || !strcmp(np->type, "pciex")) { 22 /* Do not do PCI specific frobbing if the 23 * PCI bridge lacks a ranges property. We 24 * want to pass it through up to the next 25 * parent as-is, not with the PCI translate 26 * method which chops off the top address cell. 27 */ 28 if (!of_find_property(np, "ranges", NULL)) 29 return 0; 30 31 return 1; 32 } 33 34 return 0; 35 } 36 37 static void of_bus_pci_count_cells(struct device_node *np, 38 int *addrc, int *sizec) 39 { 40 if (addrc) 41 *addrc = 3; 42 if (sizec) 43 *sizec = 2; 44 } 45 46 static int of_bus_pci_map(u32 *addr, const u32 *range, 47 int na, int ns, int pna) 48 { 49 u32 result[OF_MAX_ADDR_CELLS]; 50 int i; 51 52 /* Check address type match */ 53 if ((addr[0] ^ range[0]) & 0x03000000) 54 return -EINVAL; 55 56 if (of_out_of_range(addr + 1, range + 1, range + na + pna, 57 na - 1, ns)) 58 return -EINVAL; 59 60 /* Start with the parent range base. */ 61 memcpy(result, range + na, pna * 4); 62 63 /* Add in the child address offset, skipping high cell. */ 64 for (i = 0; i < na - 1; i++) 65 result[pna - 1 - i] += 66 (addr[na - 1 - i] - 67 range[na - 1 - i]); 68 69 memcpy(addr, result, pna * 4); 70 71 return 0; 72 } 73 74 static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) 75 { 76 u32 w = addr[0]; 77 78 /* For PCI, we override whatever child busses may have used. */ 79 flags = 0; 80 switch((w >> 24) & 0x03) { 81 case 0x01: 82 flags |= IORESOURCE_IO; 83 break; 84 85 case 0x02: /* 32 bits */ 86 case 0x03: /* 64 bits */ 87 flags |= IORESOURCE_MEM; 88 break; 89 } 90 if (w & 0x40000000) 91 flags |= IORESOURCE_PREFETCH; 92 return flags; 93 } 94 95 static unsigned long of_bus_sbus_get_flags(const u32 *addr, unsigned long flags) 96 { 97 return IORESOURCE_MEM; 98 } 99 100 101 /* 102 * Array of bus specific translators 103 */ 104 105 static struct of_bus of_busses[] = { 106 /* PCI */ 107 { 108 .name = "pci", 109 .addr_prop_name = "assigned-addresses", 110 .match = of_bus_pci_match, 111 .count_cells = of_bus_pci_count_cells, 112 .map = of_bus_pci_map, 113 .get_flags = of_bus_pci_get_flags, 114 }, 115 /* SBUS */ 116 { 117 .name = "sbus", 118 .addr_prop_name = "reg", 119 .match = of_bus_sbus_match, 120 .count_cells = of_bus_sbus_count_cells, 121 .map = of_bus_default_map, 122 .get_flags = of_bus_sbus_get_flags, 123 }, 124 /* Default */ 125 { 126 .name = "default", 127 .addr_prop_name = "reg", 128 .match = NULL, 129 .count_cells = of_bus_default_count_cells, 130 .map = of_bus_default_map, 131 .get_flags = of_bus_default_get_flags, 132 }, 133 }; 134 135 static struct of_bus *of_match_bus(struct device_node *np) 136 { 137 int i; 138 139 for (i = 0; i < ARRAY_SIZE(of_busses); i ++) 140 if (!of_busses[i].match || of_busses[i].match(np)) 141 return &of_busses[i]; 142 BUG(); 143 return NULL; 144 } 145 146 static int __init build_one_resource(struct device_node *parent, 147 struct of_bus *bus, 148 struct of_bus *pbus, 149 u32 *addr, 150 int na, int ns, int pna) 151 { 152 const u32 *ranges; 153 unsigned int rlen; 154 int rone; 155 156 ranges = of_get_property(parent, "ranges", &rlen); 157 if (ranges == NULL || rlen == 0) { 158 u32 result[OF_MAX_ADDR_CELLS]; 159 int i; 160 161 memset(result, 0, pna * 4); 162 for (i = 0; i < na; i++) 163 result[pna - 1 - i] = 164 addr[na - 1 - i]; 165 166 memcpy(addr, result, pna * 4); 167 return 0; 168 } 169 170 /* Now walk through the ranges */ 171 rlen /= 4; 172 rone = na + pna + ns; 173 for (; rlen >= rone; rlen -= rone, ranges += rone) { 174 if (!bus->map(addr, ranges, na, ns, pna)) 175 return 0; 176 } 177 178 return 1; 179 } 180 181 static int __init use_1to1_mapping(struct device_node *pp) 182 { 183 /* If we have a ranges property in the parent, use it. */ 184 if (of_find_property(pp, "ranges", NULL) != NULL) 185 return 0; 186 187 /* Some SBUS devices use intermediate nodes to express 188 * hierarchy within the device itself. These aren't 189 * real bus nodes, and don't have a 'ranges' property. 190 * But, we should still pass the translation work up 191 * to the SBUS itself. 192 */ 193 if (!strcmp(pp->name, "dma") || 194 !strcmp(pp->name, "espdma") || 195 !strcmp(pp->name, "ledma") || 196 !strcmp(pp->name, "lebuffer")) 197 return 0; 198 199 return 1; 200 } 201 202 static int of_resource_verbose; 203 204 static void __init build_device_resources(struct of_device *op, 205 struct device *parent) 206 { 207 struct of_device *p_op; 208 struct of_bus *bus; 209 int na, ns; 210 int index, num_reg; 211 const void *preg; 212 213 if (!parent) 214 return; 215 216 p_op = to_of_device(parent); 217 bus = of_match_bus(p_op->node); 218 bus->count_cells(op->node, &na, &ns); 219 220 preg = of_get_property(op->node, bus->addr_prop_name, &num_reg); 221 if (!preg || num_reg == 0) 222 return; 223 224 /* Convert to num-cells. */ 225 num_reg /= 4; 226 227 /* Conver to num-entries. */ 228 num_reg /= na + ns; 229 230 for (index = 0; index < num_reg; index++) { 231 struct resource *r = &op->resource[index]; 232 u32 addr[OF_MAX_ADDR_CELLS]; 233 const u32 *reg = (preg + (index * ((na + ns) * 4))); 234 struct device_node *dp = op->node; 235 struct device_node *pp = p_op->node; 236 struct of_bus *pbus, *dbus; 237 u64 size, result = OF_BAD_ADDR; 238 unsigned long flags; 239 int dna, dns; 240 int pna, pns; 241 242 size = of_read_addr(reg + na, ns); 243 244 memcpy(addr, reg, na * 4); 245 246 flags = bus->get_flags(reg, 0); 247 248 if (use_1to1_mapping(pp)) { 249 result = of_read_addr(addr, na); 250 goto build_res; 251 } 252 253 dna = na; 254 dns = ns; 255 dbus = bus; 256 257 while (1) { 258 dp = pp; 259 pp = dp->parent; 260 if (!pp) { 261 result = of_read_addr(addr, dna); 262 break; 263 } 264 265 pbus = of_match_bus(pp); 266 pbus->count_cells(dp, &pna, &pns); 267 268 if (build_one_resource(dp, dbus, pbus, addr, 269 dna, dns, pna)) 270 break; 271 272 flags = pbus->get_flags(addr, flags); 273 274 dna = pna; 275 dns = pns; 276 dbus = pbus; 277 } 278 279 build_res: 280 memset(r, 0, sizeof(*r)); 281 282 if (of_resource_verbose) 283 printk("%s reg[%d] -> %llx\n", 284 op->node->full_name, index, 285 result); 286 287 if (result != OF_BAD_ADDR) { 288 r->start = result & 0xffffffff; 289 r->end = result + size - 1; 290 r->flags = flags | ((result >> 32ULL) & 0xffUL); 291 } 292 r->name = op->node->name; 293 } 294 } 295 296 static struct of_device * __init scan_one_device(struct device_node *dp, 297 struct device *parent) 298 { 299 struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL); 300 const struct linux_prom_irqs *intr; 301 struct dev_archdata *sd; 302 int len, i; 303 304 if (!op) 305 return NULL; 306 307 sd = &op->dev.archdata; 308 sd->prom_node = dp; 309 sd->op = op; 310 311 op->node = dp; 312 313 op->clock_freq = of_getintprop_default(dp, "clock-frequency", 314 (25*1000*1000)); 315 op->portid = of_getintprop_default(dp, "upa-portid", -1); 316 if (op->portid == -1) 317 op->portid = of_getintprop_default(dp, "portid", -1); 318 319 intr = of_get_property(dp, "intr", &len); 320 if (intr) { 321 op->num_irqs = len / sizeof(struct linux_prom_irqs); 322 for (i = 0; i < op->num_irqs; i++) 323 op->irqs[i] = intr[i].pri; 324 } else { 325 const unsigned int *irq = 326 of_get_property(dp, "interrupts", &len); 327 328 if (irq) { 329 op->num_irqs = len / sizeof(unsigned int); 330 for (i = 0; i < op->num_irqs; i++) 331 op->irqs[i] = irq[i]; 332 } else { 333 op->num_irqs = 0; 334 } 335 } 336 if (sparc_cpu_model == sun4d) { 337 static int pil_to_sbus[] = { 338 0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0, 339 }; 340 struct device_node *io_unit, *sbi = dp->parent; 341 const struct linux_prom_registers *regs; 342 int board, slot; 343 344 while (sbi) { 345 if (!strcmp(sbi->name, "sbi")) 346 break; 347 348 sbi = sbi->parent; 349 } 350 if (!sbi) 351 goto build_resources; 352 353 regs = of_get_property(dp, "reg", NULL); 354 if (!regs) 355 goto build_resources; 356 357 slot = regs->which_io; 358 359 /* If SBI's parent is not io-unit or the io-unit lacks 360 * a "board#" property, something is very wrong. 361 */ 362 if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) { 363 printk("%s: Error, parent is not io-unit.\n", 364 sbi->full_name); 365 goto build_resources; 366 } 367 io_unit = sbi->parent; 368 board = of_getintprop_default(io_unit, "board#", -1); 369 if (board == -1) { 370 printk("%s: Error, lacks board# property.\n", 371 io_unit->full_name); 372 goto build_resources; 373 } 374 375 for (i = 0; i < op->num_irqs; i++) { 376 int this_irq = op->irqs[i]; 377 int sbusl = pil_to_sbus[this_irq]; 378 379 if (sbusl) 380 this_irq = (((board + 1) << 5) + 381 (sbusl << 2) + 382 slot); 383 384 op->irqs[i] = this_irq; 385 } 386 } 387 388 build_resources: 389 build_device_resources(op, parent); 390 391 op->dev.parent = parent; 392 op->dev.bus = &of_platform_bus_type; 393 if (!parent) 394 dev_set_name(&op->dev, "root"); 395 else 396 dev_set_name(&op->dev, "%08x", dp->node); 397 398 if (of_device_register(op)) { 399 printk("%s: Could not register of device.\n", 400 dp->full_name); 401 kfree(op); 402 op = NULL; 403 } 404 405 return op; 406 } 407 408 static void __init scan_tree(struct device_node *dp, struct device *parent) 409 { 410 while (dp) { 411 struct of_device *op = scan_one_device(dp, parent); 412 413 if (op) 414 scan_tree(dp->child, &op->dev); 415 416 dp = dp->sibling; 417 } 418 } 419 420 static void __init scan_of_devices(void) 421 { 422 struct device_node *root = of_find_node_by_path("/"); 423 struct of_device *parent; 424 425 parent = scan_one_device(root, NULL); 426 if (!parent) 427 return; 428 429 scan_tree(root->child, &parent->dev); 430 } 431 432 static int __init of_bus_driver_init(void) 433 { 434 int err; 435 436 err = of_bus_type_init(&of_platform_bus_type, "of"); 437 if (!err) 438 scan_of_devices(); 439 440 return err; 441 } 442 443 postcore_initcall(of_bus_driver_init); 444 445 static int __init of_debug(char *str) 446 { 447 int val = 0; 448 449 get_option(&str, &val); 450 if (val & 1) 451 of_resource_verbose = 1; 452 return 1; 453 } 454 455 __setup("of_debug=", of_debug); 456