Commit 7bd427d8 authored by Paolo Bonzini's avatar Paolo Bonzini
Browse files

change all rt_clock references to use millisecond resolution accessors 



This was done with:

    sed -i '/get_clock\>.*rt_clock/s/get_clock\>/get_clock_ms/' \
        $(git grep -l 'get_clock\>.*rt_clock' )
    sed -i '/new_timer\>.*rt_clock/s/new_timer\>/new_timer_ms/' \
        $(git grep -l 'new_timer\>.*rt_clock' )

after checking that get_clock and new_timer never occur twice
on the same line.  There were no missed occurrences; however, even
if there had been, they would have been caught by the compiler.

Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 0ce1b948

buffered_file.c

+3 −3
Original line number Diff line number Diff line
@@ -238,7 +238,7 @@ static void buffered_rate_tick(void *opaque) 
        return;

    }



    qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100);

    qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);



    if (s->freeze_output)

        return;
@@ -274,9 +274,9 @@ QEMUFile *qemu_fopen_ops_buffered(void *opaque, 
                             buffered_set_rate_limit,

			     buffered_get_rate_limit);



    s->timer = qemu_new_timer(rt_clock, buffered_rate_tick, s);

    s->timer = qemu_new_timer_ms(rt_clock, buffered_rate_tick, s);



    qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100);

    qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);



    return s->file;

}

console.c

+2 −2
Original line number Diff line number Diff line
@@ -1135,7 +1135,7 @@ static void kbd_send_chars(void *opaque) 
    /* characters are pending: we send them a bit later (XXX:

       horrible, should change char device API) */

    if (s->out_fifo.count > 0) {

        qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1);

        qemu_mod_timer(s->kbd_timer, qemu_get_clock_ms(rt_clock) + 1);

    }

}
@@ -1457,7 +1457,7 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds) 


    s->out_fifo.buf = s->out_fifo_buf;

    s->out_fifo.buf_size = sizeof(s->out_fifo_buf);

    s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s);

    s->kbd_timer = qemu_new_timer_ms(rt_clock, kbd_send_chars, s);

    s->ds = ds;



    if (!color_inited) {

hw/omap1.c

+5 −5
Original line number Diff line number Diff line
@@ -2802,7 +2802,7 @@ static void omap_rtc_reset(struct omap_rtc_s *s) 
    s->pm_am = 0;

    s->auto_comp = 0;

    s->round = 0;

    s->tick = qemu_get_clock(rt_clock);

    s->tick = qemu_get_clock_ms(rt_clock);

    memset(&s->alarm_tm, 0, sizeof(s->alarm_tm));

    s->alarm_tm.tm_mday = 0x01;

    s->status = 1 << 7;
@@ -2822,7 +2822,7 @@ static struct omap_rtc_s *omap_rtc_init(target_phys_addr_t base, 


    s->irq = irq[0];

    s->alarm = irq[1];

    s->clk = qemu_new_timer(rt_clock, omap_rtc_tick, s);

    s->clk = qemu_new_timer_ms(rt_clock, omap_rtc_tick, s);



    omap_rtc_reset(s);
@@ -3399,9 +3399,9 @@ static void omap_lpg_tick(void *opaque) 
    struct omap_lpg_s *s = opaque;



    if (s->cycle)

        qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->period - s->on);

        qemu_mod_timer(s->tm, qemu_get_clock_ms(rt_clock) + s->period - s->on);

    else

        qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->on);

        qemu_mod_timer(s->tm, qemu_get_clock_ms(rt_clock) + s->on);



    s->cycle = !s->cycle;

    printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off");
@@ -3516,7 +3516,7 @@ static struct omap_lpg_s *omap_lpg_init(target_phys_addr_t base, omap_clk clk) 
    struct omap_lpg_s *s = (struct omap_lpg_s *)

            qemu_mallocz(sizeof(struct omap_lpg_s));



    s->tm = qemu_new_timer(rt_clock, omap_lpg_tick, s);

    s->tm = qemu_new_timer_ms(rt_clock, omap_lpg_tick, s);



    omap_lpg_reset(s);

hw/pxa2xx.c

+14 −14
Original line number Diff line number Diff line
@@ -921,7 +921,7 @@ static inline void pxa2xx_rtc_int_update(PXA2xxRTCState *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) /

            (1000 * ((s->rttr & 0xffff) + 1));

    s->last_rdcr += ((rt - s->last_hz) << 15) /
@@ -931,7 +931,7 @@ static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *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))

        s->last_swcr += (rt - s->last_sw) / 10;

    s->last_sw = rt;
@@ -939,7 +939,7 @@ static void pxa2xx_rtc_swupdate(PXA2xxRTCState *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))

        s->last_swcr += rt - s->last_pi;

    s->last_pi = rt;
@@ -1064,16 +1064,16 @@ static uint32_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr) 
    case PIAR:

        return s->piar;

    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));

    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));

    case RYCR:

        return s->last_rycr;

    case SWCR:

        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

            return s->last_swcr;

    default:
@@ -1219,14 +1219,14 @@ static int pxa2xx_rtc_init(SysBusDevice *dev) 
    s->last_swcr = (tm.tm_hour << 19) |

            (tm.tm_min << 13) | (tm.tm_sec << 7);

    s->last_rtcpicr = 0;

    s->last_hz = s->last_sw = s->last_pi = qemu_get_clock(rt_clock);



    s->rtc_hz    = qemu_new_timer(rt_clock, pxa2xx_rtc_hz_tick,    s);

    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);

    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);

hw/twl92230.c

+4 −4
Original line number Diff line number Diff line
@@ -74,14 +74,14 @@ static inline void menelaus_update(MenelausState *s) 


static inline void menelaus_rtc_start(MenelausState *s)

{

    s->rtc.next += qemu_get_clock(rt_clock);

    s->rtc.next += qemu_get_clock_ms(rt_clock);

    qemu_mod_timer(s->rtc.hz_tm, s->rtc.next);

}



static inline void menelaus_rtc_stop(MenelausState *s)

{

    qemu_del_timer(s->rtc.hz_tm);

    s->rtc.next -= qemu_get_clock(rt_clock);

    s->rtc.next -= qemu_get_clock_ms(rt_clock);

    if (s->rtc.next < 1)

        s->rtc.next = 1;

}
@@ -786,7 +786,7 @@ static void menelaus_pre_save(void *opaque) 
{

    MenelausState *s = opaque;

    /* Should be <= 1000 */

    s->rtc_next_vmstate =  s->rtc.next - qemu_get_clock(rt_clock);

    s->rtc_next_vmstate =  s->rtc.next - qemu_get_clock_ms(rt_clock);

}



static int menelaus_post_load(void *opaque, int version_id)
@@ -847,7 +847,7 @@ static int twl92230_init(i2c_slave *i2c) 
{

    MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c);



    s->rtc.hz_tm = qemu_new_timer(rt_clock, menelaus_rtc_hz, s);

    s->rtc.hz_tm = qemu_new_timer_ms(rt_clock, menelaus_rtc_hz, s);

    /* Three output pins plus one interrupt pin.  */

    qdev_init_gpio_out(&i2c->qdev, s->out, 4);

    qdev_init_gpio_in(&i2c->qdev, menelaus_gpio_set, 3);