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         return !strcmp(np->name, "sbus") ||
 250                 !strcmp(np->name, "sbi");
 251 }
 252
 253 static void of_bus_sbus_count_cells(struct device_node *child,
 254                                    int *addrc, int *sizec)
 255 {
 256         if (addrc)
 257                 *addrc = 2;
 258         if (sizec)
 259                 *sizec = 1;
 260 }
 261
 262 static int of_bus_sbus_map(u32 *addr, const u32 *range, int na, int ns, int pna)
 263 {
 264         return of_bus_default_map(addr, range, na, ns, pna);
 265 }
 266
 267 static unsigned long of_bus_sbus_get_flags(const u32 *addr, unsigned long flags)
 268 {
 269         return IORESOURCE_MEM;
 270 }
 271
 272
 273 /*
 274  * Array of bus specific translators
 275  */
 276
 277 static struct of_bus of_busses[] = {
 278         /* PCI */
 279         {
 280                 .name = "pci",
 281                 .addr_prop_name = "assigned-addresses",
 282                 .match = of_bus_pci_match,
 283                 .count_cells = of_bus_pci_count_cells,
 284                 .map = of_bus_pci_map,
 285                 .get_flags = of_bus_pci_get_flags,
 286         },
 287         /* SBUS */
 288         {
 289                 .name = "sbus",
 290                 .addr_prop_name = "reg",
 291                 .match = of_bus_sbus_match,
 292                 .count_cells = of_bus_sbus_count_cells,
 293                 .map = of_bus_sbus_map,
 294                 .get_flags = of_bus_sbus_get_flags,
 295         },
 296         /* Default */
 297         {
 298                 .name = "default",
 299                 .addr_prop_name = "reg",
 300                 .match = NULL,
 301                 .count_cells = of_bus_default_count_cells,
 302                 .map = of_bus_default_map,
 303                 .get_flags = of_bus_default_get_flags,
 304         },
 305 };
 306
 307 static struct of_bus *of_match_bus(struct device_node *np)
 308 {
 309         int i;
 310
 311         for (i = 0; i < ARRAY_SIZE(of_busses); i ++)
 312                 if (!of_busses[i].match || of_busses[i].match(np))
 313                         return &of_busses[i];
 314         BUG();
 315         return NULL;
 316 }
 317
 318 static int __init build_one_resource(struct device_node *parent,
 319                                      struct of_bus *bus,
 320                                      struct of_bus *pbus,
 321                                      u32 *addr,
 322                                      int na, int ns, int pna)
 323 {
 324         const u32 *ranges;
 325         unsigned int rlen;
 326         int rone;
 327
 328         ranges = of_get_property(parent, "ranges", &rlen);
 329         if (ranges == NULL || rlen == 0) {
 330                 u32 result[OF_MAX_ADDR_CELLS];
 331                 int i;
 332
 333                 memset(result, 0, pna * 4);
 334                 for (i = 0; i < na; i++)
 335                         result[pna - 1 - i] =
 336                                 addr[na - 1 - i];
 337
 338                 memcpy(addr, result, pna * 4);
 339                 return 0;
 340         }
 341
 342         /* Now walk through the ranges */
 343         rlen /= 4;
 344         rone = na + pna + ns;
 345         for (; rlen >= rone; rlen -= rone, ranges += rone) {
 346                 if (!bus->map(addr, ranges, na, ns, pna))
 347                         return 0;
 348         }
 349
 350         return 1;
 351 }
 352
 353 static int __init use_1to1_mapping(struct device_node *pp)
 354 {
 355         /* If we have a ranges property in the parent, use it.  */
 356         if (of_find_property(pp, "ranges", NULL) != NULL)
 357                 return 0;
 358
 359         /* Some SBUS devices use intermediate nodes to express
 360          * hierarchy within the device itself.  These aren't
 361          * real bus nodes, and don't have a 'ranges' property.
 362          * But, we should still pass the translation work up
 363          * to the SBUS itself.
 364          */
 365         if (!strcmp(pp->name, "dma") ||
 366             !strcmp(pp->name, "espdma") ||
 367             !strcmp(pp->name, "ledma") ||
 368             !strcmp(pp->name, "lebuffer"))
 369                 return 0;
 370
 371         return 1;
 372 }
 373
 374 static int of_resource_verbose;
 375
 376 static void __init build_device_resources(struct of_device *op,
 377                                           struct device *parent)
 378 {
 379         struct of_device *p_op;
 380         struct of_bus *bus;
 381         int na, ns;
 382         int index, num_reg;
 383         const void *preg;
 384
 385         if (!parent)
 386                 return;
 387
 388         p_op = to_of_device(parent);
 389         bus = of_match_bus(p_op->node);
 390         bus->count_cells(op->node, &na, &ns);
 391
 392         preg = of_get_property(op->node, bus->addr_prop_name, &num_reg);
 393         if (!preg || num_reg == 0)
 394                 return;
 395
 396         /* Convert to num-cells.  */
 397         num_reg /= 4;
 398
 399         /* Conver to num-entries.  */
 400         num_reg /= na + ns;
 401
 402         for (index = 0; index < num_reg; index++) {
 403                 struct resource *r = &op->resource[index];
 404                 u32 addr[OF_MAX_ADDR_CELLS];
 405                 const u32 *reg = (preg + (index * ((na + ns) * 4)));
 406                 struct device_node *dp = op->node;
 407                 struct device_node *pp = p_op->node;
 408                 struct of_bus *pbus, *dbus;
 409                 u64 size, result = OF_BAD_ADDR;
 410                 unsigned long flags;
 411                 int dna, dns;
 412                 int pna, pns;
 413
 414                 size = of_read_addr(reg + na, ns);
 415
 416                 memcpy(addr, reg, na * 4);
 417
 418                 flags = bus->get_flags(reg, 0);
 419
 420                 if (use_1to1_mapping(pp)) {
 421                         result = of_read_addr(addr, na);
 422                         goto build_res;
 423                 }
 424
 425                 dna = na;
 426                 dns = ns;
 427                 dbus = bus;
 428
 429                 while (1) {
 430                         dp = pp;
 431                         pp = dp->parent;
 432                         if (!pp) {
 433                                 result = of_read_addr(addr, dna);
 434                                 break;
 435                         }
 436
 437                         pbus = of_match_bus(pp);
 438                         pbus->count_cells(dp, &pna, &pns);
 439
 440                         if (build_one_resource(dp, dbus, pbus, addr,
 441                                                dna, dns, pna))
 442                                 break;
 443
 444                         flags = pbus->get_flags(addr, flags);
 445
 446                         dna = pna;
 447                         dns = pns;
 448                         dbus = pbus;
 449                 }
 450
 451         build_res:
 452                 memset(r, 0, sizeof(*r));
 453
 454                 if (of_resource_verbose)
 455                         printk("%s reg[%d] -> %llx\n",
 456                                op->node->full_name, index,
 457                                result);
 458
 459                 if (result != OF_BAD_ADDR) {
 460                         r->start = result & 0xffffffff;
 461                         r->end = result + size - 1;
 462                         r->flags = flags | ((result >> 32ULL) & 0xffUL);
 463                 }
 464                 r->name = op->node->name;
 465         }
 466 }
 467
 468 static struct of_device * __init scan_one_device(struct device_node *dp,
 469                                                  struct device *parent)
 470 {
 471         struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL);
 472         const struct linux_prom_irqs *intr;
 473         struct dev_archdata *sd;
 474         int len, i;
 475
 476         if (!op)
 477                 return NULL;
 478
 479         sd = &op->dev.archdata;
 480         sd->prom_node = dp;
 481         sd->op = op;
 482
 483         op->node = dp;
 484
 485         op->clock_freq = of_getintprop_default(dp, "clock-frequency",
 486                                                (25*1000*1000));
 487         op->portid = of_getintprop_default(dp, "upa-portid", -1);
 488         if (op->portid == -1)
 489                 op->portid = of_getintprop_default(dp, "portid", -1);
 490
 491         intr = of_get_property(dp, "intr", &len);
 492         if (intr) {
 493                 op->num_irqs = len / sizeof(struct linux_prom_irqs);
 494                 for (i = 0; i < op->num_irqs; i++)
 495                         op->irqs[i] = intr[i].pri;
 496         } else {
 497                 const unsigned int *irq =
 498                         of_get_property(dp, "interrupts", &len);
 499
 500                 if (irq) {
 501                         op->num_irqs = len / sizeof(unsigned int);
 502                         for (i = 0; i < op->num_irqs; i++)
 503                                 op->irqs[i] = irq[i];
 504                 } else {
 505                         op->num_irqs = 0;
 506                 }
 507         }
 508         if (sparc_cpu_model == sun4d) {
 509                 static int pil_to_sbus[] = {
 510                         0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0,
 511                 };
 512                 struct device_node *io_unit, *sbi = dp->parent;
 513                 const struct linux_prom_registers *regs;
 514                 int board, slot;
 515
 516                 while (sbi) {
 517                         if (!strcmp(sbi->name, "sbi"))
 518                                 break;
 519
 520                         sbi = sbi->parent;
 521                 }
 522                 if (!sbi)
 523                         goto build_resources;
 524
 525                 regs = of_get_property(dp, "reg", NULL);
 526                 if (!regs)
 527                         goto build_resources;
 528
 529                 slot = regs->which_io;
 530
 531                 /* If SBI's parent is not io-unit or the io-unit lacks
 532                  * a "board#" property, something is very wrong.
 533                  */
 534                 if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) {
 535                         printk("%s: Error, parent is not io-unit.\n",
 536                                sbi->full_name);
 537                         goto build_resources;
 538                 }
 539                 io_unit = sbi->parent;
 540                 board = of_getintprop_default(io_unit, "board#", -1);
 541                 if (board == -1) {
 542                         printk("%s: Error, lacks board# property.\n",
 543                                io_unit->full_name);
 544                         goto build_resources;
 545                 }
 546
 547                 for (i = 0; i < op->num_irqs; i++) {
 548                         int this_irq = op->irqs[i];
 549                         int sbusl = pil_to_sbus[this_irq];
 550
 551                         if (sbusl)
 552                                 this_irq = (((board + 1) << 5) +
 553                                             (sbusl << 2) +
 554                                             slot);
 555
 556                         op->irqs[i] = this_irq;
 557                 }
 558         }
 559
 560 build_resources:
 561         build_device_resources(op, parent);
 562
 563         op->dev.parent = parent;
 564         op->dev.bus = &of_platform_bus_type;
 565         if (!parent)
 566                 dev_set_name(&op->dev, "root");
 567         else
 568                 dev_set_name(&op->dev, "%08x", dp->node);
 569
 570         if (of_device_register(op)) {
 571                 printk("%s: Could not register of device.\n",
 572                        dp->full_name);
 573                 kfree(op);
 574                 op = NULL;
 575         }
 576
 577         return op;
 578 }
 579
 580 static void __init scan_tree(struct device_node *dp, struct device *parent)
 581 {
 582         while (dp) {
 583                 struct of_device *op = scan_one_device(dp, parent);
 584
 585                 if (op)
 586                         scan_tree(dp->child, &op->dev);
 587
 588                 dp = dp->sibling;
 589         }
 590 }
 591
 592 static void __init scan_of_devices(void)
 593 {
 594         struct device_node *root = of_find_node_by_path("/");
 595         struct of_device *parent;
 596
 597         parent = scan_one_device(root, NULL);
 598         if (!parent)
 599                 return;
 600
 601         scan_tree(root->child, &parent->dev);
 602 }
 603
 604 static int __init of_bus_driver_init(void)
 605 {
 606         int err;
 607
 608         err = of_bus_type_init(&of_platform_bus_type, "of");
 609         if (!err)
 610                 scan_of_devices();
 611
 612         return err;
 613 }
 614
 615 postcore_initcall(of_bus_driver_init);
 616
 617 static int __init of_debug(char *str)
 618 {
 619         int val = 0;
 620
 621         get_option(&str, &val);
 622         if (val & 1)
 623                 of_resource_verbose = 1;
 624         return 1;
 625 }
 626
 627 __setup("of_debug=", of_debug);