Blame view
arch/sparc/kernel/of_device_64.c
15.8 KB
a2bd4fd17
|
1 2 |
#include <linux/string.h> #include <linux/kernel.h> |
f85ff3056
|
3 |
#include <linux/of.h> |
a2bd4fd17
|
4 5 6 7 |
#include <linux/init.h> #include <linux/module.h> #include <linux/mod_devicetable.h> #include <linux/slab.h> |
3f23de10f
|
8 |
#include <linux/errno.h> |
c1b1a5f1f
|
9 |
#include <linux/irq.h> |
3f23de10f
|
10 11 |
#include <linux/of_device.h> #include <linux/of_platform.h> |
a2bd4fd17
|
12 |
|
c9f5b7e77
|
13 |
#include "of_device_common.h" |
3ca9fab41
|
14 15 16 |
void __iomem *of_ioremap(struct resource *res, unsigned long offset, unsigned long size, char *name) { unsigned long ret = res->start + offset; |
6bda57365
|
17 |
struct resource *r; |
3ca9fab41
|
18 |
|
6bda57365
|
19 20 21 22 23 |
if (res->flags & IORESOURCE_MEM) r = request_mem_region(ret, size, name); else r = request_region(ret, size, name); if (!r) |
3ca9fab41
|
24 25 26 27 28 |
ret = 0; return (void __iomem *) ret; } EXPORT_SYMBOL(of_ioremap); |
e3a411a3d
|
29 |
void of_iounmap(struct resource *res, void __iomem *base, unsigned long size) |
3ca9fab41
|
30 |
{ |
e3a411a3d
|
31 32 33 34 |
if (res->flags & IORESOURCE_MEM) release_mem_region((unsigned long) base, size); else release_region((unsigned long) base, size); |
3ca9fab41
|
35 36 |
} EXPORT_SYMBOL(of_iounmap); |
cf44bbc26
|
37 38 39 40 41 42 |
/* * PCI bus specific translator */ static int of_bus_pci_match(struct device_node *np) { |
7ee766d8f
|
43 |
if (!strcmp(np->name, "pci")) { |
a165b4205
|
44 |
const char *model = of_get_property(np, "model", NULL); |
01f94c4a6
|
45 46 47 |
if (model && !strcmp(model, "SUNW,simba")) return 0; |
a83f98231
|
48 49 50 51 52 53 54 55 56 57 58 59 60 |
/* Do not do PCI specific frobbing if the * PCI bridge lacks a ranges property. We * want to pass it through up to the next * parent as-is, not with the PCI translate * method which chops off the top address cell. */ if (!of_find_property(np, "ranges", NULL)) return 0; return 1; } return 0; |
cf44bbc26
|
61 |
} |
01f94c4a6
|
62 63 |
static int of_bus_simba_match(struct device_node *np) { |
a165b4205
|
64 |
const char *model = of_get_property(np, "model", NULL); |
01f94c4a6
|
65 66 67 |
if (model && !strcmp(model, "SUNW,simba")) return 1; |
8c2786cfa
|
68 69 70 71 |
/* Treat PCI busses lacking ranges property just like * simba. */ |
7ee766d8f
|
72 |
if (!strcmp(np->name, "pci")) { |
8c2786cfa
|
73 74 75 |
if (!of_find_property(np, "ranges", NULL)) return 1; } |
01f94c4a6
|
76 77 78 79 80 81 82 83 |
return 0; } static int of_bus_simba_map(u32 *addr, const u32 *range, int na, int ns, int pna) { return 0; } |
cf44bbc26
|
84 85 86 87 88 89 90 91 |
static void of_bus_pci_count_cells(struct device_node *np, int *addrc, int *sizec) { if (addrc) *addrc = 3; if (sizec) *sizec = 2; } |
a83f98231
|
92 93 |
static int of_bus_pci_map(u32 *addr, const u32 *range, int na, int ns, int pna) |
cf44bbc26
|
94 |
{ |
a83f98231
|
95 96 |
u32 result[OF_MAX_ADDR_CELLS]; int i; |
cf44bbc26
|
97 98 |
/* Check address type match */ |
4230fa3b8
|
99 100 101 102 103 104 105 106 107 108 109 |
if (!((addr[0] ^ range[0]) & 0x03000000)) goto type_match; /* Special exception, we can map a 64-bit address into * a 32-bit range. */ if ((addr[0] & 0x03000000) == 0x03000000 && (range[0] & 0x03000000) == 0x02000000) goto type_match; return -EINVAL; |
cf44bbc26
|
110 |
|
4230fa3b8
|
111 |
type_match: |
a83f98231
|
112 113 114 |
if (of_out_of_range(addr + 1, range + 1, range + na + pna, na - 1, ns)) return -EINVAL; |
cf44bbc26
|
115 |
|
a83f98231
|
116 117 |
/* Start with the parent range base. */ memcpy(result, range + na, pna * 4); |
cf44bbc26
|
118 |
|
a83f98231
|
119 120 121 122 123 124 125 126 127 |
/* Add in the child address offset, skipping high cell. */ for (i = 0; i < na - 1; i++) result[pna - 1 - i] += (addr[na - 1 - i] - range[na - 1 - i]); memcpy(addr, result, pna * 4); return 0; |
cf44bbc26
|
128 |
} |
e3c71a329
|
129 |
static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) |
cf44bbc26
|
130 |
{ |
cf44bbc26
|
131 |
u32 w = addr[0]; |
e3c71a329
|
132 133 |
/* For PCI, we override whatever child busses may have used. */ flags = 0; |
cf44bbc26
|
134 135 136 |
switch((w >> 24) & 0x03) { case 0x01: flags |= IORESOURCE_IO; |
e3c71a329
|
137 |
break; |
cf44bbc26
|
138 139 140 |
case 0x02: /* 32 bits */ case 0x03: /* 64 bits */ flags |= IORESOURCE_MEM; |
e3c71a329
|
141 |
break; |
cf44bbc26
|
142 143 144 145 146 147 148 |
} if (w & 0x40000000) flags |= IORESOURCE_PREFETCH; return flags; } /* |
4130a4b20
|
149 150 151 152 153 154 155 156 157 |
* FHC/Central bus specific translator. * * This is just needed to hard-code the address and size cell * counts. 'fhc' and 'central' nodes lack the #address-cells and * #size-cells properties, and if you walk to the root on such * Enterprise boxes all you'll get is a #size-cells of 2 which is * not what we want to use. */ static int of_bus_fhc_match(struct device_node *np) |
cf44bbc26
|
158 |
{ |
4130a4b20
|
159 160 |
return !strcmp(np->name, "fhc") || !strcmp(np->name, "central"); |
cf44bbc26
|
161 |
} |
4130a4b20
|
162 |
#define of_bus_fhc_count_cells of_bus_sbus_count_cells |
cf44bbc26
|
163 164 165 166 167 168 169 170 171 172 173 174 175 |
/* * Array of bus specific translators */ static struct of_bus of_busses[] = { /* PCI */ { .name = "pci", .addr_prop_name = "assigned-addresses", .match = of_bus_pci_match, .count_cells = of_bus_pci_count_cells, .map = of_bus_pci_map, |
cf44bbc26
|
176 177 |
.get_flags = of_bus_pci_get_flags, }, |
01f94c4a6
|
178 179 180 181 182 183 184 185 186 |
/* SIMBA */ { .name = "simba", .addr_prop_name = "assigned-addresses", .match = of_bus_simba_match, .count_cells = of_bus_pci_count_cells, .map = of_bus_simba_map, .get_flags = of_bus_pci_get_flags, }, |
cf44bbc26
|
187 188 189 190 191 192 |
/* SBUS */ { .name = "sbus", .addr_prop_name = "reg", .match = of_bus_sbus_match, .count_cells = of_bus_sbus_count_cells, |
4130a4b20
|
193 194 195 196 197 198 199 200 201 202 203 |
.map = of_bus_default_map, .get_flags = of_bus_default_get_flags, }, /* FHC */ { .name = "fhc", .addr_prop_name = "reg", .match = of_bus_fhc_match, .count_cells = of_bus_fhc_count_cells, .map = of_bus_default_map, .get_flags = of_bus_default_get_flags, |
cf44bbc26
|
204 205 206 207 208 209 210 211 |
}, /* Default */ { .name = "default", .addr_prop_name = "reg", .match = NULL, .count_cells = of_bus_default_count_cells, .map = of_bus_default_map, |
cf44bbc26
|
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 |
.get_flags = of_bus_default_get_flags, }, }; static struct of_bus *of_match_bus(struct device_node *np) { int i; for (i = 0; i < ARRAY_SIZE(of_busses); i ++) if (!of_busses[i].match || of_busses[i].match(np)) return &of_busses[i]; BUG(); return NULL; } static int __init build_one_resource(struct device_node *parent, struct of_bus *bus, struct of_bus *pbus, u32 *addr, int na, int ns, int pna) { |
6a23acf39
|
233 |
const u32 *ranges; |
21cd88339
|
234 |
int rone, rlen; |
cf44bbc26
|
235 236 237 |
ranges = of_get_property(parent, "ranges", &rlen); if (ranges == NULL || rlen == 0) { |
a83f98231
|
238 239 240 241 242 243 244 245 246 247 |
u32 result[OF_MAX_ADDR_CELLS]; int i; memset(result, 0, pna * 4); for (i = 0; i < na; i++) result[pna - 1 - i] = addr[na - 1 - i]; memcpy(addr, result, pna * 4); return 0; |
cf44bbc26
|
248 249 250 251 252 253 |
} /* Now walk through the ranges */ rlen /= 4; rone = na + pna + ns; for (; rlen >= rone; rlen -= rone, ranges += rone) { |
a83f98231
|
254 255 |
if (!bus->map(addr, ranges, na, ns, pna)) return 0; |
cf44bbc26
|
256 |
} |
a83f98231
|
257 |
|
49d23cfce
|
258 259 260 261 262 263 |
/* When we miss an I/O space match on PCI, just pass it up * to the next PCI bridge and/or controller. */ if (!strcmp(bus->name, "pci") && (addr[0] & 0x03000000) == 0x01000000) return 0; |
a83f98231
|
264 265 266 267 268 |
return 1; } static int __init use_1to1_mapping(struct device_node *pp) { |
a83f98231
|
269 270 271 |
/* If we have a ranges property in the parent, use it. */ if (of_find_property(pp, "ranges", NULL) != NULL) return 0; |
cf44bbc26
|
272 |
|
a83f98231
|
273 274 |
/* If the parent is the dma node of an ISA bus, pass * the translation up to the root. |
5280267c1
|
275 276 277 278 279 280 |
* * Some SBUS devices use intermediate nodes to express * hierarchy within the device itself. These aren't * real bus nodes, and don't have a 'ranges' property. * But, we should still pass the translation work up * to the SBUS itself. |
a83f98231
|
281 |
*/ |
5280267c1
|
282 283 284 285 |
if (!strcmp(pp->name, "dma") || !strcmp(pp->name, "espdma") || !strcmp(pp->name, "ledma") || !strcmp(pp->name, "lebuffer")) |
a83f98231
|
286 |
return 0; |
8c2786cfa
|
287 288 289 290 |
/* Similarly for all PCI bridges, if we get this far * it lacks a ranges property, and this will include * cases like Simba. */ |
7ee766d8f
|
291 |
if (!strcmp(pp->name, "pci")) |
a83f98231
|
292 293 294 |
return 0; return 1; |
cf44bbc26
|
295 |
} |
a83f98231
|
296 |
static int of_resource_verbose; |
cd4cd7306
|
297 |
static void __init build_device_resources(struct platform_device *op, |
cf44bbc26
|
298 299 |
struct device *parent) { |
cd4cd7306
|
300 |
struct platform_device *p_op; |
cf44bbc26
|
301 302 303 |
struct of_bus *bus; int na, ns; int index, num_reg; |
6a23acf39
|
304 |
const void *preg; |
cf44bbc26
|
305 306 307 |
if (!parent) return; |
cd4cd7306
|
308 |
p_op = to_platform_device(parent); |
61c7a080a
|
309 310 |
bus = of_match_bus(p_op->dev.of_node); bus->count_cells(op->dev.of_node, &na, &ns); |
cf44bbc26
|
311 |
|
61c7a080a
|
312 |
preg = of_get_property(op->dev.of_node, bus->addr_prop_name, &num_reg); |
cf44bbc26
|
313 314 315 316 317 |
if (!preg || num_reg == 0) return; /* Convert to num-cells. */ num_reg /= 4; |
46ba6d7d8
|
318 |
/* Convert to num-entries. */ |
cf44bbc26
|
319 |
num_reg /= na + ns; |
e5dd42e4f
|
320 |
/* Prevent overrunning the op->resources[] array. */ |
46ba6d7d8
|
321 322 323 324 |
if (num_reg > PROMREG_MAX) { printk(KERN_WARNING "%s: Too many regs (%d), " "limiting to %d. ", |
61c7a080a
|
325 |
op->dev.of_node->full_name, num_reg, PROMREG_MAX); |
46ba6d7d8
|
326 327 |
num_reg = PROMREG_MAX; } |
1636f8ac2
|
328 329 |
op->resource = op->archdata.resource; op->num_resources = num_reg; |
cf44bbc26
|
330 331 332 |
for (index = 0; index < num_reg; index++) { struct resource *r = &op->resource[index]; u32 addr[OF_MAX_ADDR_CELLS]; |
6a23acf39
|
333 |
const u32 *reg = (preg + (index * ((na + ns) * 4))); |
61c7a080a
|
334 335 |
struct device_node *dp = op->dev.of_node; struct device_node *pp = p_op->dev.of_node; |
b85cdd490
|
336 |
struct of_bus *pbus, *dbus; |
cf44bbc26
|
337 338 339 340 341 342 |
u64 size, result = OF_BAD_ADDR; unsigned long flags; int dna, dns; int pna, pns; size = of_read_addr(reg + na, ns); |
cf44bbc26
|
343 |
memcpy(addr, reg, na * 4); |
e3c71a329
|
344 |
flags = bus->get_flags(addr, 0); |
a83f98231
|
345 |
if (use_1to1_mapping(pp)) { |
cf44bbc26
|
346 347 348 349 350 351 |
result = of_read_addr(addr, na); goto build_res; } dna = na; dns = ns; |
b85cdd490
|
352 |
dbus = bus; |
cf44bbc26
|
353 354 355 356 357 358 359 360 361 362 363 |
while (1) { dp = pp; pp = dp->parent; if (!pp) { result = of_read_addr(addr, dna); break; } pbus = of_match_bus(pp); pbus->count_cells(dp, &pna, &pns); |
b85cdd490
|
364 |
if (build_one_resource(dp, dbus, pbus, addr, |
a83f98231
|
365 |
dna, dns, pna)) |
cf44bbc26
|
366 |
break; |
e3c71a329
|
367 |
flags = pbus->get_flags(addr, flags); |
cf44bbc26
|
368 369 |
dna = pna; dns = pns; |
b85cdd490
|
370 |
dbus = pbus; |
cf44bbc26
|
371 372 373 374 |
} build_res: memset(r, 0, sizeof(*r)); |
a83f98231
|
375 376 |
if (of_resource_verbose) |
901811364
|
377 378 |
printk("%s reg[%d] -> %llx ", |
61c7a080a
|
379 |
op->dev.of_node->full_name, index, |
a83f98231
|
380 |
result); |
cf44bbc26
|
381 |
if (result != OF_BAD_ADDR) { |
1815aed5e
|
382 383 |
if (tlb_type == hypervisor) result &= 0x0fffffffffffffffUL; |
cf44bbc26
|
384 385 386 |
r->start = result; r->end = result + size - 1; r->flags = flags; |
cf44bbc26
|
387 |
} |
61c7a080a
|
388 |
r->name = op->dev.of_node->name; |
cf44bbc26
|
389 390 |
} } |
2b1e59787
|
391 392 |
static struct device_node * __init apply_interrupt_map(struct device_node *dp, struct device_node *pp, |
6a23acf39
|
393 |
const u32 *imap, int imlen, const u32 *imask, |
2b1e59787
|
394 395 396 397 398 399 |
unsigned int *irq_p) { struct device_node *cp; unsigned int irq = *irq_p; struct of_bus *bus; phandle handle; |
6a23acf39
|
400 |
const u32 *reg; |
2b1e59787
|
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 |
int na, num_reg, i; bus = of_match_bus(pp); bus->count_cells(dp, &na, NULL); reg = of_get_property(dp, "reg", &num_reg); if (!reg || !num_reg) return NULL; imlen /= ((na + 3) * 4); handle = 0; for (i = 0; i < imlen; i++) { int j; for (j = 0; j < na; j++) { if ((reg[j] & imask[j]) != imap[j]) goto next; } if (imap[na] == irq) { handle = imap[na + 1]; irq = imap[na + 2]; break; } next: imap += (na + 3); } |
46ba6d7d8
|
428 429 430 431 432 433 434 435 |
if (i == imlen) { /* Psycho and Sabre PCI controllers can have 'interrupt-map' * properties that do not include the on-board device * interrupts. Instead, the device's 'interrupts' property * is already a fully specified INO value. * * Handle this by deciding that, if we didn't get a * match in the parent's 'interrupt-map', and the |
25985edce
|
436 |
* parent is an IRQ translator, then use the parent as |
46ba6d7d8
|
437 438 439 440 |
* our IRQ controller. */ if (pp->irq_trans) return pp; |
2b1e59787
|
441 |
return NULL; |
46ba6d7d8
|
442 |
} |
2b1e59787
|
443 444 445 446 447 448 449 450 451 452 453 |
*irq_p = irq; cp = of_find_node_by_phandle(handle); return cp; } static unsigned int __init pci_irq_swizzle(struct device_node *dp, struct device_node *pp, unsigned int irq) { |
6a23acf39
|
454 |
const struct linux_prom_pci_registers *regs; |
bb4c18cbb
|
455 |
unsigned int bus, devfn, slot, ret; |
2b1e59787
|
456 457 458 459 460 461 462 |
if (irq < 1 || irq > 4) return irq; regs = of_get_property(dp, "reg", NULL); if (!regs) return irq; |
bb4c18cbb
|
463 |
bus = (regs->phys_hi >> 16) & 0xff; |
2b1e59787
|
464 465 |
devfn = (regs->phys_hi >> 8) & 0xff; slot = (devfn >> 3) & 0x1f; |
bb4c18cbb
|
466 467 468 469 470 471 472 473 474 475 476 |
if (pp->irq_trans) { /* Derived from Table 8-3, U2P User's Manual. This branch * is handling a PCI controller that lacks a proper set of * interrupt-map and interrupt-map-mask properties. The * Ultra-E450 is one example. * * The bit layout is BSSLL, where: * B: 0 on bus A, 1 on bus B * D: 2-bit slot number, derived from PCI device number as * (dev - 1) for bus A, or (dev - 2) for bus B * L: 2-bit line number |
bb4c18cbb
|
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 |
*/ if (bus & 0x80) { /* PBM-A */ bus = 0x00; slot = (slot - 1) << 2; } else { /* PBM-B */ bus = 0x10; slot = (slot - 2) << 2; } irq -= 1; ret = (bus | slot | irq); } else { /* Going through a PCI-PCI bridge that lacks a set of * interrupt-map and interrupt-map-mask properties. */ ret = ((irq - 1 + (slot & 3)) & 3) + 1; } |
2b1e59787
|
496 497 498 |
return ret; } |
a83f98231
|
499 |
static int of_irq_verbose; |
cd4cd7306
|
500 |
static unsigned int __init build_one_device_irq(struct platform_device *op, |
2b1e59787
|
501 502 503 |
struct device *parent, unsigned int irq) { |
61c7a080a
|
504 |
struct device_node *dp = op->dev.of_node; |
2b1e59787
|
505 506 |
struct device_node *pp, *ip; unsigned int orig_irq = irq; |
c1b1a5f1f
|
507 |
int nid; |
2b1e59787
|
508 509 510 511 512 513 514 |
if (irq == 0xffffffff) return irq; if (dp->irq_trans) { irq = dp->irq_trans->irq_build(dp, irq, dp->irq_trans->data); |
a83f98231
|
515 516 517 518 519 |
if (of_irq_verbose) printk("%s: direct translate %x --> %x ", dp->full_name, orig_irq, irq); |
c1b1a5f1f
|
520 |
goto out; |
2b1e59787
|
521 522 523 524 525 526 527 528 529 530 531 532 533 |
} /* Something more complicated. Walk up to the root, applying * interrupt-map or bus specific translations, until we hit * an IRQ translator. * * If we hit a bus type or situation we cannot handle, we * stop and assume that the original IRQ number was in a * format which has special meaning to it's immediate parent. */ pp = dp->parent; ip = NULL; while (pp) { |
6a23acf39
|
534 |
const void *imap, *imsk; |
2b1e59787
|
535 536 537 538 539 540 541 542 543 544 545 |
int imlen; imap = of_get_property(pp, "interrupt-map", &imlen); imsk = of_get_property(pp, "interrupt-map-mask", NULL); if (imap && imsk) { struct device_node *iret; int this_orig_irq = irq; iret = apply_interrupt_map(dp, pp, imap, imlen, imsk, &irq); |
a83f98231
|
546 547 548 549 |
if (of_irq_verbose) printk("%s: Apply [%s:%x] imap --> [%s:%x] ", |
61c7a080a
|
550 |
op->dev.of_node->full_name, |
a83f98231
|
551 552 |
pp->full_name, this_orig_irq, (iret ? iret->full_name : "NULL"), irq); |
2b1e59787
|
553 554 555 556 557 558 559 560 |
if (!iret) break; if (iret->irq_trans) { ip = iret; break; } } else { |
7ee766d8f
|
561 |
if (!strcmp(pp->name, "pci")) { |
2b1e59787
|
562 563 564 |
unsigned int this_orig_irq = irq; irq = pci_irq_swizzle(dp, pp, irq); |
a83f98231
|
565 566 567 568 |
if (of_irq_verbose) printk("%s: PCI swizzle [%s] " "%x --> %x ", |
61c7a080a
|
569 |
op->dev.of_node->full_name, |
a83f98231
|
570 571 |
pp->full_name, this_orig_irq, irq); |
2b1e59787
|
572 573 574 575 576 577 578 579 580 581 582 583 |
} if (pp->irq_trans) { ip = pp; break; } } dp = pp; pp = pp->parent; } if (!ip) return orig_irq; |
61c7a080a
|
584 |
irq = ip->irq_trans->irq_build(op->dev.of_node, irq, |
2b1e59787
|
585 |
ip->irq_trans->data); |
a83f98231
|
586 587 588 |
if (of_irq_verbose) printk("%s: Apply IRQ trans [%s] %x --> %x ", |
61c7a080a
|
589 |
op->dev.of_node->full_name, ip->full_name, orig_irq, irq); |
2b1e59787
|
590 |
|
c1b1a5f1f
|
591 592 593 |
out: nid = of_node_to_nid(dp); if (nid != -1) { |
96d76a748
|
594 |
cpumask_t numa_mask = *cpumask_of_node(nid); |
c1b1a5f1f
|
595 |
|
0de26520c
|
596 |
irq_set_affinity(irq, &numa_mask); |
c1b1a5f1f
|
597 |
} |
2b1e59787
|
598 599 |
return irq; } |
cd4cd7306
|
600 |
static struct platform_device * __init scan_one_device(struct device_node *dp, |
cf44bbc26
|
601 602 |
struct device *parent) { |
cd4cd7306
|
603 |
struct platform_device *op = kzalloc(sizeof(*op), GFP_KERNEL); |
6a23acf39
|
604 |
const unsigned int *irq; |
3d6e47023
|
605 |
struct dev_archdata *sd; |
2b1e59787
|
606 |
int len, i; |
cf44bbc26
|
607 608 609 |
if (!op) return NULL; |
3d6e47023
|
610 |
sd = &op->dev.archdata; |
3d6e47023
|
611 |
sd->op = op; |
d706c1b05
|
612 |
op->dev.of_node = dp; |
cf44bbc26
|
613 |
|
cf44bbc26
|
614 |
irq = of_get_property(dp, "interrupts", &len); |
2b1e59787
|
615 |
if (irq) { |
1636f8ac2
|
616 |
op->archdata.num_irqs = len / 4; |
92d9091f3
|
617 618 |
/* Prevent overrunning the op->irqs[] array. */ |
1636f8ac2
|
619 |
if (op->archdata.num_irqs > PROMINTR_MAX) { |
92d9091f3
|
620 621 622 |
printk(KERN_WARNING "%s: Too many irqs (%d), " "limiting to %d. ", |
1636f8ac2
|
623 624 |
dp->full_name, op->archdata.num_irqs, PROMINTR_MAX); op->archdata.num_irqs = PROMINTR_MAX; |
92d9091f3
|
625 |
} |
1636f8ac2
|
626 |
memcpy(op->archdata.irqs, irq, op->archdata.num_irqs * 4); |
2b1e59787
|
627 |
} else { |
1636f8ac2
|
628 |
op->archdata.num_irqs = 0; |
2b1e59787
|
629 |
} |
cf44bbc26
|
630 631 |
build_device_resources(op, parent); |
1636f8ac2
|
632 633 |
for (i = 0; i < op->archdata.num_irqs; i++) op->archdata.irqs[i] = build_one_device_irq(op, parent, op->archdata.irqs[i]); |
cf44bbc26
|
634 635 |
op->dev.parent = parent; |
eca393016
|
636 |
op->dev.bus = &platform_bus_type; |
cf44bbc26
|
637 |
if (!parent) |
2222c313e
|
638 |
dev_set_name(&op->dev, "root"); |
cf44bbc26
|
639 |
else |
6016a363f
|
640 |
dev_set_name(&op->dev, "%08x", dp->phandle); |
cf44bbc26
|
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 |
if (of_device_register(op)) { printk("%s: Could not register of device. ", dp->full_name); kfree(op); op = NULL; } return op; } static void __init scan_tree(struct device_node *dp, struct device *parent) { while (dp) { |
cd4cd7306
|
656 |
struct platform_device *op = scan_one_device(dp, parent); |
cf44bbc26
|
657 658 659 660 661 662 663 |
if (op) scan_tree(dp->child, &op->dev); dp = dp->sibling; } } |
eca393016
|
664 |
static int __init scan_of_devices(void) |
cf44bbc26
|
665 666 |
{ struct device_node *root = of_find_node_by_path("/"); |
cd4cd7306
|
667 |
struct platform_device *parent; |
cf44bbc26
|
668 669 670 |
parent = scan_one_device(root, NULL); if (!parent) |
eca393016
|
671 |
return 0; |
cf44bbc26
|
672 673 |
scan_tree(root->child, &parent->dev); |
eca393016
|
674 |
return 0; |
cf44bbc26
|
675 |
} |
eca393016
|
676 |
postcore_initcall(scan_of_devices); |
a2bd4fd17
|
677 |
|
a83f98231
|
678 679 680 681 682 683 684 685 686 687 688 689 690 |
static int __init of_debug(char *str) { int val = 0; get_option(&str, &val); if (val & 1) of_resource_verbose = 1; if (val & 2) of_irq_verbose = 1; return 1; } __setup("of_debug=", of_debug); |