X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=hw%2Fslavio_timer.c;h=1b17a3d3729ef1e9226cc93c0f04131d36ba188e;hb=cd346349b45ef056f138a184f660b8c34c3213cc;hp=2ade17788e248c2afdceeaa6dbfe372aa0c02bf7;hpb=d7edfd27021b36c5ca065293e13639e139ddd5da;p=qemu diff --git a/hw/slavio_timer.c b/hw/slavio_timer.c index 2ade177..1b17a3d 100644 --- a/hw/slavio_timer.c +++ b/hw/slavio_timer.c @@ -2,7 +2,7 @@ * QEMU Sparc SLAVIO timer controller emulation * * Copyright (c) 2003-2005 Fabrice Bellard - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights @@ -38,7 +38,7 @@ do { printf("TIMER: " fmt , ##args); } while (0) * This is the timer/counter part of chip STP2001 (Slave I/O), also * produced as NCR89C105. See * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C105.txt - * + * * The 31-bit counter is incremented every 500ns by bit 9. Bits 8..0 * are zero. Bit 31 is 1 when count has been reached. * @@ -47,17 +47,30 @@ do { printf("TIMER: " fmt , ##args); } while (0) * */ +#define MAX_CPUS 16 + typedef struct SLAVIO_TIMERState { qemu_irq irq; ptimer_state *timer; uint32_t count, counthigh, reached; uint64_t limit; - int stopped; - int mode; // 0 = processor, 1 = user, 2 = system + // processor only + int running; + struct SLAVIO_TIMERState *master; + int slave_index; + // system only + struct SLAVIO_TIMERState *slave[MAX_CPUS]; + uint32_t slave_mode; } SLAVIO_TIMERState; #define TIMER_MAXADDR 0x1f -#define TIMER_SIZE (TIMER_MAXADDR + 1) +#define SYS_TIMER_SIZE 0x14 +#define CPU_TIMER_SIZE 0x10 + +static int slavio_timer_is_user(SLAVIO_TIMERState *s) +{ + return s->master && (s->master->slave_mode & (1 << s->slave_index)); +} // Update count, set irq, update expire_time // Convert from ptimer countdown units @@ -79,9 +92,10 @@ static void slavio_timer_irq(void *opaque) slavio_timer_get_out(s); DPRINTF("callback: count %x%08x\n", s->counthigh, s->count); - s->reached = 0x80000000; - if (s->mode != 1) - qemu_irq_raise(s->irq); + if (!slavio_timer_is_user(s)) { + s->reached = 0x80000000; + qemu_irq_raise(s->irq); + } } static uint32_t slavio_timer_mem_readl(void *opaque, target_phys_addr_t addr) @@ -92,37 +106,41 @@ static uint32_t slavio_timer_mem_readl(void *opaque, target_phys_addr_t addr) saddr = (addr & TIMER_MAXADDR) >> 2; switch (saddr) { case 0: - // read limit (system counter mode) or read most signifying - // part of counter (user mode) - if (s->mode != 1) { - // clear irq + // read limit (system counter mode) or read most signifying + // part of counter (user mode) + if (slavio_timer_is_user(s)) { + // read user timer MSW + slavio_timer_get_out(s); + ret = s->counthigh; + } else { + // read limit + // clear irq qemu_irq_lower(s->irq); - s->reached = 0; + s->reached = 0; ret = s->limit & 0x7fffffff; - } - else { - slavio_timer_get_out(s); - ret = s->counthigh & 0x7fffffff; - } + } break; case 1: - // read counter and reached bit (system mode) or read lsbits - // of counter (user mode) - slavio_timer_get_out(s); - if (s->mode != 1) - ret = (s->count & 0x7fffffff) | s->reached; - else - ret = s->count; + // read counter and reached bit (system mode) or read lsbits + // of counter (user mode) + slavio_timer_get_out(s); + if (slavio_timer_is_user(s)) // read user timer LSW + ret = s->count & 0xffffffe00; + else // read limit + ret = (s->count & 0x7ffffe00) | s->reached; break; case 3: - // read start/stop status - ret = s->stopped; + // only available in processor counter/timer + // read start/stop status + ret = s->running; break; case 4: - // read user/system mode - ret = s->mode & 1; + // only available in system counter + // read user/system mode + ret = s->slave_mode; break; default: + DPRINTF("invalid read address " TARGET_FMT_plx "\n", addr); ret = 0; break; } @@ -141,42 +159,75 @@ static void slavio_timer_mem_writel(void *opaque, target_phys_addr_t addr, uint3 saddr = (addr & TIMER_MAXADDR) >> 2; switch (saddr) { case 0: - // set limit, reset counter - reload = 1; - qemu_irq_lower(s->irq); - // fall through + if (slavio_timer_is_user(s)) { + // set user counter MSW, reset counter + qemu_irq_lower(s->irq); + s->limit = 0x7ffffffffffffe00ULL; + DPRINTF("processor %d user timer reset\n", s->slave_index); + ptimer_set_limit(s->timer, s->limit >> 9, 1); + } else { + // set limit, reset counter + qemu_irq_lower(s->irq); + s->limit = val & 0x7ffffe00ULL; + if (!s->limit) + s->limit = 0x7ffffe00ULL; + ptimer_set_limit(s->timer, s->limit >> 9, 1); + } + break; + case 1: + if (slavio_timer_is_user(s)) { + // set user counter LSW, reset counter + qemu_irq_lower(s->irq); + s->limit = 0x7ffffffffffffe00ULL; + DPRINTF("processor %d user timer reset\n", s->slave_index); + ptimer_set_limit(s->timer, s->limit >> 9, 1); + } else + DPRINTF("not user timer\n"); + break; case 2: - // set limit without resetting counter + // set limit without resetting counter s->limit = val & 0x7ffffe00ULL; if (!s->limit) s->limit = 0x7ffffe00ULL; ptimer_set_limit(s->timer, s->limit >> 9, reload); - break; + break; case 3: - // start/stop user counter - if (s->mode == 1) { - if (val & 1) { - ptimer_stop(s->timer); - s->stopped = 1; - } - else { + if (slavio_timer_is_user(s)) { + // start/stop user counter + if ((val & 1) && !s->running) { + DPRINTF("processor %d user timer started\n", s->slave_index); ptimer_run(s->timer, 0); - s->stopped = 0; - } - } - break; - case 4: - // bit 0: user (1) or system (0) counter mode - if (s->mode == 0 || s->mode == 1) - s->mode = val & 1; - if (s->mode == 1) { - qemu_irq_lower(s->irq); - s->limit = -1ULL; + s->running = 1; + } else if (!(val & 1) && s->running) { + DPRINTF("processor %d user timer stopped\n", s->slave_index); + ptimer_stop(s->timer); + s->running = 0; + } } - ptimer_set_limit(s->timer, s->limit >> 9, 1); - break; + break; + case 4: + if (s->master == NULL) { + unsigned int i; + + for (i = 0; i < MAX_CPUS; i++) { + if (val & (1 << i)) { + qemu_irq_lower(s->slave[i]->irq); + s->slave[i]->limit = -1ULL; + } + if ((val & (1 << i)) != (s->slave_mode & (1 << i))) { + ptimer_stop(s->slave[i]->timer); + ptimer_set_limit(s->slave[i]->timer, s->slave[i]->limit >> 9, 1); + DPRINTF("processor %d timer changed\n", s->slave[i]->slave_index); + ptimer_run(s->slave[i]->timer, 0); + } + } + s->slave_mode = val & ((1 << MAX_CPUS) - 1); + } else + DPRINTF("not system timer\n"); + break; default: - break; + DPRINTF("invalid write address " TARGET_FMT_plx "\n", addr); + break; } } @@ -201,8 +252,8 @@ static void slavio_timer_save(QEMUFile *f, void *opaque) qemu_put_be32s(f, &s->counthigh); qemu_put_be32(f, 0); // Was irq qemu_put_be32s(f, &s->reached); - qemu_put_be32s(f, &s->stopped); - qemu_put_be32s(f, &s->mode); + qemu_put_be32s(f, &s->running); + qemu_put_be32s(f, 0); // Was mode qemu_put_ptimer(f, s->timer); } @@ -210,7 +261,7 @@ static int slavio_timer_load(QEMUFile *f, void *opaque, int version_id) { SLAVIO_TIMERState *s = opaque; uint32_t tmp; - + if (version_id != 2) return -EINVAL; @@ -219,8 +270,8 @@ static int slavio_timer_load(QEMUFile *f, void *opaque, int version_id) qemu_get_be32s(f, &s->counthigh); qemu_get_be32s(f, &tmp); // Was irq qemu_get_be32s(f, &s->reached); - qemu_get_be32s(f, &s->stopped); - qemu_get_be32s(f, &s->mode); + qemu_get_be32s(f, &s->running); + qemu_get_be32s(f, &tmp); // Was mode qemu_get_ptimer(f, s->timer); return 0; @@ -230,17 +281,22 @@ static void slavio_timer_reset(void *opaque) { SLAVIO_TIMERState *s = opaque; - s->limit = 0x7ffffe00ULL; + if (slavio_timer_is_user(s)) + s->limit = 0x7ffffffffffffe00ULL; + else + s->limit = 0x7ffffe00ULL; s->count = 0; s->reached = 0; - s->mode &= 2; ptimer_set_limit(s->timer, s->limit >> 9, 1); ptimer_run(s->timer, 0); - s->stopped = 1; + s->running = 1; qemu_irq_lower(s->irq); } -void slavio_timer_init(target_phys_addr_t addr, qemu_irq irq, int mode) +static SLAVIO_TIMERState *slavio_timer_init(target_phys_addr_t addr, + qemu_irq irq, + SLAVIO_TIMERState *master, + int slave_index) { int slavio_timer_io_memory; SLAVIO_TIMERState *s; @@ -248,17 +304,38 @@ void slavio_timer_init(target_phys_addr_t addr, qemu_irq irq, int mode) s = qemu_mallocz(sizeof(SLAVIO_TIMERState)); if (!s) - return; + return s; s->irq = irq; - s->mode = mode; + s->master = master; + s->slave_index = slave_index; bh = qemu_bh_new(slavio_timer_irq, s); s->timer = ptimer_init(bh); ptimer_set_period(s->timer, 500ULL); slavio_timer_io_memory = cpu_register_io_memory(0, slavio_timer_mem_read, - slavio_timer_mem_write, s); - cpu_register_physical_memory(addr, TIMER_SIZE, slavio_timer_io_memory); + slavio_timer_mem_write, s); + if (master) + cpu_register_physical_memory(addr, CPU_TIMER_SIZE, slavio_timer_io_memory); + else + cpu_register_physical_memory(addr, SYS_TIMER_SIZE, slavio_timer_io_memory); register_savevm("slavio_timer", addr, 2, slavio_timer_save, slavio_timer_load, s); qemu_register_reset(slavio_timer_reset, s); slavio_timer_reset(s); + + return s; +} + +void slavio_timer_init_all(target_phys_addr_t base, qemu_irq master_irq, + qemu_irq *cpu_irqs) +{ + SLAVIO_TIMERState *master; + unsigned int i; + + master = slavio_timer_init(base + 0x10000ULL, master_irq, NULL, 0); + + for (i = 0; i < MAX_CPUS; i++) { + master->slave[i] = slavio_timer_init(base + (target_phys_addr_t) + (i * TARGET_PAGE_SIZE), + cpu_irqs[i], master, i); + } }