sys/dev/fdt/fdt_common.c

   1 /*-
   2  * Copyright (c) 2009-2014 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Andrew Turner under sponsorship from
   6  * the FreeBSD Foundation.
   7  * This software was developed by Semihalf under sponsorship from
   8  * the FreeBSD Foundation.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/module.h>
  39 #include <sys/bus.h>
  40 #include <sys/limits.h>
  41
  42 #include <machine/resource.h>
  43
  44 #include <dev/fdt/fdt_common.h>
  45 #include <dev/ofw/ofw_bus.h>
  46 #include <dev/ofw/ofw_bus_subr.h>
  47 #include <dev/ofw/openfirm.h>
  48
  49 #include "ofw_bus_if.h"
  50
  51 #ifdef DEBUG
  52 #define debugf(fmt, args...) do { printf("%s(): ", __func__);   \
  53     printf(fmt,##args); } while (0)
  54 #else
  55 #define debugf(fmt, args...)
  56 #endif
  57
  58 #define FDT_COMPAT_LEN  255
  59 #define FDT_TYPE_LEN    64
  60 #define FDT_NAME_LEN    32
  61
  62 #define FDT_REG_CELLS   4
  63
  64 vm_paddr_t fdt_immr_pa;
  65 vm_offset_t fdt_immr_va;
  66 vm_offset_t fdt_immr_size;
  67
  68 struct fdt_ic_list fdt_ic_list_head = SLIST_HEAD_INITIALIZER(fdt_ic_list_head);
  69
  70 static int
  71 fdt_get_range_by_busaddr(phandle_t node, u_long addr, u_long *base,
  72     u_long *size)
  73 {
  74         pcell_t ranges[32], *rangesptr;
  75         pcell_t addr_cells, size_cells, par_addr_cells;
  76         u_long bus_addr, par_bus_addr, pbase, psize;
  77         int err, i, len, tuple_size, tuples;
  78
  79         if (node == 0) {
  80                 *base = 0;
  81                 *size = ULONG_MAX;
  82                 return (0);
  83         }
  84
  85         if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
  86                 return (ENXIO);
  87         /*
  88          * Process 'ranges' property.
  89          */
  90         par_addr_cells = fdt_parent_addr_cells(node);
  91         if (par_addr_cells > 2) {
  92                 return (ERANGE);
  93         }
  94
  95         len = OF_getproplen(node, "ranges");
  96         if (len < 0)
  97                 return (-1);
  98         if (len > sizeof(ranges))
  99                 return (ENOMEM);
 100         if (len == 0) {
 101                 return (fdt_get_range_by_busaddr(OF_parent(node), addr,
 102                     base, size));
 103         }
 104
 105         if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
 106                 return (EINVAL);
 107
 108         tuple_size = addr_cells + par_addr_cells + size_cells;
 109         tuples = len / (tuple_size * sizeof(cell_t));
 110
 111         if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
 112                 return (ERANGE);
 113
 114         *base = 0;
 115         *size = 0;
 116
 117         for (i = 0; i < tuples; i++) {
 118                 rangesptr = &ranges[i * tuple_size];
 119
 120                 bus_addr = fdt_data_get((void *)rangesptr, addr_cells);
 121                 if (bus_addr != addr)
 122                         continue;
 123                 rangesptr += addr_cells;
 124
 125                 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
 126                 rangesptr += par_addr_cells;
 127
 128                 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
 129                     &pbase, &psize);
 130                 if (err > 0)
 131                         return (err);
 132                 if (err == 0)
 133                         *base = pbase;
 134                 else
 135                         *base = par_bus_addr;
 136
 137                 *size = fdt_data_get((void *)rangesptr, size_cells);
 138
 139                 return (0);
 140         }
 141
 142         return (EINVAL);
 143 }
 144
 145 int
 146 fdt_get_range(phandle_t node, int range_id, u_long *base, u_long *size)
 147 {
 148         pcell_t ranges[6], *rangesptr;
 149         pcell_t addr_cells, size_cells, par_addr_cells;
 150         u_long par_bus_addr, pbase, psize;
 151         int err, len, tuple_size, tuples;
 152
 153         if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
 154                 return (ENXIO);
 155         /*
 156          * Process 'ranges' property.
 157          */
 158         par_addr_cells = fdt_parent_addr_cells(node);
 159         if (par_addr_cells > 2)
 160                 return (ERANGE);
 161
 162         len = OF_getproplen(node, "ranges");
 163         if (len > sizeof(ranges))
 164                 return (ENOMEM);
 165         if (len == 0) {
 166                 *base = 0;
 167                 *size = ULONG_MAX;
 168                 return (0);
 169         }
 170
 171         if (!(range_id < len))
 172                 return (ERANGE);
 173
 174         if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
 175                 return (EINVAL);
 176
 177         tuple_size = sizeof(pcell_t) * (addr_cells + par_addr_cells +
 178             size_cells);
 179         tuples = len / tuple_size;
 180
 181         if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
 182                 return (ERANGE);
 183
 184         *base = 0;
 185         *size = 0;
 186         rangesptr = &ranges[range_id];
 187
 188         *base = fdt_data_get((void *)rangesptr, addr_cells);
 189         rangesptr += addr_cells;
 190
 191         par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
 192         rangesptr += par_addr_cells;
 193
 194         err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
 195            &pbase, &psize);
 196         if (err == 0)
 197                 *base += pbase;
 198         else
 199                 *base += par_bus_addr;
 200
 201         *size = fdt_data_get((void *)rangesptr, size_cells);
 202         return (0);
 203 }
 204
 205 int
 206 fdt_immr_addr(vm_offset_t immr_va)
 207 {
 208         phandle_t node;
 209         u_long base, size;
 210         int r;
 211
 212         /*
 213          * Try to access the SOC node directly i.e. through /aliases/.
 214          */
 215         if ((node = OF_finddevice("soc")) != 0)
 216                 if (fdt_is_compatible_strict(node, "simple-bus"))
 217                         goto moveon;
 218         /*
 219          * Find the node the long way.
 220          */
 221         if ((node = OF_finddevice("/")) == 0)
 222                 return (ENXIO);
 223
 224         if ((node = fdt_find_compatible(node, "simple-bus", 1)) == 0)
 225                 return (ENXIO);
 226
 227 moveon:
 228         if ((r = fdt_get_range(node, 0, &base, &size)) == 0) {
 229                 fdt_immr_pa = base;
 230                 fdt_immr_va = immr_va;
 231                 fdt_immr_size = size;
 232         }
 233
 234         return (r);
 235 }
 236
 237 /*
 238  * This routine is an early-usage version of the ofw_bus_is_compatible() when
 239  * the ofw_bus I/F is not available (like early console routines and similar).
 240  * Note the buffer has to be on the stack since malloc() is usually not
 241  * available in such cases either.
 242  */
 243 int
 244 fdt_is_compatible(phandle_t node, const char *compatstr)
 245 {
 246         char buf[FDT_COMPAT_LEN];
 247         char *compat;
 248         int len, onelen, l, rv;
 249
 250         if ((len = OF_getproplen(node, "compatible")) <= 0)
 251                 return (0);
 252
 253         compat = (char *)&buf;
 254         bzero(compat, FDT_COMPAT_LEN);
 255
 256         if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
 257                 return (0);
 258
 259         onelen = strlen(compatstr);
 260         rv = 0;
 261         while (len > 0) {
 262                 if (strncasecmp(compat, compatstr, onelen) == 0) {
 263                         /* Found it. */
 264                         rv = 1;
 265                         break;
 266                 }
 267                 /* Slide to the next sub-string. */
 268                 l = strlen(compat) + 1;
 269                 compat += l;
 270                 len -= l;
 271         }
 272
 273         return (rv);
 274 }
 275
 276 int
 277 fdt_is_compatible_strict(phandle_t node, const char *compatible)
 278 {
 279         char compat[FDT_COMPAT_LEN];
 280
 281         if (OF_getproplen(node, "compatible") <= 0)
 282                 return (0);
 283
 284         if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
 285                 return (0);
 286
 287         if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0)
 288                 /* This fits. */
 289                 return (1);
 290
 291         return (0);
 292 }
 293
 294 phandle_t
 295 fdt_find_compatible(phandle_t start, const char *compat, int strict)
 296 {
 297         phandle_t child;
 298
 299         /*
 300          * Traverse all children of 'start' node, and find first with
 301          * matching 'compatible' property.
 302          */
 303         for (child = OF_child(start); child != 0; child = OF_peer(child))
 304                 if (fdt_is_compatible(child, compat)) {
 305                         if (strict)
 306                                 if (!fdt_is_compatible_strict(child, compat))
 307                                         continue;
 308                         return (child);
 309                 }
 310         return (0);
 311 }
 312
 313 phandle_t
 314 fdt_find_child(phandle_t start, const char *child_name)
 315 {
 316         char name[FDT_NAME_LEN];
 317         phandle_t child;
 318
 319         for (child = OF_child(start); child != 0; child = OF_peer(child)) {
 320                 if (OF_getprop(child, "name", name, sizeof(name)) <= 0)
 321                         continue;
 322                 if (strcmp(name, child_name) == 0)
 323                         return (child);
 324         }
 325
 326         return (0);
 327 }
 328
 329 phandle_t
 330 fdt_depth_search_compatible(phandle_t start, const char *compat, int strict)
 331 {
 332         phandle_t child, node;
 333
 334         /*
 335          * Depth-search all descendants of 'start' node, and find first with
 336          * matching 'compatible' property.
 337          */
 338         for (node = OF_child(start); node != 0; node = OF_peer(node)) {
 339                 if (fdt_is_compatible(node, compat) &&
 340                     (strict == 0 || fdt_is_compatible_strict(node, compat))) {
 341                         return (node);
 342                 }
 343                 child = fdt_depth_search_compatible(node, compat, strict);
 344                 if (child != 0)
 345                         return (child);
 346         }
 347         return (0);
 348 }
 349
 350 int
 351 fdt_is_enabled(phandle_t node)
 352 {
 353         char *stat;
 354         int ena, len;
 355
 356         len = OF_getprop_alloc(node, "status", sizeof(char),
 357             (void **)&stat);
 358
 359         if (len <= 0)
 360                 /* It is OK if no 'status' property. */
 361                 return (1);
 362
 363         /* Anything other than 'okay' means disabled. */
 364         ena = 0;
 365         if (strncmp((char *)stat, "okay", len) == 0)
 366                 ena = 1;
 367
 368         free(stat, M_OFWPROP);
 369         return (ena);
 370 }
 371
 372 int
 373 fdt_is_type(phandle_t node, const char *typestr)
 374 {
 375         char type[FDT_TYPE_LEN];
 376
 377         if (OF_getproplen(node, "device_type") <= 0)
 378                 return (0);
 379
 380         if (OF_getprop(node, "device_type", type, FDT_TYPE_LEN) < 0)
 381                 return (0);
 382
 383         if (strncasecmp(type, typestr, FDT_TYPE_LEN) == 0)
 384                 /* This fits. */
 385                 return (1);
 386
 387         return (0);
 388 }
 389
 390 int
 391 fdt_parent_addr_cells(phandle_t node)
 392 {
 393         pcell_t addr_cells;
 394
 395         /* Find out #address-cells of the superior bus. */
 396         if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells,
 397             sizeof(addr_cells)) <= 0)
 398                 return (2);
 399
 400         return ((int)fdt32_to_cpu(addr_cells));
 401 }
 402
 403 int
 404 fdt_pm_is_enabled(phandle_t node)
 405 {
 406         int ret;
 407
 408         ret = 1;
 409
 410 #if defined(SOC_MV_KIRKWOOD) || defined(SOC_MV_DISCOVERY)
 411         ret = fdt_pm(node);
 412 #endif
 413         return (ret);
 414 }
 415
 416 u_long
 417 fdt_data_get(void *data, int cells)
 418 {
 419
 420         if (cells == 1)
 421                 return (fdt32_to_cpu(*((uint32_t *)data)));
 422
 423         return (fdt64_to_cpu(*((uint64_t *)data)));
 424 }
 425
 426 int
 427 fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells)
 428 {
 429         pcell_t cell;
 430         int cell_size;
 431
 432         /*
 433          * Retrieve #{address,size}-cells.
 434          */
 435         cell_size = sizeof(cell);
 436         if (OF_getprop(node, "#address-cells", &cell, cell_size) < cell_size)
 437                 cell = 2;
 438         *addr_cells = fdt32_to_cpu((int)cell);
 439
 440         if (OF_getprop(node, "#size-cells", &cell, cell_size) < cell_size)
 441                 cell = 1;
 442         *size_cells = fdt32_to_cpu((int)cell);
 443
 444         if (*addr_cells > 3 || *size_cells > 2)
 445                 return (ERANGE);
 446         return (0);
 447 }
 448
 449 int
 450 fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start,
 451     u_long *count)
 452 {
 453
 454         /* Address portion. */
 455         if (addr_cells > 2)
 456                 return (ERANGE);
 457
 458         *start = fdt_data_get((void *)data, addr_cells);
 459         data += addr_cells;
 460
 461         /* Size portion. */
 462         if (size_cells > 2)
 463                 return (ERANGE);
 464
 465         *count = fdt_data_get((void *)data, size_cells);
 466         return (0);
 467 }
 468
 469 int
 470 fdt_regsize(phandle_t node, u_long *base, u_long *size)
 471 {
 472         pcell_t reg[4];
 473         int addr_cells, len, size_cells;
 474
 475         if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells))
 476                 return (ENXIO);
 477
 478         if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg))
 479                 return (ENOMEM);
 480
 481         len = OF_getprop(node, "reg", &reg, sizeof(reg));
 482         if (len <= 0)
 483                 return (EINVAL);
 484
 485         *base = fdt_data_get(&reg[0], addr_cells);
 486         *size = fdt_data_get(&reg[addr_cells], size_cells);
 487         return (0);
 488 }
 489
 490 int
 491 fdt_reg_to_rl(phandle_t node, struct resource_list *rl)
 492 {
 493         u_long end, count, start;
 494         pcell_t *reg, *regptr;
 495         pcell_t addr_cells, size_cells;
 496         int tuple_size, tuples;
 497         int i, rv;
 498         long busaddr, bussize;
 499
 500         if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0)
 501                 return (ENXIO);
 502         if (fdt_get_range(OF_parent(node), 0, &busaddr, &bussize)) {
 503                 busaddr = 0;
 504                 bussize = 0;
 505         }
 506
 507         tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
 508         tuples = OF_getprop_alloc(node, "reg", tuple_size, (void **)&reg);
 509         debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells);
 510         debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size);
 511         if (tuples <= 0)
 512                 /* No 'reg' property in this node. */
 513                 return (0);
 514
 515         regptr = reg;
 516         for (i = 0; i < tuples; i++) {
 517
 518                 rv = fdt_data_to_res(reg, addr_cells, size_cells, &start,
 519                     &count);
 520                 if (rv != 0) {
 521                         resource_list_free(rl);
 522                         goto out;
 523                 }
 524                 reg += addr_cells + size_cells;
 525
 526                 /* Calculate address range relative to base. */
 527                 start += busaddr;
 528                 end = start + count - 1;
 529
 530                 debugf("reg addr start = %lx, end = %lx, count = %lx\n", start,
 531                     end, count);
 532
 533                 resource_list_add(rl, SYS_RES_MEMORY, i, start, end,
 534                     count);
 535         }
 536         rv = 0;
 537
 538 out:
 539         free(regptr, M_OFWPROP);
 540         return (rv);
 541 }
 542
 543 int
 544 fdt_get_phyaddr(phandle_t node, device_t dev, int *phy_addr, void **phy_sc)
 545 {
 546         phandle_t phy_node;
 547         pcell_t phy_handle, phy_reg;
 548         uint32_t i;
 549         device_t parent, child;
 550
 551         if (OF_getencprop(node, "phy-handle", (void *)&phy_handle,
 552             sizeof(phy_handle)) <= 0)
 553                 return (ENXIO);
 554
 555         phy_node = OF_node_from_xref(phy_handle);
 556
 557         if (OF_getprop(phy_node, "reg", (void *)&phy_reg,
 558             sizeof(phy_reg)) <= 0)
 559                 return (ENXIO);
 560
 561         *phy_addr = fdt32_to_cpu(phy_reg);
 562
 563         /*
 564          * Search for softc used to communicate with phy.
 565          */
 566
 567         /*
 568          * Step 1: Search for ancestor of the phy-node with a "phy-handle"
 569          * property set.
 570          */
 571         phy_node = OF_parent(phy_node);
 572         while (phy_node != 0) {
 573                 if (OF_getprop(phy_node, "phy-handle", (void *)&phy_handle,
 574                     sizeof(phy_handle)) > 0)
 575                         break;
 576                 phy_node = OF_parent(phy_node);
 577         }
 578         if (phy_node == 0)
 579                 return (ENXIO);
 580
 581         /*
 582          * Step 2: For each device with the same parent and name as ours
 583          * compare its node with the one found in step 1, ancestor of phy
 584          * node (stored in phy_node).
 585          */
 586         parent = device_get_parent(dev);
 587         i = 0;
 588         child = device_find_child(parent, device_get_name(dev), i);
 589         while (child != NULL) {
 590                 if (ofw_bus_get_node(child) == phy_node)
 591                         break;
 592                 i++;
 593                 child = device_find_child(parent, device_get_name(dev), i);
 594         }
 595         if (child == NULL)
 596                 return (ENXIO);
 597
 598         /*
 599          * Use softc of the device found.
 600          */
 601         *phy_sc = (void *)device_get_softc(child);
 602
 603         return (0);
 604 }
 605
 606 int
 607 fdt_get_reserved_regions(struct mem_region *mr, int *mrcnt)
 608 {
 609         pcell_t reserve[FDT_REG_CELLS * FDT_MEM_REGIONS];
 610         pcell_t *reservep;
 611         phandle_t memory, root;
 612         uint32_t memory_size;
 613         int addr_cells, size_cells;
 614         int i, max_size, res_len, rv, tuple_size, tuples;
 615
 616         max_size = sizeof(reserve);
 617         root = OF_finddevice("/");
 618         memory = OF_finddevice("/memory");
 619         if (memory == -1) {
 620                 rv = ENXIO;
 621                 goto out;
 622         }
 623
 624         if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
 625             &size_cells)) != 0)
 626                 goto out;
 627
 628         if (addr_cells > 2) {
 629                 rv = ERANGE;
 630                 goto out;
 631         }
 632
 633         tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
 634
 635         res_len = OF_getproplen(root, "memreserve");
 636         if (res_len <= 0 || res_len > sizeof(reserve)) {
 637                 rv = ERANGE;
 638                 goto out;
 639         }
 640
 641         if (OF_getprop(root, "memreserve", reserve, res_len) <= 0) {
 642                 rv = ENXIO;
 643                 goto out;
 644         }
 645
 646         memory_size = 0;
 647         tuples = res_len / tuple_size;
 648         reservep = (pcell_t *)&reserve;
 649         for (i = 0; i < tuples; i++) {
 650
 651                 rv = fdt_data_to_res(reservep, addr_cells, size_cells,
 652                         (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
 653
 654                 if (rv != 0)
 655                         goto out;
 656
 657                 reservep += addr_cells + size_cells;
 658         }
 659
 660         *mrcnt = i;
 661         rv = 0;
 662 out:
 663         return (rv);
 664 }
 665
 666 int
 667 fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint32_t *memsize)
 668 {
 669         pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS];
 670         pcell_t *regp;
 671         phandle_t memory;
 672         uint32_t memory_size;
 673         int addr_cells, size_cells;
 674         int i, max_size, reg_len, rv, tuple_size, tuples;
 675
 676         max_size = sizeof(reg);
 677         memory = OF_finddevice("/memory");
 678         if (memory == -1) {
 679                 rv = ENXIO;
 680                 goto out;
 681         }
 682
 683         if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
 684             &size_cells)) != 0)
 685                 goto out;
 686
 687         if (addr_cells > 2) {
 688                 rv = ERANGE;
 689                 goto out;
 690         }
 691
 692         tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
 693         reg_len = OF_getproplen(memory, "reg");
 694         if (reg_len <= 0 || reg_len > sizeof(reg)) {
 695                 rv = ERANGE;
 696                 goto out;
 697         }
 698
 699         if (OF_getprop(memory, "reg", reg, reg_len) <= 0) {
 700                 rv = ENXIO;
 701                 goto out;
 702         }
 703
 704         memory_size = 0;
 705         tuples = reg_len / tuple_size;
 706         regp = (pcell_t *)&reg;
 707         for (i = 0; i < tuples; i++) {
 708
 709                 rv = fdt_data_to_res(regp, addr_cells, size_cells,
 710                         (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
 711
 712                 if (rv != 0)
 713                         goto out;
 714
 715                 regp += addr_cells + size_cells;
 716                 memory_size += mr[i].mr_size;
 717         }
 718
 719         if (memory_size == 0) {
 720                 rv = ERANGE;
 721                 goto out;
 722         }
 723
 724         *mrcnt = i;
 725         *memsize = memory_size;
 726         rv = 0;
 727 out:
 728         return (rv);
 729 }
 730
 731 int
 732 fdt_get_unit(device_t dev)
 733 {
 734         const char * name;
 735
 736         name = ofw_bus_get_name(dev);
 737         name = strchr(name, '@') + 1;
 738
 739         return (strtol(name,NULL,0));
 740 }