hw/openpic.c

   1 /*
   2  * OpenPIC emulation
   3  *
   4  * Copyright (c) 2004 Jocelyn Mayer
   5  *               2011 Alexander Graf
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25 /*
  26  *
  27  * Based on OpenPic implementations:
  28  * - Intel GW80314 I/O companion chip developer's manual
  29  * - Motorola MPC8245 & MPC8540 user manuals.
  30  * - Motorola MCP750 (aka Raven) programmer manual.
  31  * - Motorola Harrier programmer manuel
  32  *
  33  * Serial interrupts, as implemented in Raven chipset are not supported yet.
  34  *
  35  */
  36 #include "hw.h"
  37 #include "ppc_mac.h"
  38 #include "pci/pci.h"
  39 #include "openpic.h"
  40 #include "sysbus.h"
  41 #include "pci/msi.h"
  42
  43 //#define DEBUG_OPENPIC
  44
  45 #ifdef DEBUG_OPENPIC
  46 static const int debug_openpic = 1;
  47 #else
  48 static const int debug_openpic = 0;
  49 #endif
  50
  51 #define DPRINTF(fmt, ...) do { \
  52         if (debug_openpic) { \
  53             printf(fmt , ## __VA_ARGS__); \
  54         } \
  55     } while (0)
  56
  57 #define MAX_CPU     15
  58 #define MAX_SRC     256
  59 #define MAX_TMR     4
  60 #define MAX_IPI     4
  61 #define MAX_MSI     8
  62 #define MAX_IRQ     (MAX_SRC + MAX_IPI + MAX_TMR)
  63 #define VID         0x03 /* MPIC version ID */
  64
  65 /* OpenPIC capability flags */
  66 #define OPENPIC_FLAG_IDR_CRIT     (1 << 0)
  67
  68 /* OpenPIC address map */
  69 #define OPENPIC_GLB_REG_START        0x0
  70 #define OPENPIC_GLB_REG_SIZE         0x10F0
  71 #define OPENPIC_TMR_REG_START        0x10F0
  72 #define OPENPIC_TMR_REG_SIZE         0x220
  73 #define OPENPIC_MSI_REG_START        0x1600
  74 #define OPENPIC_MSI_REG_SIZE         0x200
  75 #define OPENPIC_SRC_REG_START        0x10000
  76 #define OPENPIC_SRC_REG_SIZE         (MAX_SRC * 0x20)
  77 #define OPENPIC_CPU_REG_START        0x20000
  78 #define OPENPIC_CPU_REG_SIZE         0x100 + ((MAX_CPU - 1) * 0x1000)
  79
  80 /* Raven */
  81 #define RAVEN_MAX_CPU      2
  82 #define RAVEN_MAX_EXT     48
  83 #define RAVEN_MAX_IRQ     64
  84 #define RAVEN_MAX_TMR      MAX_TMR
  85 #define RAVEN_MAX_IPI      MAX_IPI
  86
  87 /* Interrupt definitions */
  88 #define RAVEN_FE_IRQ     (RAVEN_MAX_EXT)     /* Internal functional IRQ */
  89 #define RAVEN_ERR_IRQ    (RAVEN_MAX_EXT + 1) /* Error IRQ */
  90 #define RAVEN_TMR_IRQ    (RAVEN_MAX_EXT + 2) /* First timer IRQ */
  91 #define RAVEN_IPI_IRQ    (RAVEN_TMR_IRQ + RAVEN_MAX_TMR) /* First IPI IRQ */
  92 /* First doorbell IRQ */
  93 #define RAVEN_DBL_IRQ    (RAVEN_IPI_IRQ + (RAVEN_MAX_CPU * RAVEN_MAX_IPI))
  94
  95 /* FSL_MPIC_20 */
  96 #define FSL_MPIC_20_MAX_CPU      1
  97 #define FSL_MPIC_20_MAX_EXT     12
  98 #define FSL_MPIC_20_MAX_INT     64
  99 #define FSL_MPIC_20_MAX_IRQ     MAX_IRQ
 100
 101 /* Interrupt definitions */
 102 /* IRQs, accessible through the IRQ region */
 103 #define FSL_MPIC_20_EXT_IRQ      0x00
 104 #define FSL_MPIC_20_INT_IRQ      0x10
 105 #define FSL_MPIC_20_MSG_IRQ      0xb0
 106 #define FSL_MPIC_20_MSI_IRQ      0xe0
 107 /* These are available through separate regions, but
 108    for simplicity's sake mapped into the same number space */
 109 #define FSL_MPIC_20_TMR_IRQ      0x100
 110 #define FSL_MPIC_20_IPI_IRQ      0x104
 111
 112 /*
 113  * Block Revision Register1 (BRR1): QEMU does not fully emulate
 114  * any version on MPIC. So to start with, set the IP version to 0.
 115  *
 116  * NOTE: This is Freescale MPIC specific register. Keep it here till
 117  * this code is refactored for different variants of OPENPIC and MPIC.
 118  */
 119 #define FSL_BRR1_IPID (0x0040 << 16) /* 16 bit IP-block ID */
 120 #define FSL_BRR1_IPMJ (0x00 << 8) /* 8 bit IP major number */
 121 #define FSL_BRR1_IPMN 0x00 /* 8 bit IP minor number */
 122
 123 #define FRR_NIRQ_SHIFT    16
 124 #define FRR_NCPU_SHIFT     8
 125 #define FRR_VID_SHIFT      0
 126
 127 #define VID_REVISION_1_2   2
 128 #define VID_REVISION_1_3   3
 129
 130 #define VIR_GENERIC      0x00000000 /* Generic Vendor ID */
 131
 132 #define GCR_RESET        0x80000000
 133
 134 #define TBCR_CI           0x80000000 /* count inhibit */
 135 #define TCCR_TOG          0x80000000 /* toggles when decrement to zero */
 136
 137 #define IDR_EP_SHIFT      31
 138 #define IDR_EP_MASK       (1 << IDR_EP_SHIFT)
 139 #define IDR_CI0_SHIFT     30
 140 #define IDR_CI1_SHIFT     29
 141 #define IDR_P1_SHIFT      1
 142 #define IDR_P0_SHIFT      0
 143
 144 #define MSIIR_OFFSET       0x140
 145 #define MSIIR_SRS_SHIFT    29
 146 #define MSIIR_SRS_MASK     (0x7 << MSIIR_SRS_SHIFT)
 147 #define MSIIR_IBS_SHIFT    24
 148 #define MSIIR_IBS_MASK     (0x1f << MSIIR_IBS_SHIFT)
 149
 150 #define BF_WIDTH(_bits_) \
 151 (((_bits_) + (sizeof(uint32_t) * 8) - 1) / (sizeof(uint32_t) * 8))
 152
 153 static inline void set_bit(uint32_t *field, int bit)
 154 {
 155     field[bit >> 5] |= 1 << (bit & 0x1F);
 156 }
 157
 158 static inline void reset_bit(uint32_t *field, int bit)
 159 {
 160     field[bit >> 5] &= ~(1 << (bit & 0x1F));
 161 }
 162
 163 static inline int test_bit(uint32_t *field, int bit)
 164 {
 165     return (field[bit >> 5] & 1 << (bit & 0x1F)) != 0;
 166 }
 167
 168 static int get_current_cpu(void)
 169 {
 170     if (!cpu_single_env) {
 171         return -1;
 172     }
 173
 174     return cpu_single_env->cpu_index;
 175 }
 176
 177 static uint32_t openpic_cpu_read_internal(void *opaque, hwaddr addr,
 178                                           int idx);
 179 static void openpic_cpu_write_internal(void *opaque, hwaddr addr,
 180                                        uint32_t val, int idx);
 181
 182 typedef struct IRQQueue {
 183     uint32_t queue[BF_WIDTH(MAX_IRQ)];
 184     int next;
 185     int priority;
 186 } IRQQueue;
 187
 188 typedef struct IRQSource {
 189     uint32_t ivpr;  /* IRQ vector/priority register */
 190     uint32_t idr;   /* IRQ destination register */
 191     uint32_t destmask; /* bitmap of CPU destinations */
 192     int last_cpu;
 193     int output;     /* IRQ level, e.g. OPENPIC_OUTPUT_INT */
 194     int pending;    /* TRUE if IRQ is pending */
 195     bool nomask:1;  /* critical interrupts ignore mask on some FSL MPICs */
 196 } IRQSource;
 197
 198 #define IVPR_MASK_SHIFT       31
 199 #define IVPR_MASK_MASK        (1 << IVPR_MASK_SHIFT)
 200 #define IVPR_ACTIVITY_SHIFT   30
 201 #define IVPR_ACTIVITY_MASK    (1 << IVPR_ACTIVITY_SHIFT)
 202 #define IVPR_MODE_SHIFT       29
 203 #define IVPR_MODE_MASK        (1 << IVPR_MODE_SHIFT)
 204 #define IVPR_POLARITY_SHIFT   23
 205 #define IVPR_POLARITY_MASK    (1 << IVPR_POLARITY_SHIFT)
 206 #define IVPR_SENSE_SHIFT      22
 207 #define IVPR_SENSE_MASK       (1 << IVPR_SENSE_SHIFT)
 208
 209 #define IVPR_PRIORITY_MASK     (0xF << 16)
 210 #define IVPR_PRIORITY(_ivprr_) ((int)(((_ivprr_) & IVPR_PRIORITY_MASK) >> 16))
 211 #define IVPR_VECTOR(opp, _ivprr_) ((_ivprr_) & (opp)->vector_mask)
 212
 213 /* IDR[EP/CI] are only for FSL MPIC prior to v4.0 */
 214 #define IDR_EP      0x80000000  /* external pin */
 215 #define IDR_CI      0x40000000  /* critical interrupt */
 216
 217 typedef struct IRQDest {
 218     int32_t ctpr; /* CPU current task priority */
 219     IRQQueue raised;
 220     IRQQueue servicing;
 221     qemu_irq *irqs;
 222 } IRQDest;
 223
 224 typedef struct OpenPICState {
 225     SysBusDevice busdev;
 226     MemoryRegion mem;
 227
 228     /* Behavior control */
 229     uint32_t model;
 230     uint32_t flags;
 231     uint32_t nb_irqs;
 232     uint32_t vid;
 233     uint32_t vir; /* Vendor identification register */
 234     uint32_t vector_mask;
 235     uint32_t tfrr_reset;
 236     uint32_t ivpr_reset;
 237     uint32_t idr_reset;
 238     uint32_t brr1;
 239
 240     /* Sub-regions */
 241     MemoryRegion sub_io_mem[5];
 242
 243     /* Global registers */
 244     uint32_t frr; /* Feature reporting register */
 245     uint32_t gcr; /* Global configuration register  */
 246     uint32_t pir; /* Processor initialization register */
 247     uint32_t spve; /* Spurious vector register */
 248     uint32_t tfrr; /* Timer frequency reporting register */
 249     /* Source registers */
 250     IRQSource src[MAX_IRQ];
 251     /* Local registers per output pin */
 252     IRQDest dst[MAX_CPU];
 253     uint32_t nb_cpus;
 254     /* Timer registers */
 255     struct {
 256         uint32_t tccr;  /* Global timer current count register */
 257         uint32_t tbcr;  /* Global timer base count register */
 258     } timers[MAX_TMR];
 259     /* Shared MSI registers */
 260     struct {
 261         uint32_t msir;   /* Shared Message Signaled Interrupt Register */
 262     } msi[MAX_MSI];
 263     uint32_t max_irq;
 264     uint32_t irq_ipi0;
 265     uint32_t irq_tim0;
 266     uint32_t irq_msi;
 267 } OpenPICState;
 268
 269 static inline void IRQ_setbit(IRQQueue *q, int n_IRQ)
 270 {
 271     set_bit(q->queue, n_IRQ);
 272 }
 273
 274 static inline void IRQ_resetbit(IRQQueue *q, int n_IRQ)
 275 {
 276     reset_bit(q->queue, n_IRQ);
 277 }
 278
 279 static inline int IRQ_testbit(IRQQueue *q, int n_IRQ)
 280 {
 281     return test_bit(q->queue, n_IRQ);
 282 }
 283
 284 static void IRQ_check(OpenPICState *opp, IRQQueue *q)
 285 {
 286     int next, i;
 287     int priority;
 288
 289     next = -1;
 290     priority = -1;
 291     for (i = 0; i < opp->max_irq; i++) {
 292         if (IRQ_testbit(q, i)) {
 293             DPRINTF("IRQ_check: irq %d set ivpr_pr=%d pr=%d\n",
 294                     i, IVPR_PRIORITY(opp->src[i].ivpr), priority);
 295             if (IVPR_PRIORITY(opp->src[i].ivpr) > priority) {
 296                 next = i;
 297                 priority = IVPR_PRIORITY(opp->src[i].ivpr);
 298             }
 299         }
 300     }
 301     q->next = next;
 302     q->priority = priority;
 303 }
 304
 305 static int IRQ_get_next(OpenPICState *opp, IRQQueue *q)
 306 {
 307     /* XXX: optimize */
 308     IRQ_check(opp, q);
 309
 310     return q->next;
 311 }
 312
 313 static void IRQ_local_pipe(OpenPICState *opp, int n_CPU, int n_IRQ)
 314 {
 315     IRQDest *dst;
 316     IRQSource *src;
 317     int priority;
 318
 319     dst = &opp->dst[n_CPU];
 320     src = &opp->src[n_IRQ];
 321
 322     if (src->output != OPENPIC_OUTPUT_INT) {
 323         /* On Freescale MPIC, critical interrupts ignore priority,
 324          * IACK, EOI, etc.  Before MPIC v4.1 they also ignore
 325          * masking.
 326          */
 327         src->ivpr |= IVPR_ACTIVITY_MASK;
 328         DPRINTF("%s: Raise OpenPIC output %d cpu %d irq %d\n",
 329                 __func__, src->output, n_CPU, n_IRQ);
 330         qemu_irq_raise(opp->dst[n_CPU].irqs[src->output]);
 331         return;
 332     }
 333
 334     priority = IVPR_PRIORITY(src->ivpr);
 335     if (priority <= dst->ctpr) {
 336         /* Too low priority */
 337         DPRINTF("%s: IRQ %d has too low priority on CPU %d\n",
 338                 __func__, n_IRQ, n_CPU);
 339         return;
 340     }
 341     if (IRQ_testbit(&dst->raised, n_IRQ)) {
 342         /* Interrupt miss */
 343         DPRINTF("%s: IRQ %d was missed on CPU %d\n",
 344                 __func__, n_IRQ, n_CPU);
 345         return;
 346     }
 347     src->ivpr |= IVPR_ACTIVITY_MASK;
 348     IRQ_setbit(&dst->raised, n_IRQ);
 349     if (priority < dst->raised.priority) {
 350         /* An higher priority IRQ is already raised */
 351         DPRINTF("%s: IRQ %d is hidden by raised IRQ %d on CPU %d\n",
 352                 __func__, n_IRQ, dst->raised.next, n_CPU);
 353         return;
 354     }
 355     IRQ_check(opp, &dst->raised);
 356     if (IRQ_get_next(opp, &dst->servicing) != -1 &&
 357         priority <= dst->servicing.priority) {
 358         DPRINTF("%s: IRQ %d is hidden by servicing IRQ %d on CPU %d\n",
 359                 __func__, n_IRQ, dst->servicing.next, n_CPU);
 360         /* Already servicing a higher priority IRQ */
 361         return;
 362     }
 363     DPRINTF("Raise OpenPIC INT output cpu %d irq %d\n", n_CPU, n_IRQ);
 364     qemu_irq_raise(opp->dst[n_CPU].irqs[OPENPIC_OUTPUT_INT]);
 365 }
 366
 367 /* update pic state because registers for n_IRQ have changed value */
 368 static void openpic_update_irq(OpenPICState *opp, int n_IRQ)
 369 {
 370     IRQSource *src;
 371     int i;
 372
 373     src = &opp->src[n_IRQ];
 374
 375     if (!src->pending) {
 376         /* no irq pending */
 377         DPRINTF("%s: IRQ %d is not pending\n", __func__, n_IRQ);
 378         return;
 379     }
 380     if ((src->ivpr & IVPR_MASK_MASK) && !src->nomask) {
 381         /* Interrupt source is disabled */
 382         DPRINTF("%s: IRQ %d is disabled\n", __func__, n_IRQ);
 383         return;
 384     }
 385     if (IVPR_PRIORITY(src->ivpr) == 0) {
 386         /* Priority set to zero */
 387         DPRINTF("%s: IRQ %d has 0 priority\n", __func__, n_IRQ);
 388         return;
 389     }
 390     if (src->ivpr & IVPR_ACTIVITY_MASK) {
 391         /* IRQ already active */
 392         DPRINTF("%s: IRQ %d is already active\n", __func__, n_IRQ);
 393         return;
 394     }
 395     if (src->idr == 0) {
 396         /* No target */
 397         DPRINTF("%s: IRQ %d has no target\n", __func__, n_IRQ);
 398         return;
 399     }
 400
 401     if (src->idr == (1 << src->last_cpu)) {
 402         /* Only one CPU is allowed to receive this IRQ */
 403         IRQ_local_pipe(opp, src->last_cpu, n_IRQ);
 404     } else if (!(src->ivpr & IVPR_MODE_MASK)) {
 405         /* Directed delivery mode */
 406         for (i = 0; i < opp->nb_cpus; i++) {
 407             if (src->destmask & (1 << i)) {
 408                 IRQ_local_pipe(opp, i, n_IRQ);
 409             }
 410         }
 411     } else {
 412         /* Distributed delivery mode */
 413         for (i = src->last_cpu + 1; i != src->last_cpu; i++) {
 414             if (i == opp->nb_cpus) {
 415                 i = 0;
 416             }
 417             if (src->destmask & (1 << i)) {
 418                 IRQ_local_pipe(opp, i, n_IRQ);
 419                 src->last_cpu = i;
 420                 break;
 421             }
 422         }
 423     }
 424 }
 425
 426 static void openpic_set_irq(void *opaque, int n_IRQ, int level)
 427 {
 428     OpenPICState *opp = opaque;
 429     IRQSource *src;
 430
 431     src = &opp->src[n_IRQ];
 432     DPRINTF("openpic: set irq %d = %d ivpr=0x%08x\n",
 433             n_IRQ, level, src->ivpr);
 434     if (src->ivpr & IVPR_SENSE_MASK) {
 435         /* level-sensitive irq */
 436         src->pending = level;
 437         if (!level) {
 438             src->ivpr &= ~IVPR_ACTIVITY_MASK;
 439         }
 440     } else {
 441         /* edge-sensitive irq */
 442         if (level) {
 443             src->pending = 1;
 444         }
 445     }
 446     openpic_update_irq(opp, n_IRQ);
 447 }
 448
 449 static void openpic_reset(DeviceState *d)
 450 {
 451     OpenPICState *opp = FROM_SYSBUS(typeof (*opp), sysbus_from_qdev(d));
 452     int i;
 453
 454     opp->gcr = GCR_RESET;
 455     /* Initialise controller registers */
 456     opp->frr = ((opp->nb_irqs - 1) << FRR_NIRQ_SHIFT) |
 457                ((opp->nb_cpus - 1) << FRR_NCPU_SHIFT) |
 458                (opp->vid << FRR_VID_SHIFT);
 459
 460     opp->pir = 0;
 461     opp->spve = -1 & opp->vector_mask;
 462     opp->tfrr = opp->tfrr_reset;
 463     /* Initialise IRQ sources */
 464     for (i = 0; i < opp->max_irq; i++) {
 465         opp->src[i].ivpr = opp->ivpr_reset;
 466         opp->src[i].idr  = opp->idr_reset;
 467     }
 468     /* Initialise IRQ destinations */
 469     for (i = 0; i < MAX_CPU; i++) {
 470         opp->dst[i].ctpr      = 15;
 471         memset(&opp->dst[i].raised, 0, sizeof(IRQQueue));
 472         opp->dst[i].raised.next = -1;
 473         memset(&opp->dst[i].servicing, 0, sizeof(IRQQueue));
 474         opp->dst[i].servicing.next = -1;
 475     }
 476     /* Initialise timers */
 477     for (i = 0; i < MAX_TMR; i++) {
 478         opp->timers[i].tccr = 0;
 479         opp->timers[i].tbcr = TBCR_CI;
 480     }
 481     /* Go out of RESET state */
 482     opp->gcr = 0;
 483 }
 484
 485 static inline uint32_t read_IRQreg_idr(OpenPICState *opp, int n_IRQ)
 486 {
 487     return opp->src[n_IRQ].idr;
 488 }
 489
 490 static inline uint32_t read_IRQreg_ivpr(OpenPICState *opp, int n_IRQ)
 491 {
 492     return opp->src[n_IRQ].ivpr;
 493 }
 494
 495 static inline void write_IRQreg_idr(OpenPICState *opp, int n_IRQ, uint32_t val)
 496 {
 497     IRQSource *src = &opp->src[n_IRQ];
 498     uint32_t normal_mask = (1UL << opp->nb_cpus) - 1;
 499     uint32_t crit_mask = 0;
 500     uint32_t mask = normal_mask;
 501     int crit_shift = IDR_EP_SHIFT - opp->nb_cpus;
 502     int i;
 503
 504     if (opp->flags & OPENPIC_FLAG_IDR_CRIT) {
 505         crit_mask = mask << crit_shift;
 506         mask |= crit_mask | IDR_EP;
 507     }
 508
 509     src->idr = val & mask;
 510     DPRINTF("Set IDR %d to 0x%08x\n", n_IRQ, src->idr);
 511
 512     if (opp->flags & OPENPIC_FLAG_IDR_CRIT) {
 513         if (src->idr & crit_mask) {
 514             if (src->idr & normal_mask) {
 515                 DPRINTF("%s: IRQ configured for multiple output types, using "
 516                         "critical\n", __func__);
 517             }
 518
 519             src->output = OPENPIC_OUTPUT_CINT;
 520             src->nomask = true;
 521             src->destmask = 0;
 522
 523             for (i = 0; i < opp->nb_cpus; i++) {
 524                 int n_ci = IDR_CI0_SHIFT - i;
 525
 526                 if (src->idr & (1UL << n_ci)) {
 527                     src->destmask |= 1UL << i;
 528                 }
 529             }
 530         } else {
 531             src->output = OPENPIC_OUTPUT_INT;
 532             src->nomask = false;
 533             src->destmask = src->idr & normal_mask;
 534         }
 535     } else {
 536         src->destmask = src->idr;
 537     }
 538 }
 539
 540 static inline void write_IRQreg_ivpr(OpenPICState *opp, int n_IRQ, uint32_t val)
 541 {
 542     /* NOTE: not fully accurate for special IRQs, but simple and sufficient */
 543     /* ACTIVITY bit is read-only */
 544     opp->src[n_IRQ].ivpr = (opp->src[n_IRQ].ivpr & IVPR_ACTIVITY_MASK) |
 545         (val & (IVPR_MASK_MASK | IVPR_PRIORITY_MASK | opp->vector_mask));
 546     openpic_update_irq(opp, n_IRQ);
 547     DPRINTF("Set IVPR %d to 0x%08x -> 0x%08x\n", n_IRQ, val,
 548             opp->src[n_IRQ].ivpr);
 549 }
 550
 551 static void openpic_gbl_write(void *opaque, hwaddr addr, uint64_t val,
 552                               unsigned len)
 553 {
 554     OpenPICState *opp = opaque;
 555     IRQDest *dst;
 556     int idx;
 557
 558     DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
 559             __func__, addr, val);
 560     if (addr & 0xF) {
 561         return;
 562     }
 563     switch (addr) {
 564     case 0x00: /* Block Revision Register1 (BRR1) is Readonly */
 565         break;
 566     case 0x40:
 567     case 0x50:
 568     case 0x60:
 569     case 0x70:
 570     case 0x80:
 571     case 0x90:
 572     case 0xA0:
 573     case 0xB0:
 574         openpic_cpu_write_internal(opp, addr, val, get_current_cpu());
 575         break;
 576     case 0x1000: /* FRR */
 577         break;
 578     case 0x1020: /* GCR */
 579         if (val & GCR_RESET) {
 580             openpic_reset(&opp->busdev.qdev);
 581         }
 582         break;
 583     case 0x1080: /* VIR */
 584         break;
 585     case 0x1090: /* PIR */
 586         for (idx = 0; idx < opp->nb_cpus; idx++) {
 587             if ((val & (1 << idx)) && !(opp->pir & (1 << idx))) {
 588                 DPRINTF("Raise OpenPIC RESET output for CPU %d\n", idx);
 589                 dst = &opp->dst[idx];
 590                 qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_RESET]);
 591             } else if (!(val & (1 << idx)) && (opp->pir & (1 << idx))) {
 592                 DPRINTF("Lower OpenPIC RESET output for CPU %d\n", idx);
 593                 dst = &opp->dst[idx];
 594                 qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_RESET]);
 595             }
 596         }
 597         opp->pir = val;
 598         break;
 599     case 0x10A0: /* IPI_IVPR */
 600     case 0x10B0:
 601     case 0x10C0:
 602     case 0x10D0:
 603         {
 604             int idx;
 605             idx = (addr - 0x10A0) >> 4;
 606             write_IRQreg_ivpr(opp, opp->irq_ipi0 + idx, val);
 607         }
 608         break;
 609     case 0x10E0: /* SPVE */
 610         opp->spve = val & opp->vector_mask;
 611         break;
 612     default:
 613         break;
 614     }
 615 }
 616
 617 static uint64_t openpic_gbl_read(void *opaque, hwaddr addr, unsigned len)
 618 {
 619     OpenPICState *opp = opaque;
 620     uint32_t retval;
 621
 622     DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
 623     retval = 0xFFFFFFFF;
 624     if (addr & 0xF) {
 625         return retval;
 626     }
 627     switch (addr) {
 628     case 0x1000: /* FRR */
 629         retval = opp->frr;
 630         break;
 631     case 0x1020: /* GCR */
 632         retval = opp->gcr;
 633         break;
 634     case 0x1080: /* VIR */
 635         retval = opp->vir;
 636         break;
 637     case 0x1090: /* PIR */
 638         retval = 0x00000000;
 639         break;
 640     case 0x00: /* Block Revision Register1 (BRR1) */
 641         retval = opp->brr1;
 642         break;
 643     case 0x40:
 644     case 0x50:
 645     case 0x60:
 646     case 0x70:
 647     case 0x80:
 648     case 0x90:
 649     case 0xA0:
 650     case 0xB0:
 651         retval = openpic_cpu_read_internal(opp, addr, get_current_cpu());
 652         break;
 653     case 0x10A0: /* IPI_IVPR */
 654     case 0x10B0:
 655     case 0x10C0:
 656     case 0x10D0:
 657         {
 658             int idx;
 659             idx = (addr - 0x10A0) >> 4;
 660             retval = read_IRQreg_ivpr(opp, opp->irq_ipi0 + idx);
 661         }
 662         break;
 663     case 0x10E0: /* SPVE */
 664         retval = opp->spve;
 665         break;
 666     default:
 667         break;
 668     }
 669     DPRINTF("%s: => 0x%08x\n", __func__, retval);
 670
 671     return retval;
 672 }
 673
 674 static void openpic_tmr_write(void *opaque, hwaddr addr, uint64_t val,
 675                                 unsigned len)
 676 {
 677     OpenPICState *opp = opaque;
 678     int idx;
 679
 680     DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
 681             __func__, addr, val);
 682     if (addr & 0xF) {
 683         return;
 684     }
 685     idx = (addr >> 6) & 0x3;
 686     addr = addr & 0x30;
 687
 688     if (addr == 0x0) {
 689         /* TFRR */
 690         opp->tfrr = val;
 691         return;
 692     }
 693     switch (addr & 0x30) {
 694     case 0x00: /* TCCR */
 695         break;
 696     case 0x10: /* TBCR */
 697         if ((opp->timers[idx].tccr & TCCR_TOG) != 0 &&
 698             (val & TBCR_CI) == 0 &&
 699             (opp->timers[idx].tbcr & TBCR_CI) != 0) {
 700             opp->timers[idx].tccr &= ~TCCR_TOG;
 701         }
 702         opp->timers[idx].tbcr = val;
 703         break;
 704     case 0x20: /* TVPR */
 705         write_IRQreg_ivpr(opp, opp->irq_tim0 + idx, val);
 706         break;
 707     case 0x30: /* TDR */
 708         write_IRQreg_idr(opp, opp->irq_tim0 + idx, val);
 709         break;
 710     }
 711 }
 712
 713 static uint64_t openpic_tmr_read(void *opaque, hwaddr addr, unsigned len)
 714 {
 715     OpenPICState *opp = opaque;
 716     uint32_t retval = -1;
 717     int idx;
 718
 719     DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
 720     if (addr & 0xF) {
 721         goto out;
 722     }
 723     idx = (addr >> 6) & 0x3;
 724     if (addr == 0x0) {
 725         /* TFRR */
 726         retval = opp->tfrr;
 727         goto out;
 728     }
 729     switch (addr & 0x30) {
 730     case 0x00: /* TCCR */
 731         retval = opp->timers[idx].tccr;
 732         break;
 733     case 0x10: /* TBCR */
 734         retval = opp->timers[idx].tbcr;
 735         break;
 736     case 0x20: /* TIPV */
 737         retval = read_IRQreg_ivpr(opp, opp->irq_tim0 + idx);
 738         break;
 739     case 0x30: /* TIDE (TIDR) */
 740         retval = read_IRQreg_idr(opp, opp->irq_tim0 + idx);
 741         break;
 742     }
 743
 744 out:
 745     DPRINTF("%s: => 0x%08x\n", __func__, retval);
 746
 747     return retval;
 748 }
 749
 750 static void openpic_src_write(void *opaque, hwaddr addr, uint64_t val,
 751                               unsigned len)
 752 {
 753     OpenPICState *opp = opaque;
 754     int idx;
 755
 756     DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
 757             __func__, addr, val);
 758     if (addr & 0xF) {
 759         return;
 760     }
 761     addr = addr & 0xFFF0;
 762     idx = addr >> 5;
 763     if (addr & 0x10) {
 764         /* EXDE / IFEDE / IEEDE */
 765         write_IRQreg_idr(opp, idx, val);
 766     } else {
 767         /* EXVP / IFEVP / IEEVP */
 768         write_IRQreg_ivpr(opp, idx, val);
 769     }
 770 }
 771
 772 static uint64_t openpic_src_read(void *opaque, uint64_t addr, unsigned len)
 773 {
 774     OpenPICState *opp = opaque;
 775     uint32_t retval;
 776     int idx;
 777
 778     DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
 779     retval = 0xFFFFFFFF;
 780     if (addr & 0xF) {
 781         return retval;
 782     }
 783     addr = addr & 0xFFF0;
 784     idx = addr >> 5;
 785     if (addr & 0x10) {
 786         /* EXDE / IFEDE / IEEDE */
 787         retval = read_IRQreg_idr(opp, idx);
 788     } else {
 789         /* EXVP / IFEVP / IEEVP */
 790         retval = read_IRQreg_ivpr(opp, idx);
 791     }
 792     DPRINTF("%s: => 0x%08x\n", __func__, retval);
 793
 794     return retval;
 795 }
 796
 797 static void openpic_msi_write(void *opaque, hwaddr addr, uint64_t val,
 798                               unsigned size)
 799 {
 800     OpenPICState *opp = opaque;
 801     int idx = opp->irq_msi;
 802     int srs, ibs;
 803
 804     DPRINTF("%s: addr %#" HWADDR_PRIx " <= 0x%08" PRIx64 "\n",
 805             __func__, addr, val);
 806     if (addr & 0xF) {
 807         return;
 808     }
 809
 810     switch (addr) {
 811     case MSIIR_OFFSET:
 812         srs = val >> MSIIR_SRS_SHIFT;
 813         idx += srs;
 814         ibs = (val & MSIIR_IBS_MASK) >> MSIIR_IBS_SHIFT;
 815         opp->msi[srs].msir |= 1 << ibs;
 816         openpic_set_irq(opp, idx, 1);
 817         break;
 818     default:
 819         /* most registers are read-only, thus ignored */
 820         break;
 821     }
 822 }
 823
 824 static uint64_t openpic_msi_read(void *opaque, hwaddr addr, unsigned size)
 825 {
 826     OpenPICState *opp = opaque;
 827     uint64_t r = 0;
 828     int i, srs;
 829
 830     DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
 831     if (addr & 0xF) {
 832         return -1;
 833     }
 834
 835     srs = addr >> 4;
 836
 837     switch (addr) {
 838     case 0x00:
 839     case 0x10:
 840     case 0x20:
 841     case 0x30:
 842     case 0x40:
 843     case 0x50:
 844     case 0x60:
 845     case 0x70: /* MSIRs */
 846         r = opp->msi[srs].msir;
 847         /* Clear on read */
 848         opp->msi[srs].msir = 0;
 849         openpic_set_irq(opp, opp->irq_msi + srs, 0);
 850         break;
 851     case 0x120: /* MSISR */
 852         for (i = 0; i < MAX_MSI; i++) {
 853             r |= (opp->msi[i].msir ? 1 : 0) << i;
 854         }
 855         break;
 856     }
 857
 858     return r;
 859 }
 860
 861 static void openpic_cpu_write_internal(void *opaque, hwaddr addr,
 862                                        uint32_t val, int idx)
 863 {
 864     OpenPICState *opp = opaque;
 865     IRQSource *src;
 866     IRQDest *dst;
 867     int s_IRQ, n_IRQ;
 868
 869     DPRINTF("%s: cpu %d addr %#" HWADDR_PRIx " <= 0x%08x\n", __func__, idx,
 870             addr, val);
 871
 872     if (idx < 0) {
 873         return;
 874     }
 875
 876     if (addr & 0xF) {
 877         return;
 878     }
 879     dst = &opp->dst[idx];
 880     addr &= 0xFF0;
 881     switch (addr) {
 882     case 0x40: /* IPIDR */
 883     case 0x50:
 884     case 0x60:
 885     case 0x70:
 886         idx = (addr - 0x40) >> 4;
 887         /* we use IDE as mask which CPUs to deliver the IPI to still. */
 888         write_IRQreg_idr(opp, opp->irq_ipi0 + idx,
 889                          opp->src[opp->irq_ipi0 + idx].idr | val);
 890         openpic_set_irq(opp, opp->irq_ipi0 + idx, 1);
 891         openpic_set_irq(opp, opp->irq_ipi0 + idx, 0);
 892         break;
 893     case 0x80: /* CTPR */
 894         dst->ctpr = val & 0x0000000F;
 895         break;
 896     case 0x90: /* WHOAMI */
 897         /* Read-only register */
 898         break;
 899     case 0xA0: /* IACK */
 900         /* Read-only register */
 901         break;
 902     case 0xB0: /* EOI */
 903         DPRINTF("EOI\n");
 904         s_IRQ = IRQ_get_next(opp, &dst->servicing);
 905         IRQ_resetbit(&dst->servicing, s_IRQ);
 906         /* Set up next servicing IRQ */
 907         s_IRQ = IRQ_get_next(opp, &dst->servicing);
 908         /* Check queued interrupts. */
 909         n_IRQ = IRQ_get_next(opp, &dst->raised);
 910         src = &opp->src[n_IRQ];
 911         if (n_IRQ != -1 &&
 912             (s_IRQ == -1 ||
 913              IVPR_PRIORITY(src->ivpr) > dst->servicing.priority)) {
 914             DPRINTF("Raise OpenPIC INT output cpu %d irq %d\n",
 915                     idx, n_IRQ);
 916             qemu_irq_raise(opp->dst[idx].irqs[OPENPIC_OUTPUT_INT]);
 917         }
 918         break;
 919     default:
 920         break;
 921     }
 922 }
 923
 924 static void openpic_cpu_write(void *opaque, hwaddr addr, uint64_t val,
 925                               unsigned len)
 926 {
 927     openpic_cpu_write_internal(opaque, addr, val, (addr & 0x1f000) >> 12);
 928 }
 929
 930 static uint32_t openpic_cpu_read_internal(void *opaque, hwaddr addr,
 931                                           int idx)
 932 {
 933     OpenPICState *opp = opaque;
 934     IRQSource *src;
 935     IRQDest *dst;
 936     uint32_t retval;
 937     int n_IRQ;
 938
 939     DPRINTF("%s: cpu %d addr %#" HWADDR_PRIx "\n", __func__, idx, addr);
 940     retval = 0xFFFFFFFF;
 941
 942     if (idx < 0) {
 943         return retval;
 944     }
 945
 946     if (addr & 0xF) {
 947         return retval;
 948     }
 949     dst = &opp->dst[idx];
 950     addr &= 0xFF0;
 951     switch (addr) {
 952     case 0x80: /* CTPR */
 953         retval = dst->ctpr;
 954         break;
 955     case 0x90: /* WHOAMI */
 956         retval = idx;
 957         break;
 958     case 0xA0: /* IACK */
 959         DPRINTF("Lower OpenPIC INT output\n");
 960         qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_INT]);
 961         n_IRQ = IRQ_get_next(opp, &dst->raised);
 962         DPRINTF("IACK: irq=%d\n", n_IRQ);
 963         if (n_IRQ == -1) {
 964             /* No more interrupt pending */
 965             retval = opp->spve;
 966         } else {
 967             src = &opp->src[n_IRQ];
 968             if (!(src->ivpr & IVPR_ACTIVITY_MASK) ||
 969                 !(IVPR_PRIORITY(src->ivpr) > dst->ctpr)) {
 970                 /* - Spurious level-sensitive IRQ
 971                  * - Priorities has been changed
 972                  *   and the pending IRQ isn't allowed anymore
 973                  */
 974                 src->ivpr &= ~IVPR_ACTIVITY_MASK;
 975                 retval = opp->spve;
 976             } else {
 977                 /* IRQ enter servicing state */
 978                 IRQ_setbit(&dst->servicing, n_IRQ);
 979                 retval = IVPR_VECTOR(opp, src->ivpr);
 980             }
 981             IRQ_resetbit(&dst->raised, n_IRQ);
 982             if (!(src->ivpr & IVPR_SENSE_MASK)) {
 983                 /* edge-sensitive IRQ */
 984                 src->ivpr &= ~IVPR_ACTIVITY_MASK;
 985                 src->pending = 0;
 986             }
 987
 988             if ((n_IRQ >= opp->irq_ipi0) &&  (n_IRQ < (opp->irq_ipi0 + MAX_IPI))) {
 989                 src->idr &= ~(1 << idx);
 990                 if (src->idr && !(src->ivpr & IVPR_SENSE_MASK)) {
 991                     /* trigger on CPUs that didn't know about it yet */
 992                     openpic_set_irq(opp, n_IRQ, 1);
 993                     openpic_set_irq(opp, n_IRQ, 0);
 994                     /* if all CPUs knew about it, set active bit again */
 995                     src->ivpr |= IVPR_ACTIVITY_MASK;
 996                 }
 997             }
 998         }
 999         break;
1000     case 0xB0: /* EOI */
1001         retval = 0;
1002         break;
1003     default:
1004         break;
1005     }
1006     DPRINTF("%s: => 0x%08x\n", __func__, retval);
1007
1008     return retval;
1009 }
1010
1011 static uint64_t openpic_cpu_read(void *opaque, hwaddr addr, unsigned len)
1012 {
1013     return openpic_cpu_read_internal(opaque, addr, (addr & 0x1f000) >> 12);
1014 }
1015
1016 static const MemoryRegionOps openpic_glb_ops_le = {
1017     .write = openpic_gbl_write,
1018     .read  = openpic_gbl_read,
1019     .endianness = DEVICE_LITTLE_ENDIAN,
1020     .impl = {
1021         .min_access_size = 4,
1022         .max_access_size = 4,
1023     },
1024 };
1025
1026 static const MemoryRegionOps openpic_glb_ops_be = {
1027     .write = openpic_gbl_write,
1028     .read  = openpic_gbl_read,
1029     .endianness = DEVICE_BIG_ENDIAN,
1030     .impl = {
1031         .min_access_size = 4,
1032         .max_access_size = 4,
1033     },
1034 };
1035
1036 static const MemoryRegionOps openpic_tmr_ops_le = {
1037     .write = openpic_tmr_write,
1038     .read  = openpic_tmr_read,
1039     .endianness = DEVICE_LITTLE_ENDIAN,
1040     .impl = {
1041         .min_access_size = 4,
1042         .max_access_size = 4,
1043     },
1044 };
1045
1046 static const MemoryRegionOps openpic_tmr_ops_be = {
1047     .write = openpic_tmr_write,
1048     .read  = openpic_tmr_read,
1049     .endianness = DEVICE_BIG_ENDIAN,
1050     .impl = {
1051         .min_access_size = 4,
1052         .max_access_size = 4,
1053     },
1054 };
1055
1056 static const MemoryRegionOps openpic_cpu_ops_le = {
1057     .write = openpic_cpu_write,
1058     .read  = openpic_cpu_read,
1059     .endianness = DEVICE_LITTLE_ENDIAN,
1060     .impl = {
1061         .min_access_size = 4,
1062         .max_access_size = 4,
1063     },
1064 };
1065
1066 static const MemoryRegionOps openpic_cpu_ops_be = {
1067     .write = openpic_cpu_write,
1068     .read  = openpic_cpu_read,
1069     .endianness = DEVICE_BIG_ENDIAN,
1070     .impl = {
1071         .min_access_size = 4,
1072         .max_access_size = 4,
1073     },
1074 };
1075
1076 static const MemoryRegionOps openpic_src_ops_le = {
1077     .write = openpic_src_write,
1078     .read  = openpic_src_read,
1079     .endianness = DEVICE_LITTLE_ENDIAN,
1080     .impl = {
1081         .min_access_size = 4,
1082         .max_access_size = 4,
1083     },
1084 };
1085
1086 static const MemoryRegionOps openpic_src_ops_be = {
1087     .write = openpic_src_write,
1088     .read  = openpic_src_read,
1089     .endianness = DEVICE_BIG_ENDIAN,
1090     .impl = {
1091         .min_access_size = 4,
1092         .max_access_size = 4,
1093     },
1094 };
1095
1096 static const MemoryRegionOps openpic_msi_ops_le = {
1097     .read = openpic_msi_read,
1098     .write = openpic_msi_write,
1099     .endianness = DEVICE_LITTLE_ENDIAN,
1100     .impl = {
1101         .min_access_size = 4,
1102         .max_access_size = 4,
1103     },
1104 };
1105
1106 static const MemoryRegionOps openpic_msi_ops_be = {
1107     .read = openpic_msi_read,
1108     .write = openpic_msi_write,
1109     .endianness = DEVICE_BIG_ENDIAN,
1110     .impl = {
1111         .min_access_size = 4,
1112         .max_access_size = 4,
1113     },
1114 };
1115
1116 static void openpic_save_IRQ_queue(QEMUFile* f, IRQQueue *q)
1117 {
1118     unsigned int i;
1119
1120     for (i = 0; i < BF_WIDTH(MAX_IRQ); i++)
1121         qemu_put_be32s(f, &q->queue[i]);
1122
1123     qemu_put_sbe32s(f, &q->next);
1124     qemu_put_sbe32s(f, &q->priority);
1125 }
1126
1127 static void openpic_save(QEMUFile* f, void *opaque)
1128 {
1129     OpenPICState *opp = (OpenPICState *)opaque;
1130     unsigned int i;
1131
1132     qemu_put_be32s(f, &opp->gcr);
1133     qemu_put_be32s(f, &opp->vir);
1134     qemu_put_be32s(f, &opp->pir);
1135     qemu_put_be32s(f, &opp->spve);
1136     qemu_put_be32s(f, &opp->tfrr);
1137
1138     qemu_put_be32s(f, &opp->nb_cpus);
1139
1140     for (i = 0; i < opp->nb_cpus; i++) {
1141         qemu_put_sbe32s(f, &opp->dst[i].ctpr);
1142         openpic_save_IRQ_queue(f, &opp->dst[i].raised);
1143         openpic_save_IRQ_queue(f, &opp->dst[i].servicing);
1144     }
1145
1146     for (i = 0; i < MAX_TMR; i++) {
1147         qemu_put_be32s(f, &opp->timers[i].tccr);
1148         qemu_put_be32s(f, &opp->timers[i].tbcr);
1149     }
1150
1151     for (i = 0; i < opp->max_irq; i++) {
1152         qemu_put_be32s(f, &opp->src[i].ivpr);
1153         qemu_put_be32s(f, &opp->src[i].idr);
1154         qemu_put_sbe32s(f, &opp->src[i].last_cpu);
1155         qemu_put_sbe32s(f, &opp->src[i].pending);
1156     }
1157 }
1158
1159 static void openpic_load_IRQ_queue(QEMUFile* f, IRQQueue *q)
1160 {
1161     unsigned int i;
1162
1163     for (i = 0; i < BF_WIDTH(MAX_IRQ); i++)
1164         qemu_get_be32s(f, &q->queue[i]);
1165
1166     qemu_get_sbe32s(f, &q->next);
1167     qemu_get_sbe32s(f, &q->priority);
1168 }
1169
1170 static int openpic_load(QEMUFile* f, void *opaque, int version_id)
1171 {
1172     OpenPICState *opp = (OpenPICState *)opaque;
1173     unsigned int i;
1174
1175     if (version_id != 1) {
1176         return -EINVAL;
1177     }
1178
1179     qemu_get_be32s(f, &opp->gcr);
1180     qemu_get_be32s(f, &opp->vir);
1181     qemu_get_be32s(f, &opp->pir);
1182     qemu_get_be32s(f, &opp->spve);
1183     qemu_get_be32s(f, &opp->tfrr);
1184
1185     qemu_get_be32s(f, &opp->nb_cpus);
1186
1187     for (i = 0; i < opp->nb_cpus; i++) {
1188         qemu_get_sbe32s(f, &opp->dst[i].ctpr);
1189         openpic_load_IRQ_queue(f, &opp->dst[i].raised);
1190         openpic_load_IRQ_queue(f, &opp->dst[i].servicing);
1191     }
1192
1193     for (i = 0; i < MAX_TMR; i++) {
1194         qemu_get_be32s(f, &opp->timers[i].tccr);
1195         qemu_get_be32s(f, &opp->timers[i].tbcr);
1196     }
1197
1198     for (i = 0; i < opp->max_irq; i++) {
1199         uint32_t val;
1200
1201         val = qemu_get_be32(f);
1202         write_IRQreg_idr(opp, i, val);
1203         val = qemu_get_be32(f);
1204         write_IRQreg_ivpr(opp, i, val);
1205
1206         qemu_get_be32s(f, &opp->src[i].ivpr);
1207         qemu_get_be32s(f, &opp->src[i].idr);
1208         qemu_get_sbe32s(f, &opp->src[i].last_cpu);
1209         qemu_get_sbe32s(f, &opp->src[i].pending);
1210     }
1211
1212     return 0;
1213 }
1214
1215 typedef struct MemReg {
1216     const char             *name;
1217     MemoryRegionOps const  *ops;
1218     bool                   map;
1219     hwaddr      start_addr;
1220     ram_addr_t              size;
1221 } MemReg;
1222
1223 static int openpic_init(SysBusDevice *dev)
1224 {
1225     OpenPICState *opp = FROM_SYSBUS(typeof (*opp), dev);
1226     int i, j;
1227     MemReg list_le[] = {
1228         {"glb", &openpic_glb_ops_le, true,
1229                 OPENPIC_GLB_REG_START, OPENPIC_GLB_REG_SIZE},
1230         {"tmr", &openpic_tmr_ops_le, true,
1231                 OPENPIC_TMR_REG_START, OPENPIC_TMR_REG_SIZE},
1232         {"msi", &openpic_msi_ops_le, true,
1233                 OPENPIC_MSI_REG_START, OPENPIC_MSI_REG_SIZE},
1234         {"src", &openpic_src_ops_le, true,
1235                 OPENPIC_SRC_REG_START, OPENPIC_SRC_REG_SIZE},
1236         {"cpu", &openpic_cpu_ops_le, true,
1237                 OPENPIC_CPU_REG_START, OPENPIC_CPU_REG_SIZE},
1238     };
1239     MemReg list_be[] = {
1240         {"glb", &openpic_glb_ops_be, true,
1241                 OPENPIC_GLB_REG_START, OPENPIC_GLB_REG_SIZE},
1242         {"tmr", &openpic_tmr_ops_be, true,
1243                 OPENPIC_TMR_REG_START, OPENPIC_TMR_REG_SIZE},
1244         {"msi", &openpic_msi_ops_be, true,
1245                 OPENPIC_MSI_REG_START, OPENPIC_MSI_REG_SIZE},
1246         {"src", &openpic_src_ops_be, true,
1247                 OPENPIC_SRC_REG_START, OPENPIC_SRC_REG_SIZE},
1248         {"cpu", &openpic_cpu_ops_be, true,
1249                 OPENPIC_CPU_REG_START, OPENPIC_CPU_REG_SIZE},
1250     };
1251     MemReg *list;
1252
1253     switch (opp->model) {
1254     case OPENPIC_MODEL_FSL_MPIC_20:
1255     default:
1256         opp->flags |= OPENPIC_FLAG_IDR_CRIT;
1257         opp->nb_irqs = 80;
1258         opp->vid = VID_REVISION_1_2;
1259         opp->vir = VIR_GENERIC;
1260         opp->vector_mask = 0xFFFF;
1261         opp->tfrr_reset = 0;
1262         opp->ivpr_reset = IVPR_MASK_MASK;
1263         opp->idr_reset = 1 << 0;
1264         opp->max_irq = FSL_MPIC_20_MAX_IRQ;
1265         opp->irq_ipi0 = FSL_MPIC_20_IPI_IRQ;
1266         opp->irq_tim0 = FSL_MPIC_20_TMR_IRQ;
1267         opp->irq_msi = FSL_MPIC_20_MSI_IRQ;
1268         opp->brr1 = FSL_BRR1_IPID | FSL_BRR1_IPMJ | FSL_BRR1_IPMN;
1269         msi_supported = true;
1270         list = list_be;
1271         break;
1272     case OPENPIC_MODEL_RAVEN:
1273         opp->nb_irqs = RAVEN_MAX_EXT;
1274         opp->vid = VID_REVISION_1_3;
1275         opp->vir = VIR_GENERIC;
1276         opp->vector_mask = 0xFF;
1277         opp->tfrr_reset = 4160000;
1278         opp->ivpr_reset = IVPR_MASK_MASK | IVPR_MODE_MASK;
1279         opp->idr_reset = 0;
1280         opp->max_irq = RAVEN_MAX_IRQ;
1281         opp->irq_ipi0 = RAVEN_IPI_IRQ;
1282         opp->irq_tim0 = RAVEN_TMR_IRQ;
1283         opp->brr1 = -1;
1284         list = list_le;
1285         /* Don't map MSI region */
1286         list[2].map = false;
1287
1288         /* Only UP supported today */
1289         if (opp->nb_cpus != 1) {
1290             return -EINVAL;
1291         }
1292         break;
1293     }
1294
1295     memory_region_init(&opp->mem, "openpic", 0x40000);
1296
1297     for (i = 0; i < ARRAY_SIZE(list_le); i++) {
1298         if (!list[i].map) {
1299             continue;
1300         }
1301
1302         memory_region_init_io(&opp->sub_io_mem[i], list[i].ops, opp,
1303                               list[i].name, list[i].size);
1304
1305         memory_region_add_subregion(&opp->mem, list[i].start_addr,
1306                                     &opp->sub_io_mem[i]);
1307     }
1308
1309     for (i = 0; i < opp->nb_cpus; i++) {
1310         opp->dst[i].irqs = g_new(qemu_irq, OPENPIC_OUTPUT_NB);
1311         for (j = 0; j < OPENPIC_OUTPUT_NB; j++) {
1312             sysbus_init_irq(dev, &opp->dst[i].irqs[j]);
1313         }
1314     }
1315
1316     register_savevm(&opp->busdev.qdev, "openpic", 0, 2,
1317                     openpic_save, openpic_load, opp);
1318
1319     sysbus_init_mmio(dev, &opp->mem);
1320     qdev_init_gpio_in(&dev->qdev, openpic_set_irq, opp->max_irq);
1321
1322     return 0;
1323 }
1324
1325 static Property openpic_properties[] = {
1326     DEFINE_PROP_UINT32("model", OpenPICState, model, OPENPIC_MODEL_FSL_MPIC_20),
1327     DEFINE_PROP_UINT32("nb_cpus", OpenPICState, nb_cpus, 1),
1328     DEFINE_PROP_END_OF_LIST(),
1329 };
1330
1331 static void openpic_class_init(ObjectClass *klass, void *data)
1332 {
1333     DeviceClass *dc = DEVICE_CLASS(klass);
1334     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
1335
1336     k->init = openpic_init;
1337     dc->props = openpic_properties;
1338     dc->reset = openpic_reset;
1339 }
1340
1341 static TypeInfo openpic_info = {
1342     .name          = "openpic",
1343     .parent        = TYPE_SYS_BUS_DEVICE,
1344     .instance_size = sizeof(OpenPICState),
1345     .class_init    = openpic_class_init,
1346 };
1347
1348 static void openpic_register_types(void)
1349 {
1350     type_register_static(&openpic_info);
1351 }
1352
1353 type_init(openpic_register_types)