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 39 #include <machine/fdt.h> 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 int 66 fdt_immr_addr(vm_offset_t immr_va) 67 { 68 pcell_t ranges[6], *rangesptr; 69 phandle_t node; 70 u_long base, size; 71 pcell_t addr_cells, size_cells, par_addr_cells; 72 int len, tuple_size, tuples; 73 74 /* 75 * Try to access the SOC node directly i.e. through /aliases/. 76 */ 77 if ((node = OF_finddevice("soc")) != 0) 78 if (fdt_is_compatible_strict(node, "simple-bus")) 79 goto moveon; 80 /* 81 * Find the node the long way. 82 */ 83 if ((node = OF_finddevice("/")) == 0) 84 return (ENXIO); 85 86 if ((node = fdt_find_compatible(node, "simple-bus", 1)) == 0) 87 return (ENXIO); 88 89 moveon: 90 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0) 91 return (ENXIO); 92 /* 93 * Process 'ranges' property. 94 */ 95 par_addr_cells = fdt_parent_addr_cells(node); 96 if (par_addr_cells > 2) 97 return (ERANGE); 98 99 len = OF_getproplen(node, "ranges"); 100 if (len > sizeof(ranges)) 101 return (ENOMEM); 102 103 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0) 104 return (EINVAL); 105 106 tuple_size = sizeof(pcell_t) * (addr_cells + par_addr_cells + 107 size_cells); 108 tuples = len / tuple_size; 109 110 if (fdt_ranges_verify(ranges, tuples, par_addr_cells, 111 addr_cells, size_cells)) { 112 return (ERANGE); 113 } 114 base = 0; 115 size = 0; 116 rangesptr = &ranges[0]; 117 118 base = fdt_data_get((void *)rangesptr, addr_cells); 119 rangesptr += addr_cells; 120 base += fdt_data_get((void *)rangesptr, par_addr_cells); 121 rangesptr += par_addr_cells; 122 size = fdt_data_get((void *)rangesptr, size_cells); 123 124 fdt_immr_pa = base; 125 fdt_immr_va = immr_va; 126 fdt_immr_size = size; 127 128 return (0); 129 } 130 131 /* 132 * This routine is an early-usage version of the ofw_bus_is_compatible() when 133 * the ofw_bus I/F is not available (like early console routines and similar). 134 * Note the buffer has to be on the stack since malloc() is usually not 135 * available in such cases either. 136 */ 137 int 138 fdt_is_compatible(phandle_t node, const char *compatstr) 139 { 140 char buf[FDT_COMPAT_LEN]; 141 char *compat; 142 int len, onelen, l, rv; 143 144 if ((len = OF_getproplen(node, "compatible")) <= 0) 145 return (0); 146 147 compat = (char *)&buf; 148 bzero(compat, FDT_COMPAT_LEN); 149 150 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0) 151 return (0); 152 153 onelen = strlen(compatstr); 154 rv = 0; 155 while (len > 0) { 156 if (strncasecmp(compat, compatstr, onelen) == 0) { 157 /* Found it. */ 158 rv = 1; 159 break; 160 } 161 /* Slide to the next sub-string. */ 162 l = strlen(compat) + 1; 163 compat += l; 164 len -= l; 165 } 166 167 return (rv); 168 } 169 170 int 171 fdt_is_compatible_strict(phandle_t node, const char *compatible) 172 { 173 char compat[FDT_COMPAT_LEN]; 174 175 if (OF_getproplen(node, "compatible") <= 0) 176 return (0); 177 178 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0) 179 return (0); 180 181 if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0) 182 /* This fits. */ 183 return (1); 184 185 return (0); 186 } 187 188 phandle_t 189 fdt_find_compatible(phandle_t start, const char *compat, int strict) 190 { 191 phandle_t child; 192 193 /* 194 * Traverse all children of 'start' node, and find first with 195 * matching 'compatible' property. 196 */ 197 for (child = OF_child(start); child != 0; child = OF_peer(child)) 198 if (fdt_is_compatible(child, compat)) { 199 if (strict) 200 if (!fdt_is_compatible_strict(child, compat)) 201 continue; 202 return (child); 203 } 204 return (0); 205 } 206 207 int 208 fdt_is_enabled(phandle_t node) 209 { 210 char *stat; 211 int ena, len; 212 213 len = OF_getprop_alloc(node, "status", sizeof(char), 214 (void **)&stat); 215 216 if (len <= 0) 217 /* It is OK if no 'status' property. */ 218 return (1); 219 220 /* Anything other than 'okay' means disabled. */ 221 ena = 0; 222 if (strncmp((char *)stat, "okay", len) == 0) 223 ena = 1; 224 225 free(stat, M_OFWPROP); 226 return (ena); 227 } 228 229 int 230 fdt_is_type(phandle_t node, const char *typestr) 231 { 232 char type[FDT_TYPE_LEN]; 233 234 if (OF_getproplen(node, "device_type") <= 0) 235 return (0); 236 237 if (OF_getprop(node, "device_type", type, FDT_TYPE_LEN) < 0) 238 return (0); 239 240 if (strncasecmp(type, typestr, FDT_TYPE_LEN) == 0) 241 /* This fits. */ 242 return (1); 243 244 return (0); 245 } 246 247 int 248 fdt_parent_addr_cells(phandle_t node) 249 { 250 pcell_t addr_cells; 251 252 /* Find out #address-cells of the superior bus. */ 253 if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells, 254 sizeof(addr_cells)) <= 0) 255 addr_cells = 2; 256 257 return ((int)fdt32_to_cpu(addr_cells)); 258 } 259 260 int 261 fdt_data_verify(void *data, int cells) 262 { 263 uint64_t d64; 264 265 if (cells > 1) { 266 d64 = fdt64_to_cpu(*((uint64_t *)data)); 267 if (((d64 >> 32) & 0xffffffffull) != 0 || cells > 2) 268 return (ERANGE); 269 } 270 271 return (0); 272 } 273 274 int 275 fdt_pm_is_enabled(phandle_t node) 276 { 277 int ret; 278 279 ret = 1; 280 281 #if defined(SOC_MV_KIRKWOOD) || defined(SOC_MV_DISCOVERY) 282 ret = fdt_pm(node); 283 #endif 284 return (ret); 285 } 286 287 u_long 288 fdt_data_get(void *data, int cells) 289 { 290 291 if (cells == 1) 292 return (fdt32_to_cpu(*((uint32_t *)data))); 293 294 return (fdt64_to_cpu(*((uint64_t *)data))); 295 } 296 297 int 298 fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells) 299 { 300 pcell_t cell; 301 int cell_size; 302 303 /* 304 * Retrieve #{address,size}-cells. 305 */ 306 cell_size = sizeof(cell); 307 if (OF_getprop(node, "#address-cells", &cell, cell_size) < cell_size) 308 cell = 2; 309 *addr_cells = fdt32_to_cpu((int)cell); 310 311 if (OF_getprop(node, "#size-cells", &cell, cell_size) < cell_size) 312 cell = 1; 313 *size_cells = fdt32_to_cpu((int)cell); 314 315 if (*addr_cells > 3 || *size_cells > 2) 316 return (ERANGE); 317 return (0); 318 } 319 320 int 321 fdt_ranges_verify(pcell_t *ranges, int tuples, int par_addr_cells, 322 int this_addr_cells, int this_size_cells) 323 { 324 int i, rv, ulsz; 325 326 if (par_addr_cells > 2 || this_addr_cells > 2 || this_size_cells > 2) 327 return (ERANGE); 328 329 /* 330 * This is the max size the resource manager can handle for addresses 331 * and sizes. 332 */ 333 ulsz = sizeof(u_long); 334 if (par_addr_cells <= ulsz && this_addr_cells <= ulsz && 335 this_size_cells <= ulsz) 336 /* We can handle everything */ 337 return (0); 338 339 rv = 0; 340 for (i = 0; i < tuples; i++) { 341 342 if (fdt_data_verify((void *)ranges, par_addr_cells)) 343 goto err; 344 ranges += par_addr_cells; 345 346 if (fdt_data_verify((void *)ranges, this_addr_cells)) 347 goto err; 348 ranges += this_addr_cells; 349 350 if (fdt_data_verify((void *)ranges, this_size_cells)) 351 goto err; 352 ranges += this_size_cells; 353 } 354 355 return (0); 356 357 err: 358 debugf("using address range >%d-bit not supported\n", ulsz * 8); 359 return (ERANGE); 360 } 361 362 int 363 fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start, 364 u_long *count) 365 { 366 367 /* Address portion. */ 368 if (fdt_data_verify((void *)data, addr_cells)) 369 return (ERANGE); 370 371 *start = fdt_data_get((void *)data, addr_cells); 372 data += addr_cells; 373 374 /* Size portion. */ 375 if (fdt_data_verify((void *)data, size_cells)) 376 return (ERANGE); 377 378 *count = fdt_data_get((void *)data, size_cells); 379 return (0); 380 } 381 382 int 383 fdt_regsize(phandle_t node, u_long *base, u_long *size) 384 { 385 pcell_t reg[4]; 386 int addr_cells, len, size_cells; 387 388 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells)) 389 return (ENXIO); 390 391 if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg)) 392 return (ENOMEM); 393 394 len = OF_getprop(node, "reg", ®, sizeof(reg)); 395 if (len <= 0) 396 return (EINVAL); 397 398 *base = fdt_data_get(®[0], addr_cells); 399 *size = fdt_data_get(®[addr_cells], size_cells); 400 return (0); 401 } 402 403 int 404 fdt_reg_to_rl(phandle_t node, struct resource_list *rl, u_long base) 405 { 406 u_long start, end, count; 407 pcell_t *reg, *regptr; 408 pcell_t addr_cells, size_cells; 409 int tuple_size, tuples; 410 int i, rv; 411 412 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0) 413 return (ENXIO); 414 415 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells); 416 tuples = OF_getprop_alloc(node, "reg", tuple_size, (void **)®); 417 debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells); 418 debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size); 419 if (tuples <= 0) 420 /* No 'reg' property in this node. */ 421 return (0); 422 423 regptr = reg; 424 for (i = 0; i < tuples; i++) { 425 426 rv = fdt_data_to_res(reg, addr_cells, size_cells, &start, 427 &count); 428 if (rv != 0) { 429 resource_list_free(rl); 430 goto out; 431 } 432 reg += addr_cells + size_cells; 433 434 /* Calculate address range relative to base. */ 435 start &= 0x000ffffful; 436 start = base + start; 437 end = start + count - 1; 438 439 debugf("reg addr start = %lx, end = %lx, count = %lx\n", start, 440 end, count); 441 442 resource_list_add(rl, SYS_RES_MEMORY, i, start, end, 443 count); 444 } 445 rv = 0; 446 447 out: 448 free(regptr, M_OFWPROP); 449 return (rv); 450 } 451 452 int 453 fdt_intr_decode(phandle_t intr_parent, pcell_t *intr, int *interrupt, 454 int *trig, int *pol) 455 { 456 fdt_pic_decode_t intr_decode; 457 int i, rv; 458 459 for (i = 0; fdt_pic_table[i] != NULL; i++) { 460 461 /* XXX check if pic_handle has interrupt-controller prop? */ 462 463 intr_decode = fdt_pic_table[i]; 464 rv = intr_decode(intr_parent, intr, interrupt, trig, pol); 465 466 if (rv == 0) 467 /* This was recognized as our PIC and decoded. */ 468 return (0); 469 } 470 471 return (ENXIO); 472 } 473 474 int 475 fdt_intr_to_rl(phandle_t node, struct resource_list *rl, 476 struct fdt_sense_level *intr_sl) 477 { 478 phandle_t intr_par; 479 ihandle_t iph; 480 pcell_t *intr; 481 pcell_t intr_cells; 482 int interrupt, trig, pol; 483 int i, intr_num, irq, rv; 484 485 if (OF_getproplen(node, "interrupts") <= 0) 486 /* Node does not have 'interrupts' property. */ 487 return (0); 488 489 /* 490 * Find #interrupt-cells of the interrupt domain. 491 */ 492 if (OF_getprop(node, "interrupt-parent", &iph, sizeof(iph)) <= 0) { 493 debugf("no intr-parent phandle\n"); 494 intr_par = OF_parent(node); 495 } else { 496 iph = fdt32_to_cpu(iph); 497 intr_par = OF_instance_to_package(iph); 498 } 499 500 if (OF_getprop(intr_par, "#interrupt-cells", &intr_cells, 501 sizeof(intr_cells)) <= 0) { 502 debugf("no intr-cells defined, defaulting to 1\n"); 503 intr_cells = 1; 504 } 505 intr_cells = fdt32_to_cpu(intr_cells); 506 507 intr_num = OF_getprop_alloc(node, "interrupts", 508 intr_cells * sizeof(pcell_t), (void **)&intr); 509 if (intr_num <= 0 || intr_num > DI_MAX_INTR_NUM) 510 return (ERANGE); 511 512 rv = 0; 513 for (i = 0; i < intr_num; i++) { 514 515 interrupt = -1; 516 trig = pol = 0; 517 518 if (fdt_intr_decode(intr_par, &intr[i * intr_cells], 519 &interrupt, &trig, &pol) != 0) { 520 rv = ENXIO; 521 goto out; 522 } 523 524 if (interrupt < 0) { 525 rv = ERANGE; 526 goto out; 527 } 528 529 debugf("decoded intr = %d, trig = %d, pol = %d\n", interrupt, 530 trig, pol); 531 532 intr_sl[i].trig = trig; 533 intr_sl[i].pol = pol; 534 535 irq = FDT_MAP_IRQ(intr_par, interrupt); 536 resource_list_add(rl, SYS_RES_IRQ, i, irq, irq, 1); 537 } 538 539 out: 540 free(intr, M_OFWPROP); 541 return (rv); 542 } 543 544 int 545 fdt_get_phyaddr(phandle_t node, int *phy_addr) 546 { 547 phandle_t phy_node; 548 ihandle_t phy_ihandle; 549 pcell_t phy_handle, phy_reg; 550 551 if (OF_getprop(node, "phy-handle", (void *)&phy_handle, 552 sizeof(phy_handle)) <= 0) 553 return (ENXIO); 554 555 phy_ihandle = (ihandle_t)phy_handle; 556 phy_ihandle = fdt32_to_cpu(phy_ihandle); 557 phy_node = OF_instance_to_package(phy_ihandle); 558 559 if (OF_getprop(phy_node, "reg", (void *)&phy_reg, 560 sizeof(phy_reg)) <= 0) 561 return (ENXIO); 562 563 *phy_addr = fdt32_to_cpu(phy_reg); 564 return (0); 565 } 566 567 int 568 fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint32_t *memsize) 569 { 570 pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS]; 571 pcell_t *regp; 572 phandle_t memory; 573 uint32_t memory_size; 574 int addr_cells, size_cells; 575 int i, max_size, reg_len, rv, tuple_size, tuples; 576 577 max_size = sizeof(reg); 578 memory = OF_finddevice("/memory"); 579 if (memory <= 0) { 580 rv = ENXIO; 581 goto out; 582 } 583 584 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells, 585 &size_cells)) != 0) 586 goto out; 587 588 if (addr_cells > 2) { 589 rv = ERANGE; 590 goto out; 591 } 592 593 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells); 594 reg_len = OF_getproplen(memory, "reg"); 595 if (reg_len <= 0 || reg_len > sizeof(reg)) { 596 rv = ERANGE; 597 goto out; 598 } 599 600 if (OF_getprop(memory, "reg", reg, reg_len) <= 0) { 601 rv = ENXIO; 602 goto out; 603 } 604 605 memory_size = 0; 606 tuples = reg_len / tuple_size; 607 regp = (pcell_t *)® 608 for (i = 0; i < tuples; i++) { 609 610 rv = fdt_data_to_res(regp, addr_cells, size_cells, 611 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size); 612 613 if (rv != 0) 614 goto out; 615 616 regp += addr_cells + size_cells; 617 memory_size += mr[i].mr_size; 618 } 619 620 if (memory_size == 0) { 621 rv = ERANGE; 622 goto out; 623 } 624 625 *mrcnt = i; 626 *memsize = memory_size; 627 rv = 0; 628 out: 629 return (rv); 630 } 631