hw/intc/xics.c

   1 /*
   2  * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
   3  *
   4  * PAPR Virtualized Interrupt System, aka ICS/ICP aka xics
   5  *
   6  * Copyright (c) 2010,2011 David Gibson, IBM Corporation.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  *
  26  */
  27
  28 #include "qemu/osdep.h"
  29 #include "qapi/error.h"
  30 #include "qemu-common.h"
  31 #include "cpu.h"
  32 #include "hw/hw.h"
  33 #include "trace.h"
  34 #include "qemu/timer.h"
  35 #include "hw/ppc/xics.h"
  36 #include "qemu/error-report.h"
  37 #include "qapi/visitor.h"
  38 #include "monitor/monitor.h"
  39 #include "hw/intc/intc.h"
  40
  41 int xics_get_cpu_index_by_dt_id(int cpu_dt_id)
  42 {
  43     PowerPCCPU *cpu = ppc_get_vcpu_by_dt_id(cpu_dt_id);
  44
  45     if (cpu) {
  46         return cpu->parent_obj.cpu_index;
  47     }
  48
  49     return -1;
  50 }
  51
  52 void xics_cpu_destroy(XICSState *xics, PowerPCCPU *cpu)
  53 {
  54     CPUState *cs = CPU(cpu);
  55     ICPState *ss = &xics->ss[cs->cpu_index];
  56
  57     assert(cs->cpu_index < xics->nr_servers);
  58     assert(cs == ss->cs);
  59
  60     ss->output = NULL;
  61     ss->cs = NULL;
  62 }
  63
  64 void xics_cpu_setup(XICSState *xics, PowerPCCPU *cpu)
  65 {
  66     CPUState *cs = CPU(cpu);
  67     CPUPPCState *env = &cpu->env;
  68     ICPState *ss = &xics->ss[cs->cpu_index];
  69     ICPStateClass *icpc;
  70
  71     assert(cs->cpu_index < xics->nr_servers);
  72
  73     ss->cs = cs;
  74
  75     icpc = ICP_GET_CLASS(ss);
  76     if (icpc->cpu_setup) {
  77         icpc->cpu_setup(ss, cpu);
  78     }
  79
  80     switch (PPC_INPUT(env)) {
  81     case PPC_FLAGS_INPUT_POWER7:
  82         ss->output = env->irq_inputs[POWER7_INPUT_INT];
  83         break;
  84
  85     case PPC_FLAGS_INPUT_970:
  86         ss->output = env->irq_inputs[PPC970_INPUT_INT];
  87         break;
  88
  89     default:
  90         error_report("XICS interrupt controller does not support this CPU "
  91                      "bus model");
  92         abort();
  93     }
  94 }
  95
  96 static void icp_pic_print_info(InterruptStatsProvider *obj,
  97                            Monitor *mon)
  98 {
  99     ICPState *icp = ICP(obj);
 100     int cpu_index = icp->cs ? icp->cs->cpu_index : -1;
 101
 102     if (!icp->output) {
 103         return;
 104     }
 105     monitor_printf(mon, "CPU %d XIRR=%08x (%p) PP=%02x MFRR=%02x\n",
 106                    cpu_index, icp->xirr, icp->xirr_owner,
 107                    icp->pending_priority, icp->mfrr);
 108 }
 109
 110 static void ics_simple_pic_print_info(InterruptStatsProvider *obj,
 111                                       Monitor *mon)
 112 {
 113     ICSState *ics = ICS_SIMPLE(obj);
 114     uint32_t i;
 115
 116     monitor_printf(mon, "ICS %4x..%4x %p\n",
 117                    ics->offset, ics->offset + ics->nr_irqs - 1, ics);
 118
 119     if (!ics->irqs) {
 120         return;
 121     }
 122
 123     for (i = 0; i < ics->nr_irqs; i++) {
 124         ICSIRQState *irq = ics->irqs + i;
 125
 126         if (!(irq->flags & XICS_FLAGS_IRQ_MASK)) {
 127             continue;
 128         }
 129         monitor_printf(mon, "  %4x %s %02x %02x\n",
 130                        ics->offset + i,
 131                        (irq->flags & XICS_FLAGS_IRQ_LSI) ?
 132                        "LSI" : "MSI",
 133                        irq->priority, irq->status);
 134     }
 135 }
 136
 137 /*
 138  * XICS Common class - parent for emulated XICS and KVM-XICS
 139  */
 140 static void xics_common_reset(DeviceState *d)
 141 {
 142     XICSState *xics = XICS_COMMON(d);
 143     int i;
 144
 145     for (i = 0; i < xics->nr_servers; i++) {
 146         device_reset(DEVICE(&xics->ss[i]));
 147     }
 148 }
 149
 150 static void xics_common_class_init(ObjectClass *oc, void *data)
 151 {
 152     DeviceClass *dc = DEVICE_CLASS(oc);
 153
 154     dc->reset = xics_common_reset;
 155 }
 156
 157 static const TypeInfo xics_common_info = {
 158     .name          = TYPE_XICS_COMMON,
 159     .parent        = TYPE_DEVICE,
 160     .instance_size = sizeof(XICSState),
 161     .class_size    = sizeof(XICSStateClass),
 162     .class_init    = xics_common_class_init,
 163 };
 164
 165 /*
 166  * ICP: Presentation layer
 167  */
 168
 169 #define XISR_MASK  0x00ffffff
 170 #define CPPR_MASK  0xff000000
 171
 172 #define XISR(ss)   (((ss)->xirr) & XISR_MASK)
 173 #define CPPR(ss)   (((ss)->xirr) >> 24)
 174
 175 static void ics_reject(ICSState *ics, uint32_t nr)
 176 {
 177     ICSStateClass *k = ICS_BASE_GET_CLASS(ics);
 178
 179     if (k->reject) {
 180         k->reject(ics, nr);
 181     }
 182 }
 183
 184 void ics_resend(ICSState *ics)
 185 {
 186     ICSStateClass *k = ICS_BASE_GET_CLASS(ics);
 187
 188     if (k->resend) {
 189         k->resend(ics);
 190     }
 191 }
 192
 193 static void ics_eoi(ICSState *ics, int nr)
 194 {
 195     ICSStateClass *k = ICS_BASE_GET_CLASS(ics);
 196
 197     if (k->eoi) {
 198         k->eoi(ics, nr);
 199     }
 200 }
 201
 202 static void icp_check_ipi(ICPState *ss)
 203 {
 204     if (XISR(ss) && (ss->pending_priority <= ss->mfrr)) {
 205         return;
 206     }
 207
 208     trace_xics_icp_check_ipi(ss->cs->cpu_index, ss->mfrr);
 209
 210     if (XISR(ss) && ss->xirr_owner) {
 211         ics_reject(ss->xirr_owner, XISR(ss));
 212     }
 213
 214     ss->xirr = (ss->xirr & ~XISR_MASK) | XICS_IPI;
 215     ss->pending_priority = ss->mfrr;
 216     ss->xirr_owner = NULL;
 217     qemu_irq_raise(ss->output);
 218 }
 219
 220 void icp_resend(ICPState *ss)
 221 {
 222     XICSFabric *xi = ss->xics;
 223     XICSFabricClass *xic = XICS_FABRIC_GET_CLASS(xi);
 224
 225     if (ss->mfrr < CPPR(ss)) {
 226         icp_check_ipi(ss);
 227     }
 228
 229     xic->ics_resend(xi);
 230 }
 231
 232 void icp_set_cppr(ICPState *ss, uint8_t cppr)
 233 {
 234     uint8_t old_cppr;
 235     uint32_t old_xisr;
 236
 237     old_cppr = CPPR(ss);
 238     ss->xirr = (ss->xirr & ~CPPR_MASK) | (cppr << 24);
 239
 240     if (cppr < old_cppr) {
 241         if (XISR(ss) && (cppr <= ss->pending_priority)) {
 242             old_xisr = XISR(ss);
 243             ss->xirr &= ~XISR_MASK; /* Clear XISR */
 244             ss->pending_priority = 0xff;
 245             qemu_irq_lower(ss->output);
 246             if (ss->xirr_owner) {
 247                 ics_reject(ss->xirr_owner, old_xisr);
 248                 ss->xirr_owner = NULL;
 249             }
 250         }
 251     } else {
 252         if (!XISR(ss)) {
 253             icp_resend(ss);
 254         }
 255     }
 256 }
 257
 258 void icp_set_mfrr(ICPState *ss, uint8_t mfrr)
 259 {
 260     ss->mfrr = mfrr;
 261     if (mfrr < CPPR(ss)) {
 262         icp_check_ipi(ss);
 263     }
 264 }
 265
 266 uint32_t icp_accept(ICPState *ss)
 267 {
 268     uint32_t xirr = ss->xirr;
 269
 270     qemu_irq_lower(ss->output);
 271     ss->xirr = ss->pending_priority << 24;
 272     ss->pending_priority = 0xff;
 273     ss->xirr_owner = NULL;
 274
 275     trace_xics_icp_accept(xirr, ss->xirr);
 276
 277     return xirr;
 278 }
 279
 280 uint32_t icp_ipoll(ICPState *ss, uint32_t *mfrr)
 281 {
 282     if (mfrr) {
 283         *mfrr = ss->mfrr;
 284     }
 285     return ss->xirr;
 286 }
 287
 288 void icp_eoi(ICPState *ss, uint32_t xirr)
 289 {
 290     XICSFabric *xi = ss->xics;
 291     XICSFabricClass *xic = XICS_FABRIC_GET_CLASS(xi);
 292     ICSState *ics;
 293     uint32_t irq;
 294
 295     /* Send EOI -> ICS */
 296     ss->xirr = (ss->xirr & ~CPPR_MASK) | (xirr & CPPR_MASK);
 297     trace_xics_icp_eoi(ss->cs->cpu_index, xirr, ss->xirr);
 298     irq = xirr & XISR_MASK;
 299
 300     ics = xic->ics_get(xi, irq);
 301     if (ics) {
 302         ics_eoi(ics, irq);
 303     }
 304     if (!XISR(ss)) {
 305         icp_resend(ss);
 306     }
 307 }
 308
 309 static void icp_irq(ICSState *ics, int server, int nr, uint8_t priority)
 310 {
 311     XICSState *xics = ics->xics;
 312     ICPState *ss = xics->ss + server;
 313
 314     trace_xics_icp_irq(server, nr, priority);
 315
 316     if ((priority >= CPPR(ss))
 317         || (XISR(ss) && (ss->pending_priority <= priority))) {
 318         ics_reject(ics, nr);
 319     } else {
 320         if (XISR(ss) && ss->xirr_owner) {
 321             ics_reject(ss->xirr_owner, XISR(ss));
 322             ss->xirr_owner = NULL;
 323         }
 324         ss->xirr = (ss->xirr & ~XISR_MASK) | (nr & XISR_MASK);
 325         ss->xirr_owner = ics;
 326         ss->pending_priority = priority;
 327         trace_xics_icp_raise(ss->xirr, ss->pending_priority);
 328         qemu_irq_raise(ss->output);
 329     }
 330 }
 331
 332 static void icp_dispatch_pre_save(void *opaque)
 333 {
 334     ICPState *ss = opaque;
 335     ICPStateClass *info = ICP_GET_CLASS(ss);
 336
 337     if (info->pre_save) {
 338         info->pre_save(ss);
 339     }
 340 }
 341
 342 static int icp_dispatch_post_load(void *opaque, int version_id)
 343 {
 344     ICPState *ss = opaque;
 345     ICPStateClass *info = ICP_GET_CLASS(ss);
 346
 347     if (info->post_load) {
 348         return info->post_load(ss, version_id);
 349     }
 350
 351     return 0;
 352 }
 353
 354 static const VMStateDescription vmstate_icp_server = {
 355     .name = "icp/server",
 356     .version_id = 1,
 357     .minimum_version_id = 1,
 358     .pre_save = icp_dispatch_pre_save,
 359     .post_load = icp_dispatch_post_load,
 360     .fields = (VMStateField[]) {
 361         /* Sanity check */
 362         VMSTATE_UINT32(xirr, ICPState),
 363         VMSTATE_UINT8(pending_priority, ICPState),
 364         VMSTATE_UINT8(mfrr, ICPState),
 365         VMSTATE_END_OF_LIST()
 366     },
 367 };
 368
 369 static void icp_reset(DeviceState *dev)
 370 {
 371     ICPState *icp = ICP(dev);
 372
 373     icp->xirr = 0;
 374     icp->pending_priority = 0xff;
 375     icp->mfrr = 0xff;
 376
 377     /* Make all outputs are deasserted */
 378     qemu_set_irq(icp->output, 0);
 379 }
 380
 381 static void icp_realize(DeviceState *dev, Error **errp)
 382 {
 383     ICPState *icp = ICP(dev);
 384     Object *obj;
 385     Error *err = NULL;
 386
 387     obj = object_property_get_link(OBJECT(dev), "xics", &err);
 388     if (!obj) {
 389         error_setg(errp, "%s: required link 'xics' not found: %s",
 390                    __func__, error_get_pretty(err));
 391         return;
 392     }
 393
 394     icp->xics = XICS_FABRIC(obj);
 395 }
 396
 397
 398 static void icp_class_init(ObjectClass *klass, void *data)
 399 {
 400     DeviceClass *dc = DEVICE_CLASS(klass);
 401     InterruptStatsProviderClass *ic = INTERRUPT_STATS_PROVIDER_CLASS(klass);
 402
 403     dc->reset = icp_reset;
 404     dc->vmsd = &vmstate_icp_server;
 405     dc->realize = icp_realize;
 406     ic->print_info = icp_pic_print_info;
 407 }
 408
 409 static const TypeInfo icp_info = {
 410     .name = TYPE_ICP,
 411     .parent = TYPE_DEVICE,
 412     .instance_size = sizeof(ICPState),
 413     .class_init = icp_class_init,
 414     .class_size = sizeof(ICPStateClass),
 415     .interfaces = (InterfaceInfo[]) {
 416         { TYPE_INTERRUPT_STATS_PROVIDER },
 417         { }
 418     },
 419 };
 420
 421 /*
 422  * ICS: Source layer
 423  */
 424 static void ics_simple_resend_msi(ICSState *ics, int srcno)
 425 {
 426     ICSIRQState *irq = ics->irqs + srcno;
 427
 428     /* FIXME: filter by server#? */
 429     if (irq->status & XICS_STATUS_REJECTED) {
 430         irq->status &= ~XICS_STATUS_REJECTED;
 431         if (irq->priority != 0xff) {
 432             icp_irq(ics, irq->server, srcno + ics->offset, irq->priority);
 433         }
 434     }
 435 }
 436
 437 static void ics_simple_resend_lsi(ICSState *ics, int srcno)
 438 {
 439     ICSIRQState *irq = ics->irqs + srcno;
 440
 441     if ((irq->priority != 0xff)
 442         && (irq->status & XICS_STATUS_ASSERTED)
 443         && !(irq->status & XICS_STATUS_SENT)) {
 444         irq->status |= XICS_STATUS_SENT;
 445         icp_irq(ics, irq->server, srcno + ics->offset, irq->priority);
 446     }
 447 }
 448
 449 static void ics_simple_set_irq_msi(ICSState *ics, int srcno, int val)
 450 {
 451     ICSIRQState *irq = ics->irqs + srcno;
 452
 453     trace_xics_ics_simple_set_irq_msi(srcno, srcno + ics->offset);
 454
 455     if (val) {
 456         if (irq->priority == 0xff) {
 457             irq->status |= XICS_STATUS_MASKED_PENDING;
 458             trace_xics_masked_pending();
 459         } else  {
 460             icp_irq(ics, irq->server, srcno + ics->offset, irq->priority);
 461         }
 462     }
 463 }
 464
 465 static void ics_simple_set_irq_lsi(ICSState *ics, int srcno, int val)
 466 {
 467     ICSIRQState *irq = ics->irqs + srcno;
 468
 469     trace_xics_ics_simple_set_irq_lsi(srcno, srcno + ics->offset);
 470     if (val) {
 471         irq->status |= XICS_STATUS_ASSERTED;
 472     } else {
 473         irq->status &= ~XICS_STATUS_ASSERTED;
 474     }
 475     ics_simple_resend_lsi(ics, srcno);
 476 }
 477
 478 static void ics_simple_set_irq(void *opaque, int srcno, int val)
 479 {
 480     ICSState *ics = (ICSState *)opaque;
 481
 482     if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_LSI) {
 483         ics_simple_set_irq_lsi(ics, srcno, val);
 484     } else {
 485         ics_simple_set_irq_msi(ics, srcno, val);
 486     }
 487 }
 488
 489 static void ics_simple_write_xive_msi(ICSState *ics, int srcno)
 490 {
 491     ICSIRQState *irq = ics->irqs + srcno;
 492
 493     if (!(irq->status & XICS_STATUS_MASKED_PENDING)
 494         || (irq->priority == 0xff)) {
 495         return;
 496     }
 497
 498     irq->status &= ~XICS_STATUS_MASKED_PENDING;
 499     icp_irq(ics, irq->server, srcno + ics->offset, irq->priority);
 500 }
 501
 502 static void ics_simple_write_xive_lsi(ICSState *ics, int srcno)
 503 {
 504     ics_simple_resend_lsi(ics, srcno);
 505 }
 506
 507 void ics_simple_write_xive(ICSState *ics, int srcno, int server,
 508                            uint8_t priority, uint8_t saved_priority)
 509 {
 510     ICSIRQState *irq = ics->irqs + srcno;
 511
 512     irq->server = server;
 513     irq->priority = priority;
 514     irq->saved_priority = saved_priority;
 515
 516     trace_xics_ics_simple_write_xive(ics->offset + srcno, srcno, server,
 517                                      priority);
 518
 519     if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_LSI) {
 520         ics_simple_write_xive_lsi(ics, srcno);
 521     } else {
 522         ics_simple_write_xive_msi(ics, srcno);
 523     }
 524 }
 525
 526 static void ics_simple_reject(ICSState *ics, uint32_t nr)
 527 {
 528     ICSIRQState *irq = ics->irqs + nr - ics->offset;
 529
 530     trace_xics_ics_simple_reject(nr, nr - ics->offset);
 531     if (irq->flags & XICS_FLAGS_IRQ_MSI) {
 532         irq->status |= XICS_STATUS_REJECTED;
 533     } else if (irq->flags & XICS_FLAGS_IRQ_LSI) {
 534         irq->status &= ~XICS_STATUS_SENT;
 535     }
 536 }
 537
 538 static void ics_simple_resend(ICSState *ics)
 539 {
 540     int i;
 541
 542     for (i = 0; i < ics->nr_irqs; i++) {
 543         /* FIXME: filter by server#? */
 544         if (ics->irqs[i].flags & XICS_FLAGS_IRQ_LSI) {
 545             ics_simple_resend_lsi(ics, i);
 546         } else {
 547             ics_simple_resend_msi(ics, i);
 548         }
 549     }
 550 }
 551
 552 static void ics_simple_eoi(ICSState *ics, uint32_t nr)
 553 {
 554     int srcno = nr - ics->offset;
 555     ICSIRQState *irq = ics->irqs + srcno;
 556
 557     trace_xics_ics_simple_eoi(nr);
 558
 559     if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_LSI) {
 560         irq->status &= ~XICS_STATUS_SENT;
 561     }
 562 }
 563
 564 static void ics_simple_reset(DeviceState *dev)
 565 {
 566     ICSState *ics = ICS_SIMPLE(dev);
 567     int i;
 568     uint8_t flags[ics->nr_irqs];
 569
 570     for (i = 0; i < ics->nr_irqs; i++) {
 571         flags[i] = ics->irqs[i].flags;
 572     }
 573
 574     memset(ics->irqs, 0, sizeof(ICSIRQState) * ics->nr_irqs);
 575
 576     for (i = 0; i < ics->nr_irqs; i++) {
 577         ics->irqs[i].priority = 0xff;
 578         ics->irqs[i].saved_priority = 0xff;
 579         ics->irqs[i].flags = flags[i];
 580     }
 581 }
 582
 583 static int ics_simple_post_load(ICSState *ics, int version_id)
 584 {
 585     int i;
 586
 587     for (i = 0; i < ics->xics->nr_servers; i++) {
 588         icp_resend(&ics->xics->ss[i]);
 589     }
 590
 591     return 0;
 592 }
 593
 594 static void ics_simple_dispatch_pre_save(void *opaque)
 595 {
 596     ICSState *ics = opaque;
 597     ICSStateClass *info = ICS_BASE_GET_CLASS(ics);
 598
 599     if (info->pre_save) {
 600         info->pre_save(ics);
 601     }
 602 }
 603
 604 static int ics_simple_dispatch_post_load(void *opaque, int version_id)
 605 {
 606     ICSState *ics = opaque;
 607     ICSStateClass *info = ICS_BASE_GET_CLASS(ics);
 608
 609     if (info->post_load) {
 610         return info->post_load(ics, version_id);
 611     }
 612
 613     return 0;
 614 }
 615
 616 static const VMStateDescription vmstate_ics_simple_irq = {
 617     .name = "ics/irq",
 618     .version_id = 2,
 619     .minimum_version_id = 1,
 620     .fields = (VMStateField[]) {
 621         VMSTATE_UINT32(server, ICSIRQState),
 622         VMSTATE_UINT8(priority, ICSIRQState),
 623         VMSTATE_UINT8(saved_priority, ICSIRQState),
 624         VMSTATE_UINT8(status, ICSIRQState),
 625         VMSTATE_UINT8(flags, ICSIRQState),
 626         VMSTATE_END_OF_LIST()
 627     },
 628 };
 629
 630 static const VMStateDescription vmstate_ics_simple = {
 631     .name = "ics",
 632     .version_id = 1,
 633     .minimum_version_id = 1,
 634     .pre_save = ics_simple_dispatch_pre_save,
 635     .post_load = ics_simple_dispatch_post_load,
 636     .fields = (VMStateField[]) {
 637         /* Sanity check */
 638         VMSTATE_UINT32_EQUAL(nr_irqs, ICSState),
 639
 640         VMSTATE_STRUCT_VARRAY_POINTER_UINT32(irqs, ICSState, nr_irqs,
 641                                              vmstate_ics_simple_irq,
 642                                              ICSIRQState),
 643         VMSTATE_END_OF_LIST()
 644     },
 645 };
 646
 647 static void ics_simple_initfn(Object *obj)
 648 {
 649     ICSState *ics = ICS_SIMPLE(obj);
 650
 651     ics->offset = XICS_IRQ_BASE;
 652 }
 653
 654 static void ics_simple_realize(DeviceState *dev, Error **errp)
 655 {
 656     ICSState *ics = ICS_SIMPLE(dev);
 657
 658     if (!ics->nr_irqs) {
 659         error_setg(errp, "Number of interrupts needs to be greater 0");
 660         return;
 661     }
 662     ics->irqs = g_malloc0(ics->nr_irqs * sizeof(ICSIRQState));
 663     ics->qirqs = qemu_allocate_irqs(ics_simple_set_irq, ics, ics->nr_irqs);
 664 }
 665
 666 static Property ics_simple_properties[] = {
 667     DEFINE_PROP_UINT32("nr-irqs", ICSState, nr_irqs, 0),
 668     DEFINE_PROP_END_OF_LIST(),
 669 };
 670
 671 static void ics_simple_class_init(ObjectClass *klass, void *data)
 672 {
 673     DeviceClass *dc = DEVICE_CLASS(klass);
 674     ICSStateClass *isc = ICS_BASE_CLASS(klass);
 675     InterruptStatsProviderClass *ic = INTERRUPT_STATS_PROVIDER_CLASS(klass);
 676
 677     isc->realize = ics_simple_realize;
 678     dc->props = ics_simple_properties;
 679     dc->vmsd = &vmstate_ics_simple;
 680     dc->reset = ics_simple_reset;
 681     isc->post_load = ics_simple_post_load;
 682     isc->reject = ics_simple_reject;
 683     isc->resend = ics_simple_resend;
 684     isc->eoi = ics_simple_eoi;
 685     ic->print_info = ics_simple_pic_print_info;
 686 }
 687
 688 static const TypeInfo ics_simple_info = {
 689     .name = TYPE_ICS_SIMPLE,
 690     .parent = TYPE_ICS_BASE,
 691     .instance_size = sizeof(ICSState),
 692     .class_init = ics_simple_class_init,
 693     .class_size = sizeof(ICSStateClass),
 694     .instance_init = ics_simple_initfn,
 695     .interfaces = (InterfaceInfo[]) {
 696         { TYPE_INTERRUPT_STATS_PROVIDER },
 697         { }
 698     },
 699 };
 700
 701 static void ics_base_realize(DeviceState *dev, Error **errp)
 702 {
 703     ICSStateClass *icsc = ICS_BASE_GET_CLASS(dev);
 704     ICSState *ics = ICS_BASE(dev);
 705     Object *obj;
 706     Error *err = NULL;
 707
 708     obj = object_property_get_link(OBJECT(dev), "xics", &err);
 709     if (!obj) {
 710         error_setg(errp, "%s: required link 'xics' not found: %s",
 711                    __func__, error_get_pretty(err));
 712         return;
 713     }
 714     ics->xics = XICS_COMMON(obj);
 715
 716
 717     if (icsc->realize) {
 718         icsc->realize(dev, errp);
 719     }
 720 }
 721
 722 static void ics_base_class_init(ObjectClass *klass, void *data)
 723 {
 724     DeviceClass *dc = DEVICE_CLASS(klass);
 725
 726     dc->realize = ics_base_realize;
 727 }
 728
 729 static const TypeInfo ics_base_info = {
 730     .name = TYPE_ICS_BASE,
 731     .parent = TYPE_DEVICE,
 732     .abstract = true,
 733     .instance_size = sizeof(ICSState),
 734     .class_init = ics_base_class_init,
 735     .class_size = sizeof(ICSStateClass),
 736 };
 737
 738 static const TypeInfo xics_fabric_info = {
 739     .name = TYPE_XICS_FABRIC,
 740     .parent = TYPE_INTERFACE,
 741     .class_size = sizeof(XICSFabricClass),
 742 };
 743
 744 /*
 745  * Exported functions
 746  */
 747 qemu_irq xics_get_qirq(XICSFabric *xi, int irq)
 748 {
 749     XICSFabricClass *xic = XICS_FABRIC_GET_CLASS(xi);
 750     ICSState *ics = xic->ics_get(xi, irq);
 751
 752     if (ics) {
 753         return ics->qirqs[irq - ics->offset];
 754     }
 755
 756     return NULL;
 757 }
 758
 759 void ics_set_irq_type(ICSState *ics, int srcno, bool lsi)
 760 {
 761     assert(!(ics->irqs[srcno].flags & XICS_FLAGS_IRQ_MASK));
 762
 763     ics->irqs[srcno].flags |=
 764         lsi ? XICS_FLAGS_IRQ_LSI : XICS_FLAGS_IRQ_MSI;
 765 }
 766
 767 static void xics_register_types(void)
 768 {
 769     type_register_static(&xics_common_info);
 770     type_register_static(&ics_simple_info);
 771     type_register_static(&ics_base_info);
 772     type_register_static(&icp_info);
 773     type_register_static(&xics_fabric_info);
 774 }
 775
 776 type_init(xics_register_types)