1 /* 2 * QEMU sPAPR VIO code 3 * 4 * Copyright (c) 2010 David Gibson, IBM Corporation <dwg@au1.ibm.com> 5 * Based on the s390 virtio bus code: 6 * Copyright (c) 2009 Alexander Graf <agraf@suse.de> 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2 of the License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with this library; if not, see <http://www.gnu.org/licenses/>. 20 */ 21 22 #include "hw/hw.h" 23 #include "sysemu/sysemu.h" 24 #include "hw/boards.h" 25 #include "hw/loader.h" 26 #include "elf.h" 27 #include "hw/sysbus.h" 28 #include "sysemu/kvm.h" 29 #include "sysemu/device_tree.h" 30 #include "kvm_ppc.h" 31 32 #include "hw/ppc/spapr.h" 33 #include "hw/ppc/spapr_vio.h" 34 #include "hw/ppc/xics.h" 35 36 #include <libfdt.h> 37 38 /* #define DEBUG_SPAPR */ 39 40 #ifdef DEBUG_SPAPR 41 #define DPRINTF(fmt, ...) \ 42 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) 43 #else 44 #define DPRINTF(fmt, ...) \ 45 do { } while (0) 46 #endif 47 48 static Property spapr_vio_props[] = { 49 DEFINE_PROP_UINT32("irq", VIOsPAPRDevice, irq, 0), \ 50 DEFINE_PROP_END_OF_LIST(), 51 }; 52 53 static char *spapr_vio_get_dev_name(DeviceState *qdev) 54 { 55 VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev); 56 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 57 char *name; 58 59 /* Device tree style name device@reg */ 60 name = g_strdup_printf("%s@%x", pc->dt_name, dev->reg); 61 62 return name; 63 } 64 65 static void spapr_vio_bus_class_init(ObjectClass *klass, void *data) 66 { 67 BusClass *k = BUS_CLASS(klass); 68 69 k->get_dev_path = spapr_vio_get_dev_name; 70 k->get_fw_dev_path = spapr_vio_get_dev_name; 71 } 72 73 static const TypeInfo spapr_vio_bus_info = { 74 .name = TYPE_SPAPR_VIO_BUS, 75 .parent = TYPE_BUS, 76 .class_init = spapr_vio_bus_class_init, 77 .instance_size = sizeof(VIOsPAPRBus), 78 }; 79 80 VIOsPAPRDevice *spapr_vio_find_by_reg(VIOsPAPRBus *bus, uint32_t reg) 81 { 82 BusChild *kid; 83 VIOsPAPRDevice *dev = NULL; 84 85 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 86 dev = (VIOsPAPRDevice *)kid->child; 87 if (dev->reg == reg) { 88 return dev; 89 } 90 } 91 92 return NULL; 93 } 94 95 static int vio_make_devnode(VIOsPAPRDevice *dev, 96 void *fdt) 97 { 98 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 99 int vdevice_off, node_off, ret; 100 char *dt_name; 101 102 vdevice_off = fdt_path_offset(fdt, "/vdevice"); 103 if (vdevice_off < 0) { 104 return vdevice_off; 105 } 106 107 dt_name = spapr_vio_get_dev_name(DEVICE(dev)); 108 node_off = fdt_add_subnode(fdt, vdevice_off, dt_name); 109 g_free(dt_name); 110 if (node_off < 0) { 111 return node_off; 112 } 113 114 ret = fdt_setprop_cell(fdt, node_off, "reg", dev->reg); 115 if (ret < 0) { 116 return ret; 117 } 118 119 if (pc->dt_type) { 120 ret = fdt_setprop_string(fdt, node_off, "device_type", 121 pc->dt_type); 122 if (ret < 0) { 123 return ret; 124 } 125 } 126 127 if (pc->dt_compatible) { 128 ret = fdt_setprop_string(fdt, node_off, "compatible", 129 pc->dt_compatible); 130 if (ret < 0) { 131 return ret; 132 } 133 } 134 135 if (dev->irq) { 136 uint32_t ints_prop[] = {cpu_to_be32(dev->irq), 0}; 137 138 ret = fdt_setprop(fdt, node_off, "interrupts", ints_prop, 139 sizeof(ints_prop)); 140 if (ret < 0) { 141 return ret; 142 } 143 } 144 145 ret = spapr_tcet_dma_dt(fdt, node_off, "ibm,my-dma-window", dev->tcet); 146 if (ret < 0) { 147 return ret; 148 } 149 150 if (pc->devnode) { 151 ret = (pc->devnode)(dev, fdt, node_off); 152 if (ret < 0) { 153 return ret; 154 } 155 } 156 157 return node_off; 158 } 159 160 /* 161 * CRQ handling 162 */ 163 static target_ulong h_reg_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr, 164 target_ulong opcode, target_ulong *args) 165 { 166 target_ulong reg = args[0]; 167 target_ulong queue_addr = args[1]; 168 target_ulong queue_len = args[2]; 169 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 170 171 if (!dev) { 172 hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg); 173 return H_PARAMETER; 174 } 175 176 /* We can't grok a queue size bigger than 256M for now */ 177 if (queue_len < 0x1000 || queue_len > 0x10000000) { 178 hcall_dprintf("Queue size too small or too big (0x" TARGET_FMT_lx 179 ")\n", queue_len); 180 return H_PARAMETER; 181 } 182 183 /* Check queue alignment */ 184 if (queue_addr & 0xfff) { 185 hcall_dprintf("Queue not aligned (0x" TARGET_FMT_lx ")\n", queue_addr); 186 return H_PARAMETER; 187 } 188 189 /* Check if device supports CRQs */ 190 if (!dev->crq.SendFunc) { 191 hcall_dprintf("Device does not support CRQ\n"); 192 return H_NOT_FOUND; 193 } 194 195 /* Already a queue ? */ 196 if (dev->crq.qsize) { 197 hcall_dprintf("CRQ already registered\n"); 198 return H_RESOURCE; 199 } 200 dev->crq.qladdr = queue_addr; 201 dev->crq.qsize = queue_len; 202 dev->crq.qnext = 0; 203 204 DPRINTF("CRQ for dev 0x" TARGET_FMT_lx " registered at 0x" 205 TARGET_FMT_lx "/0x" TARGET_FMT_lx "\n", 206 reg, queue_addr, queue_len); 207 return H_SUCCESS; 208 } 209 210 static target_ulong free_crq(VIOsPAPRDevice *dev) 211 { 212 dev->crq.qladdr = 0; 213 dev->crq.qsize = 0; 214 dev->crq.qnext = 0; 215 216 DPRINTF("CRQ for dev 0x%" PRIx32 " freed\n", dev->reg); 217 218 return H_SUCCESS; 219 } 220 221 static target_ulong h_free_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr, 222 target_ulong opcode, target_ulong *args) 223 { 224 target_ulong reg = args[0]; 225 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 226 227 if (!dev) { 228 hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg); 229 return H_PARAMETER; 230 } 231 232 return free_crq(dev); 233 } 234 235 static target_ulong h_send_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr, 236 target_ulong opcode, target_ulong *args) 237 { 238 target_ulong reg = args[0]; 239 target_ulong msg_hi = args[1]; 240 target_ulong msg_lo = args[2]; 241 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 242 uint64_t crq_mangle[2]; 243 244 if (!dev) { 245 hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg); 246 return H_PARAMETER; 247 } 248 crq_mangle[0] = cpu_to_be64(msg_hi); 249 crq_mangle[1] = cpu_to_be64(msg_lo); 250 251 if (dev->crq.SendFunc) { 252 return dev->crq.SendFunc(dev, (uint8_t *)crq_mangle); 253 } 254 255 return H_HARDWARE; 256 } 257 258 static target_ulong h_enable_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr, 259 target_ulong opcode, target_ulong *args) 260 { 261 target_ulong reg = args[0]; 262 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 263 264 if (!dev) { 265 hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg); 266 return H_PARAMETER; 267 } 268 269 return 0; 270 } 271 272 /* Returns negative error, 0 success, or positive: queue full */ 273 int spapr_vio_send_crq(VIOsPAPRDevice *dev, uint8_t *crq) 274 { 275 int rc; 276 uint8_t byte; 277 278 if (!dev->crq.qsize) { 279 fprintf(stderr, "spapr_vio_send_creq on uninitialized queue\n"); 280 return -1; 281 } 282 283 /* Maybe do a fast path for KVM just writing to the pages */ 284 rc = spapr_vio_dma_read(dev, dev->crq.qladdr + dev->crq.qnext, &byte, 1); 285 if (rc) { 286 return rc; 287 } 288 if (byte != 0) { 289 return 1; 290 } 291 292 rc = spapr_vio_dma_write(dev, dev->crq.qladdr + dev->crq.qnext + 8, 293 &crq[8], 8); 294 if (rc) { 295 return rc; 296 } 297 298 kvmppc_eieio(); 299 300 rc = spapr_vio_dma_write(dev, dev->crq.qladdr + dev->crq.qnext, crq, 8); 301 if (rc) { 302 return rc; 303 } 304 305 dev->crq.qnext = (dev->crq.qnext + 16) % dev->crq.qsize; 306 307 if (dev->signal_state & 1) { 308 qemu_irq_pulse(spapr_vio_qirq(dev)); 309 } 310 311 return 0; 312 } 313 314 /* "quiesce" handling */ 315 316 static void spapr_vio_quiesce_one(VIOsPAPRDevice *dev) 317 { 318 if (dev->tcet) { 319 device_reset(DEVICE(dev->tcet)); 320 } 321 free_crq(dev); 322 } 323 324 void spapr_vio_set_bypass(VIOsPAPRDevice *dev, bool bypass) 325 { 326 if (!dev->tcet) { 327 return; 328 } 329 330 memory_region_set_enabled(&dev->mrbypass, bypass); 331 memory_region_set_enabled(spapr_tce_get_iommu(dev->tcet), !bypass); 332 333 dev->tcet->bypass = bypass; 334 } 335 336 static void rtas_set_tce_bypass(PowerPCCPU *cpu, sPAPRMachineState *spapr, 337 uint32_t token, 338 uint32_t nargs, target_ulong args, 339 uint32_t nret, target_ulong rets) 340 { 341 VIOsPAPRBus *bus = spapr->vio_bus; 342 VIOsPAPRDevice *dev; 343 uint32_t unit, enable; 344 345 if (nargs != 2) { 346 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 347 return; 348 } 349 unit = rtas_ld(args, 0); 350 enable = rtas_ld(args, 1); 351 dev = spapr_vio_find_by_reg(bus, unit); 352 if (!dev) { 353 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 354 return; 355 } 356 357 if (!dev->tcet) { 358 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 359 return; 360 } 361 362 spapr_vio_set_bypass(dev, !!enable); 363 364 rtas_st(rets, 0, RTAS_OUT_SUCCESS); 365 } 366 367 static void rtas_quiesce(PowerPCCPU *cpu, sPAPRMachineState *spapr, 368 uint32_t token, 369 uint32_t nargs, target_ulong args, 370 uint32_t nret, target_ulong rets) 371 { 372 VIOsPAPRBus *bus = spapr->vio_bus; 373 BusChild *kid; 374 VIOsPAPRDevice *dev = NULL; 375 376 if (nargs != 0) { 377 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); 378 return; 379 } 380 381 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 382 dev = (VIOsPAPRDevice *)kid->child; 383 spapr_vio_quiesce_one(dev); 384 } 385 386 rtas_st(rets, 0, RTAS_OUT_SUCCESS); 387 } 388 389 static VIOsPAPRDevice *reg_conflict(VIOsPAPRDevice *dev) 390 { 391 VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->qdev.parent_bus); 392 BusChild *kid; 393 VIOsPAPRDevice *other; 394 395 /* 396 * Check for a device other than the given one which is already 397 * using the requested address. We have to open code this because 398 * the given dev might already be in the list. 399 */ 400 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 401 other = VIO_SPAPR_DEVICE(kid->child); 402 403 if (other != dev && other->reg == dev->reg) { 404 return other; 405 } 406 } 407 408 return 0; 409 } 410 411 static void spapr_vio_busdev_reset(DeviceState *qdev) 412 { 413 VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev); 414 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 415 416 /* Shut down the request queue and TCEs if necessary */ 417 spapr_vio_quiesce_one(dev); 418 419 dev->signal_state = 0; 420 421 spapr_vio_set_bypass(dev, false); 422 if (pc->reset) { 423 pc->reset(dev); 424 } 425 } 426 427 static void spapr_vio_busdev_realize(DeviceState *qdev, Error **errp) 428 { 429 sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine()); 430 VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev; 431 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 432 char *id; 433 434 if (dev->reg != -1) { 435 /* 436 * Explicitly assigned address, just verify that no-one else 437 * is using it. other mechanism). We have to open code this 438 * rather than using spapr_vio_find_by_reg() because sdev 439 * itself is already in the list. 440 */ 441 VIOsPAPRDevice *other = reg_conflict(dev); 442 443 if (other) { 444 error_setg(errp, "%s and %s devices conflict at address %#x", 445 object_get_typename(OBJECT(qdev)), 446 object_get_typename(OBJECT(&other->qdev)), 447 dev->reg); 448 return; 449 } 450 } else { 451 /* Need to assign an address */ 452 VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->qdev.parent_bus); 453 454 do { 455 dev->reg = bus->next_reg++; 456 } while (reg_conflict(dev)); 457 } 458 459 /* Don't overwrite ids assigned on the command line */ 460 if (!dev->qdev.id) { 461 id = spapr_vio_get_dev_name(DEVICE(dev)); 462 dev->qdev.id = id; 463 } 464 465 dev->irq = xics_alloc(spapr->icp, 0, dev->irq, false); 466 if (!dev->irq) { 467 error_setg(errp, "can't allocate IRQ"); 468 return; 469 } 470 471 if (pc->rtce_window_size) { 472 uint32_t liobn = SPAPR_VIO_LIOBN(dev->reg); 473 474 memory_region_init(&dev->mrroot, OBJECT(dev), "iommu-spapr-root", 475 ram_size); 476 memory_region_init_alias(&dev->mrbypass, OBJECT(dev), 477 "iommu-spapr-bypass", get_system_memory(), 478 0, ram_size); 479 memory_region_add_subregion_overlap(&dev->mrroot, 0, &dev->mrbypass, 1); 480 address_space_init(&dev->as, &dev->mrroot, qdev->id); 481 482 dev->tcet = spapr_tce_new_table(qdev, liobn, 483 0, 484 SPAPR_TCE_PAGE_SHIFT, 485 pc->rtce_window_size >> 486 SPAPR_TCE_PAGE_SHIFT, false); 487 dev->tcet->vdev = dev; 488 memory_region_add_subregion_overlap(&dev->mrroot, 0, 489 spapr_tce_get_iommu(dev->tcet), 2); 490 } 491 492 pc->realize(dev, errp); 493 } 494 495 static target_ulong h_vio_signal(PowerPCCPU *cpu, sPAPRMachineState *spapr, 496 target_ulong opcode, 497 target_ulong *args) 498 { 499 target_ulong reg = args[0]; 500 target_ulong mode = args[1]; 501 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 502 VIOsPAPRDeviceClass *pc; 503 504 if (!dev) { 505 return H_PARAMETER; 506 } 507 508 pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 509 510 if (mode & ~pc->signal_mask) { 511 return H_PARAMETER; 512 } 513 514 dev->signal_state = mode; 515 516 return H_SUCCESS; 517 } 518 519 VIOsPAPRBus *spapr_vio_bus_init(void) 520 { 521 VIOsPAPRBus *bus; 522 BusState *qbus; 523 DeviceState *dev; 524 525 /* Create bridge device */ 526 dev = qdev_create(NULL, TYPE_SPAPR_VIO_BRIDGE); 527 qdev_init_nofail(dev); 528 529 /* Create bus on bridge device */ 530 qbus = qbus_create(TYPE_SPAPR_VIO_BUS, dev, "spapr-vio"); 531 bus = SPAPR_VIO_BUS(qbus); 532 bus->next_reg = 0x71000000; 533 534 /* hcall-vio */ 535 spapr_register_hypercall(H_VIO_SIGNAL, h_vio_signal); 536 537 /* hcall-crq */ 538 spapr_register_hypercall(H_REG_CRQ, h_reg_crq); 539 spapr_register_hypercall(H_FREE_CRQ, h_free_crq); 540 spapr_register_hypercall(H_SEND_CRQ, h_send_crq); 541 spapr_register_hypercall(H_ENABLE_CRQ, h_enable_crq); 542 543 /* RTAS calls */ 544 spapr_rtas_register(RTAS_IBM_SET_TCE_BYPASS, "ibm,set-tce-bypass", 545 rtas_set_tce_bypass); 546 spapr_rtas_register(RTAS_QUIESCE, "quiesce", rtas_quiesce); 547 548 return bus; 549 } 550 551 /* Represents sPAPR hcall VIO devices */ 552 553 static int spapr_vio_bridge_init(SysBusDevice *dev) 554 { 555 /* nothing */ 556 return 0; 557 } 558 559 static void spapr_vio_bridge_class_init(ObjectClass *klass, void *data) 560 { 561 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); 562 DeviceClass *dc = DEVICE_CLASS(klass); 563 564 dc->fw_name = "vdevice"; 565 k->init = spapr_vio_bridge_init; 566 } 567 568 static const TypeInfo spapr_vio_bridge_info = { 569 .name = TYPE_SPAPR_VIO_BRIDGE, 570 .parent = TYPE_SYS_BUS_DEVICE, 571 .class_init = spapr_vio_bridge_class_init, 572 }; 573 574 const VMStateDescription vmstate_spapr_vio = { 575 .name = "spapr_vio", 576 .version_id = 1, 577 .minimum_version_id = 1, 578 .fields = (VMStateField[]) { 579 /* Sanity check */ 580 VMSTATE_UINT32_EQUAL(reg, VIOsPAPRDevice), 581 VMSTATE_UINT32_EQUAL(irq, VIOsPAPRDevice), 582 583 /* General VIO device state */ 584 VMSTATE_UINTTL(signal_state, VIOsPAPRDevice), 585 VMSTATE_UINT64(crq.qladdr, VIOsPAPRDevice), 586 VMSTATE_UINT32(crq.qsize, VIOsPAPRDevice), 587 VMSTATE_UINT32(crq.qnext, VIOsPAPRDevice), 588 589 VMSTATE_END_OF_LIST() 590 }, 591 }; 592 593 static void vio_spapr_device_class_init(ObjectClass *klass, void *data) 594 { 595 DeviceClass *k = DEVICE_CLASS(klass); 596 k->realize = spapr_vio_busdev_realize; 597 k->reset = spapr_vio_busdev_reset; 598 k->bus_type = TYPE_SPAPR_VIO_BUS; 599 k->props = spapr_vio_props; 600 } 601 602 static const TypeInfo spapr_vio_type_info = { 603 .name = TYPE_VIO_SPAPR_DEVICE, 604 .parent = TYPE_DEVICE, 605 .instance_size = sizeof(VIOsPAPRDevice), 606 .abstract = true, 607 .class_size = sizeof(VIOsPAPRDeviceClass), 608 .class_init = vio_spapr_device_class_init, 609 }; 610 611 static void spapr_vio_register_types(void) 612 { 613 type_register_static(&spapr_vio_bus_info); 614 type_register_static(&spapr_vio_bridge_info); 615 type_register_static(&spapr_vio_type_info); 616 } 617 618 type_init(spapr_vio_register_types) 619 620 static int compare_reg(const void *p1, const void *p2) 621 { 622 VIOsPAPRDevice const *dev1, *dev2; 623 624 dev1 = (VIOsPAPRDevice *)*(DeviceState **)p1; 625 dev2 = (VIOsPAPRDevice *)*(DeviceState **)p2; 626 627 if (dev1->reg < dev2->reg) { 628 return -1; 629 } 630 if (dev1->reg == dev2->reg) { 631 return 0; 632 } 633 634 /* dev1->reg > dev2->reg */ 635 return 1; 636 } 637 638 int spapr_populate_vdevice(VIOsPAPRBus *bus, void *fdt) 639 { 640 DeviceState *qdev, **qdevs; 641 BusChild *kid; 642 int i, num, ret = 0; 643 644 /* Count qdevs on the bus list */ 645 num = 0; 646 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 647 num++; 648 } 649 650 /* Copy out into an array of pointers */ 651 qdevs = g_malloc(sizeof(qdev) * num); 652 num = 0; 653 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 654 qdevs[num++] = kid->child; 655 } 656 657 /* Sort the array */ 658 qsort(qdevs, num, sizeof(qdev), compare_reg); 659 660 /* Hack alert. Give the devices to libfdt in reverse order, we happen 661 * to know that will mean they are in forward order in the tree. */ 662 for (i = num - 1; i >= 0; i--) { 663 VIOsPAPRDevice *dev = (VIOsPAPRDevice *)(qdevs[i]); 664 665 ret = vio_make_devnode(dev, fdt); 666 667 if (ret < 0) { 668 goto out; 669 } 670 } 671 672 ret = 0; 673 out: 674 g_free(qdevs); 675 676 return ret; 677 } 678 679 int spapr_populate_chosen_stdout(void *fdt, VIOsPAPRBus *bus) 680 { 681 VIOsPAPRDevice *dev; 682 char *name, *path; 683 int ret, offset; 684 685 dev = spapr_vty_get_default(bus); 686 if (!dev) 687 return 0; 688 689 offset = fdt_path_offset(fdt, "/chosen"); 690 if (offset < 0) { 691 return offset; 692 } 693 694 name = spapr_vio_get_dev_name(DEVICE(dev)); 695 path = g_strdup_printf("/vdevice/%s", name); 696 697 ret = fdt_setprop_string(fdt, offset, "linux,stdout-path", path); 698 699 g_free(name); 700 g_free(path); 701 702 return ret; 703 } 704