net: reorganize headers

[qemu.git] / hw / zaurus.c

diff --git a/hw/zaurus.c b/hw/zaurus.c
index 36be94a1799a48119ac6a1b016f07d5421450bb0..d77b34ecce07dd43e7e9f277586878cc4797f883 100644 (file)
--- a/hw/zaurus.c
+++ b/hw/zaurus.c
@@ -16,17 +16,19 @@
  * with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "hw.h"
  * with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "hw.h"

-#include "pxa.h"

 #include "sharpsl.h"
 #include "sharpsl.h"

+#include "sysbus.h"

 
 #undef REG_FMT
 #define REG_FMT                        "0x%02lx"
 
 /* SCOOP devices */
 
 
 #undef REG_FMT
 #define REG_FMT                        "0x%02lx"
 
 /* SCOOP devices */
 

+typedef struct ScoopInfo ScoopInfo;

 struct ScoopInfo {
 struct ScoopInfo {

+    SysBusDevice busdev;

     qemu_irq handler[16];
     qemu_irq handler[16];

-    qemu_irq *in;
+    MemoryRegion iomem;

     uint16_t status;
     uint16_t power;
     uint32_t gpio_level;
     uint16_t status;
     uint16_t power;
     uint32_t gpio_level;


@@ -66,7 +68,8 @@ static inline void scoop_gpio_handler_update(ScoopInfo *s) {
     s->prev_level = level;
 }
 
     s->prev_level = level;
 }
 

-static uint32_t scoop_readb(void *opaque, target_phys_addr_t addr)
+static uint64_t scoop_read(void *opaque, hwaddr addr,
+                           unsigned size)

 {
     ScoopInfo *s = (ScoopInfo *) opaque;
 
 {
     ScoopInfo *s = (ScoopInfo *) opaque;
 


@@ -99,7 +102,8 @@ static uint32_t scoop_readb(void *opaque, target_phys_addr_t addr)
     return 0;
 }
 
     return 0;
 }
 

-static void scoop_writeb(void *opaque, target_phys_addr_t addr, uint32_t value)
+static void scoop_write(void *opaque, hwaddr addr,
+                        uint64_t value, unsigned size)

 {
     ScoopInfo *s = (ScoopInfo *) opaque;
     value &= 0xffff;
 {
     ScoopInfo *s = (ScoopInfo *) opaque;
     value &= 0xffff;


@@ -142,18 +146,13 @@ static void scoop_writeb(void *opaque, target_phys_addr_t addr, uint32_t value)
     }
 }
 
     }
 }
 

-static CPUReadMemoryFunc * const scoop_readfn[] = {
-    scoop_readb,
-    scoop_readb,
-    scoop_readb,
-};
-static CPUWriteMemoryFunc * const scoop_writefn[] = {
-    scoop_writeb,
-    scoop_writeb,
-    scoop_writeb,
+static const MemoryRegionOps scoop_ops = {
+    .read = scoop_read,
+    .write = scoop_write,
+    .endianness = DEVICE_NATIVE_ENDIAN,

 };
 
 };
 

-void scoop_gpio_set(void *opaque, int line, int level)
+static void scoop_gpio_set(void *opaque, int line, int level)

 {
     ScoopInfo *s = (ScoopInfo *) opaque;
 
 {
     ScoopInfo *s = (ScoopInfo *) opaque;
 


@@ -163,83 +162,99 @@ void scoop_gpio_set(void *opaque, int line, int level)
         s->gpio_level &= ~(1 << line);
 }
 
         s->gpio_level &= ~(1 << line);
 }
 

-qemu_irq *scoop_gpio_in_get(ScoopInfo *s)
+static int scoop_init(SysBusDevice *dev)

 {
 {

-    return s->in;
-}
+    ScoopInfo *s = FROM_SYSBUS(ScoopInfo, dev);

 
 

-void scoop_gpio_out_set(ScoopInfo *s, int line,
-                qemu_irq handler) {
-    if (line >= 16) {
-        fprintf(stderr, "No GPIO pin %i\n", line);
-        exit(-1);
-    }
+    s->status = 0x02;
+    qdev_init_gpio_out(&s->busdev.qdev, s->handler, 16);
+    qdev_init_gpio_in(&s->busdev.qdev, scoop_gpio_set, 16);
+    memory_region_init_io(&s->iomem, &scoop_ops, s, "scoop", 0x1000);

 
 

-    s->handler[line] = handler;
-}
+    sysbus_init_mmio(dev, &s->iomem);

 
 

-static void scoop_save(QEMUFile *f, void *opaque)
-{
-    ScoopInfo *s = (ScoopInfo *) opaque;
-    qemu_put_be16s(f, &s->status);
-    qemu_put_be16s(f, &s->power);
-    qemu_put_be32s(f, &s->gpio_level);
-    qemu_put_be32s(f, &s->gpio_dir);
-    qemu_put_be32s(f, &s->prev_level);
-    qemu_put_be16s(f, &s->mcr);
-    qemu_put_be16s(f, &s->cdr);
-    qemu_put_be16s(f, &s->ccr);
-    qemu_put_be16s(f, &s->irr);
-    qemu_put_be16s(f, &s->imr);
-    qemu_put_be16s(f, &s->isr);
+    return 0;

 }
 
 }
 

-static int scoop_load(QEMUFile *f, void *opaque, int version_id)
+static int scoop_post_load(void *opaque, int version_id)

 {
 {

-    uint16_t dummy;

     ScoopInfo *s = (ScoopInfo *) opaque;
     ScoopInfo *s = (ScoopInfo *) opaque;

-    qemu_get_be16s(f, &s->status);
-    qemu_get_be16s(f, &s->power);
-    qemu_get_be32s(f, &s->gpio_level);
-    qemu_get_be32s(f, &s->gpio_dir);
-    qemu_get_be32s(f, &s->prev_level);
-    qemu_get_be16s(f, &s->mcr);
-    qemu_get_be16s(f, &s->cdr);
-    qemu_get_be16s(f, &s->ccr);
-    qemu_get_be16s(f, &s->irr);
-    qemu_get_be16s(f, &s->imr);
-    qemu_get_be16s(f, &s->isr);
-    if (version_id < 1)
-           qemu_get_be16s(f, &dummy);
+    int i;
+    uint32_t level;
+
+    level = s->gpio_level & s->gpio_dir;
+
+    for (i = 0; i < 16; i++) {
+        qemu_set_irq(s->handler[i], (level >> i) & 1);
+    }
+
+    s->prev_level = level;

 
     return 0;
 }
 
 
     return 0;
 }
 

-ScoopInfo *scoop_init(PXA2xxState *cpu,
-               int instance,
-               target_phys_addr_t target_base) {
-    int iomemtype;
-    ScoopInfo *s;
+static bool is_version_0 (void *opaque, int version_id)
+{
+    return version_id == 0;
+}

 
 

-    s = (ScoopInfo *)
-            qemu_mallocz(sizeof(ScoopInfo));
-    memset(s, 0, sizeof(ScoopInfo));
+static const VMStateDescription vmstate_scoop_regs = {
+    .name = "scoop",
+    .version_id = 1,
+    .minimum_version_id = 0,
+    .minimum_version_id_old = 0,
+    .post_load = scoop_post_load,
+    .fields = (VMStateField []) {
+        VMSTATE_UINT16(status, ScoopInfo),
+        VMSTATE_UINT16(power, ScoopInfo),
+        VMSTATE_UINT32(gpio_level, ScoopInfo),
+        VMSTATE_UINT32(gpio_dir, ScoopInfo),
+        VMSTATE_UINT32(prev_level, ScoopInfo),
+        VMSTATE_UINT16(mcr, ScoopInfo),
+        VMSTATE_UINT16(cdr, ScoopInfo),
+        VMSTATE_UINT16(ccr, ScoopInfo),
+        VMSTATE_UINT16(irr, ScoopInfo),
+        VMSTATE_UINT16(imr, ScoopInfo),
+        VMSTATE_UINT16(isr, ScoopInfo),
+        VMSTATE_UNUSED_TEST(is_version_0, 2),
+        VMSTATE_END_OF_LIST(),
+    },
+};

 
 

-    s->status = 0x02;
-    s->in = qemu_allocate_irqs(scoop_gpio_set, s, 16);
-    iomemtype = cpu_register_io_memory(scoop_readfn,
-                    scoop_writefn, s, DEVICE_NATIVE_ENDIAN);
-    cpu_register_physical_memory(target_base, 0x1000, iomemtype);
-    register_savevm(NULL, "scoop", instance, 1, scoop_save, scoop_load, s);
+static Property scoop_sysbus_properties[] = {
+    DEFINE_PROP_END_OF_LIST(),
+};
+
+static void scoop_sysbus_class_init(ObjectClass *klass, void *data)
+{
+    DeviceClass *dc = DEVICE_CLASS(klass);
+    SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);

 
 

-    return s;
+    k->init = scoop_init;
+    dc->desc = "Scoop2 Sharp custom ASIC";
+    dc->vmsd = &vmstate_scoop_regs;
+    dc->props = scoop_sysbus_properties;

 }
 
 }
 

+static TypeInfo scoop_sysbus_info = {
+    .name          = "scoop",
+    .parent        = TYPE_SYS_BUS_DEVICE,
+    .instance_size = sizeof(ScoopInfo),
+    .class_init    = scoop_sysbus_class_init,
+};
+
+static void scoop_register_types(void)
+{
+    type_register_static(&scoop_sysbus_info);
+}
+
+type_init(scoop_register_types)
+

 /* Write the bootloader parameters memory area.  */
 
 #define MAGIC_CHG(a, b, c, d)  ((d << 24) | (c << 16) | (b << 8) | a)
 
 /* Write the bootloader parameters memory area.  */
 
 #define MAGIC_CHG(a, b, c, d)  ((d << 24) | (c << 16) | (b << 8) | a)
 

-static struct __attribute__ ((__packed__)) sl_param_info {
+static struct QEMU_PACKED sl_param_info {

     uint32_t comadj_keyword;
     int32_t comadj;
 
     uint32_t comadj_keyword;
     int32_t comadj;
 


@@ -270,7 +285,7 @@ static struct __attribute__ ((__packed__)) sl_param_info {
     .phadadj           = 0x01,
 };
 
     .phadadj           = 0x01,
 };
 

-void sl_bootparam_write(target_phys_addr_t ptr)
+void sl_bootparam_write(hwaddr ptr)

 {
     cpu_physical_memory_write(ptr, (void *)&zaurus_bootparam,
                               sizeof(struct sl_param_info));
 {
     cpu_physical_memory_write(ptr, (void *)&zaurus_bootparam,
                               sizeof(struct sl_param_info));