sys/dev/fdt/fdt_common.c

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