hw/arm_timer.c

   1 /*
   2  * ARM PrimeCell Timer modules.
   3  *
   4  * Copyright (c) 2005-2006 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the GPL.
   8  */
   9
  10 #include "sysbus.h"
  11 #include "qemu-timer.h"
  12
  13 /* Common timer implementation.  */
  14
  15 #define TIMER_CTRL_ONESHOT      (1 << 0)
  16 #define TIMER_CTRL_32BIT        (1 << 1)
  17 #define TIMER_CTRL_DIV1         (0 << 2)
  18 #define TIMER_CTRL_DIV16        (1 << 2)
  19 #define TIMER_CTRL_DIV256       (2 << 2)
  20 #define TIMER_CTRL_IE           (1 << 5)
  21 #define TIMER_CTRL_PERIODIC     (1 << 6)
  22 #define TIMER_CTRL_ENABLE       (1 << 7)
  23
  24 typedef struct {
  25     ptimer_state *timer;
  26     uint32_t control;
  27     uint32_t limit;
  28     int freq;
  29     int int_level;
  30     qemu_irq irq;
  31 } arm_timer_state;
  32
  33 /* Check all active timers, and schedule the next timer interrupt.  */
  34
  35 static void arm_timer_update(arm_timer_state *s)
  36 {
  37     /* Update interrupts.  */
  38     if (s->int_level && (s->control & TIMER_CTRL_IE)) {
  39         qemu_irq_raise(s->irq);
  40     } else {
  41         qemu_irq_lower(s->irq);
  42     }
  43 }
  44
  45 static uint32_t arm_timer_read(void *opaque, target_phys_addr_t offset)
  46 {
  47     arm_timer_state *s = (arm_timer_state *)opaque;
  48
  49     switch (offset >> 2) {
  50     case 0: /* TimerLoad */
  51     case 6: /* TimerBGLoad */
  52         return s->limit;
  53     case 1: /* TimerValue */
  54         return ptimer_get_count(s->timer);
  55     case 2: /* TimerControl */
  56         return s->control;
  57     case 4: /* TimerRIS */
  58         return s->int_level;
  59     case 5: /* TimerMIS */
  60         if ((s->control & TIMER_CTRL_IE) == 0)
  61             return 0;
  62         return s->int_level;
  63     default:
  64         hw_error("arm_timer_read: Bad offset %x\n", (int)offset);
  65         return 0;
  66     }
  67 }
  68
  69 /* Reset the timer limit after settings have changed.  */
  70 static void arm_timer_recalibrate(arm_timer_state *s, int reload)
  71 {
  72     uint32_t limit;
  73
  74     if ((s->control & (TIMER_CTRL_PERIODIC | TIMER_CTRL_ONESHOT)) == 0) {
  75         /* Free running.  */
  76         if (s->control & TIMER_CTRL_32BIT)
  77             limit = 0xffffffff;
  78         else
  79             limit = 0xffff;
  80     } else {
  81           /* Periodic.  */
  82           limit = s->limit;
  83     }
  84     ptimer_set_limit(s->timer, limit, reload);
  85 }
  86
  87 static void arm_timer_write(void *opaque, target_phys_addr_t offset,
  88                             uint32_t value)
  89 {
  90     arm_timer_state *s = (arm_timer_state *)opaque;
  91     int freq;
  92
  93     switch (offset >> 2) {
  94     case 0: /* TimerLoad */
  95         s->limit = value;
  96         arm_timer_recalibrate(s, 1);
  97         break;
  98     case 1: /* TimerValue */
  99         /* ??? Linux seems to want to write to this readonly register.
 100            Ignore it.  */
 101         break;
 102     case 2: /* TimerControl */
 103         if (s->control & TIMER_CTRL_ENABLE) {
 104             /* Pause the timer if it is running.  This may cause some
 105                inaccuracy dure to rounding, but avoids a whole lot of other
 106                messyness.  */
 107             ptimer_stop(s->timer);
 108         }
 109         s->control = value;
 110         freq = s->freq;
 111         /* ??? Need to recalculate expiry time after changing divisor.  */
 112         switch ((value >> 2) & 3) {
 113         case 1: freq >>= 4; break;
 114         case 2: freq >>= 8; break;
 115         }
 116         arm_timer_recalibrate(s, s->control & TIMER_CTRL_ENABLE);
 117         ptimer_set_freq(s->timer, freq);
 118         if (s->control & TIMER_CTRL_ENABLE) {
 119             /* Restart the timer if still enabled.  */
 120             ptimer_run(s->timer, (s->control & TIMER_CTRL_ONESHOT) != 0);
 121         }
 122         break;
 123     case 3: /* TimerIntClr */
 124         s->int_level = 0;
 125         break;
 126     case 6: /* TimerBGLoad */
 127         s->limit = value;
 128         arm_timer_recalibrate(s, 0);
 129         break;
 130     default:
 131         hw_error("arm_timer_write: Bad offset %x\n", (int)offset);
 132     }
 133     arm_timer_update(s);
 134 }
 135
 136 static void arm_timer_tick(void *opaque)
 137 {
 138     arm_timer_state *s = (arm_timer_state *)opaque;
 139     s->int_level = 1;
 140     arm_timer_update(s);
 141 }
 142
 143 static void arm_timer_save(QEMUFile *f, void *opaque)
 144 {
 145     arm_timer_state *s = (arm_timer_state *)opaque;
 146     qemu_put_be32(f, s->control);
 147     qemu_put_be32(f, s->limit);
 148     qemu_put_be32(f, s->int_level);
 149     qemu_put_ptimer(f, s->timer);
 150 }
 151
 152 static int arm_timer_load(QEMUFile *f, void *opaque, int version_id)
 153 {
 154     arm_timer_state *s = (arm_timer_state *)opaque;
 155
 156     if (version_id != 1)
 157         return -EINVAL;
 158
 159     s->control = qemu_get_be32(f);
 160     s->limit = qemu_get_be32(f);
 161     s->int_level = qemu_get_be32(f);
 162     qemu_get_ptimer(f, s->timer);
 163     return 0;
 164 }
 165
 166 static arm_timer_state *arm_timer_init(uint32_t freq)
 167 {
 168     arm_timer_state *s;
 169     QEMUBH *bh;
 170
 171     s = (arm_timer_state *)qemu_mallocz(sizeof(arm_timer_state));
 172     s->freq = freq;
 173     s->control = TIMER_CTRL_IE;
 174
 175     bh = qemu_bh_new(arm_timer_tick, s);
 176     s->timer = ptimer_init(bh);
 177     register_savevm(NULL, "arm_timer", -1, 1, arm_timer_save, arm_timer_load, s);
 178     return s;
 179 }
 180
 181 /* ARM PrimeCell SP804 dual timer module.
 182    Docs for this device don't seem to be publicly available.  This
 183    implementation is based on guesswork, the linux kernel sources and the
 184    Integrator/CP timer modules.  */
 185
 186 typedef struct {
 187     SysBusDevice busdev;
 188     arm_timer_state *timer[2];
 189     int level[2];
 190     qemu_irq irq;
 191 } sp804_state;
 192
 193 /* Merge the IRQs from the two component devices.  */
 194 static void sp804_set_irq(void *opaque, int irq, int level)
 195 {
 196     sp804_state *s = (sp804_state *)opaque;
 197
 198     s->level[irq] = level;
 199     qemu_set_irq(s->irq, s->level[0] || s->level[1]);
 200 }
 201
 202 static uint32_t sp804_read(void *opaque, target_phys_addr_t offset)
 203 {
 204     sp804_state *s = (sp804_state *)opaque;
 205
 206     /* ??? Don't know the PrimeCell ID for this device.  */
 207     if (offset < 0x20) {
 208         return arm_timer_read(s->timer[0], offset);
 209     } else {
 210         return arm_timer_read(s->timer[1], offset - 0x20);
 211     }
 212 }
 213
 214 static void sp804_write(void *opaque, target_phys_addr_t offset,
 215                         uint32_t value)
 216 {
 217     sp804_state *s = (sp804_state *)opaque;
 218
 219     if (offset < 0x20) {
 220         arm_timer_write(s->timer[0], offset, value);
 221     } else {
 222         arm_timer_write(s->timer[1], offset - 0x20, value);
 223     }
 224 }
 225
 226 static CPUReadMemoryFunc * const sp804_readfn[] = {
 227    sp804_read,
 228    sp804_read,
 229    sp804_read
 230 };
 231
 232 static CPUWriteMemoryFunc * const sp804_writefn[] = {
 233    sp804_write,
 234    sp804_write,
 235    sp804_write
 236 };
 237
 238
 239 static const VMStateDescription vmstate_sp804 = {
 240     .name = "sp804",
 241     .version_id = 1,
 242     .minimum_version_id = 1,
 243     .minimum_version_id_old = 1,
 244     .fields      = (VMStateField[]) {
 245         VMSTATE_INT32_ARRAY(level, sp804_state, 2),
 246         VMSTATE_END_OF_LIST()
 247     }
 248 };
 249
 250 static int sp804_init(SysBusDevice *dev)
 251 {
 252     int iomemtype;
 253     sp804_state *s = FROM_SYSBUS(sp804_state, dev);
 254     qemu_irq *qi;
 255
 256     qi = qemu_allocate_irqs(sp804_set_irq, s, 2);
 257     sysbus_init_irq(dev, &s->irq);
 258     /* ??? The timers are actually configurable between 32kHz and 1MHz, but
 259        we don't implement that.  */
 260     s->timer[0] = arm_timer_init(1000000);
 261     s->timer[1] = arm_timer_init(1000000);
 262     s->timer[0]->irq = qi[0];
 263     s->timer[1]->irq = qi[1];
 264     iomemtype = cpu_register_io_memory(sp804_readfn,
 265                                        sp804_writefn, s, DEVICE_NATIVE_ENDIAN);
 266     sysbus_init_mmio(dev, 0x1000, iomemtype);
 267     vmstate_register(&dev->qdev, -1, &vmstate_sp804, s);
 268     return 0;
 269 }
 270
 271
 272 /* Integrator/CP timer module.  */
 273
 274 typedef struct {
 275     SysBusDevice busdev;
 276     arm_timer_state *timer[3];
 277 } icp_pit_state;
 278
 279 static uint32_t icp_pit_read(void *opaque, target_phys_addr_t offset)
 280 {
 281     icp_pit_state *s = (icp_pit_state *)opaque;
 282     int n;
 283
 284     /* ??? Don't know the PrimeCell ID for this device.  */
 285     n = offset >> 8;
 286     if (n > 3) {
 287         hw_error("sp804_read: Bad timer %d\n", n);
 288     }
 289
 290     return arm_timer_read(s->timer[n], offset & 0xff);
 291 }
 292
 293 static void icp_pit_write(void *opaque, target_phys_addr_t offset,
 294                           uint32_t value)
 295 {
 296     icp_pit_state *s = (icp_pit_state *)opaque;
 297     int n;
 298
 299     n = offset >> 8;
 300     if (n > 3) {
 301         hw_error("sp804_write: Bad timer %d\n", n);
 302     }
 303
 304     arm_timer_write(s->timer[n], offset & 0xff, value);
 305 }
 306
 307
 308 static CPUReadMemoryFunc * const icp_pit_readfn[] = {
 309    icp_pit_read,
 310    icp_pit_read,
 311    icp_pit_read
 312 };
 313
 314 static CPUWriteMemoryFunc * const icp_pit_writefn[] = {
 315    icp_pit_write,
 316    icp_pit_write,
 317    icp_pit_write
 318 };
 319
 320 static int icp_pit_init(SysBusDevice *dev)
 321 {
 322     int iomemtype;
 323     icp_pit_state *s = FROM_SYSBUS(icp_pit_state, dev);
 324
 325     /* Timer 0 runs at the system clock speed (40MHz).  */
 326     s->timer[0] = arm_timer_init(40000000);
 327     /* The other two timers run at 1MHz.  */
 328     s->timer[1] = arm_timer_init(1000000);
 329     s->timer[2] = arm_timer_init(1000000);
 330
 331     sysbus_init_irq(dev, &s->timer[0]->irq);
 332     sysbus_init_irq(dev, &s->timer[1]->irq);
 333     sysbus_init_irq(dev, &s->timer[2]->irq);
 334
 335     iomemtype = cpu_register_io_memory(icp_pit_readfn,
 336                                        icp_pit_writefn, s,
 337                                        DEVICE_NATIVE_ENDIAN);
 338     sysbus_init_mmio(dev, 0x1000, iomemtype);
 339     /* This device has no state to save/restore.  The component timers will
 340        save themselves.  */
 341     return 0;
 342 }
 343
 344 static void arm_timer_register_devices(void)
 345 {
 346     sysbus_register_dev("integrator_pit", sizeof(icp_pit_state), icp_pit_init);
 347     sysbus_register_dev("sp804", sizeof(sp804_state), sp804_init);
 348 }
 349
 350 device_init(arm_timer_register_devices)