Diff for /qemu/hw/pxa2xx.c between versions 1.1.1.6 and 1.1.1.7

version 1.1.1.6, 2018/04/24 18:37:37 version 1.1.1.7, 2018/04/24 18:59:38
Line 4 Line 4
  * Copyright (c) 2006 Openedhand Ltd.   * Copyright (c) 2006 Openedhand Ltd.
  * Written by Andrzej Zaborowski <balrog@zabor.org>   * Written by Andrzej Zaborowski <balrog@zabor.org>
  *   *
  * This code is licenced under the GPL.   * This code is licensed under the GPL.
  */   */
   
 #include "sysbus.h"  #include "sysbus.h"
Line 13 Line 13
 #include "pc.h"  #include "pc.h"
 #include "i2c.h"  #include "i2c.h"
 #include "ssi.h"  #include "ssi.h"
 #include "qemu-timer.h"  
 #include "qemu-char.h"  #include "qemu-char.h"
 #include "blockdev.h"  #include "blockdev.h"
   
Line 147  static CPUWriteMemoryFunc * const pxa2xx Line 146  static CPUWriteMemoryFunc * const pxa2xx
     pxa2xx_pm_write,      pxa2xx_pm_write,
 };  };
   
 static void pxa2xx_pm_save(QEMUFile *f, void *opaque)  static const VMStateDescription vmstate_pxa2xx_pm = {
 {      .name = "pxa2xx_pm",
     PXA2xxState *s = (PXA2xxState *) opaque;      .version_id = 0,
     int i;      .minimum_version_id = 0,
       .minimum_version_id_old = 0,
     for (i = 0; i < 0x40; i ++)      .fields      = (VMStateField[]) {
         qemu_put_be32s(f, &s->pm_regs[i]);          VMSTATE_UINT32_ARRAY(pm_regs, PXA2xxState, 0x40),
 }          VMSTATE_END_OF_LIST()
       }
 static int pxa2xx_pm_load(QEMUFile *f, void *opaque, int version_id)  };
 {  
     PXA2xxState *s = (PXA2xxState *) opaque;  
     int i;  
   
     for (i = 0; i < 0x40; i ++)  
         qemu_get_be32s(f, &s->pm_regs[i]);  
   
     return 0;  
 }  
   
 #define CCCR    0x00    /* Core Clock Configuration register */  #define CCCR    0x00    /* Core Clock Configuration register */
 #define CKEN    0x04    /* Clock Enable register */  #define CKEN    0x04    /* Clock Enable register */
Line 228  static CPUWriteMemoryFunc * const pxa2xx Line 218  static CPUWriteMemoryFunc * const pxa2xx
     pxa2xx_cm_write,      pxa2xx_cm_write,
 };  };
   
 static void pxa2xx_cm_save(QEMUFile *f, void *opaque)  static const VMStateDescription vmstate_pxa2xx_cm = {
 {      .name = "pxa2xx_cm",
     PXA2xxState *s = (PXA2xxState *) opaque;      .version_id = 0,
     int i;      .minimum_version_id = 0,
       .minimum_version_id_old = 0,
     for (i = 0; i < 4; i ++)      .fields      = (VMStateField[]) {
         qemu_put_be32s(f, &s->cm_regs[i]);          VMSTATE_UINT32_ARRAY(cm_regs, PXA2xxState, 4),
     qemu_put_be32s(f, &s->clkcfg);          VMSTATE_UINT32(clkcfg, PXA2xxState),
     qemu_put_be32s(f, &s->pmnc);          VMSTATE_UINT32(pmnc, PXA2xxState),
 }          VMSTATE_END_OF_LIST()
       }
 static int pxa2xx_cm_load(QEMUFile *f, void *opaque, int version_id)  };
 {  
     PXA2xxState *s = (PXA2xxState *) opaque;  
     int i;  
   
     for (i = 0; i < 4; i ++)  
         qemu_get_be32s(f, &s->cm_regs[i]);  
     qemu_get_be32s(f, &s->clkcfg);  
     qemu_get_be32s(f, &s->pmnc);  
   
     return 0;  
 }  
   
 static uint32_t pxa2xx_clkpwr_read(void *opaque, int op2, int reg, int crm)  static uint32_t pxa2xx_clkpwr_read(void *opaque, int op2, int reg, int crm)
 {  {
Line 373  static uint32_t pxa2xx_perf_read(void *o Line 352  static uint32_t pxa2xx_perf_read(void *o
         return s->pmnc;          return s->pmnc;
     case CPCCNT:      case CPCCNT:
         if (s->pmnc & 1)          if (s->pmnc & 1)
             return qemu_get_clock(vm_clock);              return qemu_get_clock_ns(vm_clock);
         else          else
             return 0;              return 0;
     case CPINTEN:      case CPINTEN:
Line 528  static CPUWriteMemoryFunc * const pxa2xx Line 507  static CPUWriteMemoryFunc * const pxa2xx
     pxa2xx_mm_write,      pxa2xx_mm_write,
 };  };
   
 static void pxa2xx_mm_save(QEMUFile *f, void *opaque)  static const VMStateDescription vmstate_pxa2xx_mm = {
 {      .name = "pxa2xx_mm",
     PXA2xxState *s = (PXA2xxState *) opaque;      .version_id = 0,
     int i;      .minimum_version_id = 0,
       .minimum_version_id_old = 0,
     for (i = 0; i < 0x1a; i ++)      .fields      = (VMStateField[]) {
         qemu_put_be32s(f, &s->mm_regs[i]);          VMSTATE_UINT32_ARRAY(mm_regs, PXA2xxState, 0x1a),
 }          VMSTATE_END_OF_LIST()
       }
 static int pxa2xx_mm_load(QEMUFile *f, void *opaque, int version_id)  };
 {  
     PXA2xxState *s = (PXA2xxState *) opaque;  
     int i;  
   
     for (i = 0; i < 0x1a; i ++)  
         qemu_get_be32s(f, &s->mm_regs[i]);  
   
     return 0;  
 }  
   
 /* Synchronous Serial Ports */  /* Synchronous Serial Ports */
 typedef struct {  typedef struct {
Line 886  static int pxa2xx_ssp_init(SysBusDevice  Line 856  static int pxa2xx_ssp_init(SysBusDevice 
 #define RTCPICR         0x34    /* RTC Periodic Interrupt Counter register */  #define RTCPICR         0x34    /* RTC Periodic Interrupt Counter register */
 #define PIAR            0x38    /* RTC Periodic Interrupt Alarm register */  #define PIAR            0x38    /* RTC Periodic Interrupt Alarm register */
   
 static inline void pxa2xx_rtc_int_update(PXA2xxState *s)  typedef struct {
       SysBusDevice busdev;
       uint32_t rttr;
       uint32_t rtsr;
       uint32_t rtar;
       uint32_t rdar1;
       uint32_t rdar2;
       uint32_t ryar1;
       uint32_t ryar2;
       uint32_t swar1;
       uint32_t swar2;
       uint32_t piar;
       uint32_t last_rcnr;
       uint32_t last_rdcr;
       uint32_t last_rycr;
       uint32_t last_swcr;
       uint32_t last_rtcpicr;
       int64_t last_hz;
       int64_t last_sw;
       int64_t last_pi;
       QEMUTimer *rtc_hz;
       QEMUTimer *rtc_rdal1;
       QEMUTimer *rtc_rdal2;
       QEMUTimer *rtc_swal1;
       QEMUTimer *rtc_swal2;
       QEMUTimer *rtc_pi;
       qemu_irq rtc_irq;
   } PXA2xxRTCState;
   
   static inline void pxa2xx_rtc_int_update(PXA2xxRTCState *s)
 {  {
     qemu_set_irq(s->pic[PXA2XX_PIC_RTCALARM], !!(s->rtsr & 0x2553));      qemu_set_irq(s->rtc_irq, !!(s->rtsr & 0x2553));
 }  }
   
 static void pxa2xx_rtc_hzupdate(PXA2xxState *s)  static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)
 {  {
     int64_t rt = qemu_get_clock(rt_clock);      int64_t rt = qemu_get_clock_ms(rt_clock);
     s->last_rcnr += ((rt - s->last_hz) << 15) /      s->last_rcnr += ((rt - s->last_hz) << 15) /
             (1000 * ((s->rttr & 0xffff) + 1));              (1000 * ((s->rttr & 0xffff) + 1));
     s->last_rdcr += ((rt - s->last_hz) << 15) /      s->last_rdcr += ((rt - s->last_hz) << 15) /
Line 901  static void pxa2xx_rtc_hzupdate(PXA2xxSt Line 900  static void pxa2xx_rtc_hzupdate(PXA2xxSt
     s->last_hz = rt;      s->last_hz = rt;
 }  }
   
 static void pxa2xx_rtc_swupdate(PXA2xxState *s)  static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
 {  {
     int64_t rt = qemu_get_clock(rt_clock);      int64_t rt = qemu_get_clock_ms(rt_clock);
     if (s->rtsr & (1 << 12))      if (s->rtsr & (1 << 12))
         s->last_swcr += (rt - s->last_sw) / 10;          s->last_swcr += (rt - s->last_sw) / 10;
     s->last_sw = rt;      s->last_sw = rt;
 }  }
   
 static void pxa2xx_rtc_piupdate(PXA2xxState *s)  static void pxa2xx_rtc_piupdate(PXA2xxRTCState *s)
 {  {
     int64_t rt = qemu_get_clock(rt_clock);      int64_t rt = qemu_get_clock_ms(rt_clock);
     if (s->rtsr & (1 << 15))      if (s->rtsr & (1 << 15))
         s->last_swcr += rt - s->last_pi;          s->last_swcr += rt - s->last_pi;
     s->last_pi = rt;      s->last_pi = rt;
 }  }
   
 static inline void pxa2xx_rtc_alarm_update(PXA2xxState *s,  static inline void pxa2xx_rtc_alarm_update(PXA2xxRTCState *s,
                 uint32_t rtsr)                  uint32_t rtsr)
 {  {
     if ((rtsr & (1 << 2)) && !(rtsr & (1 << 0)))      if ((rtsr & (1 << 2)) && !(rtsr & (1 << 0)))
Line 962  static inline void pxa2xx_rtc_alarm_upda Line 961  static inline void pxa2xx_rtc_alarm_upda
   
 static inline void pxa2xx_rtc_hz_tick(void *opaque)  static inline void pxa2xx_rtc_hz_tick(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
     s->rtsr |= (1 << 0);      s->rtsr |= (1 << 0);
     pxa2xx_rtc_alarm_update(s, s->rtsr);      pxa2xx_rtc_alarm_update(s, s->rtsr);
     pxa2xx_rtc_int_update(s);      pxa2xx_rtc_int_update(s);
Line 970  static inline void pxa2xx_rtc_hz_tick(vo Line 969  static inline void pxa2xx_rtc_hz_tick(vo
   
 static inline void pxa2xx_rtc_rdal1_tick(void *opaque)  static inline void pxa2xx_rtc_rdal1_tick(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
     s->rtsr |= (1 << 4);      s->rtsr |= (1 << 4);
     pxa2xx_rtc_alarm_update(s, s->rtsr);      pxa2xx_rtc_alarm_update(s, s->rtsr);
     pxa2xx_rtc_int_update(s);      pxa2xx_rtc_int_update(s);
Line 978  static inline void pxa2xx_rtc_rdal1_tick Line 977  static inline void pxa2xx_rtc_rdal1_tick
   
 static inline void pxa2xx_rtc_rdal2_tick(void *opaque)  static inline void pxa2xx_rtc_rdal2_tick(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
     s->rtsr |= (1 << 6);      s->rtsr |= (1 << 6);
     pxa2xx_rtc_alarm_update(s, s->rtsr);      pxa2xx_rtc_alarm_update(s, s->rtsr);
     pxa2xx_rtc_int_update(s);      pxa2xx_rtc_int_update(s);
Line 986  static inline void pxa2xx_rtc_rdal2_tick Line 985  static inline void pxa2xx_rtc_rdal2_tick
   
 static inline void pxa2xx_rtc_swal1_tick(void *opaque)  static inline void pxa2xx_rtc_swal1_tick(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
     s->rtsr |= (1 << 8);      s->rtsr |= (1 << 8);
     pxa2xx_rtc_alarm_update(s, s->rtsr);      pxa2xx_rtc_alarm_update(s, s->rtsr);
     pxa2xx_rtc_int_update(s);      pxa2xx_rtc_int_update(s);
Line 994  static inline void pxa2xx_rtc_swal1_tick Line 993  static inline void pxa2xx_rtc_swal1_tick
   
 static inline void pxa2xx_rtc_swal2_tick(void *opaque)  static inline void pxa2xx_rtc_swal2_tick(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
     s->rtsr |= (1 << 10);      s->rtsr |= (1 << 10);
     pxa2xx_rtc_alarm_update(s, s->rtsr);      pxa2xx_rtc_alarm_update(s, s->rtsr);
     pxa2xx_rtc_int_update(s);      pxa2xx_rtc_int_update(s);
Line 1002  static inline void pxa2xx_rtc_swal2_tick Line 1001  static inline void pxa2xx_rtc_swal2_tick
   
 static inline void pxa2xx_rtc_pi_tick(void *opaque)  static inline void pxa2xx_rtc_pi_tick(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
     s->rtsr |= (1 << 13);      s->rtsr |= (1 << 13);
     pxa2xx_rtc_piupdate(s);      pxa2xx_rtc_piupdate(s);
     s->last_rtcpicr = 0;      s->last_rtcpicr = 0;
Line 1012  static inline void pxa2xx_rtc_pi_tick(vo Line 1011  static inline void pxa2xx_rtc_pi_tick(vo
   
 static uint32_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr)  static uint32_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
   
     switch (addr) {      switch (addr) {
     case RTTR:      case RTTR:
Line 1036  static uint32_t pxa2xx_rtc_read(void *op Line 1035  static uint32_t pxa2xx_rtc_read(void *op
     case PIAR:      case PIAR:
         return s->piar;          return s->piar;
     case RCNR:      case RCNR:
         return s->last_rcnr + ((qemu_get_clock(rt_clock) - s->last_hz) << 15) /          return s->last_rcnr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
                 (1000 * ((s->rttr & 0xffff) + 1));                  (1000 * ((s->rttr & 0xffff) + 1));
     case RDCR:      case RDCR:
         return s->last_rdcr + ((qemu_get_clock(rt_clock) - s->last_hz) << 15) /          return s->last_rdcr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
                 (1000 * ((s->rttr & 0xffff) + 1));                  (1000 * ((s->rttr & 0xffff) + 1));
     case RYCR:      case RYCR:
         return s->last_rycr;          return s->last_rycr;
     case SWCR:      case SWCR:
         if (s->rtsr & (1 << 12))          if (s->rtsr & (1 << 12))
             return s->last_swcr + (qemu_get_clock(rt_clock) - s->last_sw) / 10;              return s->last_swcr + (qemu_get_clock_ms(rt_clock) - s->last_sw) / 10;
         else          else
             return s->last_swcr;              return s->last_swcr;
     default:      default:
Line 1058  static uint32_t pxa2xx_rtc_read(void *op Line 1057  static uint32_t pxa2xx_rtc_read(void *op
 static void pxa2xx_rtc_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_rtc_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                  uint32_t value)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
   
     switch (addr) {      switch (addr) {
     case RTTR:      case RTTR:
Line 1170  static CPUWriteMemoryFunc * const pxa2xx Line 1169  static CPUWriteMemoryFunc * const pxa2xx
     pxa2xx_rtc_write,      pxa2xx_rtc_write,
 };  };
   
 static void pxa2xx_rtc_init(PXA2xxState *s)  static int pxa2xx_rtc_init(SysBusDevice *dev)
 {  {
       PXA2xxRTCState *s = FROM_SYSBUS(PXA2xxRTCState, dev);
     struct tm tm;      struct tm tm;
     int wom;      int wom;
       int iomemtype;
   
     s->rttr = 0x7fff;      s->rttr = 0x7fff;
     s->rtsr = 0;      s->rtsr = 0;
Line 1189  static void pxa2xx_rtc_init(PXA2xxState  Line 1190  static void pxa2xx_rtc_init(PXA2xxState 
     s->last_swcr = (tm.tm_hour << 19) |      s->last_swcr = (tm.tm_hour << 19) |
             (tm.tm_min << 13) | (tm.tm_sec << 7);              (tm.tm_min << 13) | (tm.tm_sec << 7);
     s->last_rtcpicr = 0;      s->last_rtcpicr = 0;
     s->last_hz = s->last_sw = s->last_pi = qemu_get_clock(rt_clock);      s->last_hz = s->last_sw = s->last_pi = qemu_get_clock_ms(rt_clock);
   
       s->rtc_hz    = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_hz_tick,    s);
       s->rtc_rdal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal1_tick, s);
       s->rtc_rdal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal2_tick, s);
       s->rtc_swal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal1_tick, s);
       s->rtc_swal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal2_tick, s);
       s->rtc_pi    = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_pi_tick,    s);
   
       sysbus_init_irq(dev, &s->rtc_irq);
   
       iomemtype = cpu_register_io_memory(pxa2xx_rtc_readfn,
                       pxa2xx_rtc_writefn, s, DEVICE_NATIVE_ENDIAN);
       sysbus_init_mmio(dev, 0x10000, iomemtype);
   
     s->rtc_hz    = qemu_new_timer(rt_clock, pxa2xx_rtc_hz_tick,    s);      return 0;
     s->rtc_rdal1 = qemu_new_timer(rt_clock, pxa2xx_rtc_rdal1_tick, s);  
     s->rtc_rdal2 = qemu_new_timer(rt_clock, pxa2xx_rtc_rdal2_tick, s);  
     s->rtc_swal1 = qemu_new_timer(rt_clock, pxa2xx_rtc_swal1_tick, s);  
     s->rtc_swal2 = qemu_new_timer(rt_clock, pxa2xx_rtc_swal2_tick, s);  
     s->rtc_pi    = qemu_new_timer(rt_clock, pxa2xx_rtc_pi_tick,    s);  
 }  }
   
 static void pxa2xx_rtc_save(QEMUFile *f, void *opaque)  static void pxa2xx_rtc_pre_save(void *opaque)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
   
     pxa2xx_rtc_hzupdate(s);      pxa2xx_rtc_hzupdate(s);
     pxa2xx_rtc_piupdate(s);      pxa2xx_rtc_piupdate(s);
     pxa2xx_rtc_swupdate(s);      pxa2xx_rtc_swupdate(s);
   
     qemu_put_be32s(f, &s->rttr);  
     qemu_put_be32s(f, &s->rtsr);  
     qemu_put_be32s(f, &s->rtar);  
     qemu_put_be32s(f, &s->rdar1);  
     qemu_put_be32s(f, &s->rdar2);  
     qemu_put_be32s(f, &s->ryar1);  
     qemu_put_be32s(f, &s->ryar2);  
     qemu_put_be32s(f, &s->swar1);  
     qemu_put_be32s(f, &s->swar2);  
     qemu_put_be32s(f, &s->piar);  
     qemu_put_be32s(f, &s->last_rcnr);  
     qemu_put_be32s(f, &s->last_rdcr);  
     qemu_put_be32s(f, &s->last_rycr);  
     qemu_put_be32s(f, &s->last_swcr);  
     qemu_put_be32s(f, &s->last_rtcpicr);  
     qemu_put_sbe64s(f, &s->last_hz);  
     qemu_put_sbe64s(f, &s->last_sw);  
     qemu_put_sbe64s(f, &s->last_pi);  
 }  }
   
 static int pxa2xx_rtc_load(QEMUFile *f, void *opaque, int version_id)  static int pxa2xx_rtc_post_load(void *opaque, int version_id)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
   
     qemu_get_be32s(f, &s->rttr);  
     qemu_get_be32s(f, &s->rtsr);  
     qemu_get_be32s(f, &s->rtar);  
     qemu_get_be32s(f, &s->rdar1);  
     qemu_get_be32s(f, &s->rdar2);  
     qemu_get_be32s(f, &s->ryar1);  
     qemu_get_be32s(f, &s->ryar2);  
     qemu_get_be32s(f, &s->swar1);  
     qemu_get_be32s(f, &s->swar2);  
     qemu_get_be32s(f, &s->piar);  
     qemu_get_be32s(f, &s->last_rcnr);  
     qemu_get_be32s(f, &s->last_rdcr);  
     qemu_get_be32s(f, &s->last_rycr);  
     qemu_get_be32s(f, &s->last_swcr);  
     qemu_get_be32s(f, &s->last_rtcpicr);  
     qemu_get_sbe64s(f, &s->last_hz);  
     qemu_get_sbe64s(f, &s->last_sw);  
     qemu_get_sbe64s(f, &s->last_pi);  
   
     pxa2xx_rtc_alarm_update(s, s->rtsr);      pxa2xx_rtc_alarm_update(s, s->rtsr);
   
     return 0;      return 0;
 }  }
   
   static const VMStateDescription vmstate_pxa2xx_rtc_regs = {
       .name = "pxa2xx_rtc",
       .version_id = 0,
       .minimum_version_id = 0,
       .minimum_version_id_old = 0,
       .pre_save = pxa2xx_rtc_pre_save,
       .post_load = pxa2xx_rtc_post_load,
       .fields = (VMStateField[]) {
           VMSTATE_UINT32(rttr, PXA2xxRTCState),
           VMSTATE_UINT32(rtsr, PXA2xxRTCState),
           VMSTATE_UINT32(rtar, PXA2xxRTCState),
           VMSTATE_UINT32(rdar1, PXA2xxRTCState),
           VMSTATE_UINT32(rdar2, PXA2xxRTCState),
           VMSTATE_UINT32(ryar1, PXA2xxRTCState),
           VMSTATE_UINT32(ryar2, PXA2xxRTCState),
           VMSTATE_UINT32(swar1, PXA2xxRTCState),
           VMSTATE_UINT32(swar2, PXA2xxRTCState),
           VMSTATE_UINT32(piar, PXA2xxRTCState),
           VMSTATE_UINT32(last_rcnr, PXA2xxRTCState),
           VMSTATE_UINT32(last_rdcr, PXA2xxRTCState),
           VMSTATE_UINT32(last_rycr, PXA2xxRTCState),
           VMSTATE_UINT32(last_swcr, PXA2xxRTCState),
           VMSTATE_UINT32(last_rtcpicr, PXA2xxRTCState),
           VMSTATE_INT64(last_hz, PXA2xxRTCState),
           VMSTATE_INT64(last_sw, PXA2xxRTCState),
           VMSTATE_INT64(last_pi, PXA2xxRTCState),
           VMSTATE_END_OF_LIST(),
       },
   };
   
   static SysBusDeviceInfo pxa2xx_rtc_sysbus_info = {
       .init       = pxa2xx_rtc_init,
       .qdev.name  = "pxa2xx_rtc",
       .qdev.desc  = "PXA2xx RTC Controller",
       .qdev.size  = sizeof(PXA2xxRTCState),
       .qdev.vmsd  = &vmstate_pxa2xx_rtc_regs,
   };
   
 /* I2C Interface */  /* I2C Interface */
 typedef struct {  typedef struct {
     i2c_slave i2c;      i2c_slave i2c;
Line 1262  typedef struct { Line 1271  typedef struct {
 } PXA2xxI2CSlaveState;  } PXA2xxI2CSlaveState;
   
 struct PXA2xxI2CState {  struct PXA2xxI2CState {
       SysBusDevice busdev;
     PXA2xxI2CSlaveState *slave;      PXA2xxI2CSlaveState *slave;
     i2c_bus *bus;      i2c_bus *bus;
     qemu_irq irq;      qemu_irq irq;
     target_phys_addr_t offset;      uint32_t offset;
       uint32_t region_size;
   
     uint16_t control;      uint16_t control;
     uint16_t status;      uint16_t status;
Line 1499  static I2CSlaveInfo pxa2xx_i2c_slave_inf Line 1510  static I2CSlaveInfo pxa2xx_i2c_slave_inf
 PXA2xxI2CState *pxa2xx_i2c_init(target_phys_addr_t base,  PXA2xxI2CState *pxa2xx_i2c_init(target_phys_addr_t base,
                 qemu_irq irq, uint32_t region_size)                  qemu_irq irq, uint32_t region_size)
 {  {
     int iomemtype;  
     DeviceState *dev;      DeviceState *dev;
     PXA2xxI2CState *s = qemu_mallocz(sizeof(PXA2xxI2CState));      SysBusDevice *i2c_dev;
       PXA2xxI2CState *s;
   
       i2c_dev = sysbus_from_qdev(qdev_create(NULL, "pxa2xx_i2c"));
       qdev_prop_set_uint32(&i2c_dev->qdev, "size", region_size + 1);
       qdev_prop_set_uint32(&i2c_dev->qdev, "offset",
               base - (base & (~region_size) & TARGET_PAGE_MASK));
   
       qdev_init_nofail(&i2c_dev->qdev);
   
       sysbus_mmio_map(i2c_dev, 0, base & ~region_size);
       sysbus_connect_irq(i2c_dev, 0, irq);
   
       s = FROM_SYSBUS(PXA2xxI2CState, i2c_dev);
     /* FIXME: Should the slave device really be on a separate bus?  */      /* FIXME: Should the slave device really be on a separate bus?  */
     dev = i2c_create_slave(i2c_init_bus(NULL, "dummy"), "pxa2xx-i2c-slave", 0);      dev = i2c_create_slave(i2c_init_bus(NULL, "dummy"), "pxa2xx-i2c-slave", 0);
     s->slave = FROM_I2C_SLAVE(PXA2xxI2CSlaveState, I2C_SLAVE_FROM_QDEV(dev));      s->slave = FROM_I2C_SLAVE(PXA2xxI2CSlaveState, I2C_SLAVE_FROM_QDEV(dev));
     s->slave->host = s;      s->slave->host = s;
   
     s->irq = irq;      return s;
     s->bus = i2c_init_bus(NULL, "i2c");  }
     s->offset = base - (base & (~region_size) & TARGET_PAGE_MASK);  
   static int pxa2xx_i2c_initfn(SysBusDevice *dev)
   {
       PXA2xxI2CState *s = FROM_SYSBUS(PXA2xxI2CState, dev);
       int iomemtype;
   
       s->bus = i2c_init_bus(&dev->qdev, "i2c");
   
     iomemtype = cpu_register_io_memory(pxa2xx_i2c_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_i2c_readfn,
                     pxa2xx_i2c_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_i2c_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(base & ~region_size,      sysbus_init_mmio(dev, s->region_size, iomemtype);
                     region_size + 1, iomemtype);      sysbus_init_irq(dev, &s->irq);
   
     vmstate_register(NULL, base, &vmstate_pxa2xx_i2c, s);  
   
     return s;      return 0;
 }  }
   
 i2c_bus *pxa2xx_i2c_bus(PXA2xxI2CState *s)  i2c_bus *pxa2xx_i2c_bus(PXA2xxI2CState *s)
Line 1527  i2c_bus *pxa2xx_i2c_bus(PXA2xxI2CState * Line 1553  i2c_bus *pxa2xx_i2c_bus(PXA2xxI2CState *
     return s->bus;      return s->bus;
 }  }
   
   static SysBusDeviceInfo pxa2xx_i2c_info = {
       .init       = pxa2xx_i2c_initfn,
       .qdev.name  = "pxa2xx_i2c",
       .qdev.desc  = "PXA2xx I2C Bus Controller",
       .qdev.size  = sizeof(PXA2xxI2CState),
       .qdev.vmsd  = &vmstate_pxa2xx_i2c,
       .qdev.props = (Property[]) {
           DEFINE_PROP_UINT32("size", PXA2xxI2CState, region_size, 0x10000),
           DEFINE_PROP_UINT32("offset", PXA2xxI2CState, offset, 0),
           DEFINE_PROP_END_OF_LIST(),
       },
   };
   
 /* PXA Inter-IC Sound Controller */  /* PXA Inter-IC Sound Controller */
 static void pxa2xx_i2s_reset(PXA2xxI2SState *i2s)  static void pxa2xx_i2s_reset(PXA2xxI2SState *i2s)
 {  {
Line 1553  static inline void pxa2xx_i2s_update(PXA Line 1592  static inline void pxa2xx_i2s_update(PXA
     tfs = (i2s->tx_len || i2s->fifo_len < SACR_TFTH(i2s->control[0])) &&      tfs = (i2s->tx_len || i2s->fifo_len < SACR_TFTH(i2s->control[0])) &&
             i2s->enable && !SACR_DPRL(i2s->control[1]);              i2s->enable && !SACR_DPRL(i2s->control[1]);
   
     pxa2xx_dma_request(i2s->dma, PXA2XX_RX_RQ_I2S, rfs);      qemu_set_irq(i2s->rx_dma, rfs);
     pxa2xx_dma_request(i2s->dma, PXA2XX_TX_RQ_I2S, tfs);      qemu_set_irq(i2s->tx_dma, tfs);
   
     i2s->status &= 0xe0;      i2s->status &= 0xe0;
     if (i2s->fifo_len < 16 || !i2s->enable)      if (i2s->fifo_len < 16 || !i2s->enable)
Line 1631  static void pxa2xx_i2s_write(void *opaqu Line 1670  static void pxa2xx_i2s_write(void *opaqu
         }          }
         if (value & (1 << 4))                           /* EFWR */          if (value & (1 << 4))                           /* EFWR */
             printf("%s: Attempt to use special function\n", __FUNCTION__);              printf("%s: Attempt to use special function\n", __FUNCTION__);
         s->enable = ((value ^ 4) & 5) == 5;             /* ENB && !RST*/          s->enable = (value & 9) == 1;                   /* ENB && !RST*/
         pxa2xx_i2s_update(s);          pxa2xx_i2s_update(s);
         break;          break;
     case SACR1:      case SACR1:
Line 1680  static CPUWriteMemoryFunc * const pxa2xx Line 1719  static CPUWriteMemoryFunc * const pxa2xx
     pxa2xx_i2s_write,      pxa2xx_i2s_write,
 };  };
   
 static void pxa2xx_i2s_save(QEMUFile *f, void *opaque)  static const VMStateDescription vmstate_pxa2xx_i2s = {
 {      .name = "pxa2xx_i2s",
     PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;      .version_id = 0,
       .minimum_version_id = 0,
     qemu_put_be32s(f, &s->control[0]);      .minimum_version_id_old = 0,
     qemu_put_be32s(f, &s->control[1]);      .fields      = (VMStateField[]) {
     qemu_put_be32s(f, &s->status);          VMSTATE_UINT32_ARRAY(control, PXA2xxI2SState, 2),
     qemu_put_be32s(f, &s->mask);          VMSTATE_UINT32(status, PXA2xxI2SState),
     qemu_put_be32s(f, &s->clk);          VMSTATE_UINT32(mask, PXA2xxI2SState),
           VMSTATE_UINT32(clk, PXA2xxI2SState),
     qemu_put_be32(f, s->enable);          VMSTATE_INT32(enable, PXA2xxI2SState),
     qemu_put_be32(f, s->rx_len);          VMSTATE_INT32(rx_len, PXA2xxI2SState),
     qemu_put_be32(f, s->tx_len);          VMSTATE_INT32(tx_len, PXA2xxI2SState),
     qemu_put_be32(f, s->fifo_len);          VMSTATE_INT32(fifo_len, PXA2xxI2SState),
 }          VMSTATE_END_OF_LIST()
       }
 static int pxa2xx_i2s_load(QEMUFile *f, void *opaque, int version_id)  };
 {  
     PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;  
   
     qemu_get_be32s(f, &s->control[0]);  
     qemu_get_be32s(f, &s->control[1]);  
     qemu_get_be32s(f, &s->status);  
     qemu_get_be32s(f, &s->mask);  
     qemu_get_be32s(f, &s->clk);  
   
     s->enable = qemu_get_be32(f);  
     s->rx_len = qemu_get_be32(f);  
     s->tx_len = qemu_get_be32(f);  
     s->fifo_len = qemu_get_be32(f);  
   
     return 0;  
 }  
   
 static void pxa2xx_i2s_data_req(void *opaque, int tx, int rx)  static void pxa2xx_i2s_data_req(void *opaque, int tx, int rx)
 {  {
Line 1737  static void pxa2xx_i2s_data_req(void *op Line 1760  static void pxa2xx_i2s_data_req(void *op
 }  }
   
 static PXA2xxI2SState *pxa2xx_i2s_init(target_phys_addr_t base,  static PXA2xxI2SState *pxa2xx_i2s_init(target_phys_addr_t base,
                 qemu_irq irq, PXA2xxDMAState *dma)                  qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma)
 {  {
     int iomemtype;      int iomemtype;
     PXA2xxI2SState *s = (PXA2xxI2SState *)      PXA2xxI2SState *s = (PXA2xxI2SState *)
             qemu_mallocz(sizeof(PXA2xxI2SState));              qemu_mallocz(sizeof(PXA2xxI2SState));
   
     s->irq = irq;      s->irq = irq;
     s->dma = dma;      s->rx_dma = rx_dma;
       s->tx_dma = tx_dma;
     s->data_req = pxa2xx_i2s_data_req;      s->data_req = pxa2xx_i2s_data_req;
   
     pxa2xx_i2s_reset(s);      pxa2xx_i2s_reset(s);
Line 1753  static PXA2xxI2SState *pxa2xx_i2s_init(t Line 1777  static PXA2xxI2SState *pxa2xx_i2s_init(t
                     pxa2xx_i2s_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_i2s_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(base, 0x100000, iomemtype);      cpu_register_physical_memory(base, 0x100000, iomemtype);
   
     register_savevm(NULL, "pxa2xx_i2s", base, 0,      vmstate_register(NULL, base, &vmstate_pxa2xx_i2s, s);
                     pxa2xx_i2s_save, pxa2xx_i2s_load, s);  
   
     return s;      return s;
 }  }
Line 1762  static PXA2xxI2SState *pxa2xx_i2s_init(t Line 1785  static PXA2xxI2SState *pxa2xx_i2s_init(t
 /* PXA Fast Infra-red Communications Port */  /* PXA Fast Infra-red Communications Port */
 struct PXA2xxFIrState {  struct PXA2xxFIrState {
     qemu_irq irq;      qemu_irq irq;
     PXA2xxDMAState *dma;      qemu_irq rx_dma;
       qemu_irq tx_dma;
     int enable;      int enable;
     CharDriverState *chr;      CharDriverState *chr;
   
Line 1816  static inline void pxa2xx_fir_update(PXA Line 1840  static inline void pxa2xx_fir_update(PXA
             (s->status[0] & (1 << 1));                  /* TUR */              (s->status[0] & (1 << 1));                  /* TUR */
     intr |= s->status[0] & 0x25;                        /* FRE, RAB, EIF */      intr |= s->status[0] & 0x25;                        /* FRE, RAB, EIF */
   
     pxa2xx_dma_request(s->dma, PXA2XX_RX_RQ_ICP, (s->status[0] >> 4) & 1);      qemu_set_irq(s->rx_dma, (s->status[0] >> 4) & 1);
     pxa2xx_dma_request(s->dma, PXA2XX_TX_RQ_ICP, (s->status[0] >> 3) & 1);      qemu_set_irq(s->tx_dma, (s->status[0] >> 3) & 1);
   
     qemu_set_irq(s->irq, intr && s->enable);      qemu_set_irq(s->irq, intr && s->enable);
 }  }
Line 1996  static int pxa2xx_fir_load(QEMUFile *f,  Line 2020  static int pxa2xx_fir_load(QEMUFile *f, 
 }  }
   
 static PXA2xxFIrState *pxa2xx_fir_init(target_phys_addr_t base,  static PXA2xxFIrState *pxa2xx_fir_init(target_phys_addr_t base,
                 qemu_irq irq, PXA2xxDMAState *dma,                  qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma,
                 CharDriverState *chr)                  CharDriverState *chr)
 {  {
     int iomemtype;      int iomemtype;
Line 2004  static PXA2xxFIrState *pxa2xx_fir_init(t Line 2028  static PXA2xxFIrState *pxa2xx_fir_init(t
             qemu_mallocz(sizeof(PXA2xxFIrState));              qemu_mallocz(sizeof(PXA2xxFIrState));
   
     s->irq = irq;      s->irq = irq;
     s->dma = dma;      s->rx_dma = rx_dma;
       s->tx_dma = tx_dma;
     s->chr = chr;      s->chr = chr;
   
     pxa2xx_fir_reset(s);      pxa2xx_fir_reset(s);
Line 2065  PXA2xxState *pxa270_init(unsigned int sd Line 2090  PXA2xxState *pxa270_init(unsigned int sd
   
     s->pic = pxa2xx_pic_init(0x40d00000, s->env);      s->pic = pxa2xx_pic_init(0x40d00000, s->env);
   
     s->dma = pxa27x_dma_init(0x40000000, s->pic[PXA2XX_PIC_DMA]);      s->dma = pxa27x_dma_init(0x40000000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
   
     pxa27x_timer_init(0x40a00000, &s->pic[PXA2XX_PIC_OST_0],      sysbus_create_varargs("pxa27x-timer", 0x40a00000,
                     s->pic[PXA27X_PIC_OST_4_11]);                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
                       qdev_get_gpio_in(s->pic, PXA27X_PIC_OST_4_11),
                       NULL);
   
     s->gpio = pxa2xx_gpio_init(0x40e00000, s->env, s->pic, 121);      s->gpio = pxa2xx_gpio_init(0x40e00000, s->env, s->pic, 121);
   
Line 2078  PXA2xxState *pxa270_init(unsigned int sd Line 2109  PXA2xxState *pxa270_init(unsigned int sd
         exit(1);          exit(1);
     }      }
     s->mmc = pxa2xx_mmci_init(0x41100000, dinfo->bdrv,      s->mmc = pxa2xx_mmci_init(0x41100000, dinfo->bdrv,
                               s->pic[PXA2XX_PIC_MMC], s->dma);                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
                       qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
                       qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
   
     for (i = 0; pxa270_serial[i].io_base; i ++)      for (i = 0; pxa270_serial[i].io_base; i ++)
         if (serial_hds[i])          if (serial_hds[i])
 #ifdef TARGET_WORDS_BIGENDIAN  #ifdef TARGET_WORDS_BIGENDIAN
             serial_mm_init(pxa270_serial[i].io_base, 2,              serial_mm_init(pxa270_serial[i].io_base, 2,
                            s->pic[pxa270_serial[i].irqn], 14857000/16,                              qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),
                            serial_hds[i], 1, 1);                              14857000 / 16, serial_hds[i], 1, 1);
 #else  #else
             serial_mm_init(pxa270_serial[i].io_base, 2,              serial_mm_init(pxa270_serial[i].io_base, 2,
                            s->pic[pxa270_serial[i].irqn], 14857000/16,                              qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),
                            serial_hds[i], 1, 0);                              14857000 / 16, serial_hds[i], 1, 0);
 #endif  #endif
         else          else
             break;              break;
     if (serial_hds[i])      if (serial_hds[i])
         s->fir = pxa2xx_fir_init(0x40800000, s->pic[PXA2XX_PIC_ICP],          s->fir = pxa2xx_fir_init(0x40800000,
                         s->dma, serial_hds[i]);                          qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
                           qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
                           qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
                           serial_hds[i]);
   
     s->lcd = pxa2xx_lcdc_init(0x44000000, s->pic[PXA2XX_PIC_LCD]);      s->lcd = pxa2xx_lcdc_init(0x44000000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
   
     s->cm_base = 0x41300000;      s->cm_base = 0x41300000;
     s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */      s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */
Line 2105  PXA2xxState *pxa270_init(unsigned int sd Line 2142  PXA2xxState *pxa270_init(unsigned int sd
     iomemtype = cpu_register_io_memory(pxa2xx_cm_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_cm_readfn,
                     pxa2xx_cm_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_cm_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(s->cm_base, 0x1000, iomemtype);      cpu_register_physical_memory(s->cm_base, 0x1000, iomemtype);
     register_savevm(NULL, "pxa2xx_cm", 0, 0, pxa2xx_cm_save, pxa2xx_cm_load, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
   
     cpu_arm_set_cp_io(s->env, 14, pxa2xx_cp14_read, pxa2xx_cp14_write, s);      cpu_arm_set_cp_io(s->env, 14, pxa2xx_cp14_read, pxa2xx_cp14_write, s);
   
Line 2116  PXA2xxState *pxa270_init(unsigned int sd Line 2153  PXA2xxState *pxa270_init(unsigned int sd
     iomemtype = cpu_register_io_memory(pxa2xx_mm_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_mm_readfn,
                     pxa2xx_mm_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_mm_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(s->mm_base, 0x1000, iomemtype);      cpu_register_physical_memory(s->mm_base, 0x1000, iomemtype);
     register_savevm(NULL, "pxa2xx_mm", 0, 0, pxa2xx_mm_save, pxa2xx_mm_load, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
   
     s->pm_base = 0x40f00000;      s->pm_base = 0x40f00000;
     iomemtype = cpu_register_io_memory(pxa2xx_pm_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_pm_readfn,
                     pxa2xx_pm_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_pm_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(s->pm_base, 0x100, iomemtype);      cpu_register_physical_memory(s->pm_base, 0x100, iomemtype);
     register_savevm(NULL, "pxa2xx_pm", 0, 0, pxa2xx_pm_save, pxa2xx_pm_load, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
   
     for (i = 0; pxa27x_ssp[i].io_base; i ++);      for (i = 0; pxa27x_ssp[i].io_base; i ++);
     s->ssp = (SSIBus **)qemu_mallocz(sizeof(SSIBus *) * i);      s->ssp = (SSIBus **)qemu_mallocz(sizeof(SSIBus *) * i);
     for (i = 0; pxa27x_ssp[i].io_base; i ++) {      for (i = 0; pxa27x_ssp[i].io_base; i ++) {
         DeviceState *dev;          DeviceState *dev;
         dev = sysbus_create_simple("pxa2xx-ssp", pxa27x_ssp[i].io_base,          dev = sysbus_create_simple("pxa2xx-ssp", pxa27x_ssp[i].io_base,
                                    s->pic[pxa27x_ssp[i].irqn]);                          qdev_get_gpio_in(s->pic, pxa27x_ssp[i].irqn));
         s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");          s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
     }      }
   
     if (usb_enabled) {      if (usb_enabled) {
         sysbus_create_simple("sysbus-ohci", 0x4c000000,          sysbus_create_simple("sysbus-ohci", 0x4c000000,
                              s->pic[PXA2XX_PIC_USBH1]);                          qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
     }      }
   
     s->pcmcia[0] = pxa2xx_pcmcia_init(0x20000000);      s->pcmcia[0] = pxa2xx_pcmcia_init(0x20000000);
     s->pcmcia[1] = pxa2xx_pcmcia_init(0x30000000);      s->pcmcia[1] = pxa2xx_pcmcia_init(0x30000000);
   
     s->rtc_base = 0x40900000;      sysbus_create_simple("pxa2xx_rtc", 0x40900000,
     iomemtype = cpu_register_io_memory(pxa2xx_rtc_readfn,                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
                     pxa2xx_rtc_writefn, s, DEVICE_NATIVE_ENDIAN);  
     cpu_register_physical_memory(s->rtc_base, 0x1000, iomemtype);  
     pxa2xx_rtc_init(s);  
     register_savevm(NULL, "pxa2xx_rtc", 0, 0, pxa2xx_rtc_save,  
                     pxa2xx_rtc_load, s);  
   
     s->i2c[0] = pxa2xx_i2c_init(0x40301600, s->pic[PXA2XX_PIC_I2C], 0xffff);  
     s->i2c[1] = pxa2xx_i2c_init(0x40f00100, s->pic[PXA2XX_PIC_PWRI2C], 0xff);  
   
     s->i2s = pxa2xx_i2s_init(0x40400000, s->pic[PXA2XX_PIC_I2S], s->dma);      s->i2c[0] = pxa2xx_i2c_init(0x40301600,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
       s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
   
       s->i2s = pxa2xx_i2s_init(0x40400000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
                       qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
                       qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
   
     s->kp = pxa27x_keypad_init(0x41500000, s->pic[PXA2XX_PIC_KEYPAD]);      s->kp = pxa27x_keypad_init(0x41500000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_KEYPAD));
   
     /* GPIO1 resets the processor */      /* GPIO1 resets the processor */
     /* The handler can be overridden by board-specific code */      /* The handler can be overridden by board-specific code */
Line 2188  PXA2xxState *pxa255_init(unsigned int sd Line 2226  PXA2xxState *pxa255_init(unsigned int sd
   
     s->pic = pxa2xx_pic_init(0x40d00000, s->env);      s->pic = pxa2xx_pic_init(0x40d00000, s->env);
   
     s->dma = pxa255_dma_init(0x40000000, s->pic[PXA2XX_PIC_DMA]);      s->dma = pxa255_dma_init(0x40000000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_DMA));
   
     pxa25x_timer_init(0x40a00000, &s->pic[PXA2XX_PIC_OST_0]);      sysbus_create_varargs("pxa25x-timer", 0x40a00000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 0),
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 1),
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 2),
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_OST_0 + 3),
                       NULL);
   
     s->gpio = pxa2xx_gpio_init(0x40e00000, s->env, s->pic, 85);      s->gpio = pxa2xx_gpio_init(0x40e00000, s->env, s->pic, 85);
   
Line 2200  PXA2xxState *pxa255_init(unsigned int sd Line 2244  PXA2xxState *pxa255_init(unsigned int sd
         exit(1);          exit(1);
     }      }
     s->mmc = pxa2xx_mmci_init(0x41100000, dinfo->bdrv,      s->mmc = pxa2xx_mmci_init(0x41100000, dinfo->bdrv,
                               s->pic[PXA2XX_PIC_MMC], s->dma);                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_MMC),
                       qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
                       qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_MMCI));
   
     for (i = 0; pxa255_serial[i].io_base; i ++)      for (i = 0; pxa255_serial[i].io_base; i ++)
         if (serial_hds[i]) {          if (serial_hds[i]) {
 #ifdef TARGET_WORDS_BIGENDIAN  #ifdef TARGET_WORDS_BIGENDIAN
             serial_mm_init(pxa255_serial[i].io_base, 2,              serial_mm_init(pxa255_serial[i].io_base, 2,
                            s->pic[pxa255_serial[i].irqn], 14745600/16,                              qdev_get_gpio_in(s->pic, pxa255_serial[i].irqn),
                            serial_hds[i], 1, 1);                              14745600 / 16, serial_hds[i], 1, 1);
 #else  #else
             serial_mm_init(pxa255_serial[i].io_base, 2,              serial_mm_init(pxa255_serial[i].io_base, 2,
                            s->pic[pxa255_serial[i].irqn], 14745600/16,                              qdev_get_gpio_in(s->pic, pxa255_serial[i].irqn),
                            serial_hds[i], 1, 0);                              14745600 / 16, serial_hds[i], 1, 0);
 #endif  #endif
         } else {          } else {
             break;              break;
         }          }
     if (serial_hds[i])      if (serial_hds[i])
         s->fir = pxa2xx_fir_init(0x40800000, s->pic[PXA2XX_PIC_ICP],          s->fir = pxa2xx_fir_init(0x40800000,
                         s->dma, serial_hds[i]);                          qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),
                           qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_ICP),
                           qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
                           serial_hds[i]);
   
     s->lcd = pxa2xx_lcdc_init(0x44000000, s->pic[PXA2XX_PIC_LCD]);      s->lcd = pxa2xx_lcdc_init(0x44000000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_LCD));
   
     s->cm_base = 0x41300000;      s->cm_base = 0x41300000;
     s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */      s->cm_regs[CCCR >> 2] = 0x02000210; /* 416.0 MHz */
Line 2228  PXA2xxState *pxa255_init(unsigned int sd Line 2278  PXA2xxState *pxa255_init(unsigned int sd
     iomemtype = cpu_register_io_memory(pxa2xx_cm_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_cm_readfn,
                     pxa2xx_cm_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_cm_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(s->cm_base, 0x1000, iomemtype);      cpu_register_physical_memory(s->cm_base, 0x1000, iomemtype);
     register_savevm(NULL, "pxa2xx_cm", 0, 0, pxa2xx_cm_save, pxa2xx_cm_load, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, s);
   
     cpu_arm_set_cp_io(s->env, 14, pxa2xx_cp14_read, pxa2xx_cp14_write, s);      cpu_arm_set_cp_io(s->env, 14, pxa2xx_cp14_read, pxa2xx_cp14_write, s);
   
Line 2239  PXA2xxState *pxa255_init(unsigned int sd Line 2289  PXA2xxState *pxa255_init(unsigned int sd
     iomemtype = cpu_register_io_memory(pxa2xx_mm_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_mm_readfn,
                     pxa2xx_mm_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_mm_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(s->mm_base, 0x1000, iomemtype);      cpu_register_physical_memory(s->mm_base, 0x1000, iomemtype);
     register_savevm(NULL, "pxa2xx_mm", 0, 0, pxa2xx_mm_save, pxa2xx_mm_load, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, s);
   
     s->pm_base = 0x40f00000;      s->pm_base = 0x40f00000;
     iomemtype = cpu_register_io_memory(pxa2xx_pm_readfn,      iomemtype = cpu_register_io_memory(pxa2xx_pm_readfn,
                     pxa2xx_pm_writefn, s, DEVICE_NATIVE_ENDIAN);                      pxa2xx_pm_writefn, s, DEVICE_NATIVE_ENDIAN);
     cpu_register_physical_memory(s->pm_base, 0x100, iomemtype);      cpu_register_physical_memory(s->pm_base, 0x100, iomemtype);
     register_savevm(NULL, "pxa2xx_pm", 0, 0, pxa2xx_pm_save, pxa2xx_pm_load, s);      vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, s);
   
     for (i = 0; pxa255_ssp[i].io_base; i ++);      for (i = 0; pxa255_ssp[i].io_base; i ++);
     s->ssp = (SSIBus **)qemu_mallocz(sizeof(SSIBus *) * i);      s->ssp = (SSIBus **)qemu_mallocz(sizeof(SSIBus *) * i);
     for (i = 0; pxa255_ssp[i].io_base; i ++) {      for (i = 0; pxa255_ssp[i].io_base; i ++) {
         DeviceState *dev;          DeviceState *dev;
         dev = sysbus_create_simple("pxa2xx-ssp", pxa255_ssp[i].io_base,          dev = sysbus_create_simple("pxa2xx-ssp", pxa255_ssp[i].io_base,
                                    s->pic[pxa255_ssp[i].irqn]);                          qdev_get_gpio_in(s->pic, pxa255_ssp[i].irqn));
         s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");          s->ssp[i] = (SSIBus *)qdev_get_child_bus(dev, "ssi");
     }      }
   
     if (usb_enabled) {      if (usb_enabled) {
         sysbus_create_simple("sysbus-ohci", 0x4c000000,          sysbus_create_simple("sysbus-ohci", 0x4c000000,
                              s->pic[PXA2XX_PIC_USBH1]);                          qdev_get_gpio_in(s->pic, PXA2XX_PIC_USBH1));
     }      }
   
     s->pcmcia[0] = pxa2xx_pcmcia_init(0x20000000);      s->pcmcia[0] = pxa2xx_pcmcia_init(0x20000000);
     s->pcmcia[1] = pxa2xx_pcmcia_init(0x30000000);      s->pcmcia[1] = pxa2xx_pcmcia_init(0x30000000);
   
     s->rtc_base = 0x40900000;      sysbus_create_simple("pxa2xx_rtc", 0x40900000,
     iomemtype = cpu_register_io_memory(pxa2xx_rtc_readfn,                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_RTCALARM));
                     pxa2xx_rtc_writefn, s, DEVICE_NATIVE_ENDIAN);  
     cpu_register_physical_memory(s->rtc_base, 0x1000, iomemtype);  
     pxa2xx_rtc_init(s);  
     register_savevm(NULL, "pxa2xx_rtc", 0, 0, pxa2xx_rtc_save,  
                     pxa2xx_rtc_load, s);  
   
     s->i2c[0] = pxa2xx_i2c_init(0x40301600, s->pic[PXA2XX_PIC_I2C], 0xffff);  
     s->i2c[1] = pxa2xx_i2c_init(0x40f00100, s->pic[PXA2XX_PIC_PWRI2C], 0xff);  
   
     s->i2s = pxa2xx_i2s_init(0x40400000, s->pic[PXA2XX_PIC_I2S], s->dma);      s->i2c[0] = pxa2xx_i2c_init(0x40301600,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2C), 0xffff);
       s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
   
       s->i2s = pxa2xx_i2s_init(0x40400000,
                       qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),
                       qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_I2S),
                       qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
   
     /* GPIO1 resets the processor */      /* GPIO1 resets the processor */
     /* The handler can be overridden by board-specific code */      /* The handler can be overridden by board-specific code */
Line 2287  static void pxa2xx_register_devices(void Line 2337  static void pxa2xx_register_devices(void
 {  {
     i2c_register_slave(&pxa2xx_i2c_slave_info);      i2c_register_slave(&pxa2xx_i2c_slave_info);
     sysbus_register_dev("pxa2xx-ssp", sizeof(PXA2xxSSPState), pxa2xx_ssp_init);      sysbus_register_dev("pxa2xx-ssp", sizeof(PXA2xxSSPState), pxa2xx_ssp_init);
       sysbus_register_withprop(&pxa2xx_i2c_info);
       sysbus_register_withprop(&pxa2xx_rtc_sysbus_info);
 }  }
   
 device_init(pxa2xx_register_devices)  device_init(pxa2xx_register_devices)

Removed from v.1.1.1.6  
changed lines
  Added in v.1.1.1.7


unix.superglobalmegacorp.com