← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to hw/arm/musicpal.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/arm/musicpal.c
146
146
    uint32_t next;
147
147
} mv88w8618_rx_desc;
148
148
 
 
149
#define TYPE_MV88W8618_ETH "mv88w8618_eth"
 
150
#define MV88W8618_ETH(obj) \
 
151
    OBJECT_CHECK(mv88w8618_eth_state, (obj), TYPE_MV88W8618_ETH)
 
152
 
149
153
typedef struct mv88w8618_eth_state {
150
 
    SysBusDevice busdev;
 
154
    /*< private >*/
 
155
    SysBusDevice parent_obj;
 
156
    /*< public >*/
 
157
 
151
158
    MemoryRegion iomem;
152
159
    qemu_irq irq;
153
160
    uint32_t smir;
382
389
    .cleanup = eth_cleanup,
383
390
};
384
391
 
385
 
static int mv88w8618_eth_init(SysBusDevice *dev)
 
392
static int mv88w8618_eth_init(SysBusDevice *sbd)
386
393
{
387
 
    mv88w8618_eth_state *s = FROM_SYSBUS(mv88w8618_eth_state, dev);
 
394
    DeviceState *dev = DEVICE(sbd);
 
395
    mv88w8618_eth_state *s = MV88W8618_ETH(dev);
388
396
 
389
 
    sysbus_init_irq(dev, &s->irq);
 
397
    sysbus_init_irq(sbd, &s->irq);
390
398
    s->nic = qemu_new_nic(&net_mv88w8618_info, &s->conf,
391
 
                          object_get_typename(OBJECT(dev)), dev->qdev.id, s);
392
 
    memory_region_init_io(&s->iomem, &mv88w8618_eth_ops, s, "mv88w8618-eth",
393
 
                          MP_ETH_SIZE);
394
 
    sysbus_init_mmio(dev, &s->iomem);
 
399
                          object_get_typename(OBJECT(dev)), dev->id, s);
 
400
    memory_region_init_io(&s->iomem, OBJECT(s), &mv88w8618_eth_ops, s,
 
401
                          "mv88w8618-eth", MP_ETH_SIZE);
 
402
    sysbus_init_mmio(sbd, &s->iomem);
395
403
    return 0;
396
404
}
397
405
 
429
437
}
430
438
 
431
439
static const TypeInfo mv88w8618_eth_info = {
432
 
    .name          = "mv88w8618_eth",
 
440
    .name          = TYPE_MV88W8618_ETH,
433
441
    .parent        = TYPE_SYS_BUS_DEVICE,
434
442
    .instance_size = sizeof(mv88w8618_eth_state),
435
443
    .class_init    = mv88w8618_eth_class_init,
454
462
 
455
463
#define MP_LCD_TEXTCOLOR        0xe0e0ff /* RRGGBB */
456
464
 
 
465
#define TYPE_MUSICPAL_LCD "musicpal_lcd"
 
466
#define MUSICPAL_LCD(obj) \
 
467
    OBJECT_CHECK(musicpal_lcd_state, (obj), TYPE_MUSICPAL_LCD)
 
468
 
457
469
typedef struct musicpal_lcd_state {
458
 
    SysBusDevice busdev;
 
470
    /*< private >*/
 
471
    SysBusDevice parent_obj;
 
472
    /*< public >*/
 
473
 
459
474
    MemoryRegion iomem;
460
475
    uint32_t brightness;
461
476
    uint32_t mode;
534
549
{
535
550
}
536
551
 
537
 
static void musicpal_lcd_gpio_brigthness_in(void *opaque, int irq, int level)
 
552
static void musicpal_lcd_gpio_brightness_in(void *opaque, int irq, int level)
538
553
{
539
554
    musicpal_lcd_state *s = opaque;
540
555
    s->brightness &= ~(1 << irq);
606
621
    .gfx_update  = lcd_refresh,
607
622
};
608
623
 
609
 
static int musicpal_lcd_init(SysBusDevice *dev)
 
624
static int musicpal_lcd_init(SysBusDevice *sbd)
610
625
{
611
 
    musicpal_lcd_state *s = FROM_SYSBUS(musicpal_lcd_state, dev);
 
626
    DeviceState *dev = DEVICE(sbd);
 
627
    musicpal_lcd_state *s = MUSICPAL_LCD(dev);
612
628
 
613
629
    s->brightness = 7;
614
630
 
615
 
    memory_region_init_io(&s->iomem, &musicpal_lcd_ops, s,
 
631
    memory_region_init_io(&s->iomem, OBJECT(s), &musicpal_lcd_ops, s,
616
632
                          "musicpal-lcd", MP_LCD_SIZE);
617
 
    sysbus_init_mmio(dev, &s->iomem);
 
633
    sysbus_init_mmio(sbd, &s->iomem);
618
634
 
619
 
    s->con = graphic_console_init(DEVICE(dev), &musicpal_gfx_ops, s);
 
635
    s->con = graphic_console_init(dev, &musicpal_gfx_ops, s);
620
636
    qemu_console_resize(s->con, 128*3, 64*3);
621
637
 
622
 
    qdev_init_gpio_in(&dev->qdev, musicpal_lcd_gpio_brigthness_in, 3);
 
638
    qdev_init_gpio_in(dev, musicpal_lcd_gpio_brightness_in, 3);
623
639
 
624
640
    return 0;
625
641
}
650
666
}
651
667
 
652
668
static const TypeInfo musicpal_lcd_info = {
653
 
    .name          = "musicpal_lcd",
 
669
    .name          = TYPE_MUSICPAL_LCD,
654
670
    .parent        = TYPE_SYS_BUS_DEVICE,
655
671
    .instance_size = sizeof(musicpal_lcd_state),
656
672
    .class_init    = musicpal_lcd_class_init,
661
677
#define MP_PIC_ENABLE_SET       0x08
662
678
#define MP_PIC_ENABLE_CLR       0x0C
663
679
 
664
 
typedef struct mv88w8618_pic_state
665
 
{
666
 
    SysBusDevice busdev;
 
680
#define TYPE_MV88W8618_PIC "mv88w8618_pic"
 
681
#define MV88W8618_PIC(obj) \
 
682
    OBJECT_CHECK(mv88w8618_pic_state, (obj), TYPE_MV88W8618_PIC)
 
683
 
 
684
typedef struct mv88w8618_pic_state {
 
685
    /*< private >*/
 
686
    SysBusDevice parent_obj;
 
687
    /*< public >*/
 
688
 
667
689
    MemoryRegion iomem;
668
690
    uint32_t level;
669
691
    uint32_t enabled;
721
743
 
722
744
static void mv88w8618_pic_reset(DeviceState *d)
723
745
{
724
 
    mv88w8618_pic_state *s = FROM_SYSBUS(mv88w8618_pic_state,
725
 
                                         SYS_BUS_DEVICE(d));
 
746
    mv88w8618_pic_state *s = MV88W8618_PIC(d);
726
747
 
727
748
    s->level = 0;
728
749
    s->enabled = 0;
736
757
 
737
758
static int mv88w8618_pic_init(SysBusDevice *dev)
738
759
{
739
 
    mv88w8618_pic_state *s = FROM_SYSBUS(mv88w8618_pic_state, dev);
 
760
    mv88w8618_pic_state *s = MV88W8618_PIC(dev);
740
761
 
741
 
    qdev_init_gpio_in(&dev->qdev, mv88w8618_pic_set_irq, 32);
 
762
    qdev_init_gpio_in(DEVICE(dev), mv88w8618_pic_set_irq, 32);
742
763
    sysbus_init_irq(dev, &s->parent_irq);
743
 
    memory_region_init_io(&s->iomem, &mv88w8618_pic_ops, s,
 
764
    memory_region_init_io(&s->iomem, OBJECT(s), &mv88w8618_pic_ops, s,
744
765
                          "musicpal-pic", MP_PIC_SIZE);
745
766
    sysbus_init_mmio(dev, &s->iomem);
746
767
    return 0;
769
790
}
770
791
 
771
792
static const TypeInfo mv88w8618_pic_info = {
772
 
    .name          = "mv88w8618_pic",
 
793
    .name          = TYPE_MV88W8618_PIC,
773
794
    .parent        = TYPE_SYS_BUS_DEVICE,
774
795
    .instance_size = sizeof(mv88w8618_pic_state),
775
796
    .class_init    = mv88w8618_pic_class_init,
795
816
    qemu_irq irq;
796
817
} mv88w8618_timer_state;
797
818
 
 
819
#define TYPE_MV88W8618_PIT "mv88w8618_pit"
 
820
#define MV88W8618_PIT(obj) \
 
821
    OBJECT_CHECK(mv88w8618_pit_state, (obj), TYPE_MV88W8618_PIT)
 
822
 
798
823
typedef struct mv88w8618_pit_state {
799
 
    SysBusDevice busdev;
 
824
    /*< private >*/
 
825
    SysBusDevice parent_obj;
 
826
    /*< public >*/
 
827
 
800
828
    MemoryRegion iomem;
801
829
    mv88w8618_timer_state timer[4];
802
830
} mv88w8618_pit_state;
878
906
 
879
907
static void mv88w8618_pit_reset(DeviceState *d)
880
908
{
881
 
    mv88w8618_pit_state *s = FROM_SYSBUS(mv88w8618_pit_state,
882
 
                                         SYS_BUS_DEVICE(d));
 
909
    mv88w8618_pit_state *s = MV88W8618_PIT(d);
883
910
    int i;
884
911
 
885
912
    for (i = 0; i < 4; i++) {
896
923
 
897
924
static int mv88w8618_pit_init(SysBusDevice *dev)
898
925
{
899
 
    mv88w8618_pit_state *s = FROM_SYSBUS(mv88w8618_pit_state, dev);
 
926
    mv88w8618_pit_state *s = MV88W8618_PIT(dev);
900
927
    int i;
901
928
 
902
929
    /* Letting them all run at 1 MHz is likely just a pragmatic
905
932
        mv88w8618_timer_init(dev, &s->timer[i], 1000000);
906
933
    }
907
934
 
908
 
    memory_region_init_io(&s->iomem, &mv88w8618_pit_ops, s,
 
935
    memory_region_init_io(&s->iomem, OBJECT(s), &mv88w8618_pit_ops, s,
909
936
                          "musicpal-pit", MP_PIT_SIZE);
910
937
    sysbus_init_mmio(dev, &s->iomem);
911
938
    return 0;
946
973
}
947
974
 
948
975
static const TypeInfo mv88w8618_pit_info = {
949
 
    .name          = "mv88w8618_pit",
 
976
    .name          = TYPE_MV88W8618_PIT,
950
977
    .parent        = TYPE_SYS_BUS_DEVICE,
951
978
    .instance_size = sizeof(mv88w8618_pit_state),
952
979
    .class_init    = mv88w8618_pit_class_init,
955
982
/* Flash config register offsets */
956
983
#define MP_FLASHCFG_CFGR0    0x04
957
984
 
 
985
#define TYPE_MV88W8618_FLASHCFG "mv88w8618_flashcfg"
 
986
#define MV88W8618_FLASHCFG(obj) \
 
987
    OBJECT_CHECK(mv88w8618_flashcfg_state, (obj), TYPE_MV88W8618_FLASHCFG)
 
988
 
958
989
typedef struct mv88w8618_flashcfg_state {
959
 
    SysBusDevice busdev;
 
990
    /*< private >*/
 
991
    SysBusDevice parent_obj;
 
992
    /*< public >*/
 
993
 
960
994
    MemoryRegion iomem;
961
995
    uint32_t cfgr0;
962
996
} mv88w8618_flashcfg_state;
996
1030
 
997
1031
static int mv88w8618_flashcfg_init(SysBusDevice *dev)
998
1032
{
999
 
    mv88w8618_flashcfg_state *s = FROM_SYSBUS(mv88w8618_flashcfg_state, dev);
 
1033
    mv88w8618_flashcfg_state *s = MV88W8618_FLASHCFG(dev);
1000
1034
 
1001
1035
    s->cfgr0 = 0xfffe4285; /* Default as set by U-Boot for 8 MB flash */
1002
 
    memory_region_init_io(&s->iomem, &mv88w8618_flashcfg_ops, s,
 
1036
    memory_region_init_io(&s->iomem, OBJECT(s), &mv88w8618_flashcfg_ops, s,
1003
1037
                          "musicpal-flashcfg", MP_FLASHCFG_SIZE);
1004
1038
    sysbus_init_mmio(dev, &s->iomem);
1005
1039
    return 0;
1026
1060
}
1027
1061
 
1028
1062
static const TypeInfo mv88w8618_flashcfg_info = {
1029
 
    .name          = "mv88w8618_flashcfg",
 
1063
    .name          = TYPE_MV88W8618_FLASHCFG,
1030
1064
    .parent        = TYPE_SYS_BUS_DEVICE,
1031
1065
    .instance_size = sizeof(mv88w8618_flashcfg_state),
1032
1066
    .class_init    = mv88w8618_flashcfg_class_init,
1074
1108
    SysBusDevice *sd = SYS_BUS_DEVICE(obj);
1075
1109
    MusicPalMiscState *s = MUSICPAL_MISC(obj);
1076
1110
 
1077
 
    memory_region_init_io(&s->iomem, &musicpal_misc_ops, NULL,
 
1111
    memory_region_init_io(&s->iomem, OBJECT(s), &musicpal_misc_ops, NULL,
1078
1112
                          "musicpal-misc", MP_MISC_SIZE);
1079
1113
    sysbus_init_mmio(sd, &s->iomem);
1080
1114
}
1121
1155
{
1122
1156
    MemoryRegion *iomem = g_new(MemoryRegion, 1);
1123
1157
 
1124
 
    memory_region_init_io(iomem, &mv88w8618_wlan_ops, NULL,
 
1158
    memory_region_init_io(iomem, OBJECT(dev), &mv88w8618_wlan_ops, NULL,
1125
1159
                          "musicpal-wlan", MP_WLAN_SIZE);
1126
1160
    sysbus_init_mmio(dev, iomem);
1127
1161
    return 0;
1149
1183
/* LCD brightness bits in GPIO_OE_HI */
1150
1184
#define MP_OE_LCD_BRIGHTNESS    0x0007
1151
1185
 
 
1186
#define TYPE_MUSICPAL_GPIO "musicpal_gpio"
 
1187
#define MUSICPAL_GPIO(obj) \
 
1188
    OBJECT_CHECK(musicpal_gpio_state, (obj), TYPE_MUSICPAL_GPIO)
 
1189
 
1152
1190
typedef struct musicpal_gpio_state {
1153
 
    SysBusDevice busdev;
 
1191
    /*< private >*/
 
1192
    SysBusDevice parent_obj;
 
1193
    /*< public >*/
 
1194
 
1154
1195
    MemoryRegion iomem;
1155
1196
    uint32_t lcd_brightness;
1156
1197
    uint32_t out_state;
1310
1351
 
1311
1352
static void musicpal_gpio_reset(DeviceState *d)
1312
1353
{
1313
 
    musicpal_gpio_state *s = FROM_SYSBUS(musicpal_gpio_state,
1314
 
                                         SYS_BUS_DEVICE(d));
 
1354
    musicpal_gpio_state *s = MUSICPAL_GPIO(d);
1315
1355
 
1316
1356
    s->lcd_brightness = 0;
1317
1357
    s->out_state = 0;
1321
1361
    s->isr = 0;
1322
1362
}
1323
1363
 
1324
 
static int musicpal_gpio_init(SysBusDevice *dev)
 
1364
static int musicpal_gpio_init(SysBusDevice *sbd)
1325
1365
{
1326
 
    musicpal_gpio_state *s = FROM_SYSBUS(musicpal_gpio_state, dev);
1327
 
 
1328
 
    sysbus_init_irq(dev, &s->irq);
1329
 
 
1330
 
    memory_region_init_io(&s->iomem, &musicpal_gpio_ops, s,
 
1366
    DeviceState *dev = DEVICE(sbd);
 
1367
    musicpal_gpio_state *s = MUSICPAL_GPIO(dev);
 
1368
 
 
1369
    sysbus_init_irq(sbd, &s->irq);
 
1370
 
 
1371
    memory_region_init_io(&s->iomem, OBJECT(s), &musicpal_gpio_ops, s,
1331
1372
                          "musicpal-gpio", MP_GPIO_SIZE);
1332
 
    sysbus_init_mmio(dev, &s->iomem);
1333
 
 
1334
 
    qdev_init_gpio_out(&dev->qdev, s->out, ARRAY_SIZE(s->out));
1335
 
 
1336
 
    qdev_init_gpio_in(&dev->qdev, musicpal_gpio_pin_event, 32);
 
1373
    sysbus_init_mmio(sbd, &s->iomem);
 
1374
 
 
1375
    qdev_init_gpio_out(dev, s->out, ARRAY_SIZE(s->out));
 
1376
 
 
1377
    qdev_init_gpio_in(dev, musicpal_gpio_pin_event, 32);
1337
1378
 
1338
1379
    return 0;
1339
1380
}
1365
1406
}
1366
1407
 
1367
1408
static const TypeInfo musicpal_gpio_info = {
1368
 
    .name          = "musicpal_gpio",
 
1409
    .name          = TYPE_MUSICPAL_GPIO,
1369
1410
    .parent        = TYPE_SYS_BUS_DEVICE,
1370
1411
    .instance_size = sizeof(musicpal_gpio_state),
1371
1412
    .class_init    = musicpal_gpio_class_init,
1395
1436
#define MP_KEY_BTN_VOLUME      (1 << 6)
1396
1437
#define MP_KEY_BTN_NAVIGATION  (1 << 7)
1397
1438
 
 
1439
#define TYPE_MUSICPAL_KEY "musicpal_key"
 
1440
#define MUSICPAL_KEY(obj) \
 
1441
    OBJECT_CHECK(musicpal_key_state, (obj), TYPE_MUSICPAL_KEY)
 
1442
 
1398
1443
typedef struct musicpal_key_state {
1399
 
    SysBusDevice busdev;
 
1444
    /*< private >*/
 
1445
    SysBusDevice parent_obj;
 
1446
    /*< public >*/
 
1447
 
1400
1448
    MemoryRegion iomem;
1401
1449
    uint32_t kbd_extended;
1402
1450
    uint32_t pressed_keys;
1480
1528
    s->kbd_extended = 0;
1481
1529
}
1482
1530
 
1483
 
static int musicpal_key_init(SysBusDevice *dev)
 
1531
static int musicpal_key_init(SysBusDevice *sbd)
1484
1532
{
1485
 
    musicpal_key_state *s = FROM_SYSBUS(musicpal_key_state, dev);
 
1533
    DeviceState *dev = DEVICE(sbd);
 
1534
    musicpal_key_state *s = MUSICPAL_KEY(dev);
1486
1535
 
1487
 
    memory_region_init(&s->iomem, "dummy", 0);
1488
 
    sysbus_init_mmio(dev, &s->iomem);
 
1536
    memory_region_init(&s->iomem, OBJECT(s), "dummy", 0);
 
1537
    sysbus_init_mmio(sbd, &s->iomem);
1489
1538
 
1490
1539
    s->kbd_extended = 0;
1491
1540
    s->pressed_keys = 0;
1492
1541
 
1493
 
    qdev_init_gpio_out(&dev->qdev, s->out, ARRAY_SIZE(s->out));
 
1542
    qdev_init_gpio_out(dev, s->out, ARRAY_SIZE(s->out));
1494
1543
 
1495
1544
    qemu_add_kbd_event_handler(musicpal_key_event, s);
1496
1545
 
1519
1568
}
1520
1569
 
1521
1570
static const TypeInfo musicpal_key_info = {
1522
 
    .name          = "musicpal_key",
 
1571
    .name          = TYPE_MUSICPAL_KEY,
1523
1572
    .parent        = TYPE_SYS_BUS_DEVICE,
1524
1573
    .instance_size = sizeof(musicpal_key_state),
1525
1574
    .class_init    = musicpal_key_class_init,
1564
1613
    cpu_pic = arm_pic_init_cpu(cpu);
1565
1614
 
1566
1615
    /* For now we use a fixed - the original - RAM size */
1567
 
    memory_region_init_ram(ram, "musicpal.ram", MP_RAM_DEFAULT_SIZE);
 
1616
    memory_region_init_ram(ram, NULL, "musicpal.ram", MP_RAM_DEFAULT_SIZE);
1568
1617
    vmstate_register_ram_global(ram);
1569
1618
    memory_region_add_subregion(address_space_mem, 0, ram);
1570
1619
 
1571
 
    memory_region_init_ram(sram, "musicpal.sram", MP_SRAM_SIZE);
 
1620
    memory_region_init_ram(sram, NULL, "musicpal.sram", MP_SRAM_SIZE);
1572
1621
    vmstate_register_ram_global(sram);
1573
1622
    memory_region_add_subregion(address_space_mem, MP_SRAM_BASE, sram);
1574
1623
 
1575
 
    dev = sysbus_create_simple("mv88w8618_pic", MP_PIC_BASE,
 
1624
    dev = sysbus_create_simple(TYPE_MV88W8618_PIC, MP_PIC_BASE,
1576
1625
                               cpu_pic[ARM_PIC_CPU_IRQ]);
1577
1626
    for (i = 0; i < 32; i++) {
1578
1627
        pic[i] = qdev_get_gpio_in(dev, i);
1579
1628
    }
1580
 
    sysbus_create_varargs("mv88w8618_pit", MP_PIT_BASE, pic[MP_TIMER1_IRQ],
 
1629
    sysbus_create_varargs(TYPE_MV88W8618_PIT, MP_PIT_BASE, pic[MP_TIMER1_IRQ],
1581
1630
                          pic[MP_TIMER2_IRQ], pic[MP_TIMER3_IRQ],
1582
1631
                          pic[MP_TIMER4_IRQ], NULL);
1583
1632
 
1624
1673
#endif
1625
1674
 
1626
1675
    }
1627
 
    sysbus_create_simple("mv88w8618_flashcfg", MP_FLASHCFG_BASE, NULL);
 
1676
    sysbus_create_simple(TYPE_MV88W8618_FLASHCFG, MP_FLASHCFG_BASE, NULL);
1628
1677
 
1629
1678
    qemu_check_nic_model(&nd_table[0], "mv88w8618");
1630
 
    dev = qdev_create(NULL, "mv88w8618_eth");
 
1679
    dev = qdev_create(NULL, TYPE_MV88W8618_ETH);
1631
1680
    qdev_set_nic_properties(dev, &nd_table[0]);
1632
1681
    qdev_init_nofail(dev);
1633
1682
    sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, MP_ETH_BASE);
1637
1686
 
1638
1687
    sysbus_create_simple(TYPE_MUSICPAL_MISC, MP_MISC_BASE, NULL);
1639
1688
 
1640
 
    dev = sysbus_create_simple("musicpal_gpio", MP_GPIO_BASE, pic[MP_GPIO_IRQ]);
 
1689
    dev = sysbus_create_simple(TYPE_MUSICPAL_GPIO, MP_GPIO_BASE,
 
1690
                               pic[MP_GPIO_IRQ]);
1641
1691
    i2c_dev = sysbus_create_simple("gpio_i2c", -1, NULL);
1642
1692
    i2c = (i2c_bus *)qdev_get_child_bus(i2c_dev, "i2c");
1643
1693
 
1644
 
    lcd_dev = sysbus_create_simple("musicpal_lcd", MP_LCD_BASE, NULL);
1645
 
    key_dev = sysbus_create_simple("musicpal_key", -1, NULL);
 
1694
    lcd_dev = sysbus_create_simple(TYPE_MUSICPAL_LCD, MP_LCD_BASE, NULL);
 
1695
    key_dev = sysbus_create_simple(TYPE_MUSICPAL_KEY, -1, NULL);
1646
1696
 
1647
1697
    /* I2C read data */
1648
1698
    qdev_connect_gpio_out(i2c_dev, 0,