← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to hw/m48t59.c

  • Committer: Blue Swirl
  • Date: 2009-08-31 15:14:40 UTC
  • Revision ID: git-v1:528e93a9787ccfc59582a44035f5f342caf5b84f
Fix breakage due to __thread

Thread-local storage is not supported on all hosts.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/m48t59.c
23
23
 */
24
24
#include "hw.h"
25
25
#include "nvram.h"
26
 
#include "isa.h"
27
26
#include "qemu-timer.h"
28
27
#include "sysemu.h"
 
28
#include "sysbus.h"
29
29
 
30
30
//#define DEBUG_NVRAM
31
31
 
32
32
#if defined(DEBUG_NVRAM)
33
 
#define NVRAM_PRINTF(fmt, args...) do { printf(fmt , ##args); } while (0)
 
33
#define NVRAM_PRINTF(fmt, ...) do { printf(fmt , ## __VA_ARGS__); } while (0)
34
34
#else
35
 
#define NVRAM_PRINTF(fmt, args...) do { } while (0)
 
35
#define NVRAM_PRINTF(fmt, ...) do { } while (0)
36
36
#endif
37
37
 
38
38
/*
41
41
 * PPC platform there is also a nvram lock function.
42
42
 */
43
43
struct m48t59_t {
 
44
    SysBusDevice busdev;
44
45
    /* Model parameters */
45
 
    int type; // 2 = m48t02, 8 = m48t08, 59 = m48t59
 
46
    uint32_t type; // 2 = m48t02, 8 = m48t08, 59 = m48t59
46
47
    /* Hardware parameters */
47
48
    qemu_irq IRQ;
48
 
    int mem_index;
49
 
    target_phys_addr_t mem_base;
50
49
    uint32_t io_base;
51
 
    uint16_t size;
 
50
    uint32_t size;
52
51
    /* RTC management */
53
52
    time_t   time_offset;
54
53
    time_t   stop_time;
514
513
{
515
514
    m48t59_t *NVRAM = opaque;
516
515
 
517
 
    addr -= NVRAM->mem_base;
518
516
    m48t59_write(NVRAM, addr, value & 0xff);
519
517
}
520
518
 
522
520
{
523
521
    m48t59_t *NVRAM = opaque;
524
522
 
525
 
    addr -= NVRAM->mem_base;
526
523
    m48t59_write(NVRAM, addr, (value >> 8) & 0xff);
527
524
    m48t59_write(NVRAM, addr + 1, value & 0xff);
528
525
}
531
528
{
532
529
    m48t59_t *NVRAM = opaque;
533
530
 
534
 
    addr -= NVRAM->mem_base;
535
531
    m48t59_write(NVRAM, addr, (value >> 24) & 0xff);
536
532
    m48t59_write(NVRAM, addr + 1, (value >> 16) & 0xff);
537
533
    m48t59_write(NVRAM, addr + 2, (value >> 8) & 0xff);
543
539
    m48t59_t *NVRAM = opaque;
544
540
    uint32_t retval;
545
541
 
546
 
    addr -= NVRAM->mem_base;
547
542
    retval = m48t59_read(NVRAM, addr);
548
543
    return retval;
549
544
}
553
548
    m48t59_t *NVRAM = opaque;
554
549
    uint32_t retval;
555
550
 
556
 
    addr -= NVRAM->mem_base;
557
551
    retval = m48t59_read(NVRAM, addr) << 8;
558
552
    retval |= m48t59_read(NVRAM, addr + 1);
559
553
    return retval;
564
558
    m48t59_t *NVRAM = opaque;
565
559
    uint32_t retval;
566
560
 
567
 
    addr -= NVRAM->mem_base;
568
561
    retval = m48t59_read(NVRAM, addr) << 24;
569
562
    retval |= m48t59_read(NVRAM, addr + 1) << 16;
570
563
    retval |= m48t59_read(NVRAM, addr + 2) << 8;
572
565
    return retval;
573
566
}
574
567
 
575
 
static CPUWriteMemoryFunc *nvram_write[] = {
 
568
static CPUWriteMemoryFunc * const nvram_write[] = {
576
569
    &nvram_writeb,
577
570
    &nvram_writew,
578
571
    &nvram_writel,
579
572
};
580
573
 
581
 
static CPUReadMemoryFunc *nvram_read[] = {
 
574
static CPUReadMemoryFunc * const nvram_read[] = {
582
575
    &nvram_readb,
583
576
    &nvram_readw,
584
577
    &nvram_readl,
611
604
{
612
605
    m48t59_t *NVRAM = opaque;
613
606
 
 
607
    NVRAM->addr = 0;
 
608
    NVRAM->lock = 0;
614
609
    if (NVRAM->alrm_timer != NULL)
615
610
        qemu_del_timer(NVRAM->alrm_timer);
616
611
 
623
618
                       uint32_t io_base, uint16_t size,
624
619
                       int type)
625
620
{
626
 
    m48t59_t *s;
627
 
    target_phys_addr_t save_base;
 
621
    DeviceState *dev;
 
622
    SysBusDevice *s;
 
623
    m48t59_t *d;
628
624
 
629
 
    s = qemu_mallocz(sizeof(m48t59_t));
630
 
    if (!s)
631
 
        return NULL;
632
 
    s->buffer = qemu_mallocz(size);
633
 
    if (!s->buffer) {
634
 
        qemu_free(s);
635
 
        return NULL;
636
 
    }
637
 
    s->IRQ = IRQ;
638
 
    s->size = size;
639
 
    s->mem_base = mem_base;
640
 
    s->io_base = io_base;
641
 
    s->addr = 0;
642
 
    s->type = type;
 
625
    dev = qdev_create(NULL, "m48t59");
 
626
    qdev_prop_set_uint32(dev, "type", type);
 
627
    qdev_prop_set_uint32(dev, "size", size);
 
628
    qdev_prop_set_uint32(dev, "io_base", io_base);
 
629
    qdev_init(dev);
 
630
    s = sysbus_from_qdev(dev);
 
631
    sysbus_connect_irq(s, 0, IRQ);
643
632
    if (io_base != 0) {
644
633
        register_ioport_read(io_base, 0x04, 1, NVRAM_readb, s);
645
634
        register_ioport_write(io_base, 0x04, 1, NVRAM_writeb, s);
646
635
    }
647
636
    if (mem_base != 0) {
648
 
        s->mem_index = cpu_register_io_memory(0, nvram_read, nvram_write, s);
649
 
        cpu_register_physical_memory(mem_base, size, s->mem_index);
 
637
        sysbus_mmio_map(s, 0, mem_base);
650
638
    }
651
 
    if (type == 59) {
 
639
 
 
640
    d = FROM_SYSBUS(m48t59_t, s);
 
641
 
 
642
    return d;
 
643
}
 
644
 
 
645
static int m48t59_init1(SysBusDevice *dev)
 
646
{
 
647
    m48t59_t *s = FROM_SYSBUS(m48t59_t, dev);
 
648
    int mem_index;
 
649
 
 
650
    s->buffer = qemu_mallocz(s->size);
 
651
    sysbus_init_irq(dev, &s->IRQ);
 
652
 
 
653
    mem_index = cpu_register_io_memory(nvram_read, nvram_write, s);
 
654
    sysbus_init_mmio(dev, s->size, mem_index);
 
655
 
 
656
    if (s->type == 59) {
652
657
        s->alrm_timer = qemu_new_timer(vm_clock, &alarm_cb, s);
653
658
        s->wd_timer = qemu_new_timer(vm_clock, &watchdog_cb, s);
654
659
    }
655
 
    s->lock = 0;
656
660
    qemu_get_timedate(&s->alarm, 0);
657
661
 
658
662
    qemu_register_reset(m48t59_reset, s);
659
 
    save_base = mem_base ? mem_base : io_base;
660
 
    register_savevm("m48t59", save_base, 1, m48t59_save, m48t59_load, s);
661
 
 
662
 
    return s;
663
 
}
 
663
    register_savevm("m48t59", -1, 1, m48t59_save, m48t59_load, s);
 
664
    return 0;
 
665
}
 
666
 
 
667
static SysBusDeviceInfo m48t59_info = {
 
668
    .init = m48t59_init1,
 
669
    .qdev.name  = "m48t59",
 
670
    .qdev.size  = sizeof(m48t59_t),
 
671
    .qdev.props = (Property[]) {
 
672
        DEFINE_PROP_UINT32("size",    m48t59_t, size,    -1),
 
673
        DEFINE_PROP_UINT32("type",    m48t59_t, type,    -1),
 
674
        DEFINE_PROP_HEX32( "io_base", m48t59_t, io_base,  0),
 
675
        DEFINE_PROP_END_OF_LIST(),
 
676
    }
 
677
};
 
678
 
 
679
static void m48t59_register_devices(void)
 
680
{
 
681
    sysbus_register_withprop(&m48t59_info);
 
682
}
 
683
 
 
684
device_init(m48t59_register_devices)