vcs.maemo.org Git - qemu/blob - hw/slavio_intctl.c

   1 /*
   2  * QEMU Sparc SLAVIO interrupt controller emulation
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "vl.h"
  25 //#define DEBUG_IRQ_COUNT
  26 //#define DEBUG_IRQ
  27
  28 #ifdef DEBUG_IRQ
  29 #define DPRINTF(fmt, args...) \
  30 do { printf("IRQ: " fmt , ##args); } while (0)
  31 #else
  32 #define DPRINTF(fmt, args...)
  33 #endif
  34
  35 /*
  36  * Registers of interrupt controller in sun4m.
  37  *
  38  * This is the interrupt controller part of chip STP2001 (Slave I/O), also
  39  * produced as NCR89C105. See
  40  * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C105.txt
  41  *
  42  * There is a system master controller and one for each cpu.
  43  *
  44  */
  45
  46 #define MAX_CPUS 16
  47
  48 typedef struct SLAVIO_INTCTLState {
  49     uint32_t intreg_pending[MAX_CPUS];
  50     uint32_t intregm_pending;
  51     uint32_t intregm_disabled;
  52     uint32_t target_cpu;
  53 #ifdef DEBUG_IRQ_COUNT
  54     uint64_t irq_count[32];
  55 #endif
  56 } SLAVIO_INTCTLState;
  57
  58 #define INTCTL_MAXADDR 0xf
  59 #define INTCTLM_MAXADDR 0xf
  60 static void slavio_check_interrupts(void *opaque);
  61
  62 // per-cpu interrupt controller
  63 static uint32_t slavio_intctl_mem_readl(void *opaque, target_phys_addr_t addr)
  64 {
  65     SLAVIO_INTCTLState *s = opaque;
  66     uint32_t saddr;
  67     int cpu;
  68
  69     cpu = (addr & (MAX_CPUS - 1) * TARGET_PAGE_SIZE) >> 12;
  70     saddr = (addr & INTCTL_MAXADDR) >> 2;
  71     switch (saddr) {
  72     case 0:
  73         return s->intreg_pending[cpu];
  74     default:
  75         break;
  76     }
  77     return 0;
  78 }
  79
  80 static void slavio_intctl_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
  81 {
  82     SLAVIO_INTCTLState *s = opaque;
  83     uint32_t saddr;
  84     int cpu;
  85
  86     cpu = (addr & (MAX_CPUS - 1) * TARGET_PAGE_SIZE) >> 12;
  87     saddr = (addr & INTCTL_MAXADDR) >> 2;
  88     switch (saddr) {
  89     case 1: // clear pending softints
  90         if (val & 0x4000)
  91             val |= 80000000;
  92         val &= 0xfffe0000;
  93         s->intreg_pending[cpu] &= ~val;
  94         DPRINTF("Cleared cpu %d irq mask %x, curmask %x\n", cpu, val, s->intreg_pending[cpu]);
  95         break;
  96     case 2: // set softint
  97         val &= 0xfffe0000;
  98         s->intreg_pending[cpu] |= val;
  99         DPRINTF("Set cpu %d irq mask %x, curmask %x\n", cpu, val, s->intreg_pending[cpu]);
 100         break;
 101     default:
 102         break;
 103     }
 104 }
 105
 106 static CPUReadMemoryFunc *slavio_intctl_mem_read[3] = {
 107     slavio_intctl_mem_readl,
 108     slavio_intctl_mem_readl,
 109     slavio_intctl_mem_readl,
 110 };
 111
 112 static CPUWriteMemoryFunc *slavio_intctl_mem_write[3] = {
 113     slavio_intctl_mem_writel,
 114     slavio_intctl_mem_writel,
 115     slavio_intctl_mem_writel,
 116 };
 117
 118 // master system interrupt controller
 119 static uint32_t slavio_intctlm_mem_readl(void *opaque, target_phys_addr_t addr)
 120 {
 121     SLAVIO_INTCTLState *s = opaque;
 122     uint32_t saddr;
 123
 124     saddr = (addr & INTCTLM_MAXADDR) >> 2;
 125     switch (saddr) {
 126     case 0:
 127         return s->intregm_pending & 0x7fffffff;
 128     case 1:
 129         return s->intregm_disabled;
 130     case 4:
 131         return s->target_cpu;
 132     default:
 133         break;
 134     }
 135     return 0;
 136 }
 137
 138 static void slavio_intctlm_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
 139 {
 140     SLAVIO_INTCTLState *s = opaque;
 141     uint32_t saddr;
 142
 143     saddr = (addr & INTCTLM_MAXADDR) >> 2;
 144     switch (saddr) {
 145     case 2: // clear (enable)
 146         // Force clear unused bits
 147         val &= ~0x4fb2007f;
 148         s->intregm_disabled &= ~val;
 149         DPRINTF("Enabled master irq mask %x, curmask %x\n", val, s->intregm_disabled);
 150         slavio_check_interrupts(s);
 151         break;
 152     case 3: // set (disable, clear pending)
 153         // Force clear unused bits
 154         val &= ~0x4fb2007f;
 155         s->intregm_disabled |= val;
 156         s->intregm_pending &= ~val;
 157         DPRINTF("Disabled master irq mask %x, curmask %x\n", val, s->intregm_disabled);
 158         break;
 159     case 4:
 160         s->target_cpu = val & (MAX_CPUS - 1);
 161         DPRINTF("Set master irq cpu %d\n", s->target_cpu);
 162         break;
 163     default:
 164         break;
 165     }
 166 }
 167
 168 static CPUReadMemoryFunc *slavio_intctlm_mem_read[3] = {
 169     slavio_intctlm_mem_readl,
 170     slavio_intctlm_mem_readl,
 171     slavio_intctlm_mem_readl,
 172 };
 173
 174 static CPUWriteMemoryFunc *slavio_intctlm_mem_write[3] = {
 175     slavio_intctlm_mem_writel,
 176     slavio_intctlm_mem_writel,
 177     slavio_intctlm_mem_writel,
 178 };
 179
 180 void slavio_pic_info(void *opaque)
 181 {
 182     SLAVIO_INTCTLState *s = opaque;
 183     int i;
 184
 185     for (i = 0; i < MAX_CPUS; i++) {
 186         term_printf("per-cpu %d: pending 0x%08x\n", i, s->intreg_pending[i]);
 187     }
 188     term_printf("master: pending 0x%08x, disabled 0x%08x\n", s->intregm_pending, s->intregm_disabled);
 189 }
 190
 191 void slavio_irq_info(void *opaque)
 192 {
 193 #ifndef DEBUG_IRQ_COUNT
 194     term_printf("irq statistic code not compiled.\n");
 195 #else
 196     SLAVIO_INTCTLState *s = opaque;
 197     int i;
 198     int64_t count;
 199
 200     term_printf("IRQ statistics:\n");
 201     for (i = 0; i < 32; i++) {
 202         count = s->irq_count[i];
 203         if (count > 0)
 204             term_printf("%2d: %lld\n", i, count);
 205     }
 206 #endif
 207 }
 208
 209 static const uint32_t intbit_to_level[32] = {
 210     2, 3, 5, 7, 9, 11, 0, 14,   3, 5, 7, 9, 11, 13, 12, 12,
 211     6, 0, 4, 10, 8, 0, 11, 0,   0, 0, 0, 0, 15, 0, 15, 0,
 212 };
 213
 214 static void slavio_check_interrupts(void *opaque)
 215 {
 216     CPUState *env;
 217     SLAVIO_INTCTLState *s = opaque;
 218     uint32_t pending = s->intregm_pending;
 219     unsigned int i, max = 0;
 220
 221     pending &= ~s->intregm_disabled;
 222
 223     if (pending && !(s->intregm_disabled & 0x80000000)) {
 224         for (i = 0; i < 32; i++) {
 225             if (pending & (1 << i)) {
 226                 if (max < intbit_to_level[i])
 227                     max = intbit_to_level[i];
 228             }
 229         }
 230         env = first_cpu;
 231         if (env->interrupt_index == 0) {
 232             DPRINTF("Triggered pil %d\n", max);
 233 #ifdef DEBUG_IRQ_COUNT
 234             s->irq_count[max]++;
 235 #endif
 236             env->interrupt_index = TT_EXTINT | max;
 237             cpu_interrupt(env, CPU_INTERRUPT_HARD);
 238         }
 239         else
 240             DPRINTF("Not triggered (pending %x), pending exception %x\n", pending, env->interrupt_index);
 241     }
 242     else
 243         DPRINTF("Not triggered (pending %x), disabled %x\n", pending, s->intregm_disabled);
 244 }
 245
 246 /*
 247  * "irq" here is the bit number in the system interrupt register to
 248  * separate serial and keyboard interrupts sharing a level.
 249  */
 250 void slavio_pic_set_irq(void *opaque, int irq, int level)
 251 {
 252     SLAVIO_INTCTLState *s = opaque;
 253
 254     DPRINTF("Set irq %d level %d\n", irq, level);
 255     if (irq < 32) {
 256         uint32_t mask = 1 << irq;
 257         uint32_t pil = intbit_to_level[irq];
 258         if (pil > 0) {
 259             if (level) {
 260                 s->intregm_pending |= mask;
 261                 s->intreg_pending[s->target_cpu] |= 1 << pil;
 262             }
 263             else {
 264                 s->intregm_pending &= ~mask;
 265                 s->intreg_pending[s->target_cpu] &= ~(1 << pil);
 266             }
 267         }
 268     }
 269     slavio_check_interrupts(s);
 270 }
 271
 272 static void slavio_intctl_save(QEMUFile *f, void *opaque)
 273 {
 274     SLAVIO_INTCTLState *s = opaque;
 275     int i;
 276
 277     for (i = 0; i < MAX_CPUS; i++) {
 278         qemu_put_be32s(f, &s->intreg_pending[i]);
 279     }
 280     qemu_put_be32s(f, &s->intregm_pending);
 281     qemu_put_be32s(f, &s->intregm_disabled);
 282     qemu_put_be32s(f, &s->target_cpu);
 283 }
 284
 285 static int slavio_intctl_load(QEMUFile *f, void *opaque, int version_id)
 286 {
 287     SLAVIO_INTCTLState *s = opaque;
 288     int i;
 289
 290     if (version_id != 1)
 291         return -EINVAL;
 292
 293     for (i = 0; i < MAX_CPUS; i++) {
 294         qemu_get_be32s(f, &s->intreg_pending[i]);
 295     }
 296     qemu_get_be32s(f, &s->intregm_pending);
 297     qemu_get_be32s(f, &s->intregm_disabled);
 298     qemu_get_be32s(f, &s->target_cpu);
 299     return 0;
 300 }
 301
 302 static void slavio_intctl_reset(void *opaque)
 303 {
 304     SLAVIO_INTCTLState *s = opaque;
 305     int i;
 306
 307     for (i = 0; i < MAX_CPUS; i++) {
 308         s->intreg_pending[i] = 0;
 309     }
 310     s->intregm_disabled = ~0xffb2007f;
 311     s->intregm_pending = 0;
 312     s->target_cpu = 0;
 313 }
 314
 315 void *slavio_intctl_init(uint32_t addr, uint32_t addrg)
 316 {
 317     int slavio_intctl_io_memory, slavio_intctlm_io_memory, i;
 318     SLAVIO_INTCTLState *s;
 319
 320     s = qemu_mallocz(sizeof(SLAVIO_INTCTLState));
 321     if (!s)
 322         return NULL;
 323
 324     for (i = 0; i < MAX_CPUS; i++) {
 325         slavio_intctl_io_memory = cpu_register_io_memory(0, slavio_intctl_mem_read, slavio_intctl_mem_write, s);
 326         cpu_register_physical_memory(addr + i * TARGET_PAGE_SIZE, INTCTL_MAXADDR, slavio_intctl_io_memory);
 327     }
 328
 329     slavio_intctlm_io_memory = cpu_register_io_memory(0, slavio_intctlm_mem_read, slavio_intctlm_mem_write, s);
 330     cpu_register_physical_memory(addrg, INTCTLM_MAXADDR, slavio_intctlm_io_memory);
 331
 332     register_savevm("slavio_intctl", addr, 1, slavio_intctl_save, slavio_intctl_load, s);
 333     qemu_register_reset(slavio_intctl_reset, s);
 334     slavio_intctl_reset(s);
 335     return s;
 336 }
 337