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 "monitor/monitor.h" 26 #include "hw/loader.h" 27 #include "elf.h" 28 #include "hw/sysbus.h" 29 #include "sysemu/kvm.h" 30 #include "sysemu/device_tree.h" 31 #include "kvm_ppc.h" 32 33 #include "hw/ppc/spapr.h" 34 #include "hw/ppc/spapr_vio.h" 35 #include "hw/ppc/xics.h" 36 37 #include <libfdt.h> 38 39 /* #define DEBUG_SPAPR */ 40 41 #ifdef DEBUG_SPAPR 42 #define dprintf(fmt, ...) \ 43 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) 44 #else 45 #define dprintf(fmt, ...) \ 46 do { } while (0) 47 #endif 48 49 static Property spapr_vio_props[] = { 50 DEFINE_PROP_UINT32("irq", VIOsPAPRDevice, irq, 0), \ 51 DEFINE_PROP_END_OF_LIST(), 52 }; 53 54 static char *spapr_vio_get_dev_name(DeviceState *qdev) 55 { 56 VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev); 57 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 58 char *name; 59 60 /* Device tree style name device@reg */ 61 name = g_strdup_printf("%s@%x", pc->dt_name, dev->reg); 62 63 return name; 64 } 65 66 static void spapr_vio_bus_class_init(ObjectClass *klass, void *data) 67 { 68 BusClass *k = BUS_CLASS(klass); 69 70 k->get_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->dma); 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, sPAPREnvironment *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, sPAPREnvironment *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, sPAPREnvironment *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, sPAPREnvironment *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->dma) { 319 spapr_tce_reset(dev->dma); 320 } 321 free_crq(dev); 322 } 323 324 static void rtas_set_tce_bypass(sPAPREnvironment *spapr, uint32_t token, 325 uint32_t nargs, target_ulong args, 326 uint32_t nret, target_ulong rets) 327 { 328 VIOsPAPRBus *bus = spapr->vio_bus; 329 VIOsPAPRDevice *dev; 330 uint32_t unit, enable; 331 332 if (nargs != 2) { 333 rtas_st(rets, 0, -3); 334 return; 335 } 336 unit = rtas_ld(args, 0); 337 enable = rtas_ld(args, 1); 338 dev = spapr_vio_find_by_reg(bus, unit); 339 if (!dev) { 340 rtas_st(rets, 0, -3); 341 return; 342 } 343 344 if (!dev->dma) { 345 rtas_st(rets, 0, -3); 346 return; 347 } 348 349 spapr_tce_set_bypass(dev->dma, !!enable); 350 351 rtas_st(rets, 0, 0); 352 } 353 354 static void rtas_quiesce(sPAPREnvironment *spapr, uint32_t token, 355 uint32_t nargs, target_ulong args, 356 uint32_t nret, target_ulong rets) 357 { 358 VIOsPAPRBus *bus = spapr->vio_bus; 359 BusChild *kid; 360 VIOsPAPRDevice *dev = NULL; 361 362 if (nargs != 0) { 363 rtas_st(rets, 0, -3); 364 return; 365 } 366 367 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 368 dev = (VIOsPAPRDevice *)kid->child; 369 spapr_vio_quiesce_one(dev); 370 } 371 372 rtas_st(rets, 0, 0); 373 } 374 375 static VIOsPAPRDevice *reg_conflict(VIOsPAPRDevice *dev) 376 { 377 VIOsPAPRBus *bus = DO_UPCAST(VIOsPAPRBus, bus, dev->qdev.parent_bus); 378 BusChild *kid; 379 VIOsPAPRDevice *other; 380 381 /* 382 * Check for a device other than the given one which is already 383 * using the requested address. We have to open code this because 384 * the given dev might already be in the list. 385 */ 386 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 387 other = VIO_SPAPR_DEVICE(kid->child); 388 389 if (other != dev && other->reg == dev->reg) { 390 return other; 391 } 392 } 393 394 return 0; 395 } 396 397 static void spapr_vio_busdev_reset(DeviceState *qdev) 398 { 399 VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev); 400 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 401 402 /* Shut down the request queue and TCEs if necessary */ 403 spapr_vio_quiesce_one(dev); 404 405 dev->signal_state = 0; 406 407 if (pc->reset) { 408 pc->reset(dev); 409 } 410 } 411 412 static int spapr_vio_busdev_init(DeviceState *qdev) 413 { 414 VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev; 415 VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 416 char *id; 417 418 if (dev->reg != -1) { 419 /* 420 * Explicitly assigned address, just verify that no-one else 421 * is using it. other mechanism). We have to open code this 422 * rather than using spapr_vio_find_by_reg() because sdev 423 * itself is already in the list. 424 */ 425 VIOsPAPRDevice *other = reg_conflict(dev); 426 427 if (other) { 428 fprintf(stderr, "vio: %s and %s devices conflict at address %#x\n", 429 object_get_typename(OBJECT(qdev)), 430 object_get_typename(OBJECT(&other->qdev)), 431 dev->reg); 432 return -1; 433 } 434 } else { 435 /* Need to assign an address */ 436 VIOsPAPRBus *bus = DO_UPCAST(VIOsPAPRBus, bus, dev->qdev.parent_bus); 437 438 do { 439 dev->reg = bus->next_reg++; 440 } while (reg_conflict(dev)); 441 } 442 443 /* Don't overwrite ids assigned on the command line */ 444 if (!dev->qdev.id) { 445 id = spapr_vio_get_dev_name(DEVICE(dev)); 446 dev->qdev.id = id; 447 } 448 449 dev->irq = spapr_allocate_msi(dev->irq); 450 if (!dev->irq) { 451 return -1; 452 } 453 454 if (pc->rtce_window_size) { 455 uint32_t liobn = SPAPR_VIO_BASE_LIOBN | dev->reg; 456 dev->dma = spapr_tce_new_dma_context(liobn, pc->rtce_window_size); 457 } 458 459 return pc->init(dev); 460 } 461 462 static target_ulong h_vio_signal(PowerPCCPU *cpu, sPAPREnvironment *spapr, 463 target_ulong opcode, 464 target_ulong *args) 465 { 466 target_ulong reg = args[0]; 467 target_ulong mode = args[1]; 468 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 469 VIOsPAPRDeviceClass *pc; 470 471 if (!dev) { 472 return H_PARAMETER; 473 } 474 475 pc = VIO_SPAPR_DEVICE_GET_CLASS(dev); 476 477 if (mode & ~pc->signal_mask) { 478 return H_PARAMETER; 479 } 480 481 dev->signal_state = mode; 482 483 return H_SUCCESS; 484 } 485 486 VIOsPAPRBus *spapr_vio_bus_init(void) 487 { 488 VIOsPAPRBus *bus; 489 BusState *qbus; 490 DeviceState *dev; 491 492 /* Create bridge device */ 493 dev = qdev_create(NULL, "spapr-vio-bridge"); 494 qdev_init_nofail(dev); 495 496 /* Create bus on bridge device */ 497 498 qbus = qbus_create(TYPE_SPAPR_VIO_BUS, dev, "spapr-vio"); 499 bus = DO_UPCAST(VIOsPAPRBus, bus, qbus); 500 bus->next_reg = 0x71000000; 501 502 /* hcall-vio */ 503 spapr_register_hypercall(H_VIO_SIGNAL, h_vio_signal); 504 505 /* hcall-crq */ 506 spapr_register_hypercall(H_REG_CRQ, h_reg_crq); 507 spapr_register_hypercall(H_FREE_CRQ, h_free_crq); 508 spapr_register_hypercall(H_SEND_CRQ, h_send_crq); 509 spapr_register_hypercall(H_ENABLE_CRQ, h_enable_crq); 510 511 /* RTAS calls */ 512 spapr_rtas_register("ibm,set-tce-bypass", rtas_set_tce_bypass); 513 spapr_rtas_register("quiesce", rtas_quiesce); 514 515 return bus; 516 } 517 518 /* Represents sPAPR hcall VIO devices */ 519 520 static int spapr_vio_bridge_init(SysBusDevice *dev) 521 { 522 /* nothing */ 523 return 0; 524 } 525 526 static void spapr_vio_bridge_class_init(ObjectClass *klass, void *data) 527 { 528 DeviceClass *dc = DEVICE_CLASS(klass); 529 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); 530 531 k->init = spapr_vio_bridge_init; 532 dc->no_user = 1; 533 } 534 535 static const TypeInfo spapr_vio_bridge_info = { 536 .name = "spapr-vio-bridge", 537 .parent = TYPE_SYS_BUS_DEVICE, 538 .instance_size = sizeof(SysBusDevice), 539 .class_init = spapr_vio_bridge_class_init, 540 }; 541 542 static void vio_spapr_device_class_init(ObjectClass *klass, void *data) 543 { 544 DeviceClass *k = DEVICE_CLASS(klass); 545 k->init = spapr_vio_busdev_init; 546 k->reset = spapr_vio_busdev_reset; 547 k->bus_type = TYPE_SPAPR_VIO_BUS; 548 k->props = spapr_vio_props; 549 } 550 551 static const TypeInfo spapr_vio_type_info = { 552 .name = TYPE_VIO_SPAPR_DEVICE, 553 .parent = TYPE_DEVICE, 554 .instance_size = sizeof(VIOsPAPRDevice), 555 .abstract = true, 556 .class_size = sizeof(VIOsPAPRDeviceClass), 557 .class_init = vio_spapr_device_class_init, 558 }; 559 560 static void spapr_vio_register_types(void) 561 { 562 type_register_static(&spapr_vio_bus_info); 563 type_register_static(&spapr_vio_bridge_info); 564 type_register_static(&spapr_vio_type_info); 565 } 566 567 type_init(spapr_vio_register_types) 568 569 static int compare_reg(const void *p1, const void *p2) 570 { 571 VIOsPAPRDevice const *dev1, *dev2; 572 573 dev1 = (VIOsPAPRDevice *)*(DeviceState **)p1; 574 dev2 = (VIOsPAPRDevice *)*(DeviceState **)p2; 575 576 if (dev1->reg < dev2->reg) { 577 return -1; 578 } 579 if (dev1->reg == dev2->reg) { 580 return 0; 581 } 582 583 /* dev1->reg > dev2->reg */ 584 return 1; 585 } 586 587 int spapr_populate_vdevice(VIOsPAPRBus *bus, void *fdt) 588 { 589 DeviceState *qdev, **qdevs; 590 BusChild *kid; 591 int i, num, ret = 0; 592 593 /* Count qdevs on the bus list */ 594 num = 0; 595 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 596 num++; 597 } 598 599 /* Copy out into an array of pointers */ 600 qdevs = g_malloc(sizeof(qdev) * num); 601 num = 0; 602 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { 603 qdevs[num++] = kid->child; 604 } 605 606 /* Sort the array */ 607 qsort(qdevs, num, sizeof(qdev), compare_reg); 608 609 /* Hack alert. Give the devices to libfdt in reverse order, we happen 610 * to know that will mean they are in forward order in the tree. */ 611 for (i = num - 1; i >= 0; i--) { 612 VIOsPAPRDevice *dev = (VIOsPAPRDevice *)(qdevs[i]); 613 614 ret = vio_make_devnode(dev, fdt); 615 616 if (ret < 0) { 617 goto out; 618 } 619 } 620 621 ret = 0; 622 out: 623 free(qdevs); 624 625 return ret; 626 } 627 628 int spapr_populate_chosen_stdout(void *fdt, VIOsPAPRBus *bus) 629 { 630 VIOsPAPRDevice *dev; 631 char *name, *path; 632 int ret, offset; 633 634 dev = spapr_vty_get_default(bus); 635 if (!dev) 636 return 0; 637 638 offset = fdt_path_offset(fdt, "/chosen"); 639 if (offset < 0) { 640 return offset; 641 } 642 643 name = spapr_vio_get_dev_name(DEVICE(dev)); 644 path = g_strdup_printf("/vdevice/%s", name); 645 646 ret = fdt_setprop_string(fdt, offset, "linux,stdout-path", path); 647 648 g_free(name); 649 g_free(path); 650 651 return ret; 652 } 653