git.oblomov.eu Git - linux-2.6/blob - arch/sparc/kernel/of_device_32.c

   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/of_device.h>
  10 #include <linux/of_platform.h>
  11
  12 static int node_match(struct device *dev, void *data)
  13 {
  14         struct of_device *op = to_of_device(dev);
  15         struct device_node *dp = data;
  16
  17         return (op->node == dp);
  18 }
  19
  20 struct of_device *of_find_device_by_node(struct device_node *dp)
  21 {
  22         struct device *dev = bus_find_device(&of_platform_bus_type, NULL,
  23                                              dp, node_match);
  24
  25         if (dev)
  26                 return to_of_device(dev);
  27
  28         return NULL;
  29 }
  30 EXPORT_SYMBOL(of_find_device_by_node);
  31
  32 unsigned int irq_of_parse_and_map(struct device_node *node, int index)
  33 {
  34         struct of_device *op = of_find_device_by_node(node);
  35
  36         if (!op || index >= op->num_irqs)
  37                 return 0;
  38
  39         return op->irqs[index];
  40 }
  41 EXPORT_SYMBOL(irq_of_parse_and_map);
  42
  43 /* Take the archdata values for IOMMU, STC, and HOSTDATA found in
  44  * BUS and propagate to all child of_device objects.
  45  */
  46 void of_propagate_archdata(struct of_device *bus)
  47 {
  48         struct dev_archdata *bus_sd = &bus->dev.archdata;
  49         struct device_node *bus_dp = bus->node;
  50         struct device_node *dp;
  51
  52         for (dp = bus_dp->child; dp; dp = dp->sibling) {
  53                 struct of_device *op = of_find_device_by_node(dp);
  54
  55                 op->dev.archdata.iommu = bus_sd->iommu;
  56                 op->dev.archdata.stc = bus_sd->stc;
  57                 op->dev.archdata.host_controller = bus_sd->host_controller;
  58                 op->dev.archdata.numa_node = bus_sd->numa_node;
  59
  60                 if (dp->child)
  61                         of_propagate_archdata(op);
  62         }
  63 }
  64
  65 struct bus_type of_platform_bus_type;
  66 EXPORT_SYMBOL(of_platform_bus_type);
  67
  68 static inline u64 of_read_addr(const u32 *cell, int size)
  69 {
  70         u64 r = 0;
  71         while (size--)
  72                 r = (r << 32) | *(cell++);
  73         return r;
  74 }
  75
  76 static void __init get_cells(struct device_node *dp,
  77                              int *addrc, int *sizec)
  78 {
  79         if (addrc)
  80                 *addrc = of_n_addr_cells(dp);
  81         if (sizec)
  82                 *sizec = of_n_size_cells(dp);
  83 }
  84
  85 /* Max address size we deal with */
  86 #define OF_MAX_ADDR_CELLS       4
  87
  88 struct of_bus {
  89         const char      *name;
  90         const char      *addr_prop_name;
  91         int             (*match)(struct device_node *parent);
  92         void            (*count_cells)(struct device_node *child,
  93                                        int *addrc, int *sizec);
  94         int             (*map)(u32 *addr, const u32 *range,
  95                                int na, int ns, int pna);
  96         unsigned long   (*get_flags)(const u32 *addr, unsigned long);
  97 };
  98
  99 /*
 100  * Default translator (generic bus)
 101  */
 102
 103 static void of_bus_default_count_cells(struct device_node *dev,
 104                                        int *addrc, int *sizec)
 105 {
 106         get_cells(dev, addrc, sizec);
 107 }
 108
 109 /* Make sure the least significant 64-bits are in-range.  Even
 110  * for 3 or 4 cell values it is a good enough approximation.
 111  */
 112 static int of_out_of_range(const u32 *addr, const u32 *base,
 113                            const u32 *size, int na, int ns)
 114 {
 115         u64 a = of_read_addr(addr, na);
 116         u64 b = of_read_addr(base, na);
 117
 118         if (a < b)
 119                 return 1;
 120
 121         b += of_read_addr(size, ns);
 122         if (a >= b)
 123                 return 1;
 124
 125         return 0;
 126 }
 127
 128 static int of_bus_default_map(u32 *addr, const u32 *range,
 129                               int na, int ns, int pna)
 130 {
 131         u32 result[OF_MAX_ADDR_CELLS];
 132         int i;
 133
 134         if (ns > 2) {
 135                 printk("of_device: Cannot handle size cells (%d) > 2.", ns);
 136                 return -EINVAL;
 137         }
 138
 139         if (of_out_of_range(addr, range, range + na + pna, na, ns))
 140                 return -EINVAL;
 141
 142         /* Start with the parent range base.  */
 143         memcpy(result, range + na, pna * 4);
 144
 145         /* Add in the child address offset.  */
 146         for (i = 0; i < na; i++)
 147                 result[pna - 1 - i] +=
 148                         (addr[na - 1 - i] -
 149                          range[na - 1 - i]);
 150
 151         memcpy(addr, result, pna * 4);
 152
 153         return 0;
 154 }
 155
 156 static unsigned long of_bus_default_get_flags(const u32 *addr, unsigned long flags)
 157 {
 158         if (flags)
 159                 return flags;
 160         return IORESOURCE_MEM;
 161 }
 162
 163 /*
 164  * PCI bus specific translator
 165  */
 166
 167 static int of_bus_pci_match(struct device_node *np)
 168 {
 169         if (!strcmp(np->type, "pci") || !strcmp(np->type, "pciex")) {
 170                 /* Do not do PCI specific frobbing if the
 171                  * PCI bridge lacks a ranges property.  We
 172                  * want to pass it through up to the next
 173                  * parent as-is, not with the PCI translate
 174                  * method which chops off the top address cell.
 175                  */
 176                 if (!of_find_property(np, "ranges", NULL))
 177                         return 0;
 178
 179                 return 1;
 180         }
 181
 182         return 0;
 183 }
 184
 185 static void of_bus_pci_count_cells(struct device_node *np,
 186                                    int *addrc, int *sizec)
 187 {
 188         if (addrc)
 189                 *addrc = 3;
 190         if (sizec)
 191                 *sizec = 2;
 192 }
 193
 194 static int of_bus_pci_map(u32 *addr, const u32 *range,
 195                           int na, int ns, int pna)
 196 {
 197         u32 result[OF_MAX_ADDR_CELLS];
 198         int i;
 199
 200         /* Check address type match */
 201         if ((addr[0] ^ range[0]) & 0x03000000)
 202                 return -EINVAL;
 203
 204         if (of_out_of_range(addr + 1, range + 1, range + na + pna,
 205                             na - 1, ns))
 206                 return -EINVAL;
 207
 208         /* Start with the parent range base.  */
 209         memcpy(result, range + na, pna * 4);
 210
 211         /* Add in the child address offset, skipping high cell.  */
 212         for (i = 0; i < na - 1; i++)
 213                 result[pna - 1 - i] +=
 214                         (addr[na - 1 - i] -
 215                          range[na - 1 - i]);
 216
 217         memcpy(addr, result, pna * 4);
 218
 219         return 0;
 220 }
 221
 222 static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags)
 223 {
 224         u32 w = addr[0];
 225
 226         /* For PCI, we override whatever child busses may have used.  */
 227         flags = 0;
 228         switch((w >> 24) & 0x03) {
 229         case 0x01:
 230                 flags |= IORESOURCE_IO;
 231                 break;
 232
 233         case 0x02: /* 32 bits */
 234         case 0x03: /* 64 bits */
 235                 flags |= IORESOURCE_MEM;
 236                 break;
 237         }
 238         if (w & 0x40000000)
 239                 flags |= IORESOURCE_PREFETCH;
 240         return flags;
 241 }
 242
 243 /*
 244  * SBUS bus specific translator
 245  */
 246
 247 static int of_bus_sbus_match(struct device_node *np)
 248 {
 249         struct device_node *dp = np;
 250
 251         while (dp) {
 252                 if (!strcmp(dp->name, "sbus") ||
 253                     !strcmp(dp->name, "sbi"))
 254                         return 1;
 255
 256                 /* Have a look at use_1to1_mapping().  We're trying
 257                  * to match SBUS if that's the top-level bus and we
 258                  * don't have some intervening real bus that provides
 259                  * ranges based translations.
 260                  */
 261                 if (of_find_property(dp, "ranges", NULL) != NULL)
 262                         break;
 263
 264                 dp = dp->parent;
 265         }
 266
 267         return 0;
 268 }
 269
 270 static void of_bus_sbus_count_cells(struct device_node *child,
 271                                    int *addrc, int *sizec)
 272 {
 273         if (addrc)
 274                 *addrc = 2;
 275         if (sizec)
 276                 *sizec = 1;
 277 }
 278
 279 static int of_bus_sbus_map(u32 *addr, const u32 *range, int na, int ns, int pna)
 280 {
 281         return of_bus_default_map(addr, range, na, ns, pna);
 282 }
 283
 284 static unsigned long of_bus_sbus_get_flags(const u32 *addr, unsigned long flags)
 285 {
 286         return IORESOURCE_MEM;
 287 }
 288
 289
 290 /*
 291  * Array of bus specific translators
 292  */
 293
 294 static struct of_bus of_busses[] = {
 295         /* PCI */
 296         {
 297                 .name = "pci",
 298                 .addr_prop_name = "assigned-addresses",
 299                 .match = of_bus_pci_match,
 300                 .count_cells = of_bus_pci_count_cells,
 301                 .map = of_bus_pci_map,
 302                 .get_flags = of_bus_pci_get_flags,
 303         },
 304         /* SBUS */
 305         {
 306                 .name = "sbus",
 307                 .addr_prop_name = "reg",
 308                 .match = of_bus_sbus_match,
 309                 .count_cells = of_bus_sbus_count_cells,
 310                 .map = of_bus_sbus_map,
 311                 .get_flags = of_bus_sbus_get_flags,
 312         },
 313         /* Default */
 314         {
 315                 .name = "default",
 316                 .addr_prop_name = "reg",
 317                 .match = NULL,
 318                 .count_cells = of_bus_default_count_cells,
 319                 .map = of_bus_default_map,
 320                 .get_flags = of_bus_default_get_flags,
 321         },
 322 };
 323
 324 static struct of_bus *of_match_bus(struct device_node *np)
 325 {
 326         int i;
 327
 328         for (i = 0; i < ARRAY_SIZE(of_busses); i ++)
 329                 if (!of_busses[i].match || of_busses[i].match(np))
 330                         return &of_busses[i];
 331         BUG();
 332         return NULL;
 333 }
 334
 335 static int __init build_one_resource(struct device_node *parent,
 336                                      struct of_bus *bus,
 337                                      struct of_bus *pbus,
 338                                      u32 *addr,
 339                                      int na, int ns, int pna)
 340 {
 341         const u32 *ranges;
 342         unsigned int rlen;
 343         int rone;
 344
 345         ranges = of_get_property(parent, "ranges", &rlen);
 346         if (ranges == NULL || rlen == 0) {
 347                 u32 result[OF_MAX_ADDR_CELLS];
 348                 int i;
 349
 350                 memset(result, 0, pna * 4);
 351                 for (i = 0; i < na; i++)
 352                         result[pna - 1 - i] =
 353                                 addr[na - 1 - i];
 354
 355                 memcpy(addr, result, pna * 4);
 356                 return 0;
 357         }
 358
 359         /* Now walk through the ranges */
 360         rlen /= 4;
 361         rone = na + pna + ns;
 362         for (; rlen >= rone; rlen -= rone, ranges += rone) {
 363                 if (!bus->map(addr, ranges, na, ns, pna))
 364                         return 0;
 365         }
 366
 367         return 1;
 368 }
 369
 370 static int __init use_1to1_mapping(struct device_node *pp)
 371 {
 372         /* If we have a ranges property in the parent, use it.  */
 373         if (of_find_property(pp, "ranges", NULL) != NULL)
 374                 return 0;
 375
 376         /* Some SBUS devices use intermediate nodes to express
 377          * hierarchy within the device itself.  These aren't
 378          * real bus nodes, and don't have a 'ranges' property.
 379          * But, we should still pass the translation work up
 380          * to the SBUS itself.
 381          */
 382         if (!strcmp(pp->name, "dma") ||
 383             !strcmp(pp->name, "espdma") ||
 384             !strcmp(pp->name, "ledma") ||
 385             !strcmp(pp->name, "lebuffer"))
 386                 return 0;
 387
 388         return 1;
 389 }
 390
 391 static int of_resource_verbose;
 392
 393 static void __init build_device_resources(struct of_device *op,
 394                                           struct device *parent)
 395 {
 396         struct of_device *p_op;
 397         struct of_bus *bus;
 398         int na, ns;
 399         int index, num_reg;
 400         const void *preg;
 401
 402         if (!parent)
 403                 return;
 404
 405         p_op = to_of_device(parent);
 406         bus = of_match_bus(p_op->node);
 407         bus->count_cells(op->node, &na, &ns);
 408
 409         preg = of_get_property(op->node, bus->addr_prop_name, &num_reg);
 410         if (!preg || num_reg == 0)
 411                 return;
 412
 413         /* Convert to num-cells.  */
 414         num_reg /= 4;
 415
 416         /* Conver to num-entries.  */
 417         num_reg /= na + ns;
 418
 419         for (index = 0; index < num_reg; index++) {
 420                 struct resource *r = &op->resource[index];
 421                 u32 addr[OF_MAX_ADDR_CELLS];
 422                 const u32 *reg = (preg + (index * ((na + ns) * 4)));
 423                 struct device_node *dp = op->node;
 424                 struct device_node *pp = p_op->node;
 425                 struct of_bus *pbus, *dbus;
 426                 u64 size, result = OF_BAD_ADDR;
 427                 unsigned long flags;
 428                 int dna, dns;
 429                 int pna, pns;
 430
 431                 size = of_read_addr(reg + na, ns);
 432
 433                 memcpy(addr, reg, na * 4);
 434
 435                 flags = bus->get_flags(reg, 0);
 436
 437                 if (use_1to1_mapping(pp)) {
 438                         result = of_read_addr(addr, na);
 439                         goto build_res;
 440                 }
 441
 442                 dna = na;
 443                 dns = ns;
 444                 dbus = bus;
 445
 446                 while (1) {
 447                         dp = pp;
 448                         pp = dp->parent;
 449                         if (!pp) {
 450                                 result = of_read_addr(addr, dna);
 451                                 break;
 452                         }
 453
 454                         pbus = of_match_bus(pp);
 455                         pbus->count_cells(dp, &pna, &pns);
 456
 457                         if (build_one_resource(dp, dbus, pbus, addr,
 458                                                dna, dns, pna))
 459                                 break;
 460
 461                         flags = pbus->get_flags(addr, flags);
 462
 463                         dna = pna;
 464                         dns = pns;
 465                         dbus = pbus;
 466                 }
 467
 468         build_res:
 469                 memset(r, 0, sizeof(*r));
 470
 471                 if (of_resource_verbose)
 472                         printk("%s reg[%d] -> %llx\n",
 473                                op->node->full_name, index,
 474                                result);
 475
 476                 if (result != OF_BAD_ADDR) {
 477                         r->start = result & 0xffffffff;
 478                         r->end = result + size - 1;
 479                         r->flags = flags | ((result >> 32ULL) & 0xffUL);
 480                 }
 481                 r->name = op->node->name;
 482         }
 483 }
 484
 485 static struct of_device * __init scan_one_device(struct device_node *dp,
 486                                                  struct device *parent)
 487 {
 488         struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL);
 489         const struct linux_prom_irqs *intr;
 490         struct dev_archdata *sd;
 491         int len, i;
 492
 493         if (!op)
 494                 return NULL;
 495
 496         sd = &op->dev.archdata;
 497         sd->prom_node = dp;
 498         sd->op = op;
 499
 500         op->node = dp;
 501
 502         op->clock_freq = of_getintprop_default(dp, "clock-frequency",
 503                                                (25*1000*1000));
 504         op->portid = of_getintprop_default(dp, "upa-portid", -1);
 505         if (op->portid == -1)
 506                 op->portid = of_getintprop_default(dp, "portid", -1);
 507
 508         intr = of_get_property(dp, "intr", &len);
 509         if (intr) {
 510                 op->num_irqs = len / sizeof(struct linux_prom_irqs);
 511                 for (i = 0; i < op->num_irqs; i++)
 512                         op->irqs[i] = intr[i].pri;
 513         } else {
 514                 const unsigned int *irq =
 515                         of_get_property(dp, "interrupts", &len);
 516
 517                 if (irq) {
 518                         op->num_irqs = len / sizeof(unsigned int);
 519                         for (i = 0; i < op->num_irqs; i++)
 520                                 op->irqs[i] = irq[i];
 521                 } else {
 522                         op->num_irqs = 0;
 523                 }
 524         }
 525         if (sparc_cpu_model == sun4d) {
 526                 static int pil_to_sbus[] = {
 527                         0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0,
 528                 };
 529                 struct device_node *io_unit, *sbi = dp->parent;
 530                 const struct linux_prom_registers *regs;
 531                 int board, slot;
 532
 533                 while (sbi) {
 534                         if (!strcmp(sbi->name, "sbi"))
 535                                 break;
 536
 537                         sbi = sbi->parent;
 538                 }
 539                 if (!sbi)
 540                         goto build_resources;
 541
 542                 regs = of_get_property(dp, "reg", NULL);
 543                 if (!regs)
 544                         goto build_resources;
 545
 546                 slot = regs->which_io;
 547
 548                 /* If SBI's parent is not io-unit or the io-unit lacks
 549                  * a "board#" property, something is very wrong.
 550                  */
 551                 if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) {
 552                         printk("%s: Error, parent is not io-unit.\n",
 553                                sbi->full_name);
 554                         goto build_resources;
 555                 }
 556                 io_unit = sbi->parent;
 557                 board = of_getintprop_default(io_unit, "board#", -1);
 558                 if (board == -1) {
 559                         printk("%s: Error, lacks board# property.\n",
 560                                io_unit->full_name);
 561                         goto build_resources;
 562                 }
 563
 564                 for (i = 0; i < op->num_irqs; i++) {
 565                         int this_irq = op->irqs[i];
 566                         int sbusl = pil_to_sbus[this_irq];
 567
 568                         if (sbusl)
 569                                 this_irq = (((board + 1) << 5) +
 570                                             (sbusl << 2) +
 571                                             slot);
 572
 573                         op->irqs[i] = this_irq;
 574                 }
 575         }
 576
 577 build_resources:
 578         build_device_resources(op, parent);
 579
 580         op->dev.parent = parent;
 581         op->dev.bus = &of_platform_bus_type;
 582         if (!parent)
 583                 dev_set_name(&op->dev, "root");
 584         else
 585                 dev_set_name(&op->dev, "%08x", dp->node);
 586
 587         if (of_device_register(op)) {
 588                 printk("%s: Could not register of device.\n",
 589                        dp->full_name);
 590                 kfree(op);
 591                 op = NULL;
 592         }
 593
 594         return op;
 595 }
 596
 597 static void __init scan_tree(struct device_node *dp, struct device *parent)
 598 {
 599         while (dp) {
 600                 struct of_device *op = scan_one_device(dp, parent);
 601
 602                 if (op)
 603                         scan_tree(dp->child, &op->dev);
 604
 605                 dp = dp->sibling;
 606         }
 607 }
 608
 609 static void __init scan_of_devices(void)
 610 {
 611         struct device_node *root = of_find_node_by_path("/");
 612         struct of_device *parent;
 613
 614         parent = scan_one_device(root, NULL);
 615         if (!parent)
 616                 return;
 617
 618         scan_tree(root->child, &parent->dev);
 619 }
 620
 621 static int __init of_bus_driver_init(void)
 622 {
 623         int err;
 624
 625         err = of_bus_type_init(&of_platform_bus_type, "of");
 626         if (!err)
 627                 scan_of_devices();
 628
 629         return err;
 630 }
 631
 632 postcore_initcall(of_bus_driver_init);
 633
 634 static int __init of_debug(char *str)
 635 {
 636         int val = 0;
 637
 638         get_option(&str, &val);
 639         if (val & 1)
 640                 of_resource_verbose = 1;
 641         return 1;
 642 }
 643
 644 __setup("of_debug=", of_debug);