hw/arm/bcm2835_peripherals.c

   1 /*
   2  * Raspberry Pi emulation (c) 2012 Gregory Estrade
   3  * Upstreaming code cleanup [including bcm2835_*] (c) 2013 Jan Petrous
   4  *
   5  * Rasperry Pi 2 emulation and refactoring Copyright (c) 2015, Microsoft
   6  * Written by Andrew Baumann
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   9  * See the COPYING file in the top-level directory.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "qapi/error.h"
  14 #include "qemu/module.h"
  15 #include "hw/arm/bcm2835_peripherals.h"
  16 #include "hw/misc/bcm2835_mbox_defs.h"
  17 #include "hw/arm/raspi_platform.h"
  18 #include "sysemu/sysemu.h"
  19
  20 /* Peripheral base address on the VC (GPU) system bus */
  21 #define BCM2835_VC_PERI_BASE 0x7e000000
  22
  23 /* Capabilities for SD controller: no DMA, high-speed, default clocks etc. */
  24 #define BCM2835_SDHC_CAPAREG 0x52134b4
  25
  26 static void create_unimp(BCM2835PeripheralState *ps,
  27                          UnimplementedDeviceState *uds,
  28                          const char *name, hwaddr ofs, hwaddr size)
  29 {
  30     object_initialize_child(OBJECT(ps), name, uds, TYPE_UNIMPLEMENTED_DEVICE);
  31     qdev_prop_set_string(DEVICE(uds), "name", name);
  32     qdev_prop_set_uint64(DEVICE(uds), "size", size);
  33     sysbus_realize(SYS_BUS_DEVICE(uds), &error_fatal);
  34     memory_region_add_subregion_overlap(&ps->peri_mr, ofs,
  35                     sysbus_mmio_get_region(SYS_BUS_DEVICE(uds), 0), -1000);
  36 }
  37
  38 static void bcm2835_peripherals_init(Object *obj)
  39 {
  40     BCM2835PeripheralState *s = BCM2835_PERIPHERALS(obj);
  41
  42     /* Memory region for peripheral devices, which we export to our parent */
  43     memory_region_init(&s->peri_mr, obj,"bcm2835-peripherals", 0x1000000);
  44     sysbus_init_mmio(SYS_BUS_DEVICE(s), &s->peri_mr);
  45
  46     /* Internal memory region for peripheral bus addresses (not exported) */
  47     memory_region_init(&s->gpu_bus_mr, obj, "bcm2835-gpu", (uint64_t)1 << 32);
  48
  49     /* Internal memory region for request/response communication with
  50      * mailbox-addressable peripherals (not exported)
  51      */
  52     memory_region_init(&s->mbox_mr, obj, "bcm2835-mbox",
  53                        MBOX_CHAN_COUNT << MBOX_AS_CHAN_SHIFT);
  54
  55     /* Interrupt Controller */
  56     object_initialize_child(obj, "ic", &s->ic, TYPE_BCM2835_IC);
  57
  58     /* SYS Timer */
  59     object_initialize_child(obj, "systimer", &s->systmr,
  60                             TYPE_BCM2835_SYSTIMER);
  61
  62     /* UART0 */
  63     object_initialize_child(obj, "uart0", &s->uart0, TYPE_PL011);
  64
  65     /* AUX / UART1 */
  66     object_initialize_child(obj, "aux", &s->aux, TYPE_BCM2835_AUX);
  67
  68 #if 0
  69     /* System timer */
  70     object_initialize(&s->st, sizeof(s->st), TYPE_BCM2835_ST);
  71     object_property_add_child(obj, "systimer", OBJECT(&s->st), NULL);
  72     qdev_set_parent_bus(DEVICE(&s->st), sysbus_get_default());
  73
  74     /* ARM timer */
  75     object_initialize(&s->timer, sizeof(s->timer), TYPE_BCM2835_TIMER);
  76     object_property_add_child(obj, "armtimer", OBJECT(&s->timer), NULL);
  77     qdev_set_parent_bus(DEVICE(&s->timer), sysbus_get_default());
  78
  79     /* USB controller */
  80     object_initialize(&s->usb, sizeof(s->usb), TYPE_BCM2835_USB);
  81     object_property_add_child(obj, "usb", OBJECT(&s->usb), NULL);
  82     qdev_set_parent_bus(DEVICE(&s->usb), sysbus_get_default());
  83
  84     object_property_add_const_link(OBJECT(&s->usb), "dma_mr",
  85                                    OBJECT(&s->gpu_bus_mr), &error_abort);
  86 #endif
  87
  88     /* Mailboxes */
  89     object_initialize_child(obj, "mbox", &s->mboxes, TYPE_BCM2835_MBOX);
  90
  91     object_property_add_const_link(OBJECT(&s->mboxes), "mbox-mr",
  92                                    OBJECT(&s->mbox_mr));
  93
  94 #if 0
  95     /* Power management */
  96     object_initialize(&s->power, sizeof(s->power), TYPE_BCM2835_POWER);
  97     object_property_add_child(obj, "power", OBJECT(&s->power), NULL);
  98     qdev_set_parent_bus(DEVICE(&s->power), sysbus_get_default());
  99 #endif
 100
 101     /* Framebuffer */
 102     object_initialize_child(obj, "fb", &s->fb, TYPE_BCM2835_FB);
 103     object_property_add_alias(obj, "vcram-size", OBJECT(&s->fb), "vcram-size");
 104
 105     object_property_add_const_link(OBJECT(&s->fb), "dma-mr",
 106                                    OBJECT(&s->gpu_bus_mr));
 107
 108     /* Property channel */
 109     object_initialize_child(obj, "property", &s->property,
 110                             TYPE_BCM2835_PROPERTY);
 111     object_property_add_alias(obj, "board-rev", OBJECT(&s->property),
 112                               "board-rev");
 113
 114     object_property_add_const_link(OBJECT(&s->property), "fb",
 115                                    OBJECT(&s->fb));
 116     object_property_add_const_link(OBJECT(&s->property), "dma-mr",
 117                                    OBJECT(&s->gpu_bus_mr));
 118
 119     /* Random Number Generator */
 120     object_initialize_child(obj, "rng", &s->rng, TYPE_BCM2835_RNG);
 121
 122     /* Extended Mass Media Controller */
 123     object_initialize_child(obj, "sdhci", &s->sdhci, TYPE_SYSBUS_SDHCI);
 124
 125     /* SDHOST */
 126     object_initialize_child(obj, "sdhost", &s->sdhost, TYPE_BCM2835_SDHOST);
 127
 128     /* DMA Channels */
 129     object_initialize_child(obj, "dma", &s->dma, TYPE_BCM2835_DMA);
 130
 131     object_property_add_const_link(OBJECT(&s->dma), "dma-mr",
 132                                    OBJECT(&s->gpu_bus_mr));
 133
 134     /* Thermal */
 135     object_initialize_child(obj, "thermal", &s->thermal, TYPE_BCM2835_THERMAL);
 136
 137     /* GPIO */
 138     object_initialize_child(obj, "gpio", &s->gpio, TYPE_BCM2835_GPIO);
 139
 140     object_property_add_const_link(OBJECT(&s->gpio), "sdbus-sdhci",
 141                                    OBJECT(&s->sdhci.sdbus));
 142     object_property_add_const_link(OBJECT(&s->gpio), "sdbus-sdhost",
 143                                    OBJECT(&s->sdhost.sdbus));
 144
 145     /* Mphi */
 146     object_initialize_child(obj, "mphi", &s->mphi, TYPE_BCM2835_MPHI);
 147
 148     /* DWC2 */
 149     object_initialize_child(obj, "dwc2", &s->dwc2, TYPE_DWC2_USB);
 150
 151     /* CPRMAN clock manager */
 152     object_initialize_child(obj, "cprman", &s->cprman, TYPE_BCM2835_CPRMAN);
 153
 154     object_property_add_const_link(OBJECT(&s->dwc2), "dma-mr",
 155                                    OBJECT(&s->gpu_bus_mr));
 156 }
 157
 158 static void bcm2835_peripherals_realize(DeviceState *dev, Error **errp)
 159 {
 160     BCM2835PeripheralState *s = BCM2835_PERIPHERALS(dev);
 161     Object *obj;
 162     MemoryRegion *ram;
 163     Error *err = NULL;
 164     uint64_t ram_size, vcram_size;
 165     int n;
 166
 167     obj = object_property_get_link(OBJECT(dev), "ram", &error_abort);
 168
 169     ram = MEMORY_REGION(obj);
 170     ram_size = memory_region_size(ram);
 171
 172     /* Map peripherals and RAM into the GPU address space. */
 173     memory_region_init_alias(&s->peri_mr_alias, OBJECT(s),
 174                              "bcm2835-peripherals", &s->peri_mr, 0,
 175                              memory_region_size(&s->peri_mr));
 176
 177     memory_region_add_subregion_overlap(&s->gpu_bus_mr, BCM2835_VC_PERI_BASE,
 178                                         &s->peri_mr_alias, 1);
 179
 180     /* RAM is aliased four times (different cache configurations) on the GPU */
 181     for (n = 0; n < 4; n++) {
 182         memory_region_init_alias(&s->ram_alias[n], OBJECT(s),
 183                                  "bcm2835-gpu-ram-alias[*]", ram, 0, ram_size);
 184         memory_region_add_subregion_overlap(&s->gpu_bus_mr, (hwaddr)n << 30,
 185                                             &s->ram_alias[n], 0);
 186     }
 187
 188     /* Interrupt Controller */
 189     if (!sysbus_realize(SYS_BUS_DEVICE(&s->ic), errp)) {
 190         return;
 191     }
 192
 193     /* CPRMAN clock manager */
 194     if (!sysbus_realize(SYS_BUS_DEVICE(&s->cprman), errp)) {
 195         return;
 196     }
 197     memory_region_add_subregion(&s->peri_mr, CPRMAN_OFFSET,
 198                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->cprman), 0));
 199     qdev_connect_clock_in(DEVICE(&s->uart0), "clk",
 200                           qdev_get_clock_out(DEVICE(&s->cprman), "uart-out"));
 201
 202     memory_region_add_subregion(&s->peri_mr, ARMCTRL_IC_OFFSET,
 203                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->ic), 0));
 204     sysbus_pass_irq(SYS_BUS_DEVICE(s), SYS_BUS_DEVICE(&s->ic));
 205
 206     /* Sys Timer */
 207     if (!sysbus_realize(SYS_BUS_DEVICE(&s->systmr), errp)) {
 208         return;
 209     }
 210     memory_region_add_subregion(&s->peri_mr, ST_OFFSET,
 211                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->systmr), 0));
 212     sysbus_connect_irq(SYS_BUS_DEVICE(&s->systmr), 0,
 213         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 214                                INTERRUPT_TIMER0));
 215     sysbus_connect_irq(SYS_BUS_DEVICE(&s->systmr), 1,
 216         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 217                                INTERRUPT_TIMER1));
 218     sysbus_connect_irq(SYS_BUS_DEVICE(&s->systmr), 2,
 219         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 220                                INTERRUPT_TIMER2));
 221     sysbus_connect_irq(SYS_BUS_DEVICE(&s->systmr), 3,
 222         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 223                                INTERRUPT_TIMER3));
 224
 225     /* UART0 */
 226     qdev_prop_set_chr(DEVICE(&s->uart0), "chardev", serial_hd(0));
 227     if (!sysbus_realize(SYS_BUS_DEVICE(&s->uart0), errp)) {
 228         return;
 229     }
 230
 231     memory_region_add_subregion(&s->peri_mr, UART0_OFFSET,
 232                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->uart0), 0));
 233     sysbus_connect_irq(SYS_BUS_DEVICE(&s->uart0), 0,
 234         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 235                                INTERRUPT_UART0));
 236
 237     /* AUX / UART1 */
 238     qdev_prop_set_chr(DEVICE(&s->aux), "chardev", serial_hd(1));
 239
 240     if (!sysbus_realize(SYS_BUS_DEVICE(&s->aux), errp)) {
 241         return;
 242     }
 243
 244     memory_region_add_subregion(&s->peri_mr, AUX_OFFSET,
 245                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->aux), 0));
 246     sysbus_connect_irq(SYS_BUS_DEVICE(&s->aux), 0,
 247         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 248                                INTERRUPT_AUX));
 249
 250 #if 0
 251     /* System timer */
 252     object_property_set_bool(OBJECT(&s->st), true, "realized", &err);
 253     if (err) {
 254         error_propagate(errp, err);
 255         return;
 256     }
 257
 258     memory_region_add_subregion(&s->peri_mr, ST_OFFSET,
 259                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->st), 0));
 260     sysbus_connect_irq(SYS_BUS_DEVICE(&s->st), 0,
 261         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 262                                INTERRUPT_TIMER0));
 263     sysbus_connect_irq(SYS_BUS_DEVICE(&s->st), 1,
 264         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 265                                INTERRUPT_TIMER1));
 266     sysbus_connect_irq(SYS_BUS_DEVICE(&s->st), 2,
 267         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 268                                INTERRUPT_TIMER2));
 269     sysbus_connect_irq(SYS_BUS_DEVICE(&s->st), 3,
 270         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 271                                INTERRUPT_TIMER3));
 272
 273     /* ARM timer */
 274     object_property_set_bool(OBJECT(&s->timer), true, "realized", &err);
 275     if (err) {
 276         error_propagate(errp, err);
 277         return;
 278     }
 279
 280     memory_region_add_subregion(&s->peri_mr, ARMCTRL_TIMER0_1_OFFSET,
 281                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->timer), 0));
 282     sysbus_connect_irq(SYS_BUS_DEVICE(&s->timer), 0,
 283         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_ARM_IRQ,
 284                                INTERRUPT_ARM_TIMER));
 285
 286     /* USB controller */
 287     object_property_set_bool(OBJECT(&s->usb), true, "realized", &err);
 288     if (err) {
 289         error_propagate(errp, err);
 290         return;
 291     }
 292
 293     memory_region_add_subregion(&s->peri_mr, USB_OTG_OFFSET,
 294                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->usb), 0));
 295     sysbus_connect_irq(SYS_BUS_DEVICE(&s->usb), 0,
 296         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 297                                INTERRUPT_USB));
 298
 299     /* MPHI - Message-based Parallel Host Interface */
 300     object_property_set_bool(OBJECT(&s->mphi), true, "realized", &err);
 301     if (err) {
 302         error_propagate(errp, err);
 303         return;
 304     }
 305
 306     memory_region_add_subregion(&s->peri_mr, MPHI_OFFSET,
 307                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->mphi), 0));
 308     sysbus_connect_irq(SYS_BUS_DEVICE(&s->mphi), 0,
 309         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 310                                INTERRUPT_HOSTPORT));
 311 #endif
 312
 313     /* Mailboxes */
 314     if (!sysbus_realize(SYS_BUS_DEVICE(&s->mboxes), errp)) {
 315         return;
 316     }
 317
 318     memory_region_add_subregion(&s->peri_mr, ARMCTRL_0_SBM_OFFSET,
 319                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->mboxes), 0));
 320     sysbus_connect_irq(SYS_BUS_DEVICE(&s->mboxes), 0,
 321         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_ARM_IRQ,
 322                                INTERRUPT_ARM_MAILBOX));
 323
 324 #if 0
 325     /* Power management */
 326     object_property_set_bool(OBJECT(&s->power), true, "realized", &err);
 327     if (err) {
 328         error_propagate(errp, err);
 329         return;
 330     }
 331
 332     memory_region_add_subregion(&s->mbox_mr, MBOX_CHAN_POWER << MBOX_AS_CHAN_SHIFT,
 333                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->power), 0));
 334     sysbus_connect_irq(SYS_BUS_DEVICE(&s->power), 0,
 335                        qdev_get_gpio_in(DEVICE(&s->mboxes), MBOX_CHAN_POWER));
 336 #endif
 337
 338     /* Framebuffer */
 339     vcram_size = object_property_get_uint(OBJECT(s), "vcram-size", &err);
 340     if (err) {
 341         error_propagate(errp, err);
 342         return;
 343     }
 344
 345     if (!object_property_set_uint(OBJECT(&s->fb), "vcram-base",
 346                                   ram_size - vcram_size, errp)) {
 347         return;
 348     }
 349
 350     if (!sysbus_realize(SYS_BUS_DEVICE(&s->fb), errp)) {
 351         return;
 352     }
 353
 354     memory_region_add_subregion(&s->mbox_mr, MBOX_CHAN_FB << MBOX_AS_CHAN_SHIFT,
 355                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->fb), 0));
 356     sysbus_connect_irq(SYS_BUS_DEVICE(&s->fb), 0,
 357                        qdev_get_gpio_in(DEVICE(&s->mboxes), MBOX_CHAN_FB));
 358
 359     /* Property channel */
 360     if (!sysbus_realize(SYS_BUS_DEVICE(&s->property), errp)) {
 361         return;
 362     }
 363
 364     memory_region_add_subregion(&s->mbox_mr,
 365                 MBOX_CHAN_PROPERTY << MBOX_AS_CHAN_SHIFT,
 366                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->property), 0));
 367     sysbus_connect_irq(SYS_BUS_DEVICE(&s->property), 0,
 368                       qdev_get_gpio_in(DEVICE(&s->mboxes), MBOX_CHAN_PROPERTY));
 369
 370     /* Random Number Generator */
 371     if (!sysbus_realize(SYS_BUS_DEVICE(&s->rng), errp)) {
 372         return;
 373     }
 374
 375     memory_region_add_subregion(&s->peri_mr, RNG_OFFSET,
 376                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->rng), 0));
 377
 378     /* Extended Mass Media Controller
 379      *
 380      * Compatible with:
 381      * - SD Host Controller Specification Version 3.0 Draft 1.0
 382      * - SDIO Specification Version 3.0
 383      * - MMC Specification Version 4.4
 384      *
 385      * For the exact details please refer to the Arasan documentation:
 386      *   SD3.0_Host_AHB_eMMC4.4_Usersguide_ver5.9_jan11_10.pdf
 387      */
 388     object_property_set_uint(OBJECT(&s->sdhci), "sd-spec-version", 3,
 389                              &error_abort);
 390     object_property_set_uint(OBJECT(&s->sdhci), "capareg",
 391                              BCM2835_SDHC_CAPAREG, &error_abort);
 392     object_property_set_bool(OBJECT(&s->sdhci), "pending-insert-quirk", true,
 393                              &error_abort);
 394     if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhci), errp)) {
 395         return;
 396     }
 397
 398     memory_region_add_subregion(&s->peri_mr, EMMC1_OFFSET,
 399                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->sdhci), 0));
 400     sysbus_connect_irq(SYS_BUS_DEVICE(&s->sdhci), 0,
 401         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 402                                INTERRUPT_ARASANSDIO));
 403
 404     /* SDHOST */
 405     if (!sysbus_realize(SYS_BUS_DEVICE(&s->sdhost), errp)) {
 406         return;
 407     }
 408
 409     memory_region_add_subregion(&s->peri_mr, MMCI0_OFFSET,
 410                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->sdhost), 0));
 411     sysbus_connect_irq(SYS_BUS_DEVICE(&s->sdhost), 0,
 412         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 413                                INTERRUPT_SDIO));
 414
 415     /* DMA Channels */
 416     if (!sysbus_realize(SYS_BUS_DEVICE(&s->dma), errp)) {
 417         return;
 418     }
 419
 420     memory_region_add_subregion(&s->peri_mr, DMA_OFFSET,
 421                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->dma), 0));
 422     memory_region_add_subregion(&s->peri_mr, DMA15_OFFSET,
 423                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->dma), 1));
 424
 425     for (n = 0; n <= 12; n++) {
 426         sysbus_connect_irq(SYS_BUS_DEVICE(&s->dma), n,
 427                            qdev_get_gpio_in_named(DEVICE(&s->ic),
 428                                                   BCM2835_IC_GPU_IRQ,
 429                                                   INTERRUPT_DMA0 + n));
 430     }
 431
 432     /* THERMAL */
 433     if (!sysbus_realize(SYS_BUS_DEVICE(&s->thermal), errp)) {
 434         return;
 435     }
 436     memory_region_add_subregion(&s->peri_mr, THERMAL_OFFSET,
 437                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->thermal), 0));
 438
 439     /* GPIO */
 440     if (!sysbus_realize(SYS_BUS_DEVICE(&s->gpio), errp)) {
 441         return;
 442     }
 443
 444     memory_region_add_subregion(&s->peri_mr, GPIO_OFFSET,
 445                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->gpio), 0));
 446
 447     object_property_add_alias(OBJECT(s), "sd-bus", OBJECT(&s->gpio), "sd-bus");
 448
 449     /* Mphi */
 450     if (!sysbus_realize(SYS_BUS_DEVICE(&s->mphi), errp)) {
 451         return;
 452     }
 453
 454     memory_region_add_subregion(&s->peri_mr, MPHI_OFFSET,
 455                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->mphi), 0));
 456     sysbus_connect_irq(SYS_BUS_DEVICE(&s->mphi), 0,
 457         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 458                                INTERRUPT_HOSTPORT));
 459
 460     /* DWC2 */
 461     if (!sysbus_realize(SYS_BUS_DEVICE(&s->dwc2), errp)) {
 462         return;
 463     }
 464
 465     memory_region_add_subregion(&s->peri_mr, USB_OTG_OFFSET,
 466                 sysbus_mmio_get_region(SYS_BUS_DEVICE(&s->dwc2), 0));
 467     sysbus_connect_irq(SYS_BUS_DEVICE(&s->dwc2), 0,
 468         qdev_get_gpio_in_named(DEVICE(&s->ic), BCM2835_IC_GPU_IRQ,
 469                                INTERRUPT_USB));
 470
 471     create_unimp(s, &s->txp, "bcm2835-txp", TXP_OFFSET, 0x1000);
 472     create_unimp(s, &s->armtmr, "bcm2835-sp804", ARMCTRL_TIMER0_1_OFFSET, 0x40);
 473     create_unimp(s, &s->powermgt, "bcm2835-powermgt", PM_OFFSET, 0x114);
 474     create_unimp(s, &s->i2s, "bcm2835-i2s", I2S_OFFSET, 0x100);
 475     create_unimp(s, &s->smi, "bcm2835-smi", SMI_OFFSET, 0x100);
 476     create_unimp(s, &s->spi[0], "bcm2835-spi0", SPI0_OFFSET, 0x20);
 477     create_unimp(s, &s->bscsl, "bcm2835-spis", BSC_SL_OFFSET, 0x100);
 478     create_unimp(s, &s->i2c[0], "bcm2835-i2c0", BSC0_OFFSET, 0x20);
 479     create_unimp(s, &s->i2c[1], "bcm2835-i2c1", BSC1_OFFSET, 0x20);
 480     create_unimp(s, &s->i2c[2], "bcm2835-i2c2", BSC2_OFFSET, 0x20);
 481     create_unimp(s, &s->otp, "bcm2835-otp", OTP_OFFSET, 0x80);
 482     create_unimp(s, &s->dbus, "bcm2835-dbus", DBUS_OFFSET, 0x8000);
 483     create_unimp(s, &s->ave0, "bcm2835-ave0", AVE0_OFFSET, 0x8000);
 484     create_unimp(s, &s->v3d, "bcm2835-v3d", V3D_OFFSET, 0x1000);
 485     create_unimp(s, &s->sdramc, "bcm2835-sdramc", SDRAMC_OFFSET, 0x100);
 486 }
 487
 488 static void bcm2835_peripherals_class_init(ObjectClass *oc, void *data)
 489 {
 490     DeviceClass *dc = DEVICE_CLASS(oc);
 491
 492     dc->realize = bcm2835_peripherals_realize;
 493 }
 494
 495 static const TypeInfo bcm2835_peripherals_type_info = {
 496     .name = TYPE_BCM2835_PERIPHERALS,
 497     .parent = TYPE_SYS_BUS_DEVICE,
 498     .instance_size = sizeof(BCM2835PeripheralState),
 499     .instance_init = bcm2835_peripherals_init,
 500     .class_init = bcm2835_peripherals_class_init,
 501 };
 502
 503 static void bcm2835_peripherals_register_types(void)
 504 {
 505     type_register_static(&bcm2835_peripherals_type_info);
 506 }
 507
 508 type_init(bcm2835_peripherals_register_types)