PTimer fixes/features and ARM MPTimer conversion

Due to rounding down performed by ptimer_get_count, it returns counter - 1 for the active timer. That's incorrect because counter should decrement only after period been expired, not before. I.e. if running timer has been loaded with value X, then timer counter should stay with X until period expired and decrement after. Fix this by adding 1 to the counter value for the active and unexpired timer.

Signed-off-by Dmitry Osipenko <[email protected]>

---
  hw/core/ptimer.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)

hw/core/ptimer.c +0 -0

index 62f8cb1..b2044fb 100644

There is possibility to return timer counter = limit + 1, if the following ptimer calls execute in less than 1ns.

30.01.2016 19:43, Dmitry Osipenko пишет:

Quoted 23 lines

Due to rounding down performed by ptimer_get_count, it returns counter - 1 for
the active timer. That's incorrect because counter should decrement only after
period been expired, not before. I.e. if running timer has been loaded with
value X, then timer counter should stay with X until period expired and decrement after. Fix this by adding 1 to the counter value for the active and
unexpired timer.

Signed-off-by Dmitry Osipenko <[email protected]>

---
  hw/core/ptimer.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)

hw/core/ptimer.c +0 -0

index 62f8cb1..b2044fb 100644

hw/core/ptimer.c uint64_t ptimer_get_count(ptimer_state *s) · line 142

Quoted 8 lines

hw/core/ptimer.c +1 -1

@@ -136,7 +136,7 @@ uint64_t ptimer_get_count(ptimer_state *s)
                  if ((uint32_t)(period_frac << shift))
                      div += 1;
              }
-            counter = rem / div;
+            counter = rem / div + (expired ? 0 : 1);
 
              if (expired && counter != 0) {
                  /* Wrap around periodic counter.  */

Noticed one nit here:

There is possibility to return timer counter = limit + 1, if the following ptimer calls execute in less than 1ns.

        ptimer_run(t, 1);
        // counter = 91, if set() count executed in less than 1ns
        ptimer_set_count(t, 90);
        counter = ptimer_get_count(t);

Likely, it would be impossible to trigger that issue on a real current machine.
But the fix is trivial, I'll incorporate it in V13 if it looks fine:

---

(quoted diff) +2 -2

@@ -76,20 +76,20 @@ static void ptimer_tick(void *opaque)
 {
     ptimer_state *s = (ptimer_state *)opaque;
     s->delta = 0;
     ptimer_reload(s);
 }
 
 uint64_t ptimer_get_count(ptimer_state *s)
 {
+    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
     uint64_t counter;
 
-    if (s->enabled && s->delta != 0) {
-        int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
+    if (s->enabled && s->delta != 0 && now != s->last_event) {
         int64_t next = s->next_event;
         bool expired = (now - next >= 0);
         bool oneshot = (s->enabled == 2);
 
         /* Figure out the current counter value.  */
         if (expired && (oneshot || use_icount)) {
             /* Prevent timer underflowing if it should already have
                triggered.  */

@@ -131,17 +131,17 @@ uint64_t ptimer_get_count(ptimer_state *s)
             } else {
                 if (shift != 0)
                     div |= (period_frac >> (32 - shift));
                 /* Look at remaining bits of period_frac and round div up

if

                    necessary.  */
                 if ((uint32_t)(period_frac << shift))
                     div += 1;
             }

             if (expired && counter != 0) {
                 /* Wrap around periodic counter.  */
                 counter = s->limit - (counter - 1) % s->limit;
             }
         }
     } else {
         counter = s->delta;

--
Dmitry

Quoted 82 lines

30.01.2016 19:43, Dmitry Osipenko пишет:

Quoted 23 lines

Due to rounding down performed by ptimer_get_count, it returns counter - 1 for
the active timer. That's incorrect because counter should decrement only after
period been expired, not before. I.e. if running timer has been loaded with
value X, then timer counter should stay with X until period expired and decrement after. Fix this by adding 1 to the counter value for the active and
unexpired timer.

Signed-off-by Dmitry Osipenko <[email protected]>

---
   hw/core/ptimer.c | 2 +-
   1 file changed, 1 insertion(+), 1 deletion(-)

hw/core/ptimer.c +0 -0

index 62f8cb1..b2044fb 100644

hw/core/ptimer.c uint64_t ptimer_get_count(ptimer_state *s) · line 142

Quoted 8 lines

hw/core/ptimer.c +1 -1

@@ -136,7 +136,7 @@ uint64_t ptimer_get_count(ptimer_state *s)
                   if ((uint32_t)(period_frac << shift))
                       div += 1;
               }
-            counter = rem / div;
+            counter = rem / div + (expired ? 0 : 1);
 
               if (expired && counter != 0) {
                   /* Wrap around periodic counter.  */

Noticed one nit here:

There is possibility to return timer counter = limit + 1, if the following ptimer calls execute in less than 1ns.

         ptimer_run(t, 1);
         // counter = 91, if set() count executed in less than 1ns
         ptimer_set_count(t, 90);
         counter = ptimer_get_count(t);

Likely, it would be impossible to trigger that issue on a real current machine.
But the fix is trivial, I'll incorporate it in V13 if it looks fine:

---

(quoted diff) +2 -2

@@ -76,20 +76,20 @@ static void ptimer_tick(void *opaque)
  {
      ptimer_state *s = (ptimer_state *)opaque;
      s->delta = 0;
      ptimer_reload(s);
  }
 
  uint64_t ptimer_get_count(ptimer_state *s)
  {
+    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
      uint64_t counter;
 
-    if (s->enabled && s->delta != 0) {
-        int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
+    if (s->enabled && s->delta != 0 && now != s->last_event) {
          int64_t next = s->next_event;
          bool expired = (now - next >= 0);
          bool oneshot = (s->enabled == 2);
 
          /* Figure out the current counter value.  */
          if (expired && (oneshot || use_icount)) {
              /* Prevent timer underflowing if it should already have
                 triggered.  */

@@ -131,17 +131,17 @@ uint64_t ptimer_get_count(ptimer_state *s)
              } else {
                  if (shift != 0)
                      div |= (period_frac >> (32 - shift));
                  /* Look at remaining bits of period_frac and round div up

if

                     necessary.  */
                  if ((uint32_t)(period_frac << shift))
                      div += 1;
              }

hw/core/ptimer.c uint64_t ptimer_get_count(ptimer_state *s) · line 139

Quoted 2 lines

hw/core/ptimer.c +1 -1

-            counter = rem / div;
+            counter = rem / div + (expired ? 0 : 1);

Sorry about the long delays. Im wondering what this has to do with expiration though? the commit message suggests you want to change the rounding scheme, so can that be done directly with DIV_ROUND_UP?

Regards,
Peter

Quoted 11 lines

              if (expired && counter != 0) {
                  /* Wrap around periodic counter.  */
                  counter = s->limit - (counter - 1) % s->limit;
              }
          }
      } else {
          counter = s->delta;

--
Dmitry

Current ARM MPTimer implementation uses QEMUTimer for the actual timer, this implementation isn't complete and mostly tries to duplicate of what generic ptimer is already doing fine.

Conversion to ptimer brings the following benefits and fixes:
- Simple timer pausing implementation
- Fixes counter value preservation after stopping the timer
- Correctly handles prescaler != 0 / counter = 0 / load = 0 cases
- Code simplification and reduction

Bump VMSD to version 3, since VMState is changed and is not compatible with the previous implementation.

Signed-off-by Dmitry Osipenko <[email protected]>

---
 hw/timer/arm_mptimer.c         | 133 +++++++++++++++++++++--------------------
 include/hw/timer/arm_mptimer.h |   5 +-
 2 files changed, 70 insertions(+), 68 deletions(-)

hw/timer/arm_mptimer.c +69 -64

index 5dfab66..f002458 100644
@@ -19,8 +19,9 @@
  * with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "hw/ptimer.h"
 #include "hw/timer/arm_mptimer.h"
-#include "qemu/timer.h"
+#include "qemu/main-loop.h"
 #include "qom/cpu.h"
 
 /* This device implements the per-cpu private timer and watchdog block

@@ -42,55 +43,54 @@ static inline void timerblock_update_irq(TimerBlock *tb)
 }
 
 /* Return conversion factor from mpcore timer ticks to qemu timer ticks.  */
-static inline uint32_t timerblock_scale(TimerBlock *tb)
+static inline uint32_t timerblock_scale(uint32_t control)
 {
-    return (((tb->control >> 8) & 0xff) + 1) * 10;
+    return (((control >> 8) & 0xff) + 1) * 10;
 }
 
-static void timerblock_reload(TimerBlock *tb, int restart)
+static inline void timerblock_set_count(struct ptimer_state *timer,
+                                        uint32_t control, uint64_t *count)
 {
-    if (tb->count == 0) {
-        return;
+    /* PTimer would immediately trigger interrupt for periodic timer
+     * when counter set to 0, MPtimer under certain condition only.
+     */
+    if ((control & 3) == 3 && (control & 0xff00) == 0 && *count == 0) {
+        *count = ptimer_get_limit(timer);
     }
-    if (restart) {
-        tb->tick = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
+    ptimer_set_count(timer, *count);
+}
+
+static inline void timerblock_run(struct ptimer_state *timer,
+                                  uint32_t control, uint32_t load)
+{
+    if ((control & 1) && ((control & 0xff00) || load != 0)) {
+        ptimer_run(timer, !(control & 2));
     }
-    tb->tick += (int64_t)tb->count * timerblock_scale(tb);
-    timer_mod(tb->timer, tb->tick);
 }
 
 static void timerblock_tick(void *opaque)
 {
     TimerBlock *tb = (TimerBlock *)opaque;
     tb->status = 1;
-    if (tb->control & 2) {
-        tb->count = tb->load;
-        timerblock_reload(tb, 0);
-    } else {
-        tb->count = 0;
-    }
     timerblock_update_irq(tb);
+    /* Periodic timer with load = 0 and prescaler != 0 would re-trigger
+     * IRQ after one period, otherwise it either stops or wraps around.
+     */
+    if ((tb->control & 2) && (tb->control & 0xff00) &&
+            ptimer_get_limit(tb->timer) == 0) {
+        ptimer_run(tb->timer, 0);
+    }
 }
 
 static uint64_t timerblock_read(void *opaque, hwaddr addr,
                                 unsigned size)
 {
     TimerBlock *tb = (TimerBlock *)opaque;
-    int64_t val;
     switch (addr) {
     case 0: /* Load */
-        return tb->load;
+        return ptimer_get_limit(tb->timer);
     case 4: /* Counter.  */
-        if (((tb->control & 1) == 0) || (tb->count == 0)) {
-            return 0;
-        }
-        /* Slow and ugly, but hopefully won't happen too often.  */
-        val = tb->tick - qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
-        val /= timerblock_scale(tb);
-        if (val < 0) {
-            val = 0;
-        }
-        return val;
+        return ptimer_get_count(tb->timer);
     case 8: /* Control.  */
         return tb->control;
     case 12: /* Interrupt status.  */

@@ -104,37 +104,45 @@ static void timerblock_write(void *opaque, hwaddr addr,
                              uint64_t value, unsigned size)
 {
     TimerBlock *tb = (TimerBlock *)opaque;
-    int64_t old;
+    uint32_t control = tb->control;
     switch (addr) {
     case 0: /* Load */
-        tb->load = value;
-        /* Fall through.  */
-    case 4: /* Counter.  */
-        if ((tb->control & 1) && tb->count) {
-            /* Cancel the previous timer.  */
-            timer_del(tb->timer);
+        /* Setting load to 0 stops the timer without doing the tick if
+         * prescaler = 0.
+         */
+        if ((control & 1) && (control & 0xff00) == 0 && value == 0) {
+            ptimer_stop(tb->timer);
         }
-        tb->count = value;
-        if (tb->control & 1) {
-            timerblock_reload(tb, 1);
+        ptimer_set_limit(tb->timer, value, 1);
+        timerblock_run(tb->timer, control, value);
+        break;
+    case 4: /* Counter.  */
+        /* Setting counter to 0 stops the one-shot timer, or periodic with
+         * load == 0, without doing the tick if prescaler = 0.
+         */
+        if ((control & 1) && (control & 0xff00) == 0 && value == 0 &&
+                (!(control & 2) || ptimer_get_limit(tb->timer) == 0)) {
+            ptimer_stop(tb->timer);
         }
+        timerblock_set_count(tb->timer, control, &value);
+        timerblock_run(tb->timer, control, value);
         break;
     case 8: /* Control.  */
-        old = tb->control;
-        tb->control = value;
+        if ((control & 1) && !(value & 1)) {
+            ptimer_stop(tb->timer);
+        }
+        if ((control & 0xff00) != (value & 0xff00)) {
+            ptimer_set_period(tb->timer, timerblock_scale(value));
+        }
         if (value & 1) {
-            if ((old & 1) && (tb->count != 0)) {
-                /* Do nothing if timer is ticking right now.  */
-                break;
+            uint64_t count = ptimer_get_count(tb->timer);
+            /* Re-load periodic timer counter if needed.  */
+            if ((value & 2) && count == 0) {
+                timerblock_set_count(tb->timer, value, &count);
             }
-            if (tb->control & 2) {
-                tb->count = tb->load;
-            }
-            timerblock_reload(tb, 1);
-        } else if (old & 1) {
-            /* Shutdown the timer.  */
-            timer_del(tb->timer);
+            timerblock_run(tb->timer, value, count);
         }
+        tb->control = value;
         break;
     case 12: /* Interrupt status.  */
         tb->status &= ~value;

@@ -184,13 +192,12 @@ static const MemoryRegionOps timerblock_ops = {
 
 static void timerblock_reset(TimerBlock *tb)
 {
-    tb->count = 0;
-    tb->load = 0;
     tb->control = 0;
     tb->status = 0;
-    tb->tick = 0;
     if (tb->timer) {
-        timer_del(tb->timer);
+        ptimer_stop(tb->timer);
+        ptimer_set_limit(tb->timer, 0, 1);
+        ptimer_set_period(tb->timer, timerblock_scale(0));
     }
 }
 

@@ -236,7 +243,8 @@ static void arm_mptimer_realize(DeviceState *dev, Error **errp)
      */
     for (i = 0; i < s->num_cpu; i++) {
         TimerBlock *tb = &s->timerblock[i];
-        tb->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, timerblock_tick, tb);
+        QEMUBH *bh = qemu_bh_new(timerblock_tick, tb);
+        tb->timer = ptimer_init(bh);
         sysbus_init_irq(sbd, &tb->irq);
         memory_region_init_io(&tb->iomem, OBJECT(s), &timerblock_ops, tb,
                               "arm_mptimer_timerblock", 0x20);

@@ -246,26 +254,23 @@ static void arm_mptimer_realize(DeviceState *dev, Error **errp)
 
 static const VMStateDescription vmstate_timerblock = {
     .name = "arm_mptimer_timerblock",
-    .version_id = 2,
-    .minimum_version_id = 2,
+    .version_id = 3,
+    .minimum_version_id = 3,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT32(count, TimerBlock),
-        VMSTATE_UINT32(load, TimerBlock),
         VMSTATE_UINT32(control, TimerBlock),
         VMSTATE_UINT32(status, TimerBlock),
-        VMSTATE_INT64(tick, TimerBlock),
-        VMSTATE_TIMER_PTR(timer, TimerBlock),
+        VMSTATE_PTIMER(timer, TimerBlock),
         VMSTATE_END_OF_LIST()
     }
 };
 
 static const VMStateDescription vmstate_arm_mptimer = {
     .name = "arm_mptimer",
-    .version_id = 2,
-    .minimum_version_id = 2,
+    .version_id = 3,
+    .minimum_version_id = 3,
     .fields = (VMStateField[]) {
         VMSTATE_STRUCT_VARRAY_UINT32(timerblock, ARMMPTimerState, num_cpu,
-                                     2, vmstate_timerblock, TimerBlock),
+                                     3, vmstate_timerblock, TimerBlock),
         VMSTATE_END_OF_LIST()
     }
 };

include/hw/timer/arm_mptimer.h +1 -5

index b34cba0..c46d8d2 100644
@@ -27,12 +27,9 @@
 
 /* State of a single timer or watchdog block */
 typedef struct {
-    uint32_t count;
-    uint32_t load;
     uint32_t control;
     uint32_t status;
-    int64_t tick;
-    QEMUTimer *timer;
+    struct ptimer_state *timer;
     qemu_irq irq;
     MemoryRegion iomem;
 } TimerBlock;
--

2.7.0

It might be necessary by some emulated HW to perform the tick after one period if delta = 0. Given that it is much less churny to implement immediate tick by the ptimer user itself, let's make ptimer do the delayed tick.

Signed-off-by Dmitry Osipenko <[email protected]>

---
 hw/core/ptimer.c | 34 +++++++++++++++-------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

hw/core/ptimer.c +15 -20

index b2044fb..bcd090c 100644
@@ -36,19 +36,7 @@ static void ptimer_reload(ptimer_state *s)
 {
     uint32_t period_frac = s->period_frac;
     uint64_t period = s->period;
-
-    if (s->delta == 0) {
-        ptimer_trigger(s);
-    }
-
-    if (s->delta == 0 && s->enabled == 1) {
-        s->delta = s->limit;
-    }
-
-    if (s->delta == 0) {
-        ptimer_stop(s);
-        return;
-    }
+    uint64_t delta = MAX(1, s->delta);
 
     /*
      * Artificially limit timeout rate to something

@@ -59,15 +47,15 @@ static void ptimer_reload(ptimer_state *s)
      * on the current generation of host machines.
      */
 
-    if (s->enabled == 1 && (s->delta * period < 10000) && !use_icount) {
-        period = 10000 / s->delta;
+    if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
+        period = 10000 / delta;
         period_frac = 0;
     }
 
     s->last_event = s->next_event;
-    s->next_event = s->last_event + s->delta * period;
+    s->next_event = s->last_event + delta * period;
     if (period_frac) {
-        s->next_event += ((int64_t)period_frac * s->delta) >> 32;
+        s->next_event += ((int64_t)period_frac * delta) >> 32;
     }
     timer_mod(s->timer, s->next_event);
 }

@@ -75,8 +63,16 @@ static void ptimer_reload(ptimer_state *s)
 static void ptimer_tick(void *opaque)
 {
     ptimer_state *s = (ptimer_state *)opaque;
-    s->delta = 0;
-    ptimer_reload(s);
+
+    s->delta = (s->enabled == 1) ? s->limit : 0;
+
+    if (s->delta == 0) {
+        s->enabled = 0;
+    } else {
+        ptimer_reload(s);
+    }
+
+    ptimer_trigger(s);
 }
 
 uint64_t ptimer_get_count(ptimer_state *s)
--

2.7.0

Quoted 4 lines

It might be necessary by some emulated HW to perform the tick after one period if delta = 0. Given that it is much less churny to implement immediate tick by the ptimer user itself, let's make ptimer do the delayed tick.

Isn't this related to previous patch? It is kind of a rounding problem that will vary from timer to timer. Some timers may interpret the "tick" as the wrap-around back to the load value (even if that is 0) while others interpret the tick as the transition to zero (makes more sense for a one-shot). It's hard to set a universal policy here.

But is this a non-issue when we consider that event latency (usually interrupt latency) is undefined anyway?

Regards,
Peter

Quoted 72 lines

Signed-off-by Dmitry Osipenko <[email protected]>

---
  hw/core/ptimer.c | 34 +++++++++++++++-------------------
  1 file changed, 15 insertions(+), 19 deletions(-)

hw/core/ptimer.c +15 -20

index b2044fb..bcd090c 100644
@@ -36,19 +36,7 @@ static void ptimer_reload(ptimer_state *s)
  {
      uint32_t period_frac = s->period_frac;
      uint64_t period = s->period;
-
-    if (s->delta == 0) {
-        ptimer_trigger(s);
-    }
-
-    if (s->delta == 0 && s->enabled == 1) {
-        s->delta = s->limit;
-    }
-
-    if (s->delta == 0) {
-        ptimer_stop(s);
-        return;
-    }
+    uint64_t delta = MAX(1, s->delta);
 
      /*
       * Artificially limit timeout rate to something

@@ -59,15 +47,15 @@ static void ptimer_reload(ptimer_state *s)
       * on the current generation of host machines.
       */
 
-    if (s->enabled == 1 && (s->delta * period < 10000) && !use_icount) {
-        period = 10000 / s->delta;
+    if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
+        period = 10000 / delta;
          period_frac = 0;
      }
 
      s->last_event = s->next_event;
-    s->next_event = s->last_event + s->delta * period;
+    s->next_event = s->last_event + delta * period;
      if (period_frac) {
-        s->next_event += ((int64_t)period_frac * s->delta) >> 32;
+        s->next_event += ((int64_t)period_frac * delta) >> 32;
      }
      timer_mod(s->timer, s->next_event);
  }

@@ -75,8 +63,16 @@ static void ptimer_reload(ptimer_state *s)
  static void ptimer_tick(void *opaque)
  {
      ptimer_state *s = (ptimer_state *)opaque;
-    s->delta = 0;
-    ptimer_reload(s);
+
+    s->delta = (s->enabled == 1) ? s->limit : 0;
+
+    if (s->delta == 0) {
+        s->enabled = 0;
+    } else {
+        ptimer_reload(s);
+    }
+
+    ptimer_trigger(s);
  }
 
  uint64_t ptimer_get_count(ptimer_state *s)
--

2.7.0

Changelog for ARM MPTimer QEMUTimer to ptimer conversion:

Quoted 1 line

Changelog for ARM MPTimer QEMUTimer to ptimer conversion:

So, where are we with this series? It looked from the mailing list threads as if there were still a few things Peter C hadn't got closure on, but we're rapidly running out of time before hard freeze :-( I'd really rather not have to push it out by yet another release, especially since it got posted back in January..

thanks
-- PMM

Quoted 4 lines

It might be necessary by some emulated HW to perform the tick after one period if delta = 0. Given that it is much less churny to implement immediate tick by the ptimer user itself, let's make ptimer do the delayed tick.

Isn't this related to previous patch? It is kind of a rounding problem

Quoted 1 line

Changelog for ARM MPTimer QEMUTimer to ptimer conversion:

So, where are we with this series? It looked from the mailing list threads as if there were still a few things Peter C hadn't got closure on, but we're rapidly running out of time before hard freeze :-( I'd really rather not have to push it out by yet another release, especially since it got posted back in January..

thanks
-- PMM

Hello Peter,

16.03.2016 17:36, Peter Maydell пишет:

Quoted 11 lines · Dmitry Osipenko

Quoted 2 lines

Changelog for ARM MPTimer QEMUTimer to ptimer conversion:

So, where are we with this series? It looked from the mailing list threads as if there were still a few things Peter C hadn't got closure on, but we're rapidly running out of time before hard freeze :-( I'd really rather not have to push it out by yet another release, especially since it got posted back in January..

It still pending for the review and the due date is tomorrow, maybe you would want to pick some of the PTimer patches for 2.6.

PTimer fixes ready for submission:
[PATCH v12 1/9] hw/ptimer: Fix issues caused by the adjusted timer limit value
[PATCH v12 2/9] hw/ptimer: Perform counter wrap around if timer already expired
[PATCH v12 3/9] hw/ptimer: Update .delta on period/freq change

Quoted 18 lines

Hello Peter,

16.03.2016 17:36, Peter Maydell пишет:

Quoted 11 lines · Dmitry Osipenko

Quoted 2 lines

Changelog for ARM MPTimer QEMUTimer to ptimer conversion:

So, where are we with this series? It looked from the mailing list threads as if there were still a few things Peter C hadn't got closure on, but we're rapidly running out of time before hard freeze :-( I'd really rather not have to push it out by yet another release, especially since it got posted back in January..

It still pending for the review and the due date is tomorrow, maybe you would want to pick some of the PTimer patches for 2.6.

Quoted 6 lines

PTimer fixes ready for submission:
[PATCH v12 1/9] hw/ptimer: Fix issues caused by the adjusted timer limit value
[PATCH v12 2/9] hw/ptimer: Perform counter wrap around if timer already expired
[PATCH v12 3/9] hw/ptimer: Update .delta on period/freq change

I'm afraid at this point I really don't want to apply changes to code like ptimer that affects multiple platforms; this will have to go to 2.7 :-(

29.03.2016 22:00, Peter Maydell пишет:

Quoted 9 lines · Dmitry Osipenko

Quoted 6 lines

PTimer fixes ready for submission:
[PATCH v12 1/9] hw/ptimer: Fix issues caused by the adjusted timer limit value
[PATCH v12 2/9] hw/ptimer: Perform counter wrap around if timer already expired
[PATCH v12 3/9] hw/ptimer: Update .delta on period/freq change

Quoted 3 lines

I'm afraid at this point I really don't want to apply changes to code like ptimer that affects multiple platforms; this will have to go to 2.7 :-(

Okay, this is fine too :)

Quoted 10 lines · Dmitry Osipenko

29.03.2016 22:00, Peter Maydell пишет:

Quoted 9 lines · Dmitry Osipenko

Quoted 6 lines

PTimer fixes ready for submission:
[PATCH v12 1/9] hw/ptimer: Fix issues caused by the adjusted timer limit value
[PATCH v12 2/9] hw/ptimer: Perform counter wrap around if timer already expired
[PATCH v12 3/9] hw/ptimer: Update .delta on period/freq change

Quoted 5 lines

Quoted 3 lines

I'm afraid at this point I really don't want to apply changes to code like ptimer that affects multiple platforms; this will have to go to 2.7 :-(

Okay, this is fine too :)

Can I ask you to rebase this series on master and resend it, please (or at least whichever parts of it you think are ready to go in) ? I'm sorry it's been kind of left in limbo for so long but I promise to look at it when you resend it :-(

thanks
-- PMM