sys/dev/fdt/fdt_common.c

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