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

version 1.1.1.7, 2018/04/24 18:59:38 version 1.1.1.8, 2018/04/24 19:27:11
Line 88  static PXASSPDef pxa27x_ssp[] = { Line 88  static PXASSPDef pxa27x_ssp[] = {
 #define PCMD0   0x80    /* Power Manager I2C Command register File 0 */  #define PCMD0   0x80    /* Power Manager I2C Command register File 0 */
 #define PCMD31  0xfc    /* Power Manager I2C Command register File 31 */  #define PCMD31  0xfc    /* Power Manager I2C Command register File 31 */
   
 static uint32_t pxa2xx_pm_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_pm_read(void *opaque, target_phys_addr_t addr,
                                  unsigned size)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxState *s = (PXA2xxState *) opaque;
   
Line 107  static uint32_t pxa2xx_pm_read(void *opa Line 108  static uint32_t pxa2xx_pm_read(void *opa
 }  }
   
 static void pxa2xx_pm_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_pm_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                              uint64_t value, unsigned size)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxState *s = (PXA2xxState *) opaque;
   
     switch (addr) {      switch (addr) {
     case PMCR:      case PMCR:
         s->pm_regs[addr >> 2] &= 0x15 & ~(value & 0x2a);          /* Clear the write-one-to-clear bits... */
           s->pm_regs[addr >> 2] &= ~(value & 0x2a);
           /* ...and set the plain r/w bits */
           s->pm_regs[addr >> 2] &= ~0x15;
         s->pm_regs[addr >> 2] |= value & 0x15;          s->pm_regs[addr >> 2] |= value & 0x15;
         break;          break;
   
Line 134  static void pxa2xx_pm_write(void *opaque Line 138  static void pxa2xx_pm_write(void *opaque
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_pm_readfn[] = {  static const MemoryRegionOps pxa2xx_pm_ops = {
     pxa2xx_pm_read,      .read = pxa2xx_pm_read,
     pxa2xx_pm_read,      .write = pxa2xx_pm_write,
     pxa2xx_pm_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_pm_writefn[] = {  
     pxa2xx_pm_write,  
     pxa2xx_pm_write,  
     pxa2xx_pm_write,  
 };  };
   
 static const VMStateDescription vmstate_pxa2xx_pm = {  static const VMStateDescription vmstate_pxa2xx_pm = {
Line 162  static const VMStateDescription vmstate_ Line 160  static const VMStateDescription vmstate_
 #define OSCC    0x08    /* Oscillator Configuration register */  #define OSCC    0x08    /* Oscillator Configuration register */
 #define CCSR    0x0c    /* Core Clock Status register */  #define CCSR    0x0c    /* Core Clock Status register */
   
 static uint32_t pxa2xx_cm_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_cm_read(void *opaque, target_phys_addr_t addr,
                                  unsigned size)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxState *s = (PXA2xxState *) opaque;
   
Line 183  static uint32_t pxa2xx_cm_read(void *opa Line 182  static uint32_t pxa2xx_cm_read(void *opa
 }  }
   
 static void pxa2xx_cm_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_cm_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                              uint64_t value, unsigned size)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxState *s = (PXA2xxState *) opaque;
   
Line 206  static void pxa2xx_cm_write(void *opaque Line 205  static void pxa2xx_cm_write(void *opaque
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_cm_readfn[] = {  static const MemoryRegionOps pxa2xx_cm_ops = {
     pxa2xx_cm_read,      .read = pxa2xx_cm_read,
     pxa2xx_cm_read,      .write = pxa2xx_cm_write,
     pxa2xx_cm_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_cm_writefn[] = {  
     pxa2xx_cm_write,  
     pxa2xx_cm_write,  
     pxa2xx_cm_write,  
 };  };
   
 static const VMStateDescription vmstate_pxa2xx_cm = {  static const VMStateDescription vmstate_pxa2xx_cm = {
Line 461  static void pxa2xx_cp14_write(void *opaq Line 454  static void pxa2xx_cp14_write(void *opaq
 #define BSCNTR3         0x60    /* Memory Buffer Strength Control register 3 */  #define BSCNTR3         0x60    /* Memory Buffer Strength Control register 3 */
 #define SA1110          0x64    /* SA-1110 Memory Compatibility register */  #define SA1110          0x64    /* SA-1110 Memory Compatibility register */
   
 static uint32_t pxa2xx_mm_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_mm_read(void *opaque, target_phys_addr_t addr,
                                  unsigned size)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxState *s = (PXA2xxState *) opaque;
   
Line 478  static uint32_t pxa2xx_mm_read(void *opa Line 472  static uint32_t pxa2xx_mm_read(void *opa
 }  }
   
 static void pxa2xx_mm_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_mm_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                              uint64_t value, unsigned size)
 {  {
     PXA2xxState *s = (PXA2xxState *) opaque;      PXA2xxState *s = (PXA2xxState *) opaque;
   
Line 495  static void pxa2xx_mm_write(void *opaque Line 489  static void pxa2xx_mm_write(void *opaque
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_mm_readfn[] = {  static const MemoryRegionOps pxa2xx_mm_ops = {
     pxa2xx_mm_read,      .read = pxa2xx_mm_read,
     pxa2xx_mm_read,      .write = pxa2xx_mm_write,
     pxa2xx_mm_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_mm_writefn[] = {  
     pxa2xx_mm_write,  
     pxa2xx_mm_write,  
     pxa2xx_mm_write,  
 };  };
   
 static const VMStateDescription vmstate_pxa2xx_mm = {  static const VMStateDescription vmstate_pxa2xx_mm = {
Line 521  static const VMStateDescription vmstate_ Line 509  static const VMStateDescription vmstate_
 /* Synchronous Serial Ports */  /* Synchronous Serial Ports */
 typedef struct {  typedef struct {
     SysBusDevice busdev;      SysBusDevice busdev;
       MemoryRegion iomem;
     qemu_irq irq;      qemu_irq irq;
     int enable;      int enable;
     SSIBus *bus;      SSIBus *bus;
Line 627  static void pxa2xx_ssp_fifo_update(PXA2x Line 616  static void pxa2xx_ssp_fifo_update(PXA2x
     pxa2xx_ssp_int_update(s);      pxa2xx_ssp_int_update(s);
 }  }
   
 static uint32_t pxa2xx_ssp_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_ssp_read(void *opaque, target_phys_addr_t addr,
                                   unsigned size)
 {  {
     PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;      PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;
     uint32_t retval;      uint32_t retval;
Line 673  static uint32_t pxa2xx_ssp_read(void *op Line 663  static uint32_t pxa2xx_ssp_read(void *op
 }  }
   
 static void pxa2xx_ssp_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_ssp_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                               uint64_t value64, unsigned size)
 {  {
     PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;      PXA2xxSSPState *s = (PXA2xxSSPState *) opaque;
       uint32_t value = value64;
   
     switch (addr) {      switch (addr) {
     case SSCR0:      case SSCR0:
Line 762  static void pxa2xx_ssp_write(void *opaqu Line 753  static void pxa2xx_ssp_write(void *opaqu
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_ssp_readfn[] = {  static const MemoryRegionOps pxa2xx_ssp_ops = {
     pxa2xx_ssp_read,      .read = pxa2xx_ssp_read,
     pxa2xx_ssp_read,      .write = pxa2xx_ssp_write,
     pxa2xx_ssp_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_ssp_writefn[] = {  
     pxa2xx_ssp_write,  
     pxa2xx_ssp_write,  
     pxa2xx_ssp_write,  
 };  };
   
 static void pxa2xx_ssp_save(QEMUFile *f, void *opaque)  static void pxa2xx_ssp_save(QEMUFile *f, void *opaque)
Line 823  static int pxa2xx_ssp_load(QEMUFile *f,  Line 808  static int pxa2xx_ssp_load(QEMUFile *f, 
   
 static int pxa2xx_ssp_init(SysBusDevice *dev)  static int pxa2xx_ssp_init(SysBusDevice *dev)
 {  {
     int iomemtype;  
     PXA2xxSSPState *s = FROM_SYSBUS(PXA2xxSSPState, dev);      PXA2xxSSPState *s = FROM_SYSBUS(PXA2xxSSPState, dev);
   
     sysbus_init_irq(dev, &s->irq);      sysbus_init_irq(dev, &s->irq);
   
     iomemtype = cpu_register_io_memory(pxa2xx_ssp_readfn,      memory_region_init_io(&s->iomem, &pxa2xx_ssp_ops, s, "pxa2xx-ssp", 0x1000);
                                        pxa2xx_ssp_writefn, s,      sysbus_init_mmio_region(dev, &s->iomem);
                                        DEVICE_NATIVE_ENDIAN);  
     sysbus_init_mmio(dev, 0x1000, iomemtype);  
     register_savevm(&dev->qdev, "pxa2xx_ssp", -1, 0,      register_savevm(&dev->qdev, "pxa2xx_ssp", -1, 0,
                     pxa2xx_ssp_save, pxa2xx_ssp_load, s);                      pxa2xx_ssp_save, pxa2xx_ssp_load, s);
   
Line 858  static int pxa2xx_ssp_init(SysBusDevice  Line 840  static int pxa2xx_ssp_init(SysBusDevice 
   
 typedef struct {  typedef struct {
     SysBusDevice busdev;      SysBusDevice busdev;
       MemoryRegion iomem;
     uint32_t rttr;      uint32_t rttr;
     uint32_t rtsr;      uint32_t rtsr;
     uint32_t rtar;      uint32_t rtar;
Line 1009  static inline void pxa2xx_rtc_pi_tick(vo Line 992  static inline void pxa2xx_rtc_pi_tick(vo
     pxa2xx_rtc_int_update(s);      pxa2xx_rtc_int_update(s);
 }  }
   
 static uint32_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr,
                                   unsigned size)
 {  {
     PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
   
Line 1055  static uint32_t pxa2xx_rtc_read(void *op Line 1039  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)                               uint64_t value64, unsigned size)
 {  {
     PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;      PXA2xxRTCState *s = (PXA2xxRTCState *) opaque;
       uint32_t value = value64;
   
     switch (addr) {      switch (addr) {
     case RTTR:      case RTTR:
Line 1157  static void pxa2xx_rtc_write(void *opaqu Line 1142  static void pxa2xx_rtc_write(void *opaqu
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_rtc_readfn[] = {  static const MemoryRegionOps pxa2xx_rtc_ops = {
     pxa2xx_rtc_read,      .read = pxa2xx_rtc_read,
     pxa2xx_rtc_read,      .write = pxa2xx_rtc_write,
     pxa2xx_rtc_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_rtc_writefn[] = {  
     pxa2xx_rtc_write,  
     pxa2xx_rtc_write,  
     pxa2xx_rtc_write,  
 };  };
   
 static int pxa2xx_rtc_init(SysBusDevice *dev)  static int pxa2xx_rtc_init(SysBusDevice *dev)
Line 1174  static int pxa2xx_rtc_init(SysBusDevice  Line 1153  static int pxa2xx_rtc_init(SysBusDevice 
     PXA2xxRTCState *s = FROM_SYSBUS(PXA2xxRTCState, 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 1201  static int pxa2xx_rtc_init(SysBusDevice  Line 1179  static int pxa2xx_rtc_init(SysBusDevice 
   
     sysbus_init_irq(dev, &s->rtc_irq);      sysbus_init_irq(dev, &s->rtc_irq);
   
     iomemtype = cpu_register_io_memory(pxa2xx_rtc_readfn,      memory_region_init_io(&s->iomem, &pxa2xx_rtc_ops, s, "pxa2xx-rtc", 0x10000);
                     pxa2xx_rtc_writefn, s, DEVICE_NATIVE_ENDIAN);      sysbus_init_mmio_region(dev, &s->iomem);
     sysbus_init_mmio(dev, 0x10000, iomemtype);  
   
     return 0;      return 0;
 }  }
Line 1272  typedef struct { Line 1249  typedef struct {
   
 struct PXA2xxI2CState {  struct PXA2xxI2CState {
     SysBusDevice busdev;      SysBusDevice busdev;
       MemoryRegion iomem;
     PXA2xxI2CSlaveState *slave;      PXA2xxI2CSlaveState *slave;
     i2c_bus *bus;      i2c_bus *bus;
     qemu_irq irq;      qemu_irq irq;
Line 1356  static int pxa2xx_i2c_tx(i2c_slave *i2c, Line 1334  static int pxa2xx_i2c_tx(i2c_slave *i2c,
     return 1;      return 1;
 }  }
   
 static uint32_t pxa2xx_i2c_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_i2c_read(void *opaque, target_phys_addr_t addr,
                                   unsigned size)
 {  {
     PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;      PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
   
Line 1384  static uint32_t pxa2xx_i2c_read(void *op Line 1363  static uint32_t pxa2xx_i2c_read(void *op
 }  }
   
 static void pxa2xx_i2c_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_i2c_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                               uint64_t value64, unsigned size)
 {  {
     PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;      PXA2xxI2CState *s = (PXA2xxI2CState *) opaque;
       uint32_t value = value64;
     int ack;      int ack;
   
     addr -= s->offset;      addr -= s->offset;
Line 1453  static void pxa2xx_i2c_write(void *opaqu Line 1433  static void pxa2xx_i2c_write(void *opaqu
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_i2c_readfn[] = {  static const MemoryRegionOps pxa2xx_i2c_ops = {
     pxa2xx_i2c_read,      .read = pxa2xx_i2c_read,
     pxa2xx_i2c_read,      .write = pxa2xx_i2c_write,
     pxa2xx_i2c_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_i2c_writefn[] = {  
     pxa2xx_i2c_write,  
     pxa2xx_i2c_write,  
     pxa2xx_i2c_write,  
 };  };
   
 static const VMStateDescription vmstate_pxa2xx_i2c_slave = {  static const VMStateDescription vmstate_pxa2xx_i2c_slave = {
Line 1536  PXA2xxI2CState *pxa2xx_i2c_init(target_p Line 1510  PXA2xxI2CState *pxa2xx_i2c_init(target_p
 static int pxa2xx_i2c_initfn(SysBusDevice *dev)  static int pxa2xx_i2c_initfn(SysBusDevice *dev)
 {  {
     PXA2xxI2CState *s = FROM_SYSBUS(PXA2xxI2CState, dev);      PXA2xxI2CState *s = FROM_SYSBUS(PXA2xxI2CState, dev);
     int iomemtype;  
   
     s->bus = i2c_init_bus(&dev->qdev, "i2c");      s->bus = i2c_init_bus(&dev->qdev, "i2c");
   
     iomemtype = cpu_register_io_memory(pxa2xx_i2c_readfn,      memory_region_init_io(&s->iomem, &pxa2xx_i2c_ops, s,
                     pxa2xx_i2c_writefn, s, DEVICE_NATIVE_ENDIAN);                            "pxa2xx-i2x", s->region_size);
     sysbus_init_mmio(dev, s->region_size, iomemtype);      sysbus_init_mmio_region(dev, &s->iomem);
     sysbus_init_irq(dev, &s->irq);      sysbus_init_irq(dev, &s->irq);
   
     return 0;      return 0;
Line 1621  static inline void pxa2xx_i2s_update(PXA Line 1594  static inline void pxa2xx_i2s_update(PXA
 #define SADIV   0x60    /* Serial Audio Clock Divider register */  #define SADIV   0x60    /* Serial Audio Clock Divider register */
 #define SADR    0x80    /* Serial Audio Data register */  #define SADR    0x80    /* Serial Audio Data register */
   
 static uint32_t pxa2xx_i2s_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_i2s_read(void *opaque, target_phys_addr_t addr,
                                   unsigned size)
 {  {
     PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;      PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;
   
Line 1653  static uint32_t pxa2xx_i2s_read(void *op Line 1627  static uint32_t pxa2xx_i2s_read(void *op
 }  }
   
 static void pxa2xx_i2s_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_i2s_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                               uint64_t value, unsigned size)
 {  {
     PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;      PXA2xxI2SState *s = (PXA2xxI2SState *) opaque;
     uint32_t *sample;      uint32_t *sample;
Line 1707  static void pxa2xx_i2s_write(void *opaqu Line 1681  static void pxa2xx_i2s_write(void *opaqu
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_i2s_readfn[] = {  static const MemoryRegionOps pxa2xx_i2s_ops = {
     pxa2xx_i2s_read,      .read = pxa2xx_i2s_read,
     pxa2xx_i2s_read,      .write = pxa2xx_i2s_write,
     pxa2xx_i2s_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_i2s_writefn[] = {  
     pxa2xx_i2s_write,  
     pxa2xx_i2s_write,  
     pxa2xx_i2s_write,  
 };  };
   
 static const VMStateDescription vmstate_pxa2xx_i2s = {  static const VMStateDescription vmstate_pxa2xx_i2s = {
Line 1759  static void pxa2xx_i2s_data_req(void *op Line 1727  static void pxa2xx_i2s_data_req(void *op
     pxa2xx_i2s_update(s);      pxa2xx_i2s_update(s);
 }  }
   
 static PXA2xxI2SState *pxa2xx_i2s_init(target_phys_addr_t base,  static PXA2xxI2SState *pxa2xx_i2s_init(MemoryRegion *sysmem,
                   target_phys_addr_t base,
                 qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma)                  qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma)
 {  {
     int iomemtype;  
     PXA2xxI2SState *s = (PXA2xxI2SState *)      PXA2xxI2SState *s = (PXA2xxI2SState *)
             qemu_mallocz(sizeof(PXA2xxI2SState));              g_malloc0(sizeof(PXA2xxI2SState));
   
     s->irq = irq;      s->irq = irq;
     s->rx_dma = rx_dma;      s->rx_dma = rx_dma;
Line 1773  static PXA2xxI2SState *pxa2xx_i2s_init(t Line 1741  static PXA2xxI2SState *pxa2xx_i2s_init(t
   
     pxa2xx_i2s_reset(s);      pxa2xx_i2s_reset(s);
   
     iomemtype = cpu_register_io_memory(pxa2xx_i2s_readfn,      memory_region_init_io(&s->iomem, &pxa2xx_i2s_ops, s,
                     pxa2xx_i2s_writefn, s, DEVICE_NATIVE_ENDIAN);                            "pxa2xx-i2s", 0x100000);
     cpu_register_physical_memory(base, 0x100000, iomemtype);      memory_region_add_subregion(sysmem, base, &s->iomem);
   
     vmstate_register(NULL, base, &vmstate_pxa2xx_i2s, s);      vmstate_register(NULL, base, &vmstate_pxa2xx_i2s, s);
   
Line 1784  static PXA2xxI2SState *pxa2xx_i2s_init(t Line 1752  static PXA2xxI2SState *pxa2xx_i2s_init(t
   
 /* PXA Fast Infra-red Communications Port */  /* PXA Fast Infra-red Communications Port */
 struct PXA2xxFIrState {  struct PXA2xxFIrState {
       MemoryRegion iomem;
     qemu_irq irq;      qemu_irq irq;
     qemu_irq rx_dma;      qemu_irq rx_dma;
     qemu_irq tx_dma;      qemu_irq tx_dma;
Line 1854  static inline void pxa2xx_fir_update(PXA Line 1823  static inline void pxa2xx_fir_update(PXA
 #define ICSR1   0x18    /* FICP Status register 1 */  #define ICSR1   0x18    /* FICP Status register 1 */
 #define ICFOR   0x1c    /* FICP FIFO Occupancy Status register */  #define ICFOR   0x1c    /* FICP FIFO Occupancy Status register */
   
 static uint32_t pxa2xx_fir_read(void *opaque, target_phys_addr_t addr)  static uint64_t pxa2xx_fir_read(void *opaque, target_phys_addr_t addr,
                                   unsigned size)
 {  {
     PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;      PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
     uint8_t ret;      uint8_t ret;
Line 1892  static uint32_t pxa2xx_fir_read(void *op Line 1862  static uint32_t pxa2xx_fir_read(void *op
 }  }
   
 static void pxa2xx_fir_write(void *opaque, target_phys_addr_t addr,  static void pxa2xx_fir_write(void *opaque, target_phys_addr_t addr,
                 uint32_t value)                               uint64_t value64, unsigned size)
 {  {
     PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;      PXA2xxFIrState *s = (PXA2xxFIrState *) opaque;
       uint32_t value = value64;
     uint8_t ch;      uint8_t ch;
   
     switch (addr) {      switch (addr) {
Line 1923  static void pxa2xx_fir_write(void *opaqu Line 1894  static void pxa2xx_fir_write(void *opaqu
         else          else
             ch = ~value;              ch = ~value;
         if (s->chr && s->enable && (s->control[0] & (1 << 3)))  /* TXE */          if (s->chr && s->enable && (s->control[0] & (1 << 3)))  /* TXE */
             qemu_chr_write(s->chr, &ch, 1);              qemu_chr_fe_write(s->chr, &ch, 1);
         break;          break;
     case ICSR0:      case ICSR0:
         s->status[0] &= ~(value & 0x66);          s->status[0] &= ~(value & 0x66);
Line 1936  static void pxa2xx_fir_write(void *opaqu Line 1907  static void pxa2xx_fir_write(void *opaqu
     }      }
 }  }
   
 static CPUReadMemoryFunc * const pxa2xx_fir_readfn[] = {  static const MemoryRegionOps pxa2xx_fir_ops = {
     pxa2xx_fir_read,      .read = pxa2xx_fir_read,
     pxa2xx_fir_read,      .write = pxa2xx_fir_write,
     pxa2xx_fir_read,      .endianness = DEVICE_NATIVE_ENDIAN,
 };  
   
 static CPUWriteMemoryFunc * const pxa2xx_fir_writefn[] = {  
     pxa2xx_fir_write,  
     pxa2xx_fir_write,  
     pxa2xx_fir_write,  
 };  };
   
 static int pxa2xx_fir_is_empty(void *opaque)  static int pxa2xx_fir_is_empty(void *opaque)
Line 2019  static int pxa2xx_fir_load(QEMUFile *f,  Line 1984  static int pxa2xx_fir_load(QEMUFile *f, 
     return 0;      return 0;
 }  }
   
 static PXA2xxFIrState *pxa2xx_fir_init(target_phys_addr_t base,  static PXA2xxFIrState *pxa2xx_fir_init(MemoryRegion *sysmem,
                   target_phys_addr_t base,
                 qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma,                  qemu_irq irq, qemu_irq rx_dma, qemu_irq tx_dma,
                 CharDriverState *chr)                  CharDriverState *chr)
 {  {
     int iomemtype;  
     PXA2xxFIrState *s = (PXA2xxFIrState *)      PXA2xxFIrState *s = (PXA2xxFIrState *)
             qemu_mallocz(sizeof(PXA2xxFIrState));              g_malloc0(sizeof(PXA2xxFIrState));
   
     s->irq = irq;      s->irq = irq;
     s->rx_dma = rx_dma;      s->rx_dma = rx_dma;
Line 2034  static PXA2xxFIrState *pxa2xx_fir_init(t Line 1999  static PXA2xxFIrState *pxa2xx_fir_init(t
   
     pxa2xx_fir_reset(s);      pxa2xx_fir_reset(s);
   
     iomemtype = cpu_register_io_memory(pxa2xx_fir_readfn,      memory_region_init_io(&s->iomem, &pxa2xx_fir_ops, s, "pxa2xx-fir", 0x1000);
                     pxa2xx_fir_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(sysmem, base, &s->iomem);
     cpu_register_physical_memory(base, 0x1000, iomemtype);  
   
     if (chr)      if (chr)
         qemu_chr_add_handlers(chr, pxa2xx_fir_is_empty,          qemu_chr_add_handlers(chr, pxa2xx_fir_is_empty,
Line 2059  static void pxa2xx_reset(void *opaque, i Line 2023  static void pxa2xx_reset(void *opaque, i
 }  }
   
 /* Initialise a PXA270 integrated chip (ARM based core).  */  /* Initialise a PXA270 integrated chip (ARM based core).  */
 PXA2xxState *pxa270_init(unsigned int sdram_size, const char *revision)  PXA2xxState *pxa270_init(MemoryRegion *address_space,
                            unsigned int sdram_size, const char *revision)
 {  {
     PXA2xxState *s;      PXA2xxState *s;
     int iomemtype, i;      int i;
     DriveInfo *dinfo;      DriveInfo *dinfo;
     s = (PXA2xxState *) qemu_mallocz(sizeof(PXA2xxState));      s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
   
     if (revision && strncmp(revision, "pxa27", 5)) {      if (revision && strncmp(revision, "pxa27", 5)) {
         fprintf(stderr, "Machine requires a PXA27x processor.\n");          fprintf(stderr, "Machine requires a PXA27x processor.\n");
Line 2081  PXA2xxState *pxa270_init(unsigned int sd Line 2046  PXA2xxState *pxa270_init(unsigned int sd
     s->reset = qemu_allocate_irqs(pxa2xx_reset, s, 1)[0];      s->reset = qemu_allocate_irqs(pxa2xx_reset, s, 1)[0];
   
     /* SDRAM & Internal Memory Storage */      /* SDRAM & Internal Memory Storage */
     cpu_register_physical_memory(PXA2XX_SDRAM_BASE,      memory_region_init_ram(&s->sdram, NULL, "pxa270.sdram", sdram_size);
                     sdram_size, qemu_ram_alloc(NULL, "pxa270.sdram",      memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
                                                sdram_size) | IO_MEM_RAM);      memory_region_init_ram(&s->internal, NULL, "pxa270.internal", 0x40000);
     cpu_register_physical_memory(PXA2XX_INTERNAL_BASE,      memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
                     0x40000, qemu_ram_alloc(NULL, "pxa270.internal",                                  &s->internal);
                                             0x40000) | IO_MEM_RAM);  
   
     s->pic = pxa2xx_pic_init(0x40d00000, s->env);      s->pic = pxa2xx_pic_init(0x40d00000, s->env);
   
Line 2113  PXA2xxState *pxa270_init(unsigned int sd Line 2077  PXA2xxState *pxa270_init(unsigned int sd
                     qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),                      qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
                     qdev_get_gpio_in(s->dma, PXA2XX_TX_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              serial_mm_init(address_space, pxa270_serial[i].io_base, 2,
             serial_mm_init(pxa270_serial[i].io_base, 2,                             qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),
                             qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),                             14857000 / 16, serial_hds[i],
                             14857000 / 16, serial_hds[i], 1, 1);                             DEVICE_NATIVE_ENDIAN);
 #else          } else {
             serial_mm_init(pxa270_serial[i].io_base, 2,  
                             qdev_get_gpio_in(s->pic, pxa270_serial[i].irqn),  
                             14857000 / 16, serial_hds[i], 1, 0);  
 #endif  
         else  
             break;              break;
           }
       }
     if (serial_hds[i])      if (serial_hds[i])
         s->fir = pxa2xx_fir_init(0x40800000,          s->fir = pxa2xx_fir_init(address_space, 0x40800000,
                         qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),                          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_RX_RQ_ICP),
                         qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),                          qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
Line 2139  PXA2xxState *pxa270_init(unsigned int sd Line 2100  PXA2xxState *pxa270_init(unsigned int sd
     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 */
     s->clkcfg = 0x00000009;             /* Turbo mode active */      s->clkcfg = 0x00000009;             /* Turbo mode active */
     iomemtype = cpu_register_io_memory(pxa2xx_cm_readfn,      memory_region_init_io(&s->cm_iomem, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
                     pxa2xx_cm_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
     cpu_register_physical_memory(s->cm_base, 0x1000, iomemtype);  
     vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, 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 2150  PXA2xxState *pxa270_init(unsigned int sd Line 2110  PXA2xxState *pxa270_init(unsigned int sd
     s->mm_regs[MDMRS >> 2] = 0x00020002;      s->mm_regs[MDMRS >> 2] = 0x00020002;
     s->mm_regs[MDREFR >> 2] = 0x03ca4000;      s->mm_regs[MDREFR >> 2] = 0x03ca4000;
     s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */      s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */
     iomemtype = cpu_register_io_memory(pxa2xx_mm_readfn,      memory_region_init_io(&s->mm_iomem, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
                     pxa2xx_mm_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
     cpu_register_physical_memory(s->mm_base, 0x1000, iomemtype);  
     vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, 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,      memory_region_init_io(&s->pm_iomem, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
                     pxa2xx_pm_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
     cpu_register_physical_memory(s->pm_base, 0x100, iomemtype);  
     vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, 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 **)g_malloc0(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,
Line 2186  PXA2xxState *pxa270_init(unsigned int sd Line 2144  PXA2xxState *pxa270_init(unsigned int sd
     s->i2c[1] = pxa2xx_i2c_init(0x40f00100,      s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
                     qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
   
     s->i2s = pxa2xx_i2s_init(0x40400000,      s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
                     qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),                      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_RX_RQ_I2S),
                     qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));                      qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));
Line 2201  PXA2xxState *pxa270_init(unsigned int sd Line 2159  PXA2xxState *pxa270_init(unsigned int sd
 }  }
   
 /* Initialise a PXA255 integrated chip (ARM based core).  */  /* Initialise a PXA255 integrated chip (ARM based core).  */
 PXA2xxState *pxa255_init(unsigned int sdram_size)  PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size)
 {  {
     PXA2xxState *s;      PXA2xxState *s;
     int iomemtype, i;      int i;
     DriveInfo *dinfo;      DriveInfo *dinfo;
   
     s = (PXA2xxState *) qemu_mallocz(sizeof(PXA2xxState));      s = (PXA2xxState *) g_malloc0(sizeof(PXA2xxState));
   
     s->env = cpu_init("pxa255");      s->env = cpu_init("pxa255");
     if (!s->env) {      if (!s->env) {
Line 2217  PXA2xxState *pxa255_init(unsigned int sd Line 2175  PXA2xxState *pxa255_init(unsigned int sd
     s->reset = qemu_allocate_irqs(pxa2xx_reset, s, 1)[0];      s->reset = qemu_allocate_irqs(pxa2xx_reset, s, 1)[0];
   
     /* SDRAM & Internal Memory Storage */      /* SDRAM & Internal Memory Storage */
     cpu_register_physical_memory(PXA2XX_SDRAM_BASE, sdram_size,      memory_region_init_ram(&s->sdram, NULL, "pxa255.sdram", sdram_size);
                     qemu_ram_alloc(NULL, "pxa255.sdram",      memory_region_add_subregion(address_space, PXA2XX_SDRAM_BASE, &s->sdram);
                                    sdram_size) | IO_MEM_RAM);      memory_region_init_ram(&s->internal, NULL, "pxa255.internal",
     cpu_register_physical_memory(PXA2XX_INTERNAL_BASE, PXA2XX_INTERNAL_SIZE,                             PXA2XX_INTERNAL_SIZE);
                     qemu_ram_alloc(NULL, "pxa255.internal",      memory_region_add_subregion(address_space, PXA2XX_INTERNAL_BASE,
                                    PXA2XX_INTERNAL_SIZE) | IO_MEM_RAM);                                  &s->internal);
   
     s->pic = pxa2xx_pic_init(0x40d00000, s->env);      s->pic = pxa2xx_pic_init(0x40d00000, s->env);
   
Line 2248  PXA2xxState *pxa255_init(unsigned int sd Line 2206  PXA2xxState *pxa255_init(unsigned int sd
                     qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),                      qdev_get_gpio_in(s->dma, PXA2XX_RX_RQ_MMCI),
                     qdev_get_gpio_in(s->dma, PXA2XX_TX_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              serial_mm_init(address_space, pxa255_serial[i].io_base, 2,
             serial_mm_init(pxa255_serial[i].io_base, 2,                             qdev_get_gpio_in(s->pic, pxa255_serial[i].irqn),
                             qdev_get_gpio_in(s->pic, pxa255_serial[i].irqn),                             14745600 / 16, serial_hds[i],
                             14745600 / 16, serial_hds[i], 1, 1);                             DEVICE_NATIVE_ENDIAN);
 #else  
             serial_mm_init(pxa255_serial[i].io_base, 2,  
                             qdev_get_gpio_in(s->pic, pxa255_serial[i].irqn),  
                             14745600 / 16, serial_hds[i], 1, 0);  
 #endif  
         } else {          } else {
             break;              break;
         }          }
       }
     if (serial_hds[i])      if (serial_hds[i])
         s->fir = pxa2xx_fir_init(0x40800000,          s->fir = pxa2xx_fir_init(address_space, 0x40800000,
                         qdev_get_gpio_in(s->pic, PXA2XX_PIC_ICP),                          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_RX_RQ_ICP),
                         qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),                          qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_ICP),
Line 2275  PXA2xxState *pxa255_init(unsigned int sd Line 2229  PXA2xxState *pxa255_init(unsigned int sd
     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 */
     s->clkcfg = 0x00000009;             /* Turbo mode active */      s->clkcfg = 0x00000009;             /* Turbo mode active */
     iomemtype = cpu_register_io_memory(pxa2xx_cm_readfn,      memory_region_init_io(&s->cm_iomem, &pxa2xx_cm_ops, s, "pxa2xx-cm", 0x1000);
                     pxa2xx_cm_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(address_space, s->cm_base, &s->cm_iomem);
     cpu_register_physical_memory(s->cm_base, 0x1000, iomemtype);  
     vmstate_register(NULL, 0, &vmstate_pxa2xx_cm, 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 2286  PXA2xxState *pxa255_init(unsigned int sd Line 2239  PXA2xxState *pxa255_init(unsigned int sd
     s->mm_regs[MDMRS >> 2] = 0x00020002;      s->mm_regs[MDMRS >> 2] = 0x00020002;
     s->mm_regs[MDREFR >> 2] = 0x03ca4000;      s->mm_regs[MDREFR >> 2] = 0x03ca4000;
     s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */      s->mm_regs[MECR >> 2] = 0x00000001; /* Two PC Card sockets */
     iomemtype = cpu_register_io_memory(pxa2xx_mm_readfn,      memory_region_init_io(&s->mm_iomem, &pxa2xx_mm_ops, s, "pxa2xx-mm", 0x1000);
                     pxa2xx_mm_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(address_space, s->mm_base, &s->mm_iomem);
     cpu_register_physical_memory(s->mm_base, 0x1000, iomemtype);  
     vmstate_register(NULL, 0, &vmstate_pxa2xx_mm, 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,      memory_region_init_io(&s->pm_iomem, &pxa2xx_pm_ops, s, "pxa2xx-pm", 0x100);
                     pxa2xx_pm_writefn, s, DEVICE_NATIVE_ENDIAN);      memory_region_add_subregion(address_space, s->pm_base, &s->pm_iomem);
     cpu_register_physical_memory(s->pm_base, 0x100, iomemtype);  
     vmstate_register(NULL, 0, &vmstate_pxa2xx_pm, 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 **)g_malloc0(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,
Line 2322  PXA2xxState *pxa255_init(unsigned int sd Line 2273  PXA2xxState *pxa255_init(unsigned int sd
     s->i2c[1] = pxa2xx_i2c_init(0x40f00100,      s->i2c[1] = pxa2xx_i2c_init(0x40f00100,
                     qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);                      qdev_get_gpio_in(s->pic, PXA2XX_PIC_PWRI2C), 0xff);
   
     s->i2s = pxa2xx_i2s_init(0x40400000,      s->i2s = pxa2xx_i2s_init(address_space, 0x40400000,
                     qdev_get_gpio_in(s->pic, PXA2XX_PIC_I2S),                      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_RX_RQ_I2S),
                     qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));                      qdev_get_gpio_in(s->dma, PXA2XX_TX_RQ_I2S));

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


unix.superglobalmegacorp.com