コミット: ba4443e1f3f8e5f98fd91d9b977bb4ff61d78028 - qemu (git)

コミットメタ情報

• リビジョン: ba4443e1f3f8e5f98fd91d9b977bb4ff61d78028 (tree)
• 日時: 2018-12-12 14:23:32
• 作者: Yoshinori Sato <ysato@user...>
• コミッター: Yoshinori Sato

ログメッセージ

fix interrupt handling

変更サマリ

• modified: hw/intc/rx_icu.c
• modified: hw/rx/rx62n.c
• modified: include/hw/intc/rx_icu.h
• modified: target/rx/cpu.h
• modified: target/rx/helper.c

差分

--- a/hw/intc/rx_icu.c
+++ b/hw/intc/rx_icu.c
@@ -14,13 +14,33 @@
 #include "hw/intc/rx_icu.h"
 #include "qemu/error-report.h"
 
+#define request(icu, n) (icu->ipr[icu->map[n]] << 8 | n)
+
+
+static qemu_irq* rxicu_pin(RXICUState *icu, int n_IRQ)
+{
+   if ((icu->fir & 0x8000) && (icu->fir & 0xff) == n_IRQ)
+        return &icu->_fir;
+   else
+        return &icu->_irq;
+}
+
+static void rxicu_request(RXICUState *icu, int n_IRQ)
+{
+    int enable;
+
+    enable = icu->ier[n_IRQ / 8] & (1 << (n_IRQ & 7));
+    if (enable != 0 && icu->req_irq < 0) {
+        qemu_set_irq(*rxicu_pin(icu, n_IRQ), 0x1000 | request(icu, n_IRQ));
+        icu->req_irq = n_IRQ;
+    }
+}
+
 static void rxicu_set_irq(void *opaque, int n_IRQ, int level)
 {
     RXICUState *icu = opaque;
     struct IRQSource *src;
-    int req;
     int issue;
-    qemu_irq *ir;
 
     if (n_IRQ >= 256) {
         error_report("%s: IRQ %d out of range", __func__, n_IRQ);
@@ -28,14 +48,8 @@ static void rxicu_set_irq(void *opaque, int n_IRQ, int level)
     }
 
     src = &icu->src[n_IRQ];
-    if ((icu->fir & 0x8000) && (icu->fir & 0xff) == n_IRQ) {
-        ir = &icu->_fir;
-        req = 0;
-    } else {
-        ir = &icu->_irq;
-        req = icu->ipr[icu->map[n_IRQ]] << 8 | n_IRQ;
-    }  
 
+    level = (level != 0);
     switch (src->sense) {
     case TRG_LEVEL:
         /* level-sensitive irq */
@@ -55,13 +69,43 @@ static void rxicu_set_irq(void *opaque, int n_IRQ, int level)
         src->level = level;
         break;
     }
-    if (issue) {
-        qemu_set_irq(*ir, 0x1000 | req);
-        icu->ir[n_IRQ] = 1;
-    } else if (src->sense == TRG_LEVEL) {
-        qemu_set_irq(*ir, req);
+    if (issue == 0 && src->sense == TRG_LEVEL) {
         icu->ir[n_IRQ] = 0;
+        if (icu->req_irq == n_IRQ) {
+            qemu_set_irq(*rxicu_pin(icu, n_IRQ), request(icu, n_IRQ));
+            icu->req_irq = -1;
+        }
+        return;
     }
+    if (issue)
+        rxicu_request(icu, n_IRQ);
+}
+
+static void rxicu_ack_irq(void *opaque, int no, int level)
+{
+    RXICUState *icu = opaque;
+    int i;
+    int n_IRQ;
+    int max_pri;
+
+    if (icu->req_irq < 0)
+        return;
+    if (icu->src[icu->req_irq].sense != TRG_LEVEL)
+        icu->ir[icu->req_irq] = 0;
+    icu->req_irq = -1;
+
+    max_pri = 0;
+    n_IRQ = -1;
+    for (i = 0; i < 256; i++) {
+        if (icu->ir[i]) {
+            if (max_pri < icu->ipr[icu->map[i]]) {
+                n_IRQ = i;
+                max_pri = icu->ipr[icu->map[i]];
+            }
+        }
+    }
+    if (n_IRQ >= 0)
+        rxicu_request(icu, n_IRQ);
 }
 
 static uint64_t icu_read(void *opaque, hwaddr addr, unsigned size)
@@ -123,13 +167,8 @@ static void icu_write(void *opaque, hwaddr addr, uint64_t val, unsigned size)
     if (!error) {
         switch (offset) {
         case 0x000 ... 0x0ff:
-            if (icu->src[reg].sense != TRG_LEVEL && val == 0) {
+            if (icu->src[reg].sense != TRG_LEVEL && val == 0)
                 icu->ir[reg] = 0;
-                if ((icu->fir & 0xff) == reg)
-                    qemu_set_irq(icu->_fir, 0);
-                else
-                    qemu_set_irq(icu->_irq, reg);
-            }
             break;
         case 0x100 ... 0x1ff:
             icu->dtcer[reg] = val & 1;
@@ -195,6 +234,7 @@ static void rxicu_realize(DeviceState *dev, Error **errp)
         } else
             icu->src[i].sense = TRG_PEDGE;
     }
+    icu->req_irq = -1;
 }
 
 static void rxicu_init(Object *obj)
@@ -207,6 +247,7 @@ static void rxicu_init(Object *obj)
     sysbus_init_mmio(d, &icu->memory);
 
     qdev_init_gpio_in(DEVICE(d), rxicu_set_irq, 256);
+    qdev_init_gpio_in_named(DEVICE(d), rxicu_ack_irq, "ack", 1);
     sysbus_init_irq(d, &icu->_irq);
     sysbus_init_irq(d, &icu->_fir);
     sysbus_init_irq(d, &icu->_swi);

--- a/hw/rx/rx62n.c
+++ b/hw/rx/rx62n.c
@@ -68,10 +68,6 @@ static RXICUState *register_icu(RX62NState *s)
     
     icu = SYS_BUS_DEVICE(qdev_create(NULL, TYPE_RXICU));
     sysbus_mmio_map(icu, 0, 0x00087000);
-    sysbus_connect_irq(icu, RX_CPU_IRQ,
-                       qdev_get_gpio_in(DEVICE(s->cpu), RX_CPU_IRQ));
-    sysbus_connect_irq(icu, RX_CPU_FIR,
-                       qdev_get_gpio_in(DEVICE(s->cpu), RX_CPU_FIR));
     qdev_prop_set_string(DEVICE(icu), "icutype", "icua");
     qdev_prop_set_uint32(DEVICE(icu), "len-ipr-map", 256);
     for (i = 0; i < 256; i++) {
@@ -164,14 +160,15 @@ static void rx62n_realize(DeviceState *dev, Error **errp)
     
     if (!s->kernel)
         rom_add_file_fixed(bios_name, 0xfff80000, 0);
-    else
     
     object_property_set_bool(OBJECT(s->cpu), true, "realized", &err);
     if (err != NULL) {
         error_propagate(errp, err);
         return;
     }
+
     s->icu = register_icu(s);
+    s->cpu->env.ack = qdev_get_gpio_in_named(DEVICE(s->icu), "ack", 0);
     s->tmr[0] = register_tmr(s, 0);
     s->tmr[1] = register_tmr(s, 1);
     s->cmt[0] = register_cmt(s, 0);

--- a/include/hw/intc/rx_icu.h
+++ b/include/hw/intc/rx_icu.h
@@ -30,6 +30,7 @@ struct RXICUState {
     uint8_t nmier;
     uint8_t nmiclr;
     uint8_t nmicr;
+    int req_irq;
     qemu_irq _irq;
     qemu_irq _fir;
     qemu_irq _swi;

--- a/target/rx/cpu.h
+++ b/target/rx/cpu.h
@@ -120,7 +120,7 @@ typedef struct CPURXState {
     uint32_t in_sleep;
     uint32_t intlevel;
     uint32_t irq;
-    uint32_t int_insn_len;
+    uint32_t sirq;
     float_status fp_status;
     uint32_t op_a1[12];
     uint32_t op_a2[12];
@@ -131,7 +131,7 @@ typedef struct CPURXState {
 
     CPU_COMMON
 
-    void *intc_handle;
+    void *ack;
 } CPURXState;
 
 /**
@@ -177,6 +177,7 @@ void rx_cpu_list(FILE *f, fprintf_function cpu_fprintf);
 void rx_load_image(RXCPU *cpu, const char *filename,
                    uint32_t start, uint32_t size);
 void rx_cpu_pack_psw(CPURXState *env);
+void rx_cpu_unpack_psw(CPURXState *env, int all);
 
 #define cpu_signal_handler cpu_rx_signal_handler
 #define cpu_list rx_cpu_list
@@ -200,27 +201,6 @@ enum {
     ACCESS_INT = 0x20
 };
 
-static inline target_ulong cpu_read_psw(CPURXState *env)
-{
-    return (env->psw_o << PSW_O) | (env->psw_s << PSW_S) |
-        (env->psw_z << PSW_Z) | (env->psw_c << PSW_C) |
-        (env->psw_u << PSW_U) | (env->psw_u << PSW_I) |
-        (env->psw_u << PSW_PM) | (env->psw_u << PSW_IPL);
-}
-
-static inline void cpu_write_psw(CPURXState *env, target_ulong psw)
-{
-    env->psw = psw;
-    env->psw_o = (psw >> PSW_O) & 1;
-    env->psw_s = (psw >> PSW_S) & 1;
-    env->psw_z = (psw >> PSW_Z) & 1;
-    env->psw_c = (psw >> PSW_C) & 1;
-    env->psw_i = (psw >> PSW_I) & 1;
-    env->psw_u = (psw >> PSW_U) & 1;
-    env->psw_pm = (psw >> PSW_PM) & 1;
-    env->psw_ipl = (psw >> PSW_IPL) & 4;
-}
-
 static inline void cpu_get_tb_cpu_state(CPURXState *env, target_ulong *pc,
                                         target_ulong *cs_base, uint32_t *flags)
 {

--- a/target/rx/helper.c
+++ b/target/rx/helper.c
@@ -210,24 +210,20 @@ void rx_cpu_do_interrupt(CPUState *cs)
     CPURXState *env = &cpu->env;
     int do_irq = cs->interrupt_request &
         (CPU_INTERRUPT_HARD | CPU_INTERRUPT_SOFT | CPU_INTERRUPT_FIR);
-    int do_exp, irq_vector = -1;
-
-    do_exp = cs->exception_index < 0x100;
+    int irq_vector = -1;
 
     env->in_sleep = 0;
 
-    if (!do_irq) {
-        cs->interrupt_request = 0;
-        return ;
-    }
     if (do_irq & CPU_INTERRUPT_HARD) {
         irq_vector = env->irq;
-        if (irq_vector == -1 || env->psw_i == 0) {
+        if (irq_vector == -1 ||
+            (env->psw_i == 0 && !(do_irq & CPU_INTERRUPT_SOFT))) {
             return; /* masked */
 	}
+        cs->interrupt_request &= ~CPU_INTERRUPT_HARD;
     }
-    if (do_irq & CPU_INTERRUPT_SOFT) {
-        irq_vector = env->irq;
+    if (irq_vector == -1 && do_irq & CPU_INTERRUPT_SOFT) {
+        irq_vector = env->sirq;
         cs->interrupt_request &= ~CPU_INTERRUPT_SOFT;
     }
 
@@ -278,23 +274,24 @@ void rx_cpu_do_interrupt(CPUState *cs)
         env->bpc = env->pc;
         env->bpsw = env->psw;
     }
-    env->psw &= ~((1UL << PSW_PM) | (1UL << PSW_I) | (1UL << PSW_U));
     env->psw_pm = env->psw_i = env->psw_u = 0;
     env->regs[0] = env->isp;
-    if (do_irq & CPU_INTERRUPT_HARD)
-        env->psw_ipl = env->intlevel;
-
-    if (do_exp) {
-        uint32_t vec = cs->exception_index;
-        env->pc = cpu_ldl_all(env, 0xffffffc0 + vec * 4);
-        return;
-    }
-
     if (do_irq) {
-        if (do_irq & CPU_INTERRUPT_FIR)
+        if (do_irq & CPU_INTERRUPT_FIR) {
             env->pc = env->fintv;
-        else
-            env->pc = cpu_ldl_all(env, env->intb + irq_vector * 4);
+            env->psw_ipl = 15;
+            cs->interrupt_request &= ~CPU_INTERRUPT_FIR;
+            qemu_set_irq(env->ack, 0);
+            return;
+        } else if (do_irq & CPU_INTERRUPT_HARD) {
+            env->psw_ipl = env->intlevel;
+            qemu_set_irq(env->ack, 0);
+        }
+        env->pc = cpu_ldl_all(env, env->intb + irq_vector * 4);
+        return;
+    } else {
+        uint32_t vec = cs->exception_index;
+        env->pc = cpu_ldl_all(env, 0xffffffc0 + vec * 4);
         return;
     }
 }
@@ -306,11 +303,11 @@ bool rx_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
     if (((interrupt_request & CPU_INTERRUPT_HARD) &&
          (env->psw_i && (env->psw_ipl < env->intlevel))) |
         (interrupt_request & CPU_INTERRUPT_SOFT) ||
-        (env->psw_i && (interrupt_request & CPU_INTERRUPT_FIR))) {
+        (env->psw_i && (interrupt_request & CPU_INTERRUPT_FIR) &&
+         (env->psw_ipl < 15))) {
         rx_cpu_do_interrupt(cs);
         return true;
     }
-    
     return false;
 }
 
@@ -365,8 +362,7 @@ void QEMU_NORETURN helper_rxint(CPURXState *env, uint32_t vec)
     CPUState *cs = CPU(rx_env_get_cpu(env));
 
     cs->interrupt_request |= CPU_INTERRUPT_SOFT;
-    env->irq = vec;
-    printf("int r13=0x%08x, r15=0x%08x\n", env->regs[13], env->regs[15]);
+    env->sirq = vec;
     raise_exception(env, 0x100, 0);
 }
 
@@ -375,7 +371,7 @@ void QEMU_NORETURN helper_rxbrk(CPURXState *env)
     CPUState *cs = CPU(rx_env_get_cpu(env));
 
     cs->interrupt_request |= CPU_INTERRUPT_SOFT;
-    env->irq = 0;
+    env->sirq = 0;
     raise_exception(env, 0x100, 0);
 }